faset over fra Z3950 til google books

python/gdata/Crypto/Util/RFC1751.py

@@ -0,0 +1,342 @@
+#!/usr/local/bin/python
+# rfc1751.py : Converts between 128-bit strings and a human-readable
+# sequence of words, as defined in RFC1751: "A Convention for
+# Human-Readable 128-bit Keys", by Daniel L. McDonald.
+
+__revision__ = "$Id: RFC1751.py,v 1.6 2003/04/04 15:15:10 akuchling Exp $"
+
+
+import string, binascii
+
+binary={0:'0000', 1:'0001', 2:'0010', 3:'0011', 4:'0100', 5:'0101',
+        6:'0110', 7:'0111', 8:'1000', 9:'1001', 10:'1010', 11:'1011',
+        12:'1100', 13:'1101', 14:'1110', 15:'1111'}
+
+def _key2bin(s):
+    "Convert a key into a string of binary digits"
+    kl=map(lambda x: ord(x), s)
+    kl=map(lambda x: binary[x/16]+binary[x&15], kl)
+    return ''.join(kl)
+
+def _extract(key, start, length):
+    """Extract a bitstring from a string of binary digits, and return its
+    numeric value."""
+    k=key[start:start+length]
+    return reduce(lambda x,y: x*2+ord(y)-48, k, 0)
+
+def key_to_english (key):
+    """key_to_english(key:string) : string
+    Transform an arbitrary key into a string containing English words.
+    The key length must be a multiple of 8.
+    """
+    english=''
+    for index in range(0, len(key), 8): # Loop over 8-byte subkeys
+        subkey=key[index:index+8]
+        # Compute the parity of the key
+        skbin=_key2bin(subkey) ; p=0
+        for i in range(0, 64, 2): p=p+_extract(skbin, i, 2)
+        # Append parity bits to the subkey
+        skbin=_key2bin(subkey+chr((p<<6) & 255))
+        for i in range(0, 64, 11):
+            english=english+wordlist[_extract(skbin, i, 11)]+' '
+
+    return english[:-1]                 # Remove the trailing space
+
+def english_to_key (str):
+    """english_to_key(string):string
+    Transform a string into a corresponding key.
+    The string must contain words separated by whitespace; the number
+    of words must be a multiple of 6.
+    """
+
+    L=string.split(string.upper(str)) ; key=''
+    for index in range(0, len(L), 6):
+        sublist=L[index:index+6] ; char=9*[0] ; bits=0
+        for i in sublist:
+            index = wordlist.index(i)
+            shift = (8-(bits+11)%8) %8
+            y = index << shift
+            cl, cc, cr = (y>>16), (y>>8)&0xff, y & 0xff
+            if (shift>5):
+                char[bits/8] = char[bits/8] | cl
+                char[bits/8+1] = char[bits/8+1] | cc
+                char[bits/8+2] = char[bits/8+2] | cr
+            elif shift>-3:
+                char[bits/8] = char[bits/8] | cc
+                char[bits/8+1] = char[bits/8+1] | cr
+            else: char[bits/8] = char[bits/8] | cr
+            bits=bits+11
+        subkey=reduce(lambda x,y:x+chr(y), char, '')
+
+        # Check the parity of the resulting key
+        skbin=_key2bin(subkey)
+        p=0
+        for i in range(0, 64, 2): p=p+_extract(skbin, i, 2)
+        if (p&3) != _extract(skbin, 64, 2):
+            raise ValueError, "Parity error in resulting key"
+        key=key+subkey[0:8]
+    return key
+
+wordlist=[ "A", "ABE", "ACE", "ACT", "AD", "ADA", "ADD",
+   "AGO", "AID", "AIM", "AIR", "ALL", "ALP", "AM", "AMY", "AN", "ANA",
+   "AND", "ANN", "ANT", "ANY", "APE", "APS", "APT", "ARC", "ARE", "ARK",
+   "ARM", "ART", "AS", "ASH", "ASK", "AT", "ATE", "AUG", "AUK", "AVE",
+   "AWE", "AWK", "AWL", "AWN", "AX", "AYE", "BAD", "BAG", "BAH", "BAM",
+   "BAN", "BAR", "BAT", "BAY", "BE", "BED", "BEE", "BEG", "BEN", "BET",
+   "BEY", "BIB", "BID", "BIG", "BIN", "BIT", "BOB", "BOG", "BON", "BOO",
+   "BOP", "BOW", "BOY", "BUB", "BUD", "BUG", "BUM", "BUN", "BUS", "BUT",
+   "BUY", "BY", "BYE", "CAB", "CAL", "CAM", "CAN", "CAP", "CAR", "CAT",
+   "CAW", "COD", "COG", "COL", "CON", "COO", "COP", "COT", "COW", "COY",
+   "CRY", "CUB", "CUE", "CUP", "CUR", "CUT", "DAB", "DAD", "DAM", "DAN",
+   "DAR", "DAY", "DEE", "DEL", "DEN", "DES", "DEW", "DID", "DIE", "DIG",
+   "DIN", "DIP", "DO", "DOE", "DOG", "DON", "DOT", "DOW", "DRY", "DUB",
+   "DUD", "DUE", "DUG", "DUN", "EAR", "EAT", "ED", "EEL", "EGG", "EGO",
+   "ELI", "ELK", "ELM", "ELY", "EM", "END", "EST", "ETC", "EVA", "EVE",
+   "EWE", "EYE", "FAD", "FAN", "FAR", "FAT", "FAY", "FED", "FEE", "FEW",
+   "FIB", "FIG", "FIN", "FIR", "FIT", "FLO", "FLY", "FOE", "FOG", "FOR",
+   "FRY", "FUM", "FUN", "FUR", "GAB", "GAD", "GAG", "GAL", "GAM", "GAP",
+   "GAS", "GAY", "GEE", "GEL", "GEM", "GET", "GIG", "GIL", "GIN", "GO",
+   "GOT", "GUM", "GUN", "GUS", "GUT", "GUY", "GYM", "GYP", "HA", "HAD",
+   "HAL", "HAM", "HAN", "HAP", "HAS", "HAT", "HAW", "HAY", "HE", "HEM",
+   "HEN", "HER", "HEW", "HEY", "HI", "HID", "HIM", "HIP", "HIS", "HIT",
+   "HO", "HOB", "HOC", "HOE", "HOG", "HOP", "HOT", "HOW", "HUB", "HUE",
+   "HUG", "HUH", "HUM", "HUT", "I", "ICY", "IDA", "IF", "IKE", "ILL",
+   "INK", "INN", "IO", "ION", "IQ", "IRA", "IRE", "IRK", "IS", "IT",
+   "ITS", "IVY", "JAB", "JAG", "JAM", "JAN", "JAR", "JAW", "JAY", "JET",
+   "JIG", "JIM", "JO", "JOB", "JOE", "JOG", "JOT", "JOY", "JUG", "JUT",
+   "KAY", "KEG", "KEN", "KEY", "KID", "KIM", "KIN", "KIT", "LA", "LAB",
+   "LAC", "LAD", "LAG", "LAM", "LAP", "LAW", "LAY", "LEA", "LED", "LEE",
+   "LEG", "LEN", "LEO", "LET", "LEW", "LID", "LIE", "LIN", "LIP", "LIT",
+   "LO", "LOB", "LOG", "LOP", "LOS", "LOT", "LOU", "LOW", "LOY", "LUG",
+   "LYE", "MA", "MAC", "MAD", "MAE", "MAN", "MAO", "MAP", "MAT", "MAW",
+   "MAY", "ME", "MEG", "MEL", "MEN", "MET", "MEW", "MID", "MIN", "MIT",
+   "MOB", "MOD", "MOE", "MOO", "MOP", "MOS", "MOT", "MOW", "MUD", "MUG",
+   "MUM", "MY", "NAB", "NAG", "NAN", "NAP", "NAT", "NAY", "NE", "NED",
+   "NEE", "NET", "NEW", "NIB", "NIL", "NIP", "NIT", "NO", "NOB", "NOD",
+   "NON", "NOR", "NOT", "NOV", "NOW", "NU", "NUN", "NUT", "O", "OAF",
+   "OAK", "OAR", "OAT", "ODD", "ODE", "OF", "OFF", "OFT", "OH", "OIL",
+   "OK", "OLD", "ON", "ONE", "OR", "ORB", "ORE", "ORR", "OS", "OTT",
+   "OUR", "OUT", "OVA", "OW", "OWE", "OWL", "OWN", "OX", "PA", "PAD",
+   "PAL", "PAM", "PAN", "PAP", "PAR", "PAT", "PAW", "PAY", "PEA", "PEG",
+   "PEN", "PEP", "PER", "PET", "PEW", "PHI", "PI", "PIE", "PIN", "PIT",
+   "PLY", "PO", "POD", "POE", "POP", "POT", "POW", "PRO", "PRY", "PUB",
+   "PUG", "PUN", "PUP", "PUT", "QUO", "RAG", "RAM", "RAN", "RAP", "RAT",
+   "RAW", "RAY", "REB", "RED", "REP", "RET", "RIB", "RID", "RIG", "RIM",
+   "RIO", "RIP", "ROB", "ROD", "ROE", "RON", "ROT", "ROW", "ROY", "RUB",
+   "RUE", "RUG", "RUM", "RUN", "RYE", "SAC", "SAD", "SAG", "SAL", "SAM",
+   "SAN", "SAP", "SAT", "SAW", "SAY", "SEA", "SEC", "SEE", "SEN", "SET",
+   "SEW", "SHE", "SHY", "SIN", "SIP", "SIR", "SIS", "SIT", "SKI", "SKY",
+   "SLY", "SO", "SOB", "SOD", "SON", "SOP", "SOW", "SOY", "SPA", "SPY",
+   "SUB", "SUD", "SUE", "SUM", "SUN", "SUP", "TAB", "TAD", "TAG", "TAN",
+   "TAP", "TAR", "TEA", "TED", "TEE", "TEN", "THE", "THY", "TIC", "TIE",
+   "TIM", "TIN", "TIP", "TO", "TOE", "TOG", "TOM", "TON", "TOO", "TOP",
+   "TOW", "TOY", "TRY", "TUB", "TUG", "TUM", "TUN", "TWO", "UN", "UP",
+   "US", "USE", "VAN", "VAT", "VET", "VIE", "WAD", "WAG", "WAR", "WAS",
+   "WAY", "WE", "WEB", "WED", "WEE", "WET", "WHO", "WHY", "WIN", "WIT",
+   "WOK", "WON", "WOO", "WOW", "WRY", "WU", "YAM", "YAP", "YAW", "YE",
+   "YEA", "YES", "YET", "YOU", "ABED", "ABEL", "ABET", "ABLE", "ABUT",
+   "ACHE", "ACID", "ACME", "ACRE", "ACTA", "ACTS", "ADAM", "ADDS",
+   "ADEN", "AFAR", "AFRO", "AGEE", "AHEM", "AHOY", "AIDA", "AIDE",
+   "AIDS", "AIRY", "AJAR", "AKIN", "ALAN", "ALEC", "ALGA", "ALIA",
+   "ALLY", "ALMA", "ALOE", "ALSO", "ALTO", "ALUM", "ALVA", "AMEN",
+   "AMES", "AMID", "AMMO", "AMOK", "AMOS", "AMRA", "ANDY", "ANEW",
+   "ANNA", "ANNE", "ANTE", "ANTI", "AQUA", "ARAB", "ARCH", "AREA",
+   "ARGO", "ARID", "ARMY", "ARTS", "ARTY", "ASIA", "ASKS", "ATOM",
+   "AUNT", "AURA", "AUTO", "AVER", "AVID", "AVIS", "AVON", "AVOW",
+   "AWAY", "AWRY", "BABE", "BABY", "BACH", "BACK", "BADE", "BAIL",
+   "BAIT", "BAKE", "BALD", "BALE", "BALI", "BALK", "BALL", "BALM",
+   "BAND", "BANE", "BANG", "BANK", "BARB", "BARD", "BARE", "BARK",
+   "BARN", "BARR", "BASE", "BASH", "BASK", "BASS", "BATE", "BATH",
+   "BAWD", "BAWL", "BEAD", "BEAK", "BEAM", "BEAN", "BEAR", "BEAT",
+   "BEAU", "BECK", "BEEF", "BEEN", "BEER",
+   "BEET", "BELA", "BELL", "BELT", "BEND", "BENT", "BERG", "BERN",
+   "BERT", "BESS", "BEST", "BETA", "BETH", "BHOY", "BIAS", "BIDE",
+   "BIEN", "BILE", "BILK", "BILL", "BIND", "BING", "BIRD", "BITE",
+   "BITS", "BLAB", "BLAT", "BLED", "BLEW", "BLOB", "BLOC", "BLOT",
+   "BLOW", "BLUE", "BLUM", "BLUR", "BOAR", "BOAT", "BOCA", "BOCK",
+   "BODE", "BODY", "BOGY", "BOHR", "BOIL", "BOLD", "BOLO", "BOLT",
+   "BOMB", "BONA", "BOND", "BONE", "BONG", "BONN", "BONY", "BOOK",
+   "BOOM", "BOON", "BOOT", "BORE", "BORG", "BORN", "BOSE", "BOSS",
+   "BOTH", "BOUT", "BOWL", "BOYD", "BRAD", "BRAE", "BRAG", "BRAN",
+   "BRAY", "BRED", "BREW", "BRIG", "BRIM", "BROW", "BUCK", "BUDD",
+   "BUFF", "BULB", "BULK", "BULL", "BUNK", "BUNT", "BUOY", "BURG",
+   "BURL", "BURN", "BURR", "BURT", "BURY", "BUSH", "BUSS", "BUST",
+   "BUSY", "BYTE", "CADY", "CAFE", "CAGE", "CAIN", "CAKE", "CALF",
+   "CALL", "CALM", "CAME", "CANE", "CANT", "CARD", "CARE", "CARL",
+   "CARR", "CART", "CASE", "CASH", "CASK", "CAST", "CAVE", "CEIL",
+   "CELL", "CENT", "CERN", "CHAD", "CHAR", "CHAT", "CHAW", "CHEF",
+   "CHEN", "CHEW", "CHIC", "CHIN", "CHOU", "CHOW", "CHUB", "CHUG",
+   "CHUM", "CITE", "CITY", "CLAD", "CLAM", "CLAN", "CLAW", "CLAY",
+   "CLOD", "CLOG", "CLOT", "CLUB", "CLUE", "COAL", "COAT", "COCA",
+   "COCK", "COCO", "CODA", "CODE", "CODY", "COED", "COIL", "COIN",
+   "COKE", "COLA", "COLD", "COLT", "COMA", "COMB", "COME", "COOK",
+   "COOL", "COON", "COOT", "CORD", "CORE", "CORK", "CORN", "COST",
+   "COVE", "COWL", "CRAB", "CRAG", "CRAM", "CRAY", "CREW", "CRIB",
+   "CROW", "CRUD", "CUBA", "CUBE", "CUFF", "CULL", "CULT", "CUNY",
+   "CURB", "CURD", "CURE", "CURL", "CURT", "CUTS", "DADE", "DALE",
+   "DAME", "DANA", "DANE", "DANG", "DANK", "DARE", "DARK", "DARN",
+   "DART", "DASH", "DATA", "DATE", "DAVE", "DAVY", "DAWN", "DAYS",
+   "DEAD", "DEAF", "DEAL", "DEAN", "DEAR", "DEBT", "DECK", "DEED",
+   "DEEM", "DEER", "DEFT", "DEFY", "DELL", "DENT", "DENY", "DESK",
+   "DIAL", "DICE", "DIED", "DIET", "DIME", "DINE", "DING", "DINT",
+   "DIRE", "DIRT", "DISC", "DISH", "DISK", "DIVE", "DOCK", "DOES",
+   "DOLE", "DOLL", "DOLT", "DOME", "DONE", "DOOM", "DOOR", "DORA",
+   "DOSE", "DOTE", "DOUG", "DOUR", "DOVE", "DOWN", "DRAB", "DRAG",
+   "DRAM", "DRAW", "DREW", "DRUB", "DRUG", "DRUM", "DUAL", "DUCK",
+   "DUCT", "DUEL", "DUET", "DUKE", "DULL", "DUMB", "DUNE", "DUNK",
+   "DUSK", "DUST", "DUTY", "EACH", "EARL", "EARN", "EASE", "EAST",
+   "EASY", "EBEN", "ECHO", "EDDY", "EDEN", "EDGE", "EDGY", "EDIT",
+   "EDNA", "EGAN", "ELAN", "ELBA", "ELLA", "ELSE", "EMIL", "EMIT",
+   "EMMA", "ENDS", "ERIC", "EROS", "EVEN", "EVER", "EVIL", "EYED",
+   "FACE", "FACT", "FADE", "FAIL", "FAIN", "FAIR", "FAKE", "FALL",
+   "FAME", "FANG", "FARM", "FAST", "FATE", "FAWN", "FEAR", "FEAT",
+   "FEED", "FEEL", "FEET", "FELL", "FELT", "FEND", "FERN", "FEST",
+   "FEUD", "FIEF", "FIGS", "FILE", "FILL", "FILM", "FIND", "FINE",
+   "FINK", "FIRE", "FIRM", "FISH", "FISK", "FIST", "FITS", "FIVE",
+   "FLAG", "FLAK", "FLAM", "FLAT", "FLAW", "FLEA", "FLED", "FLEW",
+   "FLIT", "FLOC", "FLOG", "FLOW", "FLUB", "FLUE", "FOAL", "FOAM",
+   "FOGY", "FOIL", "FOLD", "FOLK", "FOND", "FONT", "FOOD", "FOOL",
+   "FOOT", "FORD", "FORE", "FORK", "FORM", "FORT", "FOSS", "FOUL",
+   "FOUR", "FOWL", "FRAU", "FRAY", "FRED", "FREE", "FRET", "FREY",
+   "FROG", "FROM", "FUEL", "FULL", "FUME", "FUND", "FUNK", "FURY",
+   "FUSE", "FUSS", "GAFF", "GAGE", "GAIL", "GAIN", "GAIT", "GALA",
+   "GALE", "GALL", "GALT", "GAME", "GANG", "GARB", "GARY", "GASH",
+   "GATE", "GAUL", "GAUR", "GAVE", "GAWK", "GEAR", "GELD", "GENE",
+   "GENT", "GERM", "GETS", "GIBE", "GIFT", "GILD", "GILL", "GILT",
+   "GINA", "GIRD", "GIRL", "GIST", "GIVE", "GLAD", "GLEE", "GLEN",
+   "GLIB", "GLOB", "GLOM", "GLOW", "GLUE", "GLUM", "GLUT", "GOAD",
+   "GOAL", "GOAT", "GOER", "GOES", "GOLD", "GOLF", "GONE", "GONG",
+   "GOOD", "GOOF", "GORE", "GORY", "GOSH", "GOUT", "GOWN", "GRAB",
+   "GRAD", "GRAY", "GREG", "GREW", "GREY", "GRID", "GRIM", "GRIN",
+   "GRIT", "GROW", "GRUB", "GULF", "GULL", "GUNK", "GURU", "GUSH",
+   "GUST", "GWEN", "GWYN", "HAAG", "HAAS", "HACK", "HAIL", "HAIR",
+   "HALE", "HALF", "HALL", "HALO", "HALT", "HAND", "HANG", "HANK",
+   "HANS", "HARD", "HARK", "HARM", "HART", "HASH", "HAST", "HATE",
+   "HATH", "HAUL", "HAVE", "HAWK", "HAYS", "HEAD", "HEAL", "HEAR",
+   "HEAT", "HEBE", "HECK", "HEED", "HEEL", "HEFT", "HELD", "HELL",
+   "HELM", "HERB", "HERD", "HERE", "HERO", "HERS", "HESS", "HEWN",
+   "HICK", "HIDE", "HIGH", "HIKE", "HILL", "HILT", "HIND", "HINT",
+   "HIRE", "HISS", "HIVE", "HOBO", "HOCK", "HOFF", "HOLD", "HOLE",
+   "HOLM", "HOLT", "HOME", "HONE", "HONK", "HOOD", "HOOF", "HOOK",
+   "HOOT", "HORN", "HOSE", "HOST", "HOUR", "HOVE", "HOWE", "HOWL",
+   "HOYT", "HUCK", "HUED", "HUFF", "HUGE", "HUGH", "HUGO", "HULK",
+   "HULL", "HUNK", "HUNT", "HURD", "HURL", "HURT", "HUSH", "HYDE",
+   "HYMN", "IBIS", "ICON", "IDEA", "IDLE", "IFFY", "INCA", "INCH",
+   "INTO", "IONS", "IOTA", "IOWA", "IRIS", "IRMA", "IRON", "ISLE",
+   "ITCH", "ITEM", "IVAN", "JACK", "JADE", "JAIL", "JAKE", "JANE",
+   "JAVA", "JEAN", "JEFF", "JERK", "JESS", "JEST", "JIBE", "JILL",
+   "JILT", "JIVE", "JOAN", "JOBS", "JOCK", "JOEL", "JOEY", "JOHN",
+   "JOIN", "JOKE", "JOLT", "JOVE", "JUDD", "JUDE", "JUDO", "JUDY",
+   "JUJU", "JUKE", "JULY", "JUNE", "JUNK", "JUNO", "JURY", "JUST",
+   "JUTE", "KAHN", "KALE", "KANE", "KANT", "KARL", "KATE", "KEEL",
+   "KEEN", "KENO", "KENT", "KERN", "KERR", "KEYS", "KICK", "KILL",
+   "KIND", "KING", "KIRK", "KISS", "KITE", "KLAN", "KNEE", "KNEW",
+   "KNIT", "KNOB", "KNOT", "KNOW", "KOCH", "KONG", "KUDO", "KURD",
+   "KURT", "KYLE", "LACE", "LACK", "LACY", "LADY", "LAID", "LAIN",
+   "LAIR", "LAKE", "LAMB", "LAME", "LAND", "LANE", "LANG", "LARD",
+   "LARK", "LASS", "LAST", "LATE", "LAUD", "LAVA", "LAWN", "LAWS",
+   "LAYS", "LEAD", "LEAF", "LEAK", "LEAN", "LEAR", "LEEK", "LEER",
+   "LEFT", "LEND", "LENS", "LENT", "LEON", "LESK", "LESS", "LEST",
+   "LETS", "LIAR", "LICE", "LICK", "LIED", "LIEN", "LIES", "LIEU",
+   "LIFE", "LIFT", "LIKE", "LILA", "LILT", "LILY", "LIMA", "LIMB",
+   "LIME", "LIND", "LINE", "LINK", "LINT", "LION", "LISA", "LIST",
+   "LIVE", "LOAD", "LOAF", "LOAM", "LOAN", "LOCK", "LOFT", "LOGE",
+   "LOIS", "LOLA", "LONE", "LONG", "LOOK", "LOON", "LOOT", "LORD",
+   "LORE", "LOSE", "LOSS", "LOST", "LOUD", "LOVE", "LOWE", "LUCK",
+   "LUCY", "LUGE", "LUKE", "LULU", "LUND", "LUNG", "LURA", "LURE",
+   "LURK", "LUSH", "LUST", "LYLE", "LYNN", "LYON", "LYRA", "MACE",
+   "MADE", "MAGI", "MAID", "MAIL", "MAIN", "MAKE", "MALE", "MALI",
+   "MALL", "MALT", "MANA", "MANN", "MANY", "MARC", "MARE", "MARK",
+   "MARS", "MART", "MARY", "MASH", "MASK", "MASS", "MAST", "MATE",
+   "MATH", "MAUL", "MAYO", "MEAD", "MEAL", "MEAN", "MEAT", "MEEK",
+   "MEET", "MELD", "MELT", "MEMO", "MEND", "MENU", "MERT", "MESH",
+   "MESS", "MICE", "MIKE", "MILD", "MILE", "MILK", "MILL", "MILT",
+   "MIMI", "MIND", "MINE", "MINI", "MINK", "MINT", "MIRE", "MISS",
+   "MIST", "MITE", "MITT", "MOAN", "MOAT", "MOCK", "MODE", "MOLD",
+   "MOLE", "MOLL", "MOLT", "MONA", "MONK", "MONT", "MOOD", "MOON",
+   "MOOR", "MOOT", "MORE", "MORN", "MORT", "MOSS", "MOST", "MOTH",
+   "MOVE", "MUCH", "MUCK", "MUDD", "MUFF", "MULE", "MULL", "MURK",
+   "MUSH", "MUST", "MUTE", "MUTT", "MYRA", "MYTH", "NAGY", "NAIL",
+   "NAIR", "NAME", "NARY", "NASH", "NAVE", "NAVY", "NEAL", "NEAR",
+   "NEAT", "NECK", "NEED", "NEIL", "NELL", "NEON", "NERO", "NESS",
+   "NEST", "NEWS", "NEWT", "NIBS", "NICE", "NICK", "NILE", "NINA",
+   "NINE", "NOAH", "NODE", "NOEL", "NOLL", "NONE", "NOOK", "NOON",
+   "NORM", "NOSE", "NOTE", "NOUN", "NOVA", "NUDE", "NULL", "NUMB",
+   "OATH", "OBEY", "OBOE", "ODIN", "OHIO", "OILY", "OINT", "OKAY",
+   "OLAF", "OLDY", "OLGA", "OLIN", "OMAN", "OMEN", "OMIT", "ONCE",
+   "ONES", "ONLY", "ONTO", "ONUS", "ORAL", "ORGY", "OSLO", "OTIS",
+   "OTTO", "OUCH", "OUST", "OUTS", "OVAL", "OVEN", "OVER", "OWLY",
+   "OWNS", "QUAD", "QUIT", "QUOD", "RACE", "RACK", "RACY", "RAFT",
+   "RAGE", "RAID", "RAIL", "RAIN", "RAKE", "RANK", "RANT", "RARE",
+   "RASH", "RATE", "RAVE", "RAYS", "READ", "REAL", "REAM", "REAR",
+   "RECK", "REED", "REEF", "REEK", "REEL", "REID", "REIN", "RENA",
+   "REND", "RENT", "REST", "RICE", "RICH", "RICK", "RIDE", "RIFT",
+   "RILL", "RIME", "RING", "RINK", "RISE", "RISK", "RITE", "ROAD",
+   "ROAM", "ROAR", "ROBE", "ROCK", "RODE", "ROIL", "ROLL", "ROME",
+   "ROOD", "ROOF", "ROOK", "ROOM", "ROOT", "ROSA", "ROSE", "ROSS",
+   "ROSY", "ROTH", "ROUT", "ROVE", "ROWE", "ROWS", "RUBE", "RUBY",
+   "RUDE", "RUDY", "RUIN", "RULE", "RUNG", "RUNS", "RUNT", "RUSE",
+   "RUSH", "RUSK", "RUSS", "RUST", "RUTH", "SACK", "SAFE", "SAGE",
+   "SAID", "SAIL", "SALE", "SALK", "SALT", "SAME", "SAND", "SANE",
+   "SANG", "SANK", "SARA", "SAUL", "SAVE", "SAYS", "SCAN", "SCAR",
+   "SCAT", "SCOT", "SEAL", "SEAM", "SEAR", "SEAT", "SEED", "SEEK",
+   "SEEM", "SEEN", "SEES", "SELF", "SELL", "SEND", "SENT", "SETS",
+   "SEWN", "SHAG", "SHAM", "SHAW", "SHAY", "SHED", "SHIM", "SHIN",
+   "SHOD", "SHOE", "SHOT", "SHOW", "SHUN", "SHUT", "SICK", "SIDE",
+   "SIFT", "SIGH", "SIGN", "SILK", "SILL", "SILO", "SILT", "SINE",
+   "SING", "SINK", "SIRE", "SITE", "SITS", "SITU", "SKAT", "SKEW",
+   "SKID", "SKIM", "SKIN", "SKIT", "SLAB", "SLAM", "SLAT", "SLAY",
+   "SLED", "SLEW", "SLID", "SLIM", "SLIT", "SLOB", "SLOG", "SLOT",
+   "SLOW", "SLUG", "SLUM", "SLUR", "SMOG", "SMUG", "SNAG", "SNOB",
+   "SNOW", "SNUB", "SNUG", "SOAK", "SOAR", "SOCK", "SODA", "SOFA",
+   "SOFT", "SOIL", "SOLD", "SOME", "SONG", "SOON", "SOOT", "SORE",
+   "SORT", "SOUL", "SOUR", "SOWN", "STAB", "STAG", "STAN", "STAR",
+   "STAY", "STEM", "STEW", "STIR", "STOW", "STUB", "STUN", "SUCH",
+   "SUDS", "SUIT", "SULK", "SUMS", "SUNG", "SUNK", "SURE", "SURF",
+   "SWAB", "SWAG", "SWAM", "SWAN", "SWAT", "SWAY", "SWIM", "SWUM",
+   "TACK", "TACT", "TAIL", "TAKE", "TALE", "TALK", "TALL", "TANK",
+   "TASK", "TATE", "TAUT", "TEAL", "TEAM", "TEAR", "TECH", "TEEM",
+   "TEEN", "TEET", "TELL", "TEND", "TENT", "TERM", "TERN", "TESS",
+   "TEST", "THAN", "THAT", "THEE", "THEM", "THEN", "THEY", "THIN",
+   "THIS", "THUD", "THUG", "TICK", "TIDE", "TIDY", "TIED", "TIER",
+   "TILE", "TILL", "TILT", "TIME", "TINA", "TINE", "TINT", "TINY",
+   "TIRE", "TOAD", "TOGO", "TOIL", "TOLD", "TOLL", "TONE", "TONG",
+   "TONY", "TOOK", "TOOL", "TOOT", "TORE", "TORN", "TOTE", "TOUR",
+   "TOUT", "TOWN", "TRAG", "TRAM", "TRAY", "TREE", "TREK", "TRIG",
+   "TRIM", "TRIO", "TROD", "TROT", "TROY", "TRUE", "TUBA", "TUBE",
+   "TUCK", "TUFT", "TUNA", "TUNE", "TUNG", "TURF", "TURN", "TUSK",
+   "TWIG", "TWIN", "TWIT", "ULAN", "UNIT", "URGE", "USED", "USER",
+   "USES", "UTAH", "VAIL", "VAIN", "VALE", "VARY", "VASE", "VAST",
+   "VEAL", "VEDA", "VEIL", "VEIN", "VEND", "VENT", "VERB", "VERY",
+   "VETO", "VICE", "VIEW", "VINE", "VISE", "VOID", "VOLT", "VOTE",
+   "WACK", "WADE", "WAGE", "WAIL", "WAIT", "WAKE", "WALE", "WALK",
+   "WALL", "WALT", "WAND", "WANE", "WANG", "WANT", "WARD", "WARM",
+   "WARN", "WART", "WASH", "WAST", "WATS", "WATT", "WAVE", "WAVY",
+   "WAYS", "WEAK", "WEAL", "WEAN", "WEAR", "WEED", "WEEK", "WEIR",
+   "WELD", "WELL", "WELT", "WENT", "WERE", "WERT", "WEST", "WHAM",
+   "WHAT", "WHEE", "WHEN", "WHET", "WHOA", "WHOM", "WICK", "WIFE",
+   "WILD", "WILL", "WIND", "WINE", "WING", "WINK", "WINO", "WIRE",
+   "WISE", "WISH", "WITH", "WOLF", "WONT", "WOOD", "WOOL", "WORD",
+   "WORE", "WORK", "WORM", "WORN", "WOVE", "WRIT", "WYNN", "YALE",
+   "YANG", "YANK", "YARD", "YARN", "YAWL", "YAWN", "YEAH", "YEAR",
+   "YELL", "YOGA", "YOKE" ]
+
+if __name__=='__main__':
+    data = [('EB33F77EE73D4053', 'TIDE ITCH SLOW REIN RULE MOT'),
+            ('CCAC2AED591056BE4F90FD441C534766',
+             'RASH BUSH MILK LOOK BAD BRIM AVID GAFF BAIT ROT POD LOVE'),
+            ('EFF81F9BFBC65350920CDD7416DE8009',
+             'TROD MUTE TAIL WARM CHAR KONG HAAG CITY BORE O TEAL AWL')
+           ]
+
+    for key, words in data:
+        print 'Trying key', key
+        key=binascii.a2b_hex(key)
+        w2=key_to_english(key)
+        if w2!=words:
+            print 'key_to_english fails on key', repr(key), ', producing', str(w2)
+        k2=english_to_key(words)
+        if k2!=key:
+            print 'english_to_key fails on key', repr(key), ', producing', repr(k2)
+
+

