How to use the rsa.newkeys function in rsa

To help you get started, we’ve selected a few rsa examples, based on popular ways it is used in public projects.

Secure your code as it's written. Use Snyk Code to scan source code in minutes - no build needed - and fix issues immediately.

github sybrenstuvel / python-rsa / tests / View on Github external
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)
github ospaceteam / outerspace / server / lib / ige / View on Github external
def _generateKeys(privatePath, publicPath, size):
    global publicKey, privateKey
    # no keys, let's generate them
    log.message("Generating RSA keys of size {0}, please wait...".format(size))
    publicKey, privateKey = rsa.newkeys(size)
    with open(privatePath, 'w') as privKeyFile:
    with open(publicPath, 'w') as pubKeyFile:
github tlsnotary / tlsnotary / src / auditee / View on Github external
def newkeys():
    global my_prv_key,my_pub_key
    #Usually the auditee would reuse a keypair from the previous session
    #but for privacy reasons the auditee may want to generate a new key
    my_pub_key, my_prv_key = rsa.newkeys(1024)

    my_pem_pubkey = my_pub_key.save_pkcs1()
    my_pem_privkey = my_prv_key.save_pkcs1()
    with open(join(current_session_dir, 'myprivkey'), 'wb') as f: f.write(my_pem_privkey)
    with open(join(current_session_dir, 'mypubkey'), 'wb') as f: f.write(my_pem_pubkey)
    #also save the keys as recent, so that they could be reused in the next session
    if not os.path.exists(join(data_dir, 'recentkeys')): os.makedirs(join(data_dir, 'recentkeys'))
    with open(join(data_dir, 'recentkeys', 'myprivkey'), 'wb') as f: f.write(my_pem_privkey)
    with open(join(data_dir, 'recentkeys', 'mypubkey'), 'wb') as f: f.write(my_pem_pubkey)
    pubkey_export = b64encode(shared.bi2ba(my_pub_key.n))
    return pubkey_export
github MechWolf / MechWolf / scripts / View on Github external
raise ValueError("Invalid Private Key File")

        # get private key
        rsa_public_filepath = click.prompt("RSA authentication public key filepath", type=str, default="./public.pem")
        with open(rsa_public_filepath, "rb") as f:
            rsa_public_filepath = os.path.realpath(
            data =
            raise ValueError("Invalid Public Key File")

    # if they don't have an RSA key, make one
        print("Now generating RSA authentication key for hub. This will allow your hub to prove its identity to the MechWolf resolver. This step may take a few seconds.")
        public, private = rsa.newkeys(2048)

        with open("public.pem", "wb+") as f:
            rsa_public_filepath = os.path.realpath(

        with open("private.pem", "wb+") as f:
            rsa_private_filepath = os.path.realpath(

    # store key location
    config_data["resolver_info"]["rsa_private_filepath"] = rsa_private_filepath
    config_data["resolver_info"]["rsa_public_filepath"] = rsa_public_filepath

    print("Now generating SSL certificate to encrypt communications between hub and client...")
github Lamden / flora / View on Github external
def register(name):
	# hit api to see if name is already registered
	if check_name(name)['status'] == 'error':
		print('{} already registered.'.format(name))
		# generate new keypair
		(pub, priv) = rsa.newkeys(512)

		if os.path.exists(KEY_LOCATION) == False:

		# save to disk
		with open('{}/.key'.format(KEY_LOCATION), 'wb') as f:
		    pickle.dump((pub, priv), f, pickle.HIGHEST_PROTOCOL)

		r ='{}/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))
			print('Error registering name: {}'.format(name))
github liamylian / x-rsa / python / View on Github external
def create_keys(key_size=2048):
        (pub_key, pri_key) = rsa.newkeys(key_size)
        return (
github nicolas-carolo / hsploit / searcher / vulnerabilities / exploits / multiple / webapps / View on Github external
def generate_key(key_size):
    #create rsa priv & public key
    print ("[+]Creating-RSA-pair-key")
    (public_key,private_key) = rsa.newkeys(key_size,poolsize=8)
    print ("\t[+]Pair-key-created")
    return private_key, public_key
github cedricbonhomme / pyHIDS / View on Github external

__author__ = "Cedric Bonhomme"
__version__ = "$Revision: 0.2 $"
__date__ = "$Date: 2010/03/06 $"
__revision__ = "$Date: 2013/02/16 $"
__copyright__ = "Copyright (c) 2010-2018 Cedric Bonhomme"
__license__ = "GPL v3"

import pickle
import rsa

import conf

print("Generating", conf.NB_BITS, "bits RSA keys ...")
pub, priv = rsa.newkeys(conf.NB_BITS)

public_key = open(conf.PUBLIC_KEY, "wb")
private_key = open(conf.PRIVATE_KEY, "wb")

print("Dumping Keys")
pickle.dump(pub, public_key)
pickle.dump(priv, private_key)


github johnnykv / heralding / heralding / libs / msrdp / View on Github external
# (at your option) any later version.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# GNU General Public License for more details.
# You should have received a copy of the GNU General Public License
# along with this program. If not, see .

import rsa
import hashlib

# Generate New RSA Keys
rsa_key = rsa.newkeys(512)

def getRSAKeys():
  """Returns a 512-Bit RSA keys"""
  return rsa_key

def PrivateKey(d, n):
    @param d: {long | str}private exponent
    @param n: {long | str}modulus
  if isinstance(d, bytes):
    d = rsa.transform.bytes2int(d)
  if isinstance(n, bytes):
    n = rsa.transform.bytes2int(n)