def gen_key(self, key_size):
self.vlog('%s generating key size %s' % (
self,
key_size,
))
signer = rsa.generate(key_size)
verifier = signer.get_verifying_key()
return verifier.serialize(), signer.serialize()
def test_serialize_and_deserialize_signing_key_and_test(self):
signer = rsa.generate(KEYSIZE)
verifier = signer.get_verifying_key()
serstr = signer.serialize()
signer = None
newsigner = rsa.create_signing_key_from_string(serstr)
self._help_test_sign_and_check(newsigner, verifier, "a")
self._help_test_sign_and_check_random(newsigner, verifier)
self._help_test_sign_and_failcheck(newsigner, verifier, "a")
self._help_test_sign_and_failcheck_random(newsigner, verifier)
def test_serialize_and_deserialize_signing_key_and_test(self):
signer = rsa.generate(KEYSIZE)
verifier = signer.get_verifying_key()
serstr = signer.serialize()
signer = None
newsigner = rsa.create_signing_key_from_string(serstr)
self._help_test_sign_and_check(newsigner, verifier, "a")
self._help_test_sign_and_check_random(newsigner, verifier)
self._help_test_sign_and_failcheck(newsigner, verifier, "a")
self._help_test_sign_and_failcheck_random(newsigner, verifier)
def generate(self, keysize=None):
"""I return a Deferred that fires with a (verifyingkey, signingkey)
pair. I accept a keysize in bits (2048 bit keys are standard, smaller
keys are used for testing). If you do not provide a keysize, I will
use my default, which is set by a call to set_default_keysize(). If
set_default_keysize() has never been called, I will create 2048 bit
keys."""
keysize = keysize or self.default_keysize
# RSA key generation for a 2048 bit key takes between 0.8 and 3.2
# secs
signer = rsa.generate(keysize)
verifier = signer.get_verifying_key()
return defer.succeed( (verifier, signer) )
def generate(self, keysize=None):
"""I return a Deferred that fires with a (verifyingkey, signingkey)
pair. I accept a keysize in bits (2048 bit keys are standard, smaller
keys are used for testing). If you do not provide a keysize, I will
use my default, which is set by a call to set_default_keysize(). If
set_default_keysize() has never been called, I will create 2048 bit
keys."""
keysize = keysize or self.default_keysize
# RSA key generation for a 2048 bit key takes between 0.8 and 3.2
# secs
signer = rsa.generate(keysize)
verifier = signer.get_verifying_key()
return defer.succeed((verifier, signer))
def __init__(self, name ):
PublicKey.__init__(self)
key_file = os.path.join('keys', name)
if os.path.exists(key_file):
log.info('loading %s\'s private key'%(name,))
self.private_key = rsa.create_signing_key_from_string( read_file(key_file) )
if self.private_key:
log.info('private key %s loaded'%(name,))
else:
log.error('invalid private key for %s'%(name,))
raise Exception('no private key for %s'%(name,))
else:
log.info('genreating new private key for user %s'%(name,))
self.private_key = rsa.generate(get_default_key_size())
if not os.path.exists('keys'):
os.mkdir('keys')
write_file(key_file, self.private_key.serialize())
self.public_key = self.private_key.get_verifying_key()
def generate(self, keysize=None):
"""I return a Deferred that fires with a (verifyingkey, signingkey)
pair. I accept a keysize in bits (2048 bit keys are standard, smaller
keys are used for testing). If you do not provide a keysize, I will
use my default, which is set by a call to set_default_keysize(). If
set_default_keysize() has never been called, I will create 2048 bit
keys."""
keysize = keysize or self.default_keysize
if self._remote:
d = self._remote.callRemote('get_rsa_key_pair', keysize)
def make_key_objs((verifying_key, signing_key)):
v = rsa.create_verifying_key_from_string(verifying_key)
s = rsa.create_signing_key_from_string(signing_key)
return v, s
d.addCallback(make_key_objs)
return d
else:
# RSA key generation for a 2048 bit key takes between 0.8 and 3.2
# secs
signer = rsa.generate(keysize)
verifier = signer.get_verifying_key()
return defer.succeed( (verifier, signer) )
def generate(self, keysize=None):
"""I return a Deferred that fires with a (verifyingkey, signingkey)
pair. I accept a keysize in bits (2048 bit keys are standard, smaller
keys are used for testing). If you do not provide a keysize, I will
use my default, which is set by a call to set_default_keysize(). If
set_default_keysize() has never been called, I will create 2048 bit
keys."""
keysize = keysize or self.default_keysize
if self._remote:
d = self._remote.callRemote('get_rsa_key_pair', keysize)
def make_key_objs((verifying_key, signing_key)):
v = rsa.create_verifying_key_from_string(verifying_key)
s = rsa.create_signing_key_from_string(signing_key)
return v, s
d.addCallback(make_key_objs)
return d
else:
# RSA key generation for a 2048 bit key takes between 0.8 and 3.2
# secs
signer = rsa.generate(keysize)
verifier = signer.get_verifying_key()
return defer.succeed( (verifier, signer) )
def test_sign(self):
signer = rsa.generate(KEYSIZE)
result = signer.sign("abc")
self.failUnlessEqual(len(result), ((KEYSIZE+7)/8))
def test_generate(self):
rsa.generate(KEYSIZE)
# Hooray! It didn't raise an exception! We win!
rsa.generate(sizeinbits=KEYSIZE)
def test_generate_bad_size(self):
try:
rsa.generate(KEYSIZE-1)
except rsa.Error, le:
self.failUnless("size in bits is required to be >=" in str(le), le)
def test_generate(self):
rsa.generate(KEYSIZE)
# Hooray! It didn't raise an exception! We win!
rsa.generate(sizeinbits=KEYSIZE)
def randstr(n):
return ''.join(map(chr, map(random.randrange, [0]*n, [256]*n)))
KEYSIZE=522 # 522 bits is far too few for actual security -- it is used only for faster unit tests
class Signer(unittest.TestCase):
def test_generate_bad_size(self):
try:
rsa.generate(KEYSIZE-1)
except rsa.Error, le:
self.failUnless("size in bits is required to be >=" in str(le), le)
else:
self.fail("Should have raised error from size being too small.")
try:
rsa.generate(sizeinbits=KEYSIZE-1)
except rsa.Error, le:
self.failUnless("size in bits is required to be >=" in str(le), le)
else:
self.fail("Should have raised error from size being too small.")
def test_generate(self):
rsa.generate(KEYSIZE)
# Hooray! It didn't raise an exception! We win!
rsa.generate(sizeinbits=KEYSIZE)
# Hooray! It didn't raise an exception! We win!
def test_sign(self):
signer = rsa.generate(KEYSIZE)
result = signer.sign("abc")
self.failUnlessEqual(len(result), ((KEYSIZE+7)/8))
def test_sign_and_check_a(self):
signer = rsa.generate(KEYSIZE)
verifier = signer.get_verifying_key()
return self._help_test_sign_and_check(signer, verifier, "a")
def test_generate_bad_size(self):
try:
rsa.generate(KEYSIZE - 1)
except rsa.Error, le:
self.failUnless("size in bits is required to be >=" in str(le), le)
def __init__(self):
self.signer = rsa.generate(sizeinbits=self.SIZEINBITS)
def test_sign_and_failcheck_random(self):
signer = rsa.generate(KEYSIZE)
verifier = signer.get_verifying_key()
return self._help_test_sign_and_failcheck_random(signer, verifier)
def test_sign(self):
signer = rsa.generate(KEYSIZE)
result = signer.sign("abc")
self.failUnlessEqual(len(result), ((KEYSIZE + 7) / 8))
def gen(self, N):
for i in xrange(N):
rsa.generate(sizeinbits=self.SIZEINBITS)
def ver_init(self, N):
signer = rsa.generate(sizeinbits=self.SIZEINBITS)
self.sig = signer.sign(msg)
self.verifier = signer.get_verifying_key()
def sign_init(self, N):
self.signer = rsa.generate(sizeinbits=self.SIZEINBITS)
def test_sign_and_check_random(self):
signer = rsa.generate(KEYSIZE)
verifier = signer.get_verifying_key()
return self._help_test_sign_and_check_random(signer, verifier)
def test_sign_and_failcheck_a(self):
signer = rsa.generate(KEYSIZE)
verifier = signer.get_verifying_key()
return self._help_test_sign_and_failcheck(signer, verifier, "a")
def gen_key(self, key_size):
self.vlog('%s generating key size %s' % (self, key_size, ))
signer = rsa.generate(key_size)
verifier = signer.get_verifying_key()
return verifier.serialize(), signer.serialize()
return ''.join(map(chr, map(random.randrange, [0] * n, [256] * n)))
KEYSIZE = 522 # 522 bits is far too few for actual security -- it is used only for faster unit tests
class Signer(unittest.TestCase):
def test_generate_bad_size(self):
try:
rsa.generate(KEYSIZE - 1)
except rsa.Error, le:
self.failUnless("size in bits is required to be >=" in str(le), le)
else:
self.fail("Should have raised error from size being too small.")
try:
rsa.generate(sizeinbits=KEYSIZE - 1)
except rsa.Error, le:
self.failUnless("size in bits is required to be >=" in str(le), le)
else:
self.fail("Should have raised error from size being too small.")
def test_generate(self):
rsa.generate(KEYSIZE)
# Hooray! It didn't raise an exception! We win!
rsa.generate(sizeinbits=KEYSIZE)
# Hooray! It didn't raise an exception! We win!
def test_sign(self):
signer = rsa.generate(KEYSIZE)
result = signer.sign("abc")
self.failUnlessEqual(len(result), ((KEYSIZE + 7) / 8))
def __init__(self):
self.signer = rsa.generate(sizeinbits=self.SIZEINBITS)
