# Rsa Key Generation Example Python

Posted on by
Rsa Key Generation Example Python Rating: 4,0/5 3028 votes

This is a really simple RSA implementation. It does not want to be neither fast nor safe; it's aim is to provide a working and easy to read codebase for people interested in discovering the RSA algorithm. The following code encrypts a piece of data for a receiver we have the RSA public key of. The RSA public key is stored in a file called receiver.pem. Since we want to be able to encrypt an arbitrary amount of data, we use a hybrid encryption scheme. We use RSA with PKCS#1 OAEP for asymmetric encryption of an AES session key. The session key can then be used to encrypt all the actual data.

Python PyCrypto: Generate RSA Keys Example.py
 defgenerate_RSA(bits=2048): '' Generate an RSA keypair with an exponent of 65537 in PEM format param: bits The key length in bits Return private key and public key '' fromCrypto.PublicKeyimportRSA new_key=RSA.generate(bits, e=65537) public_key=new_key.publickey().exportKey('PEM') private_key=new_key.exportKey('PEM') returnprivate_key, public_key

Generate a random number which is relatively prime with (p-1) and (q-1). Let the number be called as e. Calculate the modular inverse of e. The calculated inverse will be called as d. Algorithms for generating RSA keys. We need two primary algorithms for generating RSA keys using Python − Cryptomath module and Rabin Miller module. Cryptomath Module. Oct 05, 2007 Generating Keys. Generating public keys for authentication is the basic and most often used feature of ssh-keygen. Ssh-keygen can generate both RSA and DSA keys. RSA keys have a minimum key length of 768 bits and the default length is 2048. When generating new RSA keys you should use at least 2048 bits of key length unless you really have a good reason for using a shorter and less secure key.

### commented Aug 5, 2016• edited

 Pycrypto is unmaintained and has known vulnerabilities. Use `pycryptodome`, it is a drop-in replacement.

### commented Jan 17, 2017

 e should be random methinks =P ### commented May 17, 2017• edited

 @miigotu 'youthinks' wrong. e should be chosen so that e and λ(n) are coprime. It is not chosen at random, and since it is usually small for computation reasons, and included in the public key, it can always be known by an attacker anyway.

### commented Aug 17, 2017

 from Crypto.PublicKey import RSAcode = 'nooneknows'key = RSA.generate(2048)privatekey = key.exportKey(passphrase=code, pkcs=8)publickey = key.publickey().exportKey()

### commented Jan 15, 2018

 Nice But How Can I Write The Private Key I Tried This:f = open('PublicKey.pem','w')f.write(publick_key)f.close()BUT IT DOESN'T WORK WITH THE PRIVATE KEY, JUST RETURNS 0B ### commented Jan 30, 2018

 @WarAtLord try `publick_key.exportKey('PEM')`

RSA is the most widespread and used public key algorithm. Its security isbased on the difficulty of factoring large integers. The algorithm haswithstood attacks for more than 30 years, and it is therefore consideredreasonably secure for new designs.

The algorithm can be used for both confidentiality (encryption) andauthentication (digital signature). It is worth noting that signing anddecryption are significantly slower than verification and encryption.

The cryptographic strength is primarily linked to the length of the RSA modulus n.In 2017, a sufficient length is deemed to be 2048 bits. For more information,see the most recent ECRYPT report.

Both RSA ciphertexts and RSA signatures are as large as the RSA modulus n (256bytes if n is 2048 bit long).

The module `Crypto.PublicKey.RSA` provides facilities for generating new RSA keys,reconstructing them from known components, exporting them, and importing them.

As an example, this is how you generate a new RSA key pair, save it in a filecalled `mykey.pem`, and then read it back:

`Crypto.PublicKey.RSA.``generate`(bits, randfunc=None, e=65537)

Create a new RSA key pair.

The algorithm closely follows NIST FIPS 186-4 in itssections B.3.1 and B.3.3. The modulus is the product oftwo non-strong probable primes.Each prime passes a suitable number of Miller-Rabin testswith random bases and a single Lucas test.

