python - password - how to decrypt hash 256

Cifrado y descifrado RSA en Python

Question

Necesito ayuda para usar el cifrado y descifrado RSA en Python.

Estoy creando un par de claves privadas / públicas, cifrando un mensaje con claves y escribiendo el mensaje en un archivo. Luego estoy leyendo el texto cifrado del archivo y descifrando el texto usando la clave.

Estoy teniendo problemas con la parte de descifrado. Como puede ver en mi código a continuación, cuando puse en decrypted = key.decrypt(message) que el programa funciona, el mensaje descifrado se cifra nuevamente. Parece que no está leyendo el texto cifrado del archivo.

¿Puede alguien ayudarme a escribir este código para que el descifrado lea el texto cifrado del archivo y luego use la clave para descifrar el texto cifrado?

import Crypto
from Crypto.PublicKey import RSA
from Crypto import Random

random_generator = Random.new().read
key = RSA.generate(1024, random_generator) #generate public and private keys

publickey = key.publickey # pub key export for exchange

encrypted = publickey.encrypt(''encrypt this message'', 32)
#message to encrypt is in the above line ''encrypt this message''

print ''encrypted message:'', encrypted #ciphertext

f = open (''encryption.txt'', ''w''w)
f.write(str(encrypted)) #write ciphertext to file
f.close()

#decrypted code below

f = open (''encryption.txt'', ''r'')
message = f.read()

decrypted = key.decrypt(message)

print ''decrypted'', decrypted

f = open (''encryption.txt'', ''w'')
f.write(str(message))
f.write(str(decrypted))
f.close()

Answer 1

Aquí está mi implementación para python 3 y pycrypto

from Crypto.PublicKey import RSA
key = RSA.generate(4096)
f = open(''/home/john/Desktop/my_rsa_public.pem'', ''wb'')
f.write(key.publickey().exportKey(''PEM''))
f.close()
f = open(''/home/john/Desktop/my_rsa_private.pem'', ''wb'')
f.write(key.exportKey(''PEM''))
f.close()

f = open(''/home/john/Desktop/my_rsa_public.pem'', ''rb'')
f1 = open(''/home/john/Desktop/my_rsa_private.pem'', ''rb'')
key = RSA.importKey(f.read())
key1 = RSA.importKey(f1.read())

x = key.encrypt(b"dddddd",32)

print(x)
z = key1.decrypt(x)
print(z)

Answer 2

Para que funcione, es necesario convertir la clave de str a tuple antes del descifrado (función ast.literal_eval). Aquí está el código fijo:

import Crypto
from Crypto.PublicKey import RSA
from Crypto import Random
import ast

random_generator = Random.new().read
key = RSA.generate(1024, random_generator) #generate pub and priv key

publickey = key.publickey() # pub key export for exchange

encrypted = publickey.encrypt(''encrypt this message'', 32)
#message to encrypt is in the above line ''encrypt this message''

print ''encrypted message:'', encrypted #ciphertext
f = open (''encryption.txt'', ''w'')
f.write(str(encrypted)) #write ciphertext to file
f.close()

#decrypted code below

f = open(''encryption.txt'', ''r'')
message = f.read()


decrypted = key.decrypt(ast.literal_eval(str(encrypted)))

print ''decrypted'', decrypted

f = open (''encryption.txt'', ''w'')
f.write(str(message))
f.write(str(decrypted))
f.close()

Answer 3

# coding: utf-8
from __future__ import unicode_literals
import base64
import os

import six
from Crypto import Random
from Crypto.PublicKey import RSA


class PublicKeyFileExists(Exception): pass


