Imported Upstream version 0.7.1

17 files changed, 376 insertions, 58 deletions

diff --git a/src/pycryptopp/_version.py b/src/pycryptopp/_version.py
deleted file mode 100644
index c5c437f..0000000
--- a/src/pycryptopp/_version.py
+++ /dev/null
@@ -1,8 +0,0 @@
-
-# This is the version of this tree, as created by pycryptopp's setup.py from the
-# git information: the main version number is taken from the most recent
-# release tag. If some patches have been added since the last release, this
-# will have a -NN "build number" suffix, followed by -gXXX "revid" suffix.
-
-__pkgname__ = "pycryptopp"
-__version__ = "0.6.0.1206569328141510525648634803928199668821045408958"
diff --git a/src/pycryptopp/bench/__init__.py b/src/pycryptopp/bench/__init__.py
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/src/pycryptopp/bench/__init__.py
diff --git a/src/pycryptopp/bench/bench_algs.py b/src/pycryptopp/bench/bench_algs.py
new file mode 100644
index 0000000..a896d2b
--- /dev/null
+++ b/src/pycryptopp/bench/bench_algs.py
@@ -0,0 +1,9 @@
+import bench_sigs, bench_ciphers, bench_hashes
+
+def bench(MAXTIME=10.0):
+    bench_sigs.bench(MAXTIME)
+    bench_ciphers.bench(MAXTIME)
+    bench_hashes.bench(MAXTIME)
+
+if __name__ == '__main__':
+    bench()
diff --git a/src/pycryptopp/bench/bench_ciphers.py b/src/pycryptopp/bench/bench_ciphers.py
new file mode 100644
index 0000000..bb9a160
--- /dev/null
+++ b/src/pycryptopp/bench/bench_ciphers.py
@@ -0,0 +1,45 @@
+from pycryptopp.cipher import aes, xsalsa20
+
+from common import insecurerandstr, rep_bench
+
+UNITS_PER_SECOND = 10**9
+
+class BenchCrypt(object):
+    def __init__(self, klass, keysize):
+        self.klass = klass
+        self.keysize = keysize
+
+    def __repr__(self):
+        return "<%s-%d>" % (self.klass.__name__, self.keysize*8)
+
+    def crypt_init(self, N):
+        self.msg = insecurerandstr(N)
+        self.key = insecurerandstr(self.keysize)
+
+    def crypt(self, N):
+        cryptor = self.klass(self.key)
+        cryptor.process(self.msg)
+        
+def bench_ciphers(MAXTIME):
+    for (klass, keysize) in [
+        (aes.AES, 16),
+        (aes.AES, 32),
+        (xsalsa20.XSalsa20, 32),
+        ]:
+        ob = BenchCrypt(klass, keysize)
+        print ob
+        for (legend, size) in [
+            ("large (%d B)",  10**7),
+            ]:
+            print legend % size
+            rep_bench(ob.crypt, size, UNITS_PER_SECOND=UNITS_PER_SECOND, MAXTIME=MAXTIME, MAXREPS=100, initfunc=ob.crypt_init)
+            print
+
+    print "nanoseconds per byte crypted"
+    print
+
+def bench(MAXTIME=10.0):
+    bench_ciphers(MAXTIME)
+
+if __name__ == '__main__':
+    bench()
diff --git a/src/pycryptopp/bench/bench_hashes.py b/src/pycryptopp/bench/bench_hashes.py
new file mode 100644
index 0000000..c681ff8
--- /dev/null
+++ b/src/pycryptopp/bench/bench_hashes.py
@@ -0,0 +1,52 @@
+from pycryptopp.hash import sha256
+
+from common import insecurerandstr, rep_bench
+
+UNITS_PER_SECOND = 10**9
+
+class SHA256(object):
+    def proc_init(self, N):
+        self.msg = insecurerandstr(N)
+
+    def proc(self, N):
+        h = sha256.SHA256()
+        h.update(self.msg)
+        h.digest()
+
+def generate_hash_benchers():
+    try:
+        import hashlib
+    except ImportError:
+        return [SHA256]
+    else:
+        class hashlibSHA256(object):
+            def proc_init(self, N):
+                self.msg = insecurerandstr(N)
+
+            def proc(self, N):
+                h = hashlib.sha256()
+                h.update(self.msg)
+                h.digest()
+                
+        return [SHA256, hashlibSHA256]
+    
+def bench_hashes(MAXTIME):
+    for klass in generate_hash_benchers():
+        print klass
+        ob = klass()
+        for (legend, size) in [
+            ("large (%d B)",  10**7),
+            ]:
+            print legend % size
+            rep_bench(ob.proc, size, UNITS_PER_SECOND=UNITS_PER_SECOND, MAXTIME=MAXTIME, MAXREPS=100, initfunc=ob.proc_init)
+            print
+
+    print "nanoseconds per byte hashed"
+    print
+
+
+def bench(MAXTIME=10.0):
+    bench_hashes(MAXTIME)
+
+if __name__ == '__main__':
+    bench()
diff --git a/src/pycryptopp/bench/bench_sigs.py b/src/pycryptopp/bench/bench_sigs.py
new file mode 100644
index 0000000..e0fe37b
--- /dev/null
+++ b/src/pycryptopp/bench/bench_sigs.py
@@ -0,0 +1,151 @@
+from pycryptopp.publickey import ecdsa, ed25519, rsa
+
+from common import insecurerandstr, rep_bench
+
+msg = 'crypto libraries should come with benchmarks'
+
+class ECDSA256(object):
+    def __init__(self):
+        self.seed = insecurerandstr(32)
+        self.signer = None
+
+    def gen(self, N):
+        for i in xrange(N):
+             ecdsa.SigningKey(self.seed)
+        
+    def sign_init(self, N):
+        self.signer = ecdsa.SigningKey(self.seed)
+        
+    def sign(self, N):
+        signer = self.signer
+        for i in xrange(N):
+            signer.sign(msg)
+        
+    def ver_init(self, N):
+        signer = ecdsa.SigningKey(self.seed)
+        self.sig = signer.sign(msg)
+        self.verifier = signer.get_verifying_key()
+        
+    def ver(self, N):
+        sig = self.sig
+        verifier = self.verifier
+        for i in xrange(N):
+            verifier.verify(sig, msg)
+        
+class Ed25519(object):
+    def __init__(self):
+        self.seed = insecurerandstr(32)
+        self.signer = None
+
+    def gen(self, N):
+        for i in xrange(N):
+             ed25519.SigningKey(self.seed)
+        
+    def sign_init(self, N):
+        self.signer = ed25519.SigningKey(self.seed)
+        
+    def sign(self, N):
+        signer = self.signer
+        for i in xrange(N):
+            signer.sign(msg)
+        
+    def ver_init(self, N):
+        signer = ed25519.SigningKey(self.seed)
+        self.sig = signer.sign(msg)
+        self.verifier = ed25519.VerifyingKey(signer.get_verifying_key_bytes())
+        
+    def ver(self, N):
+        sig = self.sig
+        verifier = self.verifier
+        for i in xrange(N):
+            verifier.verify(sig, msg)
+        
+class RSA2048(object):
+    SIZEINBITS=2048
+
+    def __init__(self):
+        self.signer = None
+
+    def gen(self, N):
+        for i in xrange(N):
+             rsa.generate(sizeinbits=self.SIZEINBITS)
+        
+    def sign_init(self, N):
+        self.signer = rsa.generate(sizeinbits=self.SIZEINBITS)
+        
+    def sign(self, N):
+        signer = self.signer
+        for i in xrange(N):
+            signer.sign(msg)
+        
+    def ver_init(self, N):
+        signer = rsa.generate(sizeinbits=self.SIZEINBITS)
+        self.sig = signer.sign(msg)
+        self.verifier = signer.get_verifying_key()
+        
+    def ver(self, N):
+        sig = self.sig
+        verifier = self.verifier
+        for i in xrange(N):
+            verifier.verify(msg, sig)
+        
+class RSA3248(object):
+    SIZEINBITS=3248
+
+    def __init__(self):
+        self.signer = None
+
+    def gen(self, N):
+        for i in xrange(N):
+             rsa.generate(sizeinbits=self.SIZEINBITS)
+        
+    def sign_init(self, N):
+        self.signer = rsa.generate(sizeinbits=self.SIZEINBITS)
+        
+    def sign(self, N):
+        signer = self.signer
+        for i in xrange(N):
+            signer.sign(msg)
+        
+    def ver_init(self, N):
+        signer = rsa.generate(sizeinbits=self.SIZEINBITS)
+        self.sig = signer.sign(msg)
+        self.verifier = signer.get_verifying_key()
+        
+    def ver(self, N):
+        sig = self.sig
+        verifier = self.verifier
+        for i in xrange(N):
+            verifier.verify(msg, sig)
+        
+def bench_sigs(MAXTIME):
+    for klass in [ECDSA256, Ed25519,]:
+        print klass
+        ob = klass()
+        print "generate key"
+        rep_bench(ob.gen, 1000, UNITS_PER_SECOND=1000, MAXTIME=MAXTIME, MAXREPS=100)
+        print "sign"
+        rep_bench(ob.sign, 1000, UNITS_PER_SECOND=1000, initfunc=ob.sign_init, MAXTIME=MAXTIME, MAXREPS=100)
+        print "verify"
+        rep_bench(ob.ver, 1000, UNITS_PER_SECOND=1000, initfunc=ob.ver_init, MAXTIME=MAXTIME, MAXREPS=100)
+        print
+
+    for klass in [RSA2048, RSA3248]:
+        print klass
+        ob = klass()
+        print "generate key"
+        rep_bench(ob.gen, 1, UNITS_PER_SECOND=1000, MAXTIME=MAXTIME, MAXREPS=100)
+        print "sign"
+        rep_bench(ob.sign, 1000, UNITS_PER_SECOND=1000, initfunc=ob.sign_init, MAXTIME=MAXTIME, MAXREPS=100)
+        print "verify"
+        rep_bench(ob.ver, 10000, UNITS_PER_SECOND=1000, initfunc=ob.ver_init, MAXTIME=MAXTIME, MAXREPS=100)
+        print
+
+    print "milliseconds per operation"
+    print
+
+def bench(MAXTIME=10.0):
+    bench_sigs(MAXTIME)
+
+if __name__ == '__main__':
+    bench()
diff --git a/src/pycryptopp/bench/common.py b/src/pycryptopp/bench/common.py
new file mode 100644
index 0000000..2d8f315
--- /dev/null
+++ b/src/pycryptopp/bench/common.py
@@ -0,0 +1,67 @@
+msg = "crypto libraries should come with benchmarks"
+
+try:
+    import pyutil.benchutil
+    rep_bench = pyutil.benchutil.rep_bench
+except (ImportError, AttributeError):
+    import platform, time
+    if 'windows' in platform.system().lower():
+        clock = time.clock
+    else:
+        clock = time.time
+
+    def this_rep_bench(func, N, UNITS_PER_SECOND, MAXTIME, MAXREPS, initfunc=None):
+        tt = time.time
+
+        if initfunc is not None:
+            initfunc(N)
+
+        meanc = 0
+        MAXREPS = 100
+
+        timeout = tt() + MAXTIME
+
+        for i in range(MAXREPS):
+            startc = clock()
+
+            func(N)
+
+            stopc = clock()
+
+            deltac = stopc - startc
+            if deltac <= 0:
+                print "clock jump backward or wrapped -- ignoring this sample. startc: %s, stopc: %s, deltac: %s" % (startc, stopc, deltac,)
+            else:
+                meanc += deltac
+
+            if time.time() >= timeout:
+                break
+
+        num = i+1
+        meanc *= UNITS_PER_SECOND
+        meanc /= num
+        meanc /= N
+
+        res = {
+            'meanc': meanc,
+            'num': num
+            }
+        print "mean: %(meanc)#8.03e (of %(num)6d)" % res
+    rep_bench = this_rep_bench
+
+import random as insecurerandom
+def insecurerandstr(n):
+    return ''.join(map(chr, map(insecurerandom.randrange, [0]*n, [256]*n)))
+
+def calib_clock():
+    interval = 1.0
+    
+    import time
+    tc = time.clock
+    tt = time.time
+
+    def measure_sleep(x, clock):
+        st = clock()
+        time.sleep(x)
+        
+    
diff --git a/src/pycryptopp/cipher/aesmodule.cpp b/src/pycryptopp/cipher/aesmodule.cpp
index 0599911..360827d 100644
--- a/src/pycryptopp/cipher/aesmodule.cpp
+++ b/src/pycryptopp/cipher/aesmodule.cpp
@@ -50,7 +50,7 @@ this:\n\
 Where 'masterkey' is a secret key used only for generating onetimekeys this\
 way, and 'nonce' is a value that is guaranteed to never repeat.\
 \n\