python/gdata/Crypto/Util/__init__.py

@@ -0,0 +1,16 @@
+"""Miscellaneous modules
+
+Contains useful modules that don't belong into any of the
+other Crypto.* subpackages.
+
+Crypto.Util.number        Number-theoretic functions (primality testing, etc.)
+Crypto.Util.randpool      Random number generation
+Crypto.Util.RFC1751       Converts between 128-bit keys and human-readable
+                          strings of words.
+
+"""
+
+__all__ = ['randpool', 'RFC1751', 'number']
+
+__revision__ = "$Id: __init__.py,v 1.4 2003/02/28 15:26:00 akuchling Exp $"
+

python/gdata/Crypto/Util/number.py

@@ -0,0 +1,201 @@
+#
+#   number.py : Number-theoretic functions
+#
+#  Part of the Python Cryptography Toolkit
+#
+# Distribute and use freely; there are no restrictions on further
+# dissemination and usage except those imposed by the laws of your
+# country of residence.  This software is provided "as is" without
+# warranty of fitness for use or suitability for any purpose, express
+# or implied. Use at your own risk or not at all.
+#
+
+__revision__ = "$Id: number.py,v 1.13 2003/04/04 18:21:07 akuchling Exp $"
+
+bignum = long
+try:
+    from Crypto.PublicKey import _fastmath
+except ImportError:
+    _fastmath = None
+
+# Commented out and replaced with faster versions below
+## def long2str(n):
+##     s=''
+##     while n>0:
+##         s=chr(n & 255)+s
+##         n=n>>8
+##     return s
+
+## import types
+## def str2long(s):
+##     if type(s)!=types.StringType: return s   # Integers will be left alone
+##     return reduce(lambda x,y : x*256+ord(y), s, 0L)
+
+def size (N):
+    """size(N:long) : int
+    Returns the size of the number N in bits.
+    """
+    bits, power = 0,1L
+    while N >= power:
+        bits += 1
+        power = power << 1
+    return bits
+
+def getRandomNumber(N, randfunc):
+    """getRandomNumber(N:int, randfunc:callable):long
+    Return an N-bit random number."""
+
+    S = randfunc(N/8)
+    odd_bits = N % 8
+    if odd_bits != 0:
+        char = ord(randfunc(1)) >> (8-odd_bits)
+        S = chr(char) + S
+    value = bytes_to_long(S)
+    value |= 2L ** (N-1)                # Ensure high bit is set
+    assert size(value) >= N
+    return value
+
+def GCD(x,y):
+    """GCD(x:long, y:long): long
+    Return the GCD of x and y.
+    """
+    x = abs(x) ; y = abs(y)
+    while x > 0:
+        x, y = y % x, x
+    return y
+
+def inverse(u, v):
+    """inverse(u:long, u:long):long
+    Return the inverse of u mod v.
+    """
+    u3, v3 = long(u), long(v)
+    u1, v1 = 1L, 0L
+    while v3 > 0:
+        q=u3 / v3
+        u1, v1 = v1, u1 - v1*q
+        u3, v3 = v3, u3 - v3*q
+    while u1<0:
+        u1 = u1 + v
+    return u1
+
+# Given a number of bits to generate and a random generation function,
+# find a prime number of the appropriate size.
+
+def getPrime(N, randfunc):
+    """getPrime(N:int, randfunc:callable):long
+    Return a random N-bit prime number.
+    """
+
+    number=getRandomNumber(N, randfunc) | 1
+    while (not isPrime(number)):
+        number=number+2
+    return number
+
+def isPrime(N):
+    """isPrime(N:long):bool
+    Return true if N is prime.
+    """
+    if N == 1:
+        return 0
+    if N in sieve:
+        return 1
+    for i in sieve:
+        if (N % i)==0:
+            return 0
+
+    # Use the accelerator if available
+    if _fastmath is not None:
+        return _fastmath.isPrime(N)
+
+    # Compute the highest bit that's set in N
+    N1 = N - 1L
+    n = 1L
+    while (n<N):
+        n=n<<1L
+    n = n >> 1L
+
+    # Rabin-Miller test
+    for c in sieve[:7]:
+        a=long(c) ; d=1L ; t=n
+        while (t):  # Iterate over the bits in N1
+            x=(d*d) % N
+            if x==1L and d!=1L and d!=N1:
+                return 0  # Square root of 1 found
+            if N1 & t:
+                d=(x*a) % N
+            else:
+                d=x
+            t = t >> 1L
+        if d!=1L:
+            return 0
+    return 1
+
+# Small primes used for checking primality; these are all the primes
+# less than 256.  This should be enough to eliminate most of the odd
+# numbers before needing to do a Rabin-Miller test at all.
+
+sieve=[2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59,
+       61, 67, 71, 73, 79, 83, 89, 97, 101, 103, 107, 109, 113, 127,
+       131, 137, 139, 149, 151, 157, 163, 167, 173, 179, 181, 191, 193,
+       197, 199, 211, 223, 227, 229, 233, 239, 241, 251]
+
+# Improved conversion functions contributed by Barry Warsaw, after
+# careful benchmarking
+
+import struct
+
+def long_to_bytes(n, blocksize=0):
+    """long_to_bytes(n:long, blocksize:int) : string
+    Convert a long integer to a byte string.
+
+    If optional blocksize is given and greater than zero, pad the front of the
+    byte string with binary zeros so that the length is a multiple of
+    blocksize.
+    """
+    # after much testing, this algorithm was deemed to be the fastest
+    s = ''
+    n = long(n)
+    pack = struct.pack
+    while n > 0:
+        s = pack('>I', n & 0xffffffffL) + s
+        n = n >> 32
+    # strip off leading zeros
+    for i in range(len(s)):
+        if s[i] != '\000':
+            break
+    else:
+        # only happens when n == 0
+        s = '\000'
+        i = 0
+    s = s[i:]
+    # add back some pad bytes.  this could be done more efficiently w.r.t. the
+    # de-padding being done above, but sigh...
+    if blocksize > 0 and len(s) % blocksize:
+        s = (blocksize - len(s) % blocksize) * '\000' + s
+    return s
+
+def bytes_to_long(s):
+    """bytes_to_long(string) : long
+    Convert a byte string to a long integer.
+
+    This is (essentially) the inverse of long_to_bytes().
+    """
+    acc = 0L
+    unpack = struct.unpack
+    length = len(s)
+    if length % 4:
+        extra = (4 - length % 4)
+        s = '\000' * extra + s
+        length = length + extra
+    for i in range(0, length, 4):
+        acc = (acc << 32) + unpack('>I', s[i:i+4])[0]
+    return acc
+
+# For backwards compatibility...
+import warnings
+def long2str(n, blocksize=0):
+    warnings.warn("long2str() has been replaced by long_to_bytes()")
+    return long_to_bytes(n, blocksize)
+def str2long(s):
+    warnings.warn("str2long() has been replaced by bytes_to_long()")
+    return bytes_to_long(s)

