tests.py

#!/usr/bin/env python
'''
    Copyright 2009 Slide, Inc.

'''
import copy
import gc
import sys
import types
import unittest

import pyecc

#
# These values are built by running the seccure binary 
# and assume the curve of DEFAULT_CURVE (currently p384)
#
DEFAULT_DATA = 'This message will be signed\n'
DEFAULT_SIG = '#cE/UfJ@]qte8w-ajzi%S%tO<?$?@QK_hTL&pk-ES1L~C9~4lpm+P7ZXu[mXTJ:%tdhQa:z~~q)BAw{.3dvt!ub+s?sXyxk;S%&+^P-~%}+G3G?Oj-nSDc/'
DEFAULT_PUBKEY = '#&M=6cSQ}m6C(hUz-7j@E=>oS#TL3F[F[a[q9S;RhMh+F#gP|Q6R}lhT_e7b'
DEFAULT_PRIVKEY = '!!![t{l5N^uZd=Bg(P#N|PH#IN8I0,Jq/PvdVNi^PxR,(5~p-o[^hPE#40.<|'
DEFAULT_PLAINTEXT = 'This is a very very secret message!\n'
LOOPS = 100

class ECC_KeyGen_Tests(unittest.TestCase):
    def test_GenerateBoth(self):
        ecc = pyecc.ECC.generate()
        print ('private', 'public', ecc._private, len(ecc._private), 
                ecc._public, len(ecc._public))

        encrypted = ecc.encrypt(DEFAULT_PLAINTEXT)
        assert encrypted, ('Failed to encrypt?', encrypted, ecc)

        decrypted = ecc.decrypt(encrypted)
        assert decrypted, ('Failed to decrypt?', decrypted, ecc)
        
        assert decrypted == DEFAULT_PLAINTEXT, ('Decrypted wrong',
            decrypted, DEFAULT_PLAINTEXT)

class ECC_Verify_Tests(unittest.TestCase):
    def setUp(self):
        super(ECC_Verify_Tests, self).setUp()
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY, private=DEFAULT_PRIVKEY)

    def test_BasicVerification(self):
        assert self.ecc.verify(DEFAULT_DATA, DEFAULT_SIG), ('Failed to verify signature',
                DEFAULT_DATA, DEFAULT_SIG, DEFAULT_PUBKEY, DEFAULT_PRIVKEY)

    def test_BadVerification(self):
        assert self.ecc.verify(DEFAULT_DATA, "FAIL") == False , ('Verified on a bad sig',
                DEFAULT_DATA, DEFAULT_SIG, DEFAULT_PUBKEY, DEFAULT_PRIVKEY)

class ECC_Sign_Tests(unittest.TestCase):
    def setUp(self):
        super(ECC_Sign_Tests, self).setUp()
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY, private=DEFAULT_PRIVKEY)

    def test_BasicSign(self):
        signature = self.ecc.sign(DEFAULT_DATA)

        assert signature == DEFAULT_SIG, ('Failed to generate a legit signature',
                DEFAULT_SIG, signature)

    def test_SignNone(self):
        signature = self.ecc.sign(None)

        assert signature == None, ('Should have a None sig')

class ECC_Encrypt_Tests(unittest.TestCase):
    def setUp(self):
        super(ECC_Encrypt_Tests, self).setUp()
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY)

    def test_BasicEncrypt(self):
        encrypted = self.ecc.encrypt(DEFAULT_PLAINTEXT)
        assert encrypted

        # Resetup self.ecc with a private key so I can decrypt
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY, private=DEFAULT_PRIVKEY)
        decrypted = self.ecc.decrypt(encrypted)
        assert decrypted == DEFAULT_PLAINTEXT

class ECC_Decrypt_Tests(unittest.TestCase):
    def setUp(self):
        super(ECC_Decrypt_Tests, self).setUp()
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY, private=DEFAULT_PRIVKEY)

    def test_BasicDecrypt(self):
        encrypted = "\x01\xa9\xc0\x1a\x03\\h\xd8\xea,\x8f\xd6\x91W\x8d\xe74x:\x1d\xa8 \xee\x0eD\xfe\xb6\xb0P\x04\xbf\xd5=\xf1?\x00\x9cDw\xae\x0b\xc3\x05BuX\xf1\x9a\x05f\x81\xd1\x15\x8c\x80Q\xa6\xf9\xd7\xf0\x8e\x99\xf2\x11<t\xff\x92\x14\x1c%0W\x8e\x8f\n\n\x9ed\xf8\xff\xc7p\r\x03\xbbw|\xb1h\xc9\xbd+\x02\x87"
        decrypted = self.ecc.decrypt(encrypted)
        assert decrypted  == DEFAULT_PLAINTEXT

class ECC_Fail(unittest.TestCase):
    def setUp(self):
        super(ECC_Fail, self).setUp()
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY, private=DEFAULT_PRIVKEY)

    def test_EncryptNullByte(self):
        rc = self.ecc.encrypt('\x00')
        assert rc, (rc, 'Fail')

    def test_EmptyString(self):
        self.failUnlessRaises(TypeError, self.ecc.encrypt, '')

class ECC_GC_Checks(unittest.TestCase):
    def setUp(self):
        super(ECC_GC_Checks, self).setUp()
        self.ecc = pyecc.ECC(public=DEFAULT_PUBKEY, private=DEFAULT_PRIVKEY)

    def test_Encrypts(self):
        objects = None
        for i in xrange(LOOPS):
            encrypted = self.ecc.encrypt(DEFAULT_PLAINTEXT)
            assert encrypted

            l = len(gc.get_objects())
            if objects:
                assert objects == l, (l, objects, 'Count is off')
            objects = l

if __name__ == '__main__':
    suites = []
    items = copy.copy(locals())
    for k, v in items.iteritems():
        if isinstance(v, types.TypeType) and issubclass(v, unittest.TestCase):
            suites.append(unittest.makeSuite(v))

    runner = unittest.TextTestRunner()
    if 'xml' in sys.argv:
        import xmlrunner
        runner = xmlrunner.XMLTestRunner(filename='Pyecc.pytests.xml')

    results = runner.run(unittest.TestSuite(suites))