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