python/gdata/Crypto/Util/randpool.py

@@ -0,0 +1,421 @@
+#
+#  randpool.py : Cryptographically strong random number generation
+#
+# Part of the Python Cryptography Toolkit
+#
+# Distribute and use freely; there are no restrictions on further
+# dissemination and usage except those imposed by the laws of your
+# country of residence.  This software is provided "as is" without
+# warranty of fitness for use or suitability for any purpose, express
+# or implied. Use at your own risk or not at all.
+#
+
+__revision__ = "$Id: randpool.py,v 1.14 2004/05/06 12:56:54 akuchling Exp $"
+
+import time, array, types, warnings, os.path
+from Crypto.Util.number import long_to_bytes
+try:
+    import Crypto.Util.winrandom as winrandom
+except:
+    winrandom = None
+
+STIRNUM = 3
+
+class RandomPool:
+    """randpool.py : Cryptographically strong random number generation.
+
+    The implementation here is similar to the one in PGP.  To be
+    cryptographically strong, it must be difficult to determine the RNG's
+    output, whether in the future or the past.  This is done by using
+    a cryptographic hash function to "stir" the random data.
+
+    Entropy is gathered in the same fashion as PGP; the highest-resolution
+    clock around is read and the data is added to the random number pool.
+    A conservative estimate of the entropy is then kept.
+
+    If a cryptographically secure random source is available (/dev/urandom
+    on many Unixes, Windows CryptGenRandom on most Windows), then use
+    it.
+
+    Instance Attributes:
+    bits : int
+      Maximum size of pool in bits
+    bytes : int
+      Maximum size of pool in bytes
+    entropy : int
+      Number of bits of entropy in this pool.
+
+    Methods:
+    add_event([s]) : add some entropy to the pool
+    get_bytes(int) : get N bytes of random data
+    randomize([N]) : get N bytes of randomness from external source
+    """
+
+
+    def __init__(self, numbytes = 160, cipher=None, hash=None):
+        if hash is None:
+            from Crypto.Hash import SHA as hash
+
+        # The cipher argument is vestigial; it was removed from
+        # version 1.1 so RandomPool would work even in the limited
+        # exportable subset of the code
+        if cipher is not None:
+            warnings.warn("'cipher' parameter is no longer used")
+
+        if isinstance(hash, types.StringType):
+            # ugly hack to force __import__ to give us the end-path module
+            hash = __import__('Crypto.Hash.'+hash,
+                              None, None, ['new'])
+            warnings.warn("'hash' parameter should now be a hashing module")
+
+        self.bytes = numbytes
+        self.bits = self.bytes*8
+        self.entropy = 0
+        self._hash = hash
+
+        # Construct an array to hold the random pool,
+        # initializing it to 0.
+        self._randpool = array.array('B', [0]*self.bytes)
+
+        self._event1 = self._event2 = 0
+        self._addPos = 0
+        self._getPos = hash.digest_size
+        self._lastcounter=time.time()
+        self.__counter = 0
+
+        self._measureTickSize()        # Estimate timer resolution
+        self._randomize()
+
+    def _updateEntropyEstimate(self, nbits):
+        self.entropy += nbits
+        if self.entropy < 0:
+            self.entropy = 0
+        elif self.entropy > self.bits:
+            self.entropy = self.bits
+
+    def _randomize(self, N = 0, devname = '/dev/urandom'):
+        """_randomize(N, DEVNAME:device-filepath)
+        collects N bits of randomness from some entropy source (e.g.,
+        /dev/urandom on Unixes that have it, Windows CryptoAPI
+        CryptGenRandom, etc)
+        DEVNAME is optional, defaults to /dev/urandom.  You can change it
+        to /dev/random if you want to block till you get enough
+        entropy.
+        """
+        data = ''
+        if N <= 0:
+            nbytes = int((self.bits - self.entropy)/8+0.5)
+        else:
+            nbytes = int(N/8+0.5)
+        if winrandom:
+            # Windows CryptGenRandom provides random data.
+            data = winrandom.new().get_bytes(nbytes)
+        elif os.path.exists(devname):
+            # Many OSes support a /dev/urandom device
+            try:
+                f=open(devname)
+                data=f.read(nbytes)
+                f.close()
+            except IOError, (num, msg):
+                if num!=2: raise IOError, (num, msg)
+                # If the file wasn't found, ignore the error
+        if data:
+            self._addBytes(data)
+            # Entropy estimate: The number of bits of
+            # data obtained from the random source.
+            self._updateEntropyEstimate(8*len(data))
+        self.stir_n()                   # Wash the random pool
+
+    def randomize(self, N=0):
+        """randomize(N:int)
+        use the class entropy source to get some entropy data.
+        This is overridden by KeyboardRandomize().
+        """
+        return self._randomize(N)
+
+    def stir_n(self, N = STIRNUM):
+        """stir_n(N)
+        stirs the random pool N times
+        """
+        for i in xrange(N):
+            self.stir()
+
+    def stir (self, s = ''):
+        """stir(s:string)
+        Mix up the randomness pool.  This will call add_event() twice,
+        but out of paranoia the entropy attribute will not be
+        increased.  The optional 's' parameter is a string that will
+        be hashed with the randomness pool.
+        """
+
+        entropy=self.entropy            # Save inital entropy value
+        self.add_event()
+
+        # Loop over the randomness pool: hash its contents
+        # along with a counter, and add the resulting digest
+        # back into the pool.
+        for i in range(self.bytes / self._hash.digest_size):
+            h = self._hash.new(self._randpool)
+            h.update(str(self.__counter) + str(i) + str(self._addPos) + s)
+            self._addBytes( h.digest() )
+            self.__counter = (self.__counter + 1) & 0xFFFFffffL
+
+        self._addPos, self._getPos = 0, self._hash.digest_size
+        self.add_event()
+
+        # Restore the old value of the entropy.
+        self.entropy=entropy
+
+
+    def get_bytes (self, N):
+        """get_bytes(N:int) : string
+        Return N bytes of random data.
+        """
+
+        s=''
+        i, pool = self._getPos, self._randpool
+        h=self._hash.new()
+        dsize = self._hash.digest_size
+        num = N
+        while num > 0:
+            h.update( self._randpool[i:i+dsize] )
+            s = s + h.digest()
+            num = num - dsize
+            i = (i + dsize) % self.bytes
+            if i<dsize:
+                self.stir()
+                i=self._getPos
+
+        self._getPos = i
+        self._updateEntropyEstimate(- 8*N)
+        return s[:N]
+
+
+    def add_event(self, s=''):
+        """add_event(s:string)
+        Add an event to the random pool.  The current time is stored
+        between calls and used to estimate the entropy.  The optional
+        's' parameter is a string that will also be XORed into the pool.
+        Returns the estimated number of additional bits of entropy gain.
+        """
+        event = time.time()*1000
+        delta = self._noise()
+        s = (s + long_to_bytes(event) +
+             4*chr(0xaa) + long_to_bytes(delta) )
+        self._addBytes(s)
+        if event==self._event1 and event==self._event2:
+            # If events are coming too closely together, assume there's
+            # no effective entropy being added.
+            bits=0
+        else:
+            # Count the number of bits in delta, and assume that's the entropy.
+            bits=0
+            while delta:
+                delta, bits = delta>>1, bits+1
+            if bits>8: bits=8
+
+        self._event1, self._event2 = event, self._event1
+
+        self._updateEntropyEstimate(bits)
+        return bits
+
+    # Private functions
+    def _noise(self):
+        # Adds a bit of noise to the random pool, by adding in the
+        # current time and CPU usage of this process.
+        # The difference from the previous call to _noise() is taken
+        # in an effort to estimate the entropy.
+        t=time.time()
+        delta = (t - self._lastcounter)/self._ticksize*1e6
+        self._lastcounter = t
+        self._addBytes(long_to_bytes(long(1000*time.time())))
+        self._addBytes(long_to_bytes(long(1000*time.clock())))
+        self._addBytes(long_to_bytes(long(1000*time.time())))
+        self._addBytes(long_to_bytes(long(delta)))
+
+        # Reduce delta to a maximum of 8 bits so we don't add too much
+        # entropy as a result of this call.
+        delta=delta % 0xff
+        return int(delta)
+
+
+    def _measureTickSize(self):
+        # _measureTickSize() tries to estimate a rough average of the
+        # resolution of time that you can see from Python.  It does
+        # this by measuring the time 100 times, computing the delay
+        # between measurements, and taking the median of the resulting
+        # list.  (We also hash all the times and add them to the pool)
+        interval = [None] * 100
+        h = self._hash.new(`(id(self),id(interval))`)
+
+        # Compute 100 differences
+        t=time.time()
+        h.update(`t`)
+        i = 0
+        j = 0
+        while i < 100:
+            t2=time.time()
+            h.update(`(i,j,t2)`)
+            j += 1
+            delta=int((t2-t)*1e6)
+            if delta:
+                interval[i] = delta
+                i += 1
+                t=t2
+
+        # Take the median of the array of intervals
+        interval.sort()
+        self._ticksize=interval[len(interval)/2]
+        h.update(`(interval,self._ticksize)`)
+        # mix in the measurement times and wash the random pool
+        self.stir(h.digest())
+
+    def _addBytes(self, s):
+        "XOR the contents of the string S into the random pool"
+        i, pool = self._addPos, self._randpool
+        for j in range(0, len(s)):
+            pool[i]=pool[i] ^ ord(s[j])
+            i=(i+1) % self.bytes
+        self._addPos = i
+
+    # Deprecated method names: remove in PCT 2.1 or later.
+    def getBytes(self, N):
+        warnings.warn("getBytes() method replaced by get_bytes()",
+                      DeprecationWarning)
+        return self.get_bytes(N)
+
+    def addEvent (self, event, s=""):
+        warnings.warn("addEvent() method replaced by add_event()",
+                      DeprecationWarning)
+        return self.add_event(s + str(event))
+
+class PersistentRandomPool (RandomPool):
+    def __init__ (self, filename=None, *args, **kwargs):
+        RandomPool.__init__(self, *args, **kwargs)
+        self.filename = filename
+        if filename:
+            try:
+                # the time taken to open and read the file might have
+                # a little disk variability, modulo disk/kernel caching...
+                f=open(filename, 'rb')
+                self.add_event()
+                data = f.read()
+                self.add_event()
+                # mix in the data from the file and wash the random pool
+                self.stir(data)
+                f.close()
+            except IOError:
+                # Oh, well; the file doesn't exist or is unreadable, so
+                # we'll just ignore it.
+                pass
+
+    def save(self):
+        if self.filename == "":
+            raise ValueError, "No filename set for this object"
+        # wash the random pool before save, provides some forward secrecy for
+        # old values of the pool.
+        self.stir_n()
+        f=open(self.filename, 'wb')
+        self.add_event()
+        f.write(self._randpool.tostring())
+        f.close()
+        self.add_event()
+        # wash the pool again, provide some protection for future values
+        self.stir()
+
+# non-echoing Windows keyboard entry
+_kb = 0
+if not _kb:
+    try:
+        import msvcrt
+        class KeyboardEntry:
+            def getch(self):
+                c = msvcrt.getch()
+                if c in ('\000', '\xe0'):
+                    # function key
+                    c += msvcrt.getch()
+                return c
+            def close(self, delay = 0):
+                if delay:
+                    time.sleep(delay)
+                    while msvcrt.kbhit():
+                        msvcrt.getch()
+        _kb = 1
+    except:
+        pass
+
+# non-echoing Posix keyboard entry
+if not _kb:
+    try:
+        import termios
+        class KeyboardEntry:
+            def __init__(self, fd = 0):
+                self._fd = fd
+                self._old = termios.tcgetattr(fd)
+                new = termios.tcgetattr(fd)
+                new[3]=new[3] & ~termios.ICANON & ~termios.ECHO
+                termios.tcsetattr(fd, termios.TCSANOW, new)
+            def getch(self):
+                termios.tcflush(0, termios.TCIFLUSH) # XXX Leave this in?
+                return os.read(self._fd, 1)
+            def close(self, delay = 0):
+                if delay:
+                    time.sleep(delay)
+                    termios.tcflush(self._fd, termios.TCIFLUSH)
+                termios.tcsetattr(self._fd, termios.TCSAFLUSH, self._old)
+        _kb = 1
+    except:
+        pass
+
+class KeyboardRandomPool (PersistentRandomPool):
+    def __init__(self, *args, **kwargs):
+        PersistentRandomPool.__init__(self, *args, **kwargs)
+
+    def randomize(self, N = 0):
+        "Adds N bits of entropy to random pool.  If N is 0, fill up pool."
+        import os, string, time
+        if N <= 0:
+            bits = self.bits - self.entropy
+        else:
+            bits = N*8
+        if bits == 0:
+            return
+        print bits,'bits of entropy are now required.  Please type on the keyboard'
+        print 'until enough randomness has been accumulated.'
+        kb = KeyboardEntry()
+        s=''    # We'll save the characters typed and add them to the pool.
+        hash = self._hash
+        e = 0
+        try:
+            while e < bits:
+                temp=str(bits-e).rjust(6)
+                os.write(1, temp)
+                s=s+kb.getch()
+                e += self.add_event(s)
+                os.write(1, 6*chr(8))
+            self.add_event(s+hash.new(s).digest() )
+        finally:
+            kb.close()
+        print '\n\007 Enough.  Please wait a moment.\n'
+        self.stir_n()   # wash the random pool.
+        kb.close(4)
+
+if __name__ == '__main__':
+    pool = RandomPool()
+    print 'random pool entropy', pool.entropy, 'bits'
+    pool.add_event('something')
+    print `pool.get_bytes(100)`
+    import tempfile, os
+    fname = tempfile.mktemp()
+    pool = KeyboardRandomPool(filename=fname)
+    print 'keyboard random pool entropy', pool.entropy, 'bits'
+    pool.randomize()
+    print 'keyboard random pool entropy', pool.entropy, 'bits'
+    pool.randomize(128)
+    pool.save()
+    saved = open(fname, 'rb').read()
+    print 'saved', `saved`
+    print 'pool ', `pool._randpool.tostring()`
+    newpool = PersistentRandomPool(fname)
+    print 'persistent random pool entropy', pool.entropy, 'bits'
+    os.remove(fname)