Parameters: bits (integer) – Key length, or size (in bits) of the RSA modulus.It must be at least 1024, but 2048 is recommended.The FIPS standard only defines 1024, 2048 and 3072.randfunc (callable) – Function that returns random bytes.The default is `Crypto.Random.get_random_bytes()`.e (integer) – Public RSA exponent. It must be an odd positive integer.It is typically a small number with very few ones in itsbinary representation.The FIPS standard requires the public exponent to beat least 65537 (the default).

Returns: an RSA key object (`RsaKey`, with private key).

`Crypto.PublicKey.RSA.``construct`(rsa_components, consistency_check=True)

Construct an RSA key from a tuple of valid RSA components.

The modulus n must be the product of two primes.The public exponent e must be odd and larger than 1.

In case of a private key, the following equations must apply:

[begin{split}begin{align}p*q &= n e*d &equiv 1 ( text{mod lcm} [(p-1)(q-1)]) p*u &equiv 1 ( text{mod } q)end{align}end{split}]
Parameters: rsa_components (tuple) – A tuple of integers, with at least 2 and nomore than 6 items. The items come in the following order:RSA modulus n.Public exponent e.Private exponent d.Only required if the key is private.First factor of n (p).Optional, but the other factor q must also be present.Second factor of n (q). Optional.CRT coefficient q, that is (p^{-1} text{mod }q). Optional.consistency_check (boolean) – If `True`, the library will verify that the provided componentsfulfil the main RSA properties. `ValueError` – when the key being imported fails the most basic RSA validity checks.

Returns: An RSA key object (`RsaKey`).

`Crypto.PublicKey.RSA.``import_key`(extern_key, passphrase=None)

Import an RSA key (public or private).

Parameters: extern_key (string or byte string) – The RSA key to import.The following formats are supported for an RSA public key:X.509 certificate (binary or PEM format)X.509 `subjectPublicKeyInfo` DER SEQUENCE (binary or PEMencoding)PKCS#1`RSAPublicKey` DER SEQUENCE (binary or PEM encoding)An OpenSSH line (e.g. the content of `~/.ssh/id_ecdsa`, ASCII)The following formats are supported for an RSA private key:PKCS#1 `RSAPrivateKey` DER SEQUENCE (binary or PEM encoding)PKCS#8`PrivateKeyInfo` or `EncryptedPrivateKeyInfo`DER SEQUENCE (binary or PEM encoding)OpenSSH (text format, introduced in OpenSSH 6.5)For details about the PEM encoding, see RFC1421/RFC1423.passphrase (string or byte string) – For private keys only, the pass phrase that encrypts the key.

Returns: An RSA key object (`RsaKey`).

Raises: `ValueError/IndexError/TypeError` – When the given key cannot be parsed (possibly because the passphrase is wrong).
class `Crypto.PublicKey.RSA.``RsaKey`(**kwargs)

Class defining an actual RSA key.Do not instantiate directly.Use `generate()`, `construct()` or `import_key()` instead.

Variables: n (integer) – RSA moduluse (integer) – RSA public exponentd (integer) – RSA private exponentp (integer) – First factor of the RSA modulusq (integer) – Second factor of the RSA modulusu – Chinese remainder component ((p^{-1} text{mod } q))
`exportKey`(format='PEM', passphrase=None, pkcs=1, protection=None, randfunc=None)

Export this RSA key.