-@param key: the symmetric encryption key; a string of exactly 16 bytes\
+@param key: the symmetric encryption key; a string of exactly 16 or 32 bytes\
 ");
 
 static PyObject *
diff --git a/src/pycryptopp/publickey/ecdsamodule.cpp b/src/pycryptopp/publickey/ecdsamodule.cpp
index 1ec7eec..ab18a50 100644
--- a/src/pycryptopp/publickey/ecdsamodule.cpp
+++ b/src/pycryptopp/publickey/ecdsamodule.cpp
@@ -18,7 +18,7 @@
  * ECDSA(1363)/EMSA1(SHA-256) -- <a
  * href="http://www.weidai.com/scan-mirror/sig.html#ECDSA">ECDSA</a>.
  *
- * The keys (192-bit) use the curve ASN1::secp192r1() and SHA-256 as the
+ * The keys (256-bit) use the curve ASN1::secp256r1() and SHA-256 as the
  * hash function.  The Key Derivation Protocol is P1363_KDF2<SHA256>
  * http://www.users.zetnet.co.uk/hopwood/crypto/scan/prf.html#KDF2
  * to generate private (signing) keys from unguessable seeds -- see
@@ -41,7 +41,6 @@ typedef int Py_ssize_t;
 #include <cryptopp/osrng.h>
 #include <cryptopp/eccrypto.h>
 #include <cryptopp/oids.h>
