我们从Python开源项目中，提取了以下47个代码示例，用于说明如何使用rsa.newkeys()。
def register(name): # hit api to see if name is already registered if check_name(name)['status'] == 'error': print('{} already registered.'.format(name)) else: # generate new keypair (pub, priv) = rsa.newkeys(512) if os.path.exists(KEY_LOCATION) == False: os.mkdir(KEY_LOCATION) # save to disk with open('{}/.key'.format(KEY_LOCATION), 'wb') as f: pickle.dump((pub, priv), f, pickle.HIGHEST_PROTOCOL) r = requests.post('{}/names'.format(API_LOCATION), data = {'name' : name, 'n' : pub.n, 'e' : pub.e}) if r.json()['status'] == 'success': print('Successfully registered new name: {}'.format(name)) else: print('Error registering name: {}'.format(name))
def __init__(self, path, public=None, private=None): debug("crypto", "starting crpyto init") self.path = path if (public and private): self.DRMPublicKey = rsa.PublicKey.load_pkcs1(public) self.DRMPrivateKey = rsa.PrivateKey.load_pkcs1(private) else: try: if (not os.path.isfile("%sdrm.pub" % self.path) or not os.path.isfile("%sdrm.pem" % self.path)): (self.DRMPublicKey, self.DRMPrivateKey) = rsa.newkeys(RSA_KEY_LEN) self.saveKeys() else: self.loadKeys() except Exception as e: debug("crypto", "failed gen keys %s" % str(e)) melt() os._exit(420) # Load internal trusted key self.DRMTrustedKey = rsa.PublicKey.load_pkcs1(TRUSTED_KEY) return # AES crypts a file with s simple lib
def on_connected(self): self.state = YY_CLIENT_HANDSHAKING proto = YYProto_pb2.YYProto() (pub_key, pri_key) = rsa.newkeys(512, 3) self.rsa_pub_key = pub_key self.rsa_pri_key = pri_key proto.cmd = 0x1 proto.key_req.f1 = chr(0x01) + chr(0x00) + chr(0x01) rsa_key = rsa.transform.int2bytes(pub_key.n) reversed(rsa_key) proto.key_req.rsa_key = chr(0x00) + rsa_key buffer = proto.SerializeToString() #hexdump.hexdump(buffer) self.stream.write(struct.pack('I', len(buffer)) + buffer)
def run_speed_test(bitsize): iterations = 0 start = end = time.time() # At least a number of iterations, and at least 2 seconds while iterations < 10 or end - start < 2: iterations += 1 rsa.newkeys(bitsize, accurate=accurate, poolsize=poolsize) end = time.time() duration = end - start dur_per_call = duration / iterations print '%5i bit: %9.3f sec. (%i iterations over %.1f seconds)' % (bitsize, dur_per_call, iterations, duration)
def test_sign_verify_bigfile(self): # Large enough to store MD5-sum and ASN.1 code for MD5 pub_key, priv_key = rsa.newkeys((34 + 11) * 8) # Sign the file msgfile = BytesIO(b('123456Sybren')) signature = pkcs1.sign(msgfile, priv_key, 'MD5') # Check the signature msgfile.seek(0) self.assertTrue(pkcs1.verify(msgfile, signature, pub_key)) # Alter the message, re-check msgfile = BytesIO(b('123456sybren')) self.assertRaises(pkcs1.VerificationError, pkcs1.verify, msgfile, signature, pub_key)
def test_encrypt_decrypt_bigfile(self): # Expected block size + 11 bytes padding pub_key, priv_key = rsa.newkeys((6 + 11) * 8) # Encrypt the file message = b('123456Sybren') infile = BytesIO(message) outfile = BytesIO() bigfile.encrypt_bigfile(infile, outfile, pub_key) # Test crypto = outfile.getvalue() cryptfile = BytesIO(crypto) clearfile = BytesIO() bigfile.decrypt_bigfile(cryptfile, clearfile, priv_key) self.assertEquals(clearfile.getvalue(), message) # We have 2x6 bytes in the message, so that should result in two # bigfile. cryptfile.seek(0) varblocks = list(varblock.yield_varblocks(cryptfile)) self.assertEqual(2, len(varblocks))
def test_sign(self): """Test sign works.""" # rsa_pk = M2Crypto.RSA.gen_key(2048, 65537) rsa_keys = rsa.newkeys(2048, 65537) rsa_pk = rsa_keys[1] rsa_pub = rsa_keys[0] salt = 'salt' data = {"flags": 8, "name": "MyAwesomeVM", "ram": 512, "secret": "mg041na39123", "userData": "[amiconfig]\nplugins=cernvm\n[cernvm]\nusers=user:users;password", "vcpus": 1, "version": "1.5"} strBuffer = vmcp.calculate_buffer(data, salt) with patch('rsa.PrivateKey.load_pkcs1', return_value=rsa_pk): with patch('pybossa.vmcp.open', mock_open(read_data=''), create=True) as m: out = vmcp.sign(data, salt, 'testkey') err_msg = "There should be a key named signature" assert out.get('signature'), err_msg err_msg = "The signature should not be empty" assert out['signature'] is not None, err_msg assert out['signature'] != '', err_msg err_msg = "The signature should be the same" signature = base64.b64decode(out['signature']) assert rsa.verify(strBuffer, signature, rsa_pub) == 1, err_msg # The output must be convertible into json object import json assert_not_raises(Exception, json.dumps, out)
def test_vmcp_02(self): """Test VMCP signing works.""" rsa_keys = rsa.newkeys(2048, 65537) rsa_pk = rsa_keys[1] rsa_pub = rsa_keys[0] with patch('os.path.exists', return_value=True): with patch('rsa.PrivateKey.load_pkcs1', return_value=rsa_pk): with patch('pybossa.vmcp.open', mock_open(read_data=''), create=True) as m: res = self.app.get('api/vmcp?cvm_salt=testsalt', follow_redirects=True) out = json.loads(res.data) assert res.status_code == 200, out assert out.get('signature') is not None, out # Now with a post res = self.app.post('api/vmcp?cvm_salt=testsalt', follow_redirects=True) assert res.status_code == 405, res.status_code
def generate_new_key(self, keysize=2048): try: self._public_key, self._private_key = PYRSA.newkeys(keysize, poolsize=4) except: self._public_key, self._private_key = PYRSA.newkeys(keysize)
def __init__(self): self.pub, self.priv = rsa.newkeys(512)
def build_new_rsa_keys() : keys_file=open(get_current_path()+'keys.pem','w') if keys_file : new_public_key,new_private_key=rsa.newkeys(1024) serialization_data=pickle.dumps((new_public_key,new_private_key)) keys_file.write(serialization_data) keys_file.close()
def generate_key(keysize = 1024, show=True): """ generate and save to mypubkey, myprivkey if show, write mypub to clipboard return (mypubkey, myprivkey) """ (mypub, mypriv) = rsa.newkeys(keysize, poolsize=4, accurate=False) storage_save("mypub",mypub) storage_save("mypriv",mypriv) if show: show_pubkey(mypub) return (mypub, mypriv)
def __init__(self, username, password): self.username = username self.password = hashlib.sha1(password).hexdigest() self.rc4_e = None self.rc4_d = None #self.rsa = rsa #rsa.newkeys(512, 3) self.state = YY_CLIENT_WAITING self.recv_buffer = '' self.challenge = '' self.imei = gen_imei(username + ':-P') self.last_active = None self.score = 0 self.sigin_time = 0 self.uptime = '0' self.login_retry = 3
def run_speed_test(bitsize): iterations = 0 start = end = time.time() # At least a number of iterations, and at least 2 seconds while iterations < 10 or end - start < 2: iterations += 1 rsa.newkeys(bitsize, accurate=accurate, poolsize=poolsize) end = time.time() duration = end - start dur_per_call = duration / iterations print('%5i bit: %9.3f sec. (%i iterations over %.1f seconds)' % (bitsize, dur_per_call, iterations, duration))
def setUp(self): (self.pub, self.priv) = rsa.newkeys(64)
def setUp(self): (self.pub, self.priv) = rsa.newkeys(256)
def setUp(self): (self.pub, self.priv) = rsa.newkeys(512)
def setUp(self): (self.pub, self.priv) = rsa.newkeys(384)
def setUpClass(cls): # Ensure there is a key to use cls.pub_key, cls.priv_key = rsa.newkeys(512) cls.pub_fname = '%s.pub' % cls.__name__ cls.priv_fname = '%s.key' % cls.__name__ with open(cls.pub_fname, 'wb') as outfile: outfile.write(cls.pub_key.save_pkcs1()) with open(cls.priv_fname, 'wb') as outfile: outfile.write(cls.priv_key.save_pkcs1())
def test_sign_different_key(self): '''Signing with another key should let the verification fail.''' (otherpub, _) = rsa.newkeys(512) message = b('je moeder') signature = pkcs1.sign(message, self.priv, 'SHA-256') self.assertRaises(pkcs1.VerificationError, pkcs1.verify, message, signature, otherpub)
def test_sign_different_key(self): """Signing with another key should let the verification fail.""" (otherpub, _) = rsa.newkeys(512) message = b('je moeder') signature = pkcs1.sign(message, self.priv, 'SHA-256') self.assertRaises(pkcs1.VerificationError, pkcs1.verify, message, signature, otherpub)
def keygen(): '''Key generator.''' # Parse the CLI options parser = OptionParser(usage='usage: %prog [options] keysize', description='Generates a new RSA keypair of "keysize" bits.') parser.add_option('--pubout', type='string', help='Output filename for the public key. The public key is ' 'not saved if this option is not present. You can use ' 'pyrsa-priv2pub to create the public key file later.') parser.add_option('-o', '--out', type='string', help='Output filename for the private key. The key is ' 'written to stdout if this option is not present.') parser.add_option('--form', help='key format of the private and public keys - default PEM', choices=('PEM', 'DER'), default='PEM') (cli, cli_args) = parser.parse_args(sys.argv[1:]) if len(cli_args) != 1: parser.print_help() raise SystemExit(1) try: keysize = int(cli_args[0]) except ValueError: parser.print_help() print('Not a valid number: %s' % cli_args[0], file=sys.stderr) raise SystemExit(1) print('Generating %i-bit key' % keysize, file=sys.stderr) (pub_key, priv_key) = rsa.newkeys(keysize) # Save public key if cli.pubout: print('Writing public key to %s' % cli.pubout, file=sys.stderr) data = pub_key.save_pkcs1(format=cli.form) with open(cli.pubout, 'wb') as outfile: outfile.write(data) # Save private key data = priv_key.save_pkcs1(format=cli.form) if cli.out: print('Writing private key to %s' % cli.out, file=sys.stderr) with open(cli.out, 'wb') as outfile: outfile.write(data) else: print('Writing private key to stdout', file=sys.stderr) sys.stdout.write(data)
def keygen(): """Key generator.""" # Parse the CLI options parser = OptionParser(usage='usage: %prog [options] keysize', description='Generates a new RSA keypair of "keysize" bits.') parser.add_option('--pubout', type='string', help='Output filename for the public key. The public key is ' 'not saved if this option is not present. You can use ' 'pyrsa-priv2pub to create the public key file later.') parser.add_option('-o', '--out', type='string', help='Output filename for the private key. The key is ' 'written to stdout if this option is not present.') parser.add_option('--form', help='key format of the private and public keys - default PEM', choices=('PEM', 'DER'), default='PEM') (cli, cli_args) = parser.parse_args(sys.argv[1:]) if len(cli_args) != 1: parser.print_help() raise SystemExit(1) try: keysize = int(cli_args[0]) except ValueError: parser.print_help() print('Not a valid number: %s' % cli_args[0], file=sys.stderr) raise SystemExit(1) print('Generating %i-bit key' % keysize, file=sys.stderr) (pub_key, priv_key) = rsa.newkeys(keysize) # Save public key if cli.pubout: print('Writing public key to %s' % cli.pubout, file=sys.stderr) data = pub_key.save_pkcs1(format=cli.form) with open(cli.pubout, 'wb') as outfile: outfile.write(data) # Save private key data = priv_key.save_pkcs1(format=cli.form) if cli.out: print('Writing private key to %s' % cli.out, file=sys.stderr) with open(cli.out, 'wb') as outfile: outfile.write(data) else: print('Writing private key to stdout', file=sys.stderr) sys.stdout.write(data)
def keygen(): """Key generator.""" # Parse the CLI options parser = OptionParser(usage='usage: %prog [options] keysize', description='Generates a new RSA keypair of "keysize" bits.') parser.add_option('--pubout', type='string', help='Output filename for the public key. The public key is ' 'not saved if this option is not present. You can use ' 'pyrsa-priv2pub to create the public key file later.') parser.add_option('-o', '--out', type='string', help='Output filename for the private key. The key is ' 'written to stdout if this option is not present.') parser.add_option('--form', help='key format of the private and public keys - default PEM', choices=('PEM', 'DER'), default='PEM') (cli, cli_args) = parser.parse_args(sys.argv[1:]) if len(cli_args) != 1: parser.print_help() raise SystemExit(1) try: keysize = int(cli_args[0]) except ValueError: parser.print_help() print('Not a valid number: %s' % cli_args[0], file=sys.stderr) raise SystemExit(1) print('Generating %i-bit key' % keysize, file=sys.stderr) (pub_key, priv_key) = rsa.newkeys(keysize) # Save public key if cli.pubout: print('Writing public key to %s' % cli.pubout, file=sys.stderr) data = pub_key.save_pkcs1(format=cli.form) with open(cli.pubout, 'wb') as outfile: outfile.write(data) # Save private key data = priv_key.save_pkcs1(format=cli.form) if cli.out: print('Writing private key to %s' % cli.out, file=sys.stderr) with open(cli.out, 'wb') as outfile: outfile.write(data) else: print('Writing private key to stdout', file=sys.stderr) rsa._compat.write_to_stdout(data)