python/gdata/Crypto/Util/test.py

@@ -0,0 +1,453 @@
+#
+#   test.py : Functions used for testing the modules
+#
+#  Part of the Python Cryptography Toolkit
+#
+# Distribute and use freely; there are no restrictions on further
+# dissemination and usage except those imposed by the laws of your
+# country of residence.  This software is provided "as is" without
+# warranty of fitness for use or suitability for any purpose, express
+# or implied. Use at your own risk or not at all.
+#
+
+__revision__ = "$Id: test.py,v 1.16 2004/08/13 22:24:18 akuchling Exp $"
+
+import binascii
+import string
+import testdata
+
+from Crypto.Cipher import *
+
+def die(string):
+    import sys
+    print '***ERROR: ', string
+#    sys.exit(0)   # Will default to continuing onward...
+
+def print_timing (size, delta, verbose):
+    if verbose:
+        if delta == 0:
+            print 'Unable to measure time -- elapsed time too small'
+        else:
+            print '%.2f K/sec' % (size/delta)
+            
+def exerciseBlockCipher(cipher, verbose):
+    import string, time
+    try:
+        ciph = eval(cipher)
+    except NameError:
+        print cipher, 'module not available'
+        return None
+    print cipher+ ':'
+    str='1'                             # Build 128K of test data
+    for i in xrange(0, 17):
+        str=str+str
+    if ciph.key_size==0: ciph.key_size=16
+    password = 'password12345678Extra text for password'[0:ciph.key_size]
+    IV = 'Test IV Test IV Test IV Test'[0:ciph.block_size]
+
+    if verbose: print '  ECB mode:',
+    obj=ciph.new(password, ciph.MODE_ECB)
+    if obj.block_size != ciph.block_size:
+        die("Module and cipher object block_size don't match")
+
+    text='1234567812345678'[0:ciph.block_size]
+    c=obj.encrypt(text)
+    if (obj.decrypt(c)!=text): die('Error encrypting "'+text+'"')
+    text='KuchlingKuchling'[0:ciph.block_size]
+    c=obj.encrypt(text)
+    if (obj.decrypt(c)!=text): die('Error encrypting "'+text+'"')
+    text='NotTodayNotEver!'[0:ciph.block_size]
+    c=obj.encrypt(text)
+    if (obj.decrypt(c)!=text): die('Error encrypting "'+text+'"')
+
+    start=time.time()
+    s=obj.encrypt(str)
+    s2=obj.decrypt(s)
+    end=time.time()
+    if (str!=s2):
+        die('Error in resulting plaintext from ECB mode')
+    print_timing(256, end-start, verbose)
+    del obj
+
+    if verbose: print '  CFB mode:',
+    obj1=ciph.new(password, ciph.MODE_CFB, IV)
+    obj2=ciph.new(password, ciph.MODE_CFB, IV)
+    start=time.time()
+    ciphertext=obj1.encrypt(str[0:65536])
+    plaintext=obj2.decrypt(ciphertext)
+    end=time.time()
+    if (plaintext!=str[0:65536]):
+        die('Error in resulting plaintext from CFB mode')
+    print_timing(64, end-start, verbose)
+    del obj1, obj2
+
+    if verbose: print '  CBC mode:',
+    obj1=ciph.new(password, ciph.MODE_CBC, IV)
+    obj2=ciph.new(password, ciph.MODE_CBC, IV)
+    start=time.time()
+    ciphertext=obj1.encrypt(str)
+    plaintext=obj2.decrypt(ciphertext)
+    end=time.time()
+    if (plaintext!=str):
+        die('Error in resulting plaintext from CBC mode')
+    print_timing(256, end-start, verbose)
+    del obj1, obj2
+
+    if verbose: print '  PGP mode:',
+    obj1=ciph.new(password, ciph.MODE_PGP, IV)
+    obj2=ciph.new(password, ciph.MODE_PGP, IV)
+    start=time.time()
+    ciphertext=obj1.encrypt(str)
+    plaintext=obj2.decrypt(ciphertext)
+    end=time.time()
+    if (plaintext!=str):
+        die('Error in resulting plaintext from PGP mode')
+    print_timing(256, end-start, verbose)
+    del obj1, obj2
+
+    if verbose: print '  OFB mode:',
+    obj1=ciph.new(password, ciph.MODE_OFB, IV)
+    obj2=ciph.new(password, ciph.MODE_OFB, IV)
+    start=time.time()
+    ciphertext=obj1.encrypt(str)
+    plaintext=obj2.decrypt(ciphertext)
+    end=time.time()
+    if (plaintext!=str):
+        die('Error in resulting plaintext from OFB mode')
+    print_timing(256, end-start, verbose)
+    del obj1, obj2
+
+    def counter(length=ciph.block_size):
+        return length * 'a'
+
+    if verbose: print '  CTR mode:',
+    obj1=ciph.new(password, ciph.MODE_CTR, counter=counter)
+    obj2=ciph.new(password, ciph.MODE_CTR, counter=counter)
+    start=time.time()
+    ciphertext=obj1.encrypt(str)
+    plaintext=obj2.decrypt(ciphertext)
+    end=time.time()
+    if (plaintext!=str):
+        die('Error in resulting plaintext from CTR mode')
+    print_timing(256, end-start, verbose)
+    del obj1, obj2
+
+    # Test the IV handling
+    if verbose: print '  Testing IV handling'
+    obj1=ciph.new(password, ciph.MODE_CBC, IV)
+    plaintext='Test'*(ciph.block_size/4)*3
+    ciphertext1=obj1.encrypt(plaintext)
+    obj1.IV=IV
+    ciphertext2=obj1.encrypt(plaintext)
+    if ciphertext1!=ciphertext2:
+        die('Error in setting IV')
+
+    # Test keyword arguments
+    obj1=ciph.new(key=password)
+    obj1=ciph.new(password, mode=ciph.MODE_CBC)
+    obj1=ciph.new(mode=ciph.MODE_CBC, key=password)
+    obj1=ciph.new(IV=IV, mode=ciph.MODE_CBC, key=password)
+
+    return ciph
+
+def exerciseStreamCipher(cipher, verbose):
+    import string, time
+    try:
+        ciph = eval(cipher)
+    except (NameError):
+        print cipher, 'module not available'
+        return None
+    print cipher + ':',
+    str='1'                             # Build 128K of test data
+    for i in xrange(0, 17):
+        str=str+str
+    key_size = ciph.key_size or 16
+    password = 'password12345678Extra text for password'[0:key_size]
+
+    obj1=ciph.new(password)
+    obj2=ciph.new(password)
+    if obj1.block_size != ciph.block_size:
+        die("Module and cipher object block_size don't match")
+    if obj1.key_size != ciph.key_size:
+        die("Module and cipher object key_size don't match")
+
+    text='1234567812345678Python'
+    c=obj1.encrypt(text)
+    if (obj2.decrypt(c)!=text): die('Error encrypting "'+text+'"')
+    text='B1FF I2 A R3A11Y |<00L D00D!!!!!'
+    c=obj1.encrypt(text)
+    if (obj2.decrypt(c)!=text): die('Error encrypting "'+text+'"')
+    text='SpamSpamSpamSpamSpamSpamSpamSpamSpam'
+    c=obj1.encrypt(text)
+    if (obj2.decrypt(c)!=text): die('Error encrypting "'+text+'"')
+
+    start=time.time()
+    s=obj1.encrypt(str)
+    str=obj2.decrypt(s)
+    end=time.time()
+    print_timing(256, end-start, verbose)
+    del obj1, obj2
+
+    return ciph
+
+def TestStreamModules(args=['arc4', 'XOR'], verbose=1):
+    import sys, string
+    args=map(string.lower, args)
+
+    if 'arc4' in args:
+        # Test ARC4 stream cipher
+        arc4=exerciseStreamCipher('ARC4', verbose)
+        if (arc4!=None):
+                for entry in testdata.arc4:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=arc4.new(key)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('ARC4 failed on entry '+`entry`)
+
+    if 'xor' in args:
+        # Test XOR stream cipher
+        XOR=exerciseStreamCipher('XOR', verbose)
+        if (XOR!=None):
+                for entry in testdata.xor:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=XOR.new(key)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('XOR failed on entry '+`entry`)
+
+
+def TestBlockModules(args=['aes', 'arc2', 'des', 'blowfish', 'cast', 'des3',
+                           'idea', 'rc5'],
+                     verbose=1):
+    import string
+    args=map(string.lower, args)
+    if 'aes' in args:
+        ciph=exerciseBlockCipher('AES', verbose)        # AES
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.aes:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, ciph.MODE_ECB)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('AES failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+
+                for entry in testdata.aes_modes:
+                    mode, key, plain, cipher, kw = entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, mode, **kw)
+                    obj2=ciph.new(key, mode, **kw)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('AES encrypt failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+
+                    plain2=obj2.decrypt(ciphertext)
+                    if plain2!=plain:
+                        die('AES decrypt failed on entry '+`entry`)
+                        for i in plain2:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+
+
+    if 'arc2' in args:
+        ciph=exerciseBlockCipher('ARC2', verbose)           # Alleged RC2
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.arc2:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, ciph.MODE_ECB)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('ARC2 failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        print
+
+    if 'blowfish' in args:
+        ciph=exerciseBlockCipher('Blowfish',verbose)# Bruce Schneier's Blowfish cipher
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.blowfish:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, ciph.MODE_ECB)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('Blowfish failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+
+    if 'cast' in args:
+        ciph=exerciseBlockCipher('CAST', verbose)        # CAST-128
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.cast:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, ciph.MODE_ECB)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('CAST failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+
+                if 0:
+                    # The full-maintenance test; it requires 4 million encryptions,
+                    # and correspondingly is quite time-consuming.  I've disabled
+                    # it; it's faster to compile block/cast.c with -DTEST and run
+                    # the resulting program.
+                    a = b = '\x01\x23\x45\x67\x12\x34\x56\x78\x23\x45\x67\x89\x34\x56\x78\x9A'
+
+                    for i in range(0, 1000000):
+                        obj = cast.new(b, cast.MODE_ECB)
+                        a = obj.encrypt(a[:8]) + obj.encrypt(a[-8:])
+                        obj = cast.new(a, cast.MODE_ECB)
+                        b = obj.encrypt(b[:8]) + obj.encrypt(b[-8:])
+
+                    if a!="\xEE\xA9\xD0\xA2\x49\xFD\x3B\xA6\xB3\x43\x6F\xB8\x9D\x6D\xCA\x92":
+                        if verbose: print 'CAST test failed: value of "a" doesn\'t match'
+                    if b!="\xB2\xC9\x5E\xB0\x0C\x31\xAD\x71\x80\xAC\x05\xB8\xE8\x3D\x69\x6E":
+                        if verbose: print 'CAST test failed: value of "b" doesn\'t match'
+
+    if 'des' in args:
+        # Test/benchmark DES block cipher
+        des=exerciseBlockCipher('DES', verbose)
+        if (des!=None):
+            # Various tests taken from the DES library packaged with Kerberos V4
+            obj=des.new(binascii.a2b_hex('0123456789abcdef'), des.MODE_ECB)
+            s=obj.encrypt('Now is t')
+            if (s!=binascii.a2b_hex('3fa40e8a984d4815')):
+                die('DES fails test 1')
+            obj=des.new(binascii.a2b_hex('08192a3b4c5d6e7f'), des.MODE_ECB)
+            s=obj.encrypt('\000\000\000\000\000\000\000\000')
+            if (s!=binascii.a2b_hex('25ddac3e96176467')):
+                die('DES fails test 2')
+            obj=des.new(binascii.a2b_hex('0123456789abcdef'), des.MODE_CBC,
+                        binascii.a2b_hex('1234567890abcdef'))
+            s=obj.encrypt("Now is the time for all ")
+            if (s!=binascii.a2b_hex('e5c7cdde872bf27c43e934008c389c0f683788499a7c05f6')):
+                die('DES fails test 3')
+            obj=des.new(binascii.a2b_hex('0123456789abcdef'), des.MODE_CBC,
+                        binascii.a2b_hex('fedcba9876543210'))
+            s=obj.encrypt("7654321 Now is the time for \000\000\000\000")
+            if (s!=binascii.a2b_hex("ccd173ffab2039f4acd8aefddfd8a1eb468e91157888ba681d269397f7fe62b4")):
+                die('DES fails test 4')
+            del obj,s
+
+            # R. Rivest's test: see http://theory.lcs.mit.edu/~rivest/destest.txt
+            x=binascii.a2b_hex('9474B8E8C73BCA7D')
+            for i in range(0, 16):
+                obj=des.new(x, des.MODE_ECB)
+                if (i & 1): x=obj.decrypt(x)
+                else: x=obj.encrypt(x)
+            if x!=binascii.a2b_hex('1B1A2DDB4C642438'):
+                die("DES fails Rivest's test")
+
+            if verbose: print '  Verifying against test suite...'
+            for entry in testdata.des:
+                key,plain,cipher=entry
+                key=binascii.a2b_hex(key)
+                plain=binascii.a2b_hex(plain)
+                cipher=binascii.a2b_hex(cipher)
+                obj=des.new(key, des.MODE_ECB)
+                ciphertext=obj.encrypt(plain)
+                if (ciphertext!=cipher):
+                    die('DES failed on entry '+`entry`)
+            for entry in testdata.des_cbc:
+                key, iv, plain, cipher=entry
+                key, iv, cipher=binascii.a2b_hex(key),binascii.a2b_hex(iv),binascii.a2b_hex(cipher)
+                obj1=des.new(key, des.MODE_CBC, iv)
+                obj2=des.new(key, des.MODE_CBC, iv)
+                ciphertext=obj1.encrypt(plain)
+                if (ciphertext!=cipher):
+                    die('DES CBC mode failed on entry '+`entry`)
+
+    if 'des3' in args:
+        ciph=exerciseBlockCipher('DES3', verbose)        # Triple DES
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.des3:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, ciph.MODE_ECB)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('DES3 failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+                for entry in testdata.des3_cbc:
+                    key, iv, plain, cipher=entry
+                    key, iv, cipher=binascii.a2b_hex(key),binascii.a2b_hex(iv),binascii.a2b_hex(cipher)
+                    obj1=ciph.new(key, ciph.MODE_CBC, iv)
+                    obj2=ciph.new(key, ciph.MODE_CBC, iv)
+                    ciphertext=obj1.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('DES3 CBC mode failed on entry '+`entry`)
+
+    if 'idea' in args:
+        ciph=exerciseBlockCipher('IDEA', verbose)       # IDEA block cipher
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.idea:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key, ciph.MODE_ECB)
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('IDEA failed on entry '+`entry`)
+
+    if 'rc5' in args:
+        # Ronald Rivest's RC5 algorithm
+        ciph=exerciseBlockCipher('RC5', verbose)
+        if (ciph!=None):
+                if verbose: print '  Verifying against test suite...'
+                for entry in testdata.rc5:
+                    key,plain,cipher=entry
+                    key=binascii.a2b_hex(key)
+                    plain=binascii.a2b_hex(plain)
+                    cipher=binascii.a2b_hex(cipher)
+                    obj=ciph.new(key[4:], ciph.MODE_ECB,
+                                 version =ord(key[0]),
+                                 word_size=ord(key[1]),
+                                 rounds  =ord(key[2]) )
+                    ciphertext=obj.encrypt(plain)
+                    if (ciphertext!=cipher):
+                        die('RC5 failed on entry '+`entry`)
+                        for i in ciphertext:
+                            if verbose: print hex(ord(i)),
+                        if verbose: print
+
+
+