Parameters: format (string) – The format to use for wrapping the key:’PEM’. (Default) Text encoding, done according to RFC1421/RFC1423.’DER’. Binary encoding.’OpenSSH’. Textual encoding, done according to OpenSSH specification.Only suitable for public keys (not private keys).passphrase (string) – (For private keys only) The pass phrase used for protecting the output.pkcs (integer) – (For private keys only) The ASN.1 structure to use forserializing the key. Note that even in case of PEMencoding, there is an inner ASN.1 DER structure.With `pkcs=1` (default), the private key is encoded in asimple PKCS#1 structure (`RSAPrivateKey`).With `pkcs=8`, the private key is encoded in a PKCS#8 structure(`PrivateKeyInfo`).NoteThis parameter is ignored for a public key.For DER and PEM, an ASN.1 DER `SubjectPublicKeyInfo`structure is always used.protection (string) – (For private keys only)The encryption scheme to use for protecting the private key.If `None` (default), the behavior depends on `format`:For ‘DER’, the PBKDF2WithHMAC-SHA1AndDES-EDE3-CBCscheme is used. The following operations are performed:A 16 byte Triple DES key is derived from the passphraseusing `Crypto.Protocol.KDF.PBKDF2()` with 8 bytes salt,and 1 000 iterations of `Crypto.Hash.HMAC`.The private key is encrypted using CBC.The encrypted key is encoded according to PKCS#8.For ‘PEM’, the obsolete PEM encryption scheme is used.It is based on MD5 for key derivation, and Triple DES for encryption.Specifying a value for `protection` is only meaningful for PKCS#8(that is, `pkcs=8`) and only if a pass phrase is present too.The supported schemes for PKCS#8 are listed in the`Crypto.IO.PKCS8` module (see `wrap_algo` parameter).randfunc (callable) – A function that provides random bytes. Only used for PEM encoding.The default is `Crypto.Random.get_random_bytes()`. the encoded key byte string `ValueError` – when the format is unknown or when you try to encrypt a privatekey with DER format and PKCS#1.

Warning

If you don’t provide a pass phrase, the private key will beexported in the clear!

`export_key`(format='PEM', passphrase=None, pkcs=1, protection=None, randfunc=None)

Export this RSA key.

Parameters: format (string) – The format to use for wrapping the key:’PEM’. (Default) Text encoding, done according to RFC1421/RFC1423.’DER’. Binary encoding.’OpenSSH’. Textual encoding, done according to OpenSSH specification.Only suitable for public keys (not private keys).passphrase (string) – (For private keys only) The pass phrase used for protecting the output.pkcs (integer) – (For private keys only) The ASN.1 structure to use forserializing the key. Note that even in case of PEMencoding, there is an inner ASN.1 DER structure.With `pkcs=1` (default), the private key is encoded in asimple PKCS#1 structure (`RSAPrivateKey`).With `pkcs=8`, the private key is encoded in a PKCS#8 structure(`PrivateKeyInfo`).NoteThis parameter is ignored for a public key.For DER and PEM, an ASN.1 DER `SubjectPublicKeyInfo`structure is always used.protection (string) – (For private keys only)The encryption scheme to use for protecting the private key.If `None` (default), the behavior depends on `format`:For ‘DER’, the PBKDF2WithHMAC-SHA1AndDES-EDE3-CBCscheme is used. The following operations are performed:A 16 byte Triple DES key is derived from the passphraseusing `Crypto.Protocol.KDF.PBKDF2()` with 8 bytes salt,and 1 000 iterations of `Crypto.Hash.HMAC`.The private key is encrypted using CBC.The encrypted key is encoded according to PKCS#8.For ‘PEM’, the obsolete PEM encryption scheme is used.It is based on MD5 for key derivation, and Triple DES for encryption.Specifying a value for `protection` is only meaningful for PKCS#8(that is, `pkcs=8`) and only if a pass phrase is present too.Monster hunter generations ultimate key quests hr 13. The supported schemes for PKCS#8 are listed in the`Crypto.IO.PKCS8` module (see `wrap_algo` parameter).randfunc (callable) – A function that provides random bytes. Only used for PEM encoding.The default is `Crypto.Random.get_random_bytes()`. the encoded key byte string `ValueError` – when the format is unknown or when you try to encrypt a privatekey with DER format and PKCS#1.

Warning

If you don’t provide a pass phrase, the private key will beexported in the clear!

### Python Rsa Example

`has_private`()

### Rsa Public Key Generation

Whether this is an RSA private key

`publickey`()

A matching RSA public key.

Returns: a new `RsaKey` object
`size_in_bits`()

### Rsa Public Key Example

Size of the RSA modulus in bits

`size_in_bytes`()

The minimal amount of bytes that can hold the RSA modulus

`Crypto.PublicKey.RSA.``oid` = '1.2.840.113549.1.1.1'