class RSAEncryption(object):
    PRIVATE_KEY_FILE_PATH = None
    PUBLIC_KEY_FILE_PATH = None

    def encrypt(self, message):
        public_key = self._get_public_key()
        public_key_object = RSA.importKey(public_key)
        random_phrase = ''M''
        encrypted_message = public_key_object.encrypt(self._to_format_for_encrypt(message), random_phrase)[0]
        # use base64 for save encrypted_message in database without problems with encoding
        return base64.b64encode(encrypted_message)

    def decrypt(self, encoded_encrypted_message):
        encrypted_message = base64.b64decode(encoded_encrypted_message)
        private_key = self._get_private_key()
        private_key_object = RSA.importKey(private_key)
        decrypted_message = private_key_object.decrypt(encrypted_message)
        return six.text_type(decrypted_message, encoding=''utf8'')

    def generate_keys(self):
        """Be careful rewrite your keys"""
        random_generator = Random.new().read
        key = RSA.generate(1024, random_generator)
        private, public = key.exportKey(), key.publickey().exportKey()

        if os.path.isfile(self.PUBLIC_KEY_FILE_PATH):
            raise PublicKeyFileExists(''Файл с публичным ключом существует. Удалите ключ'')
        self.create_directories()

        with open(self.PRIVATE_KEY_FILE_PATH, ''w'') as private_file:
            private_file.write(private)
        with open(self.PUBLIC_KEY_FILE_PATH, ''w'') as public_file:
            public_file.write(public)
        return private, public

    def create_directories(self, for_private_key=True):
        public_key_path = self.PUBLIC_KEY_FILE_PATH.rsplit(''/'', 1)
        if not os.path.exists(public_key_path):
            os.makedirs(public_key_path)
        if for_private_key:
            private_key_path = self.PRIVATE_KEY_FILE_PATH.rsplit(''/'', 1)
            if not os.path.exists(private_key_path):
                os.makedirs(private_key_path)

    def _get_public_key(self):
        """run generate_keys() before get keys """
        with open(self.PUBLIC_KEY_FILE_PATH, ''r'') as _file:
            return _file.read()

    def _get_private_key(self):
        """run generate_keys() before get keys """
        with open(self.PRIVATE_KEY_FILE_PATH, ''r'') as _file:
            return _file.read()

    def _to_format_for_encrypt(value):
        if isinstance(value, int):
            return six.binary_type(value)
        for str_type in six.string_types:
            if isinstance(value, str_type):
                return value.encode(''utf8'')
        if isinstance(value, six.binary_type):
            return value

Y use

KEYS_DIRECTORY = settings.SURVEY_DIR_WITH_ENCRYPTED_KEYS

class TestingEncryption(RSAEncryption):
    PRIVATE_KEY_FILE_PATH = KEYS_DIRECTORY + ''private.key''
    PUBLIC_KEY_FILE_PATH = KEYS_DIRECTORY + ''public.key''


# django/flask
from django.core.files import File

class ProductionEncryption(RSAEncryption):
    PUBLIC_KEY_FILE_PATH = settings.SURVEY_DIR_WITH_ENCRYPTED_KEYS + ''public.key''

    def _get_private_key(self):
        """run generate_keys() before get keys """
        from corportal.utils import global_elements
        private_key = global_elements.request.FILES.get(''private_key'')
        if private_key:
            private_key_file = File(private_key)
            return private_key_file.read()

message = ''Hello мой friend''
encrypted_mes = ProductionEncryption().encrypt(message)
decrypted_mes = ProductionEncryption().decrypt(message)

Answer 4

from Crypto.Cipher import DES

des = DES.new(''01234567'', DES.MODE_ECB)
text = "abcdefgh8"
leno = len(text)
if leno % 8 != 0:
    for i in range(0, 8 -leno%8):
        text += " "

cipher_text = des.encrypt(text)

des.decrypt(cipher_text)

Básicamente, en el código anterior puede cifrar su texto con una contraseña como "01234567" y descifrarlo nuevamente con esa contraseña. Es simple. La única precaución es que la longitud del texto debe tener un poder de 8, por lo que hay un pequeño bucle que agrega suficiente espacio para que la longitud del texto sea divisible entre 8. Eso es.