Главная » Языки программирования

Python rsa key to byte

Содержание
  1. RSA шифрование на Python.
  2. RSA и Python.
  3. Цифровая подпись.
  4. Проблема больших сообщений.
  5. Python rsa key to byte
  6. 5. Usage¶
  7. 5.1. Generating keys¶
  8. 5.1.1. Time to generate a key¶

RSA шифрование на Python.

RSA это асимметричный алгоритм шифрования. Зашифровка и расшифровка сообщение происходит двумя разными ключами, так называемый Публичны ключ за зашифровки и приватный(секретный) ключ для расшифровки сообщений . Допустим Сережа хочет отправить сообщение Алисе. Он спрашивает у Алисы ее публичный ключ для зашифровки сообщения, а Алиса вторым(секретным) ключом его расшифрует.

RSA и Python.

Для реализации RSA в Питоне мы будем использовать модуль который так и называется RSA. Он поддерживает шифрование и расшифровку, подписание и проверку подписей в соответствии с PKCS#1 версия 1.5.

Первым делом нам надо сгенерировать пару ключей(публичный и приватный).

import rsa
(pubkey, privkey) = rsa.newkeys(512) # 512 bits длина ключа, рекомендуется не меньше 1024

Так же модуль поддерживает сохранение и загрузку ключей в формате PEM и DER.

pubkey_pem = pubkey.save_pkcs1() # (format='PEM') 
privkey_pem = privkey.save_pkcs1()
pubkey = rsa.PublicKey.load_pkcs1(pubkey_tmp, 'PEM') #(keyfile:bytes, format='PEM')

Теперь зашифруем и расшифруем сообщение :

message = ‘hello Alisa!’.encode(‘utf8’)
crypto = rsa.encrypt(message, pubkey) # Зашифровка
message = rsa.decrypt(crypto, privkey) # Расшифровка
print(message.decode(‘utf8’))

Цифровая подпись.

Цифровая подпись (ЦП) позволяет подтвердить авторство электронного документа . Подпись связана как с автором, так и с самим документом с помощью криптографических методов, и не может быть подделана с помощью обычного копирования. Наш модуль RSA позволяет подписывать сообщения для подтверждения автора и целостности сообщения :

(pubkey, privkey) = rsa.newkeys(512) 
message = 'Test message' 
signature = rsa.sign(message, privkey, 'SHA-1') # Создание подписи rsa.sign(message, priv_key, hash_method),можно использовать ‘MD5’, ‘SHA-1’, ‘SHA-224’, 'SHA-256’, ‘SHA-384’ и ‘SHA-512’

Для проверки подписи используйте rsa.verify() функция. Эта функция возвращает значение True, если проверка прошла успешно:

>>> message = 'Test message'
>>> rsa.verify(message, signature, pubkey)
True

Если подпись не действительно выйдет исключение rsa.pkcs1.VerificationError

>>> message = 'Test message not true'
>>> rsa.verify(message, signature, pubkey) 
Traceback (most recent call last): 
File "", line 1, in 
File "/home/sybren/workspace/python-rsa/rsa/pkcs1.py", line 289, in verify 
raise VerificationError('Verification failed') 
rsa.pkcs1.VerificationError: Verification failed

Проблема больших сообщений.

RSA может шифровать только сообщения, которые меньше, чем ключ. Пара байт теряются на случайном заполнении, а остальное доступно для само послание. Например, 512-битный ключ может кодировать 53-байт сообщения (512 бит = 64 байта, 11 байт используются для случайного заполнения и другая вещь.)

Но оф. руководство нам предлагает для шифрования больших сообщений воспользоваться блочным шифром, например AES. А его ключ передать зашифрованным с помощью алгоритма RSA :

import rsa.randnum
aes_key = rsa.randnum.read_random_bits(128)# Создаем случайный ключ 128 бит
encrypted_aes_key = rsa.encrypt(aes_key, public_rsa_key) # Зашифровываем ключ и передаем для расшифровки большого сообщения.

Ошибка в тексте? Выделите её и нажмите «Ctrl + Enter»

Источник

Python rsa key to byte

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

The algorithm can be used for both confidentiality (encryption) and authentication (digital signature). It is worth noting that signing and decryption 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 (256 bytes 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 file called mykey.pem , and then read it back:

>>> from Crypto.PublicKey import RSA >>> >>> key = RSA.generate(2048) >>> f = open('mykey.pem','wb') >>> f.write(key.export_key('PEM')) >>> f.close() . >>> f = open('mykey.pem','r') >>> key = RSA.import_key(f.read())

Create a new RSA key pair.

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

  • 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 its binary representation. The FIPS standard requires the public exponent to be at 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:

  • rsa_components (tuple) – A tuple of integers, with at least 2 and no more than 6 items. The items come in the following order:
    1. RSA modulus n.
    2. Public exponent e.
    3. Private exponent d. Only required if the key is private.
    4. First factor of n (p). Optional, but the other factor q must also be present.
    5. Second factor of n (q). Optional.
    6. CRT coefficient q, that is \(p^ \textq\) . Optional.
  • consistency_check (boolean) – If True , the library will verify that the provided components fulfil 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).

  • extern_key (stringorbyte 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 PEM encoding)
    • 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.

    Returns: An RSA key object ( RsaKey ).

    Raises: ValueError/IndexError/TypeError – When the given key cannot be parsed (possibly because the pass phrase 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.

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

      Note This parameter is ignored for a public key. For DER and PEM, an ASN.1 DER SubjectPublicKeyInfo structure is always used.

      1. A 16 byte Triple DES key is derived from the passphrase using Crypto.Protocol.KDF.PBKDF2() with 8 bytes salt, and 1 000 iterations of Crypto.Hash.HMAC .
      2. The private key is encrypted using CBC.
      3. The encrypted key is encoded according to PKCS#8.

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

      ValueError – when the format is unknown or when you try to encrypt a private key with DER format and PKCS#1.

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

Оцените статью
© 2024 Программирование