Crypter un fichier avec RSA en Python

Je suis la mise en œuvre de cryptage de fichier avec le RSA, l'aide de PyCrypto.

Je sais que c'est un peu faux, d'abord parce que RSA est très lent et en second lieu parce que PyCrypto RSA ne peut crypter 128 caractères, de sorte que vous avez à faire exploser le fichier de 128 caractères morceaux.

C'est le code pour l'instant:

from Crypto.PublicKey import RSA

file_to_encrypt = open('my_file.ext', 'rb').read()
pub_key = open('my_pub_key.pem', 'rb').read()
o = RSA.importKey(pub_key)

to_join = []
step = 0

while 1:
    # Read 128 characters at a time.
    s = file_to_encrypt[step*128:(step+1)*128]
    if not s: break
    # Encrypt with RSA and append the result to list.
    # RSA encryption returns a tuple containing 1 string, so i fetch the string.
    to_join.append(o.encrypt(s, 0)[0])
    step += 1

# Join the results.
# I hope the \r\r\r sequence won't appear in the encrypted result,
# when i explode the string back for decryption.
encrypted = '\r\r\r'.join(to_join)
# Write the encrypted file.
open('encrypted_file.ext', 'wb').write(encrypted)

Donc ma question est : existe-il des meilleures méthodes pour l'utilisation Privée/clé Publique de chiffrement SUR les FICHIERS ?

J'ai entendu parler de Mcrypt et d'OpenSSL, mais je ne sais pas si on peut crypter des fichiers.

Vous devez utiliser un chiffrement symétrique comme AES pour crypter le fichier, puis utilisation de RSA pour crypter la clé AES.
B: je souhaite que je pourrais, comme ce commentaire 100 fois.
Gpg4win fait quoi @Petey B dit que vous devriez faire.
1. Le montant qui peut être chiffré est une fonction du module RSA de taille. 2. Le bloc que vous chiffrez doit être inférieur au module d'élasticité que les entiers, de sorte que vous ne peut pas garantir le fonctionnement correct de 1024 bits module si vous chiffrer des blocs de 128 octets à la fois. 3. Vous vous demandez s'il existe de meilleures méthodes, mais vous avez rejeté les suggestions. Dans ce cas, quelle est votre définition de "mieux"?
Merci beaucoup pour vos conseils!!! Je sais que je suis un peu têtu, mais je l'écoute à l'avis de l'expert.

OriginalL'auteur Cristi Constantin | 2011-06-10

30

De chiffrement à clé publique est généralement utilisé pour de petites quantités de données. Il est lent, et ils peuvent être difficiles à utiliser. La pratique habituelle consiste à utiliser d'autres méthodes pour réduire l'asymétrie de problème à un endroit où la sécurité est assurée par une clé partagée, puis utilisez le chiffrement à clé publique pour protéger la clé partagée. Par exemple:
- Pour crypter un fichier, générer aléatoirement une clé secrète d'un bloc ou de chiffrement de flux (par exemple, AES). Stocker les données chiffrées avec ce chiffre, et de stocker la clé secrète chiffrée avec la clé publique à côté de la charge utile cryptée.
- Pour signer un fichier, calculer un chiffrement digest (par exemple SHA-256). Signe de l'empreinte de fichier avec la clé privée et le magasin avec le fichier.
Voici donc une esquisse de la façon dont le cryptage peut ressembler (attention, le code non testé, tapé directement dans le navigateur):
```
import os
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
import Crypto.Util.number
def encrypt_file(rsa, input, output):
    # Generate secret key
    secret_key = os.urandom(16)
    # Padding (see explanations below)
    plaintext_length = (Crypto.Util.number.size(rsa.n) - 2) / 8
    padding = '\xff' + os.urandom(16)
    padding += 'import os
from Crypto.Cipher import AES
from Crypto.PublicKey import RSA
import Crypto.Util.number
def encrypt_file(rsa, input, output):
# Generate secret key
secret_key = os.urandom(16)
# Padding (see explanations below)
plaintext_length = (Crypto.Util.number.size(rsa.n) - 2) / 8
padding = '\xff' + os.urandom(16)
padding += '\0' * (plaintext_length - len(padding) - len(secret_key))
# Encrypt the secret key with RSA
encrypted_secret_key = rsa.encrypt(padding + secret_key, None)
# Write out the encrypted secret key, preceded by a length indication
output.write(str(len(encrypted_secret_key)) + '\n')
output.write(encrypted_secret_key)
# Encrypt the file (see below regarding iv)
iv = '\x00' * 16
aes_engine = AES.new(secret_key, AES.MODE_CBC, iv)
output.write(aes_engine.encrypt(input.read()))
' * (plaintext_length - len(padding) - len(secret_key))
    # Encrypt the secret key with RSA
    encrypted_secret_key = rsa.encrypt(padding + secret_key, None)
    # Write out the encrypted secret key, preceded by a length indication
    output.write(str(len(encrypted_secret_key)) + '\n')
    output.write(encrypted_secret_key)
    # Encrypt the file (see below regarding iv)
    iv = '\x00' * 16
    aes_engine = AES.new(secret_key, AES.MODE_CBC, iv)
    output.write(aes_engine.encrypt(input.read()))
```
La iv est un vecteur d'initialisation pour la CBC mode de fonctionnement. Il doit être unique par clé par message. Normalement, il est envoyé avec les données en clair. Ici, étant donné que la clé n'est jamais utilisé une fois, vous pouvez utiliser un connu IV.

L'API de chiffrement par bloc est décrit dans PEP 272. Malheureusement, il ne supporte tout-à-une fois le chiffrement. Pour les gros fichiers, il serait préférable de le chiffrer morceau par morceau; vous pouvez chiffrer aussi peu que un bloc à la fois (16 octets pour l'AES), mais vous avez besoin d'une meilleure librairie de cryptographie.

Remarque qu'en général, vous ne devriez pas directement de crypter les données avec le RSA. La plus évidente préoccupation est que l'attaquant connaît la clé publique et peut donc tenter de deviner le texte en clair (si l'attaquant pense que le texte en clair peut être swordfish, l'attaquant peut chiffrer swordfish avec la clé publique RSA, et comparer le résultat avec la sortie de le cryptage RSA). Une autre question qui se poserait si vous voulez envoyer le fichier à plusieurs destinataires, c'est que si le cryptage RSA étape est déterministe, alors l'attaquant peut dire que le plaintexts sont les mêmes parce que le chiffrés sont les mêmes. Les normales de défense contre ces problèmes est d'utiliser un le protocole de remplissage, qui consiste en l'ajout de certains secrète aléatoire de données pour le texte en clair; ces données sont appelées rembourrage. L'attaquant ne peut pas deviner les données aléatoires, et voit des résultats différents pour chaque chiffrement, car le même texte en clair est jamais chiffré deux fois; en ce qui concerne le bénéficiaire légitime, le rembourrage est juste des données qui peuvent être jetés.

Ici, il peut sembler que les préoccupations ci-dessus ne s'appliquent pas dans ce scénario. Cependant, il y a d'autres faiblesses qui peuvent résulter de l'utilisation de RSA non protégés. En particulier, si l'exposant est très petit (pas le cas ici, que PyCrypto utilise 65537) ou vous chiffrer le même matériau pour beaucoup de différents destinataires (de nouveau, probablement pas le cas ici, puisque chaque message possède sa propre clé secrète), puis un simple calcul mathématique permettrait à l'attaquant de récupérer le RSA en clair. Pour éviter cette attaque, la valeur qui est chiffré avec un RSA doit être “assez près” à la lsf, d'élasticité, de sorte que l'opération de chiffrement effectue une exponentiation modulaire. Le rembourrage je propose assure qu'en faisant le plus élevé-de l'ordre d'octets qui correspond à 0xff; c'est cru pour être sûr, bien que dans le monde réel vous devriez utilisé approuvé mode de remplissage (OAEP.).

OriginalL'auteur Gilles

Vous devez vous connecter pour publier un commentaire.