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 __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_and_failcheck_a(self):
     signer = rsa.generate(KEYSIZE)
     verifier = signer.get_verifying_key()
     return self._help_test_sign_and_failcheck(signer, verifier, "a")

 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(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 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 __init__(self):
     self.signer = rsa.generate(sizeinbits=self.SIZEINBITS)

 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)