-#include <cryptopp/tiger.h>
 #include <cryptopp/sha.h>
 #include <cryptopp/pubkey.h>
 // only needed for debugging -- the _dump() function
@@ -53,7 +52,6 @@ typedef int Py_ssize_t;
 #include <src-cryptopp/osrng.h>
 #include <src-cryptopp/eccrypto.h>
 #include <src-cryptopp/oids.h>
-#include <src-cryptopp/tiger.h>
 #include <src-cryptopp/sha.h>
 #include <src-cryptopp/pubkey.h>
 // only needed for debugging -- the _dump() function
@@ -62,13 +60,13 @@ typedef int Py_ssize_t;
 #include <src-cryptopp/hex.h>
 #endif
 
-static const int KEY_SIZE_BITS=192;
+static const int KEY_SIZE_BITS=256;
 
 USING_NAMESPACE(CryptoPP)
 
-static const char*const ecdsa___doc__ = "ecdsa -- ECDSA(1363)/EMSA1(Tiger) signatures\n\
+static const char*const ecdsa___doc__ = "ecdsa -- ECDSA(1363)/EMSA1(SHA-256) signatures\n\
 \n\
-To create a new ECDSA signing key (deterministically from a 12-byte seed), construct an instance of the class, passing the seed as argument, i.e. SigningKey(seed).\n\
+To create a new ECDSA signing key (deterministically from a 32-byte seed), construct an instance of the class, passing the seed as argument, i.e. SigningKey(seed).\n\
 \n\
 To get a verifying key from a signing key, call get_verifying_key() on the signing key instance.\n\
 \n\
@@ -80,7 +78,7 @@ typedef struct {
     PyObject_HEAD
 
     /* internal */
-    ECDSA<ECP, Tiger>::Verifier *k;
+    ECDSA<ECP, SHA256>::Verifier *k;
 } VerifyingKey;
 
 PyDoc_STRVAR(VerifyingKey__doc__,
@@ -96,8 +94,8 @@ VerifyingKey___init__(PyObject* self, PyObject* args, PyObject* kwdict) {
         return NULL;
     assert (serializedverifyingkeysize >= 0);
 
-    if (serializedverifyingkeysize != 25) {
-        PyErr_Format(ecdsa_error, "Precondition violation: size in bits is required to be %d (for %d-bit key), but it was %Zd", 25, KEY_SIZE_BITS, serializedverifyingkeysize);
+    if (serializedverifyingkeysize != 33) {
+        PyErr_Format(ecdsa_error, "Precondition violation: size in bits is required to be %d (for %d-bit key), but it was %d", 33, KEY_SIZE_BITS, serializedverifyingkeysize);
         return -1;
     }
 
@@ -106,11 +104,11 @@ VerifyingKey___init__(PyObject* self, PyObject* args, PyObject* kwdict) {
     StringSource ss(reinterpret_cast<const byte*>(serializedverifyingkey), serializedverifyingkeysize, true);
 
     ECP::Element element;
-    DL_GroupParameters_EC<ECP> params(ASN1::secp192r1());
+    DL_GroupParameters_EC<ECP> params(ASN1::secp256r1());
     params.SetPointCompression(true);
     try {
         element = params.DecodeElement(reinterpret_cast<const byte*>(serializedverifyingkey), true);
-        mself->k = new ECDSA<ECP, Tiger>::Verifier(params, element);
+        mself->k = new ECDSA<ECP, SHA256>::Verifier(params, element);
         if (!mself->k) {
             PyErr_NoMemory();
             return -1;
@@ -153,8 +151,8 @@ PyDoc_STRVAR(VerifyingKey_verify__doc__,
 
 static PyObject *
 VerifyingKey_serialize(VerifyingKey *self, PyObject *dummy) {
-    ECDSA<ECP, Tiger>::Verifier *pubkey;
-    pubkey = new ECDSA<ECP, Tiger>::Verifier(*(self->k));
+    ECDSA<ECP, SHA256>::Verifier *pubkey;
+    pubkey = new ECDSA<ECP, SHA256>::Verifier(*(self->k));
     const DL_GroupParameters_EC<ECP>& params = pubkey->GetKey().GetGroupParameters();
 
     Py_ssize_t len = params.GetEncodedElementSize(true);
@@ -222,7 +220,7 @@ typedef struct {
     PyObject_HEAD
 
     /* internal */
-    ECDSA<ECP, Tiger>::Signer *k;
+    ECDSA<ECP, SHA256>::Signer *k;
 } SigningKey;
 
 static void
@@ -232,7 +230,7 @@ SigningKey_dealloc(SigningKey* self) {
     self->ob_type->tp_free((PyObject*)self);
 }
 
-static const char* TAG_AND_SALT = "102:pycryptopp v0.5.3 key derivation algorithm using Tiger hash to generate ECDSA 192-bit secret exponents," \
+static const char* TAG_AND_SALT = "102:pycryptopp v0.5.3 key derivation algorithm using SHA-256 hash to generate ECDSA 256-bit secret exponents," \
     "16:H1yGNvUONoc0FD1d,";
 static const size_t TAG_AND_SALT_len = 127;
 
@@ -275,39 +273,39 @@ SigningKey___init__(PyObject* self, PyObject* args, PyObject* kwdict) {
         return -1;
     }
 
-    if (seedlen != 12) {
-        PyErr_Format(ecdsa_error, "Precondition violation: seed is required to be of length 12, but it was %zd", seedlen);
+    if (seedlen != 32) {
+        PyErr_Format(ecdsa_error, "Precondition violation: seed is required to be of length 32, but it was %zd", seedlen);
         return -1;
     }
 
     OID curve;
     Integer grouporderm1;
-    byte privexpbytes[24] = {0};
+    byte privexpbytes[32] = {0};
     Integer privexponentm1;
     privexponentm1.Decode(privexpbytes, sizeof(privexpbytes)); assert (privexponentm1 == 0); // just checking..
 
-    DL_GroupParameters_EC<ECP> params(ASN1::secp192r1());
+    DL_GroupParameters_EC<ECP> params(ASN1::secp256r1());
     params.SetPointCompression(true);
     grouporderm1 = params.GetGroupOrder() - 1;
-    Tiger t;
+    SHA256 t;
 
     t.Update(reinterpret_cast<const byte*>(TAG_AND_SALT), TAG_AND_SALT_len);
     t.Update(reinterpret_cast<const byte*>(seed), seedlen);
-    t.TruncatedFinal(privexpbytes, Tiger::DIGESTSIZE);
+    t.TruncatedFinal(privexpbytes, SHA256::DIGESTSIZE);
     privexponentm1.Decode(privexpbytes, sizeof(privexpbytes));
 
     while (privexponentm1 >= grouporderm1) {
-        Tiger t2;
+        SHA256 t2;
         t2.Update(reinterpret_cast<const byte*>(TAG_AND_SALT), TAG_AND_SALT_len);
         std::cerr << "WHEE " << sizeof(privexpbytes) << "\n";std::cerr.flush();
         t2.Update(privexpbytes, sizeof(privexpbytes));
-        t2.TruncatedFinal(privexpbytes, Tiger::DIGESTSIZE);
+        t2.TruncatedFinal(privexpbytes, SHA256::DIGESTSIZE);
         privexponentm1.Decode(privexpbytes, sizeof(privexpbytes));
     }
 
     SigningKey* mself = reinterpret_cast<SigningKey*>(self);
 
-    mself->k = new ECDSA<ECP, Tiger>::Signer(params, privexponentm1+1);
+    mself->k = new ECDSA<ECP, SHA256>::Signer(params, privexponentm1+1);
 
     if (!mself->k) {
         PyErr_NoMemory();
@@ -318,9 +316,9 @@ SigningKey___init__(PyObject* self, PyObject* args, PyObject* kwdict) {
 }
 
 PyDoc_STRVAR(SigningKey__init____doc__,
-"Create a signing key (192 bits) deterministically from the given seed.\n\
+"Create a signing key (256 bits) deterministically from the given seed.\n\
 \n\
-This implies that if someone can guess the seed then they can learn the signing key.  A good way to get an unguessable seed is os.urandom(12).\n\
+This implies that if someone can guess the seed then they can learn the signing key.  A good way to get an unguessable seed is os.urandom(32).\n\
 \n\
 @param seed seed\n\
 \n\
@@ -444,7 +442,7 @@ SigningKey_get_verifying_key(SigningKey *self, PyObject *dummy) {
     if (!verifier)
         return NULL;
 
-    verifier->k = new ECDSA<ECP, Tiger>::Verifier(*(self->k));
+    verifier->k = new ECDSA<ECP, SHA256>::Verifier(*(self->k));
     if (!verifier->k)
         return PyErr_NoMemory();
     verifier->k->AccessKey().AccessGroupParameters().SetPointCompression(true);
diff --git a/src/pycryptopp/publickey/ed25519/__init__.py b/src/pycryptopp/publickey/ed25519/__init__.py
index f399769..4dd94ad 100644
--- a/src/pycryptopp/publickey/ed25519/__init__.py
+++ b/src/pycryptopp/publickey/ed25519/__init__.py
@@ -1,6 +1,6 @@
-from keys import (BadSignatureError, SigningKey, VerifyingKey)
+from keys import (BadSignatureError, SigningKey, VerifyingKey, __doc__)
 
-(BadSignatureError, SigningKey, VerifyingKey) # hush pyflakes
+(BadSignatureError, SigningKey, VerifyingKey, __doc__) # hush pyflakes
 
 from _version import get_versions
 __version__ = get_versions()['version']
diff --git a/src/pycryptopp/publickey/ed25519/keys.py b/src/pycryptopp/publickey/ed25519/keys.py
index 5d7eafb..ebd82ff 100644
--- a/src/pycryptopp/publickey/ed25519/keys.py
+++ b/src/pycryptopp/publickey/ed25519/keys.py
@@ -1,6 +1,23 @@
 import _ed25519
 BadSignatureError = _ed25519.BadSignatureError
 
+__doc__ = """\
+ed25519 -- Ed25519 public-key signatures
+
+To create a new Ed25519 signing key, create a 32-byte unguessable bytestring,
+with keybytes=os.urandom(32), and pass it to the SigningKey(keybytes)
+constructor. To create the same key in the future, call the constructor with
+the same string.
+
+To get a verifying key from a signing key, first get the verifying key bytes
+with verfbytes=sk.get_verifying_key_bytes(), then construct the VerifyingKey
+instance with VerifyingKey(verfbytes).
+
+To sign a message, use sig=sk.sign(msg), which returns the signature as a
+64-byte binary bytestring. To verify a signature, use vk.verify(sig, msg),
+which either returns None or raises BadSignatureError.
+"""
+
 class SigningKey(object):
     # this is how all keys are created
     def __init__(self, sk_bytes):
diff --git a/src/pycryptopp/test/test_aes.py b/src/pycryptopp/test/test_aes.py
index 16c3e20..591b171 100644
--- a/src/pycryptopp/test/test_aes.py
+++ b/src/pycryptopp/test/test_aes.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import random, re
 
 import unittest
diff --git a/src/pycryptopp/test/test_ecdsa.py b/src/pycryptopp/test/test_ecdsa.py
index d70a000..85f809d 100644
--- a/src/pycryptopp/test/test_ecdsa.py
+++ b/src/pycryptopp/test/test_ecdsa.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import random
 import base64
 
@@ -53,11 +51,9 @@ def div_ceil(n, d):
     """
     return (n/d) + (n%d != 0)
 
-KEYBITS=192
+KEYBITS =256
 
-# The number of bytes required for a seed to have the same security level as a
-# key in this elliptic curve: 2 bits of public key per bit of security.
-SEEDBITS=div_ceil(192, 2)
+SEEDBITS=256
 SEEDBYTES=div_ceil(SEEDBITS, 8)
 
 # The number of bytes required to encode a public key in this elliptic curve.
@@ -246,16 +242,15 @@ class Compatibility(unittest.TestCase):
     def test_compatibility(self):
         # Confirm that the KDF used by the SigningKey constructor doesn't
         # change without suitable backwards-compability
-        seed = base64.b32decode('XS27TJRP3JBZKDEFBDKQ====')
+        seed = 'bd616451f65d151ddd63efef42202c13457d1a0a44fb6f642be4bf9567ef19c6'.decode('hex')
         signer = ecdsa.SigningKey(seed)
         v1 = signer.get_verifying_key()
         vs = v1.serialize()
         vs32 = base64.b32encode(vs)
-        self.failUnlessEqual(vs32, "ANPNDWJWHQXYSQMD4L36D7WQEGXA42MS5JRUFIWA")
+        self.failUnlessEqual(vs32, "AIWKEM44YHQCR3VI7SF7IJI7SSW6YNLMGMWBIXQWXC5522H2KXXHO===")
         v2 = ecdsa.VerifyingKey(vs)
-        #print base64.b32encode(signer.sign("message"))
-        sig32 = "EA3Y7A4T62J3K6MUPJQN3WJ5S4SS53EGZXOSTQW7EQ7OXEMS6QJLYL63BLHMHZD7KFT37KEPJBAKI==="
-        sig = base64.b32decode(sig32)
+        # print signer.sign("message").encode('hex')
+        sig = 'a914953c6e6cecaf97d3d7f142ed1da88014752c3e1cd43b38f3327a73be67075bda7ec4a2ead5bb8a3471271a44ffbbd456b4d3ca470584c05703fdbe7b5bc0'.decode('hex')
         self.failUnless(v1.verify("message", sig))
         self.failUnless(v2.verify("message", sig))
 
diff --git a/src/pycryptopp/test/test_from_Nikratio.py b/src/pycryptopp/test/test_from_Nikratio.py
index a991415..d680daf 100644
--- a/src/pycryptopp/test/test_from_Nikratio.py
+++ b/src/pycryptopp/test/test_from_Nikratio.py
@@ -2,7 +2,7 @@ import unittest
 
 # This was reported as triggering a "Use of uninitialised value of
 # size 4" under valgrind by Nikratio in pycryptopp-0.5.17 and Crypto++
-# 5.6.0. See http://tahoe-lafs.org/trac/pycryptopp/ticket/67
+# 5.6.0. See https://tahoe-lafs.org/trac/pycryptopp/ticket/67
 
 class T(unittest.TestCase):
     def test_t(self):
diff --git a/src/pycryptopp/test/test_rsa.py b/src/pycryptopp/test/test_rsa.py
index 15294bc..7311a4f 100644
--- a/src/pycryptopp/test/test_rsa.py
+++ b/src/pycryptopp/test/test_rsa.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import random
 
 import unittest
diff --git a/src/pycryptopp/test/test_sha256.py b/src/pycryptopp/test/test_sha256.py
index 5e982dc..5705b91 100644
--- a/src/pycryptopp/test/test_sha256.py
+++ b/src/pycryptopp/test/test_sha256.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import random, re
 
 import unittest
diff --git a/src/pycryptopp/test/test_xsalsa20.py b/src/pycryptopp/test/test_xsalsa20.py
index f3ee02a..0f949e7 100644
--- a/src/pycryptopp/test/test_xsalsa20.py
+++ b/src/pycryptopp/test/test_xsalsa20.py
@@ -1,5 +1,3 @@
-#!/usr/bin/env python
-
 import random, re
 import unittest