/gdata/Crypto/Util/test.py

#
#   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