Verschlüsseln und Entschlüsseln mit python und nodejs

Ich versuche zu verschlüsseln, einigen Inhalt in Python und entschlüsseln es in einer nodejs-Anwendung.

Ich bin kämpfen, um die zwei AES-Implementierungen arbeiten zusammen. Hier ist, wo ich bin.

In Knoten:

var crypto = require('crypto');

var password = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
var input = 'hello world';

var encrypt = function (input, password, callback) {
    var m = crypto.createHash('md5');
    m.update(password)
    var key = m.digest('hex');

    m = crypto.createHash('md5');
    m.update(password + key)
    var iv = m.digest('hex');

    //add padding
    while (input.length % 16 !== 0) {
        input += ' ';
    }

    var data = new Buffer(input, 'utf8').toString('binary');

    var cipher = crypto.createCipheriv('aes-256-cbc', key, iv.slice(0,16));
    var encrypted = cipher.update(data, 'binary') + cipher.final('binary');
    var encoded = new Buffer(encrypted, 'binary').toString('base64');

    callback(encoded);
};

var decrypt = function (input, password, callback) {
    //Convert urlsafe base64 to normal base64
    var input = input.replace('-', '+').replace('/', '_');
    //Convert from base64 to binary string
    var edata = new Buffer(input, 'base64').toString('binary')

    //Create key from password
    var m = crypto.createHash('md5');
    m.update(password)
    var key = m.digest('hex');

    //Create iv from password and key
    m = crypto.createHash('md5');
    m.update(password + key)
    var iv = m.digest('hex');

    //Decipher encrypted data
    var decipher = crypto.createDecipheriv('aes-256-cbc', key, iv.slice(0,16));
    var decrypted = decipher.update(edata, 'binary') + decipher.final('binary');
    var plaintext = new Buffer(decrypted, 'binary').toString('utf8');

    callback(plaintext);
};

encrypt(input, password, function (encoded) {
    console.log(encoded);
    decrypt(encoded, password, function (output) {
        console.log(output);
    });
});

Dieses Beispiel erzeugt die Ausgabe:

BXSGjDAYKeXlaRXVVJGuREKTPiiXeam8W9e96Nknt3E=
hello world

In python

from Crypto.Cipher import AES
from hashlib import md5
import base64

password = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
input = 'hello world'

def _encrypt(data, nonce, password):
    m = md5()
    m.update(password)
    key = m.hexdigest()

    m = md5()
    m.update(password + key)
    iv = m.hexdigest()

    # pad to 16 bytes
    data = data + " " * (16 - len(data) % 16)

    aes = AES.new(key, AES.MODE_CBC, iv[:16])

    encrypted = aes.encrypt(data)
    return base64.urlsafe_b64encode(encrypted)

def _decrypt(edata, nonce, password):
    edata = base64.urlsafe_b64decode(edata)

    m = md5()
    m.update(password)
    key = m.hexdigest()

    m = md5()
    m.update(password + key)
    iv = m.hexdigest()

    aes = AES.new(key, AES.MODE_CBC, iv[:16])
    return aes.decrypt(edata)

output = _encrypt(input, "", password) 
print(output)
plaintext = _decrypt(output, "", password)
print(plaintext)

Dieses Beispiel erzeugt die Ausgabe

BXSGjDAYKeXlaRXVVJGuRA==
hello world

Klar, Sie sind sehr nahe, aber Knoten scheint Polsterung die Ausgabe mit etwas. Irgendwelche Ideen, wie ich können die beiden zusammenarbeiten?

1) brauchst du wirklich Passwort-basierte Verschlüsselung, statt mit einem zufälligen Schlüssel? 2) Wenn Sie das tun, verwenden Sie nicht eine einzige iteration von hash-Funktionen. Verwenden Sie ein Salz, und slow-Taste-Ableitung Funktionen wie PBKDF2, bcrypt oder scrypt.
3) Sie nicht die IV richtig entweder. Es sollte eine neue, zufällige Wert für jede Nachricht. Es sollte auch die gleiche Größe wie die Blockgröße, und nicht die Hälfte der Blockgröße, wie in deinem Beispiel.
Danke @CodeInChaos dies ist Beispielcode, damit ich vereinfacht einiges. Das Passwort wird erzeugt mit PBKDF2 und die IV randomisiert werden, in der Produktion.

InformationsquelleAutor dave | 2012-05-11

OK, ich habe es herausgefunden, Knoten verwendet OpenSSL verwendet PKCS5 zu tun-Polsterung. PyCrypto nicht handhaben, die Polsterung so war ich es selbst zu tun, fügen Sie einfach '' in beiden.

Wenn ich PKCS5 padding in der python-code, und entfernen Sie die Polsterung in den Knoten der code, es funktioniert.

So aktualisiert, funktionierenden code.
Knoten:

var crypto = require('crypto');

var password = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa';
var input = 'hello world';

var encrypt = function (input, password, callback) {
    var m = crypto.createHash('md5');
    m.update(password)
    var key = m.digest('hex');

    m = crypto.createHash('md5');
    m.update(password + key)
    var iv = m.digest('hex');

    var data = new Buffer(input, 'utf8').toString('binary');

    var cipher = crypto.createCipheriv('aes-256-cbc', key, iv.slice(0,16));

    //UPDATE: crypto changed in v0.10
    //https://github.com/joyent/node/wiki/Api-changes-between-v0.8-and-v0.10 
    var nodev = process.version.match(/^v(\d+)\.(\d+)/);
    var encrypted;

    if( nodev[1] === '0' && parseInt(nodev[2]) < 10) {
        encrypted = cipher.update(data, 'binary') + cipher.final('binary');
    } else {
        encrypted = cipher.update(data, 'utf8', 'binary') + cipher.final('binary');
    }

    var encoded = new Buffer(encrypted, 'binary').toString('base64');

    callback(encoded);
};

var decrypt = function (input, password, callback) {
    //Convert urlsafe base64 to normal base64
    var input = input.replace(/\-/g, '+').replace(/_/g, '/');
    //Convert from base64 to binary string
    var edata = new Buffer(input, 'base64').toString('binary')

    //Create key from password
    var m = crypto.createHash('md5');
    m.update(password)
    var key = m.digest('hex');

    //Create iv from password and key
    m = crypto.createHash('md5');
    m.update(password + key)
    var iv = m.digest('hex');

    //Decipher encrypted data
    var decipher = crypto.createDecipheriv('aes-256-cbc', key, iv.slice(0,16));

    //UPDATE: crypto changed in v0.10
    //https://github.com/joyent/node/wiki/Api-changes-between-v0.8-and-v0.10 
    var nodev = process.version.match(/^v(\d+)\.(\d+)/);
    var decrypted, plaintext;

    if( nodev[1] === '0' && parseInt(nodev[2]) < 10) {  
        decrypted = decipher.update(edata, 'binary') + decipher.final('binary');    
        plaintext = new Buffer(decrypted, 'binary').toString('utf8');
    } else {
        plaintext = (decipher.update(edata, 'binary', 'utf8') + decipher.final('utf8'));
    }

    callback(plaintext);
};

encrypt(input, password, function (encoded) {
    console.log(encoded);
    decrypt(encoded, password, function (output) {
        console.log(output);
    });
});

Python:

from Crypto.Cipher import AES
from hashlib import md5
import base64


password = 'aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa'
input = 'hello world'

BLOCK_SIZE = 16

def pad (data):
    pad = BLOCK_SIZE - len(data) % BLOCK_SIZE
    return data + pad * chr(pad)

def unpad (padded):
    pad = ord(padded[-1])
    return padded[:-pad]

def _encrypt(data, nonce, password):
    m = md5()
    m.update(password)
    key = m.hexdigest()

    m = md5()
    m.update(password + key)
    iv = m.hexdigest()

    data = pad(data)

    aes = AES.new(key, AES.MODE_CBC, iv[:16])

    encrypted = aes.encrypt(data)
    return base64.urlsafe_b64encode(encrypted)

def _decrypt(edata, nonce, password):
    edata = base64.urlsafe_b64decode(edata)

    m = md5()
    m.update(password)
    key = m.hexdigest()

    m = md5()
    m.update(password + key)
    iv = m.hexdigest()

    aes = AES.new(key, AES.MODE_CBC, iv[:16])
    return unpad(aes.decrypt(edata))

output = _encrypt(input, "", password) 
print(output)
plaintext = _decrypt(output, "", password)
print("'" + plaintext + "'")

Es gibt einen kleinen bug in Ihrem Node.js entschlüsseln Funktion. Es wird nicht in der Lage mehrere - oder mehrere /. Auch im entschlüsseln, die Sie ersetzen müssen _ mit /, nicht die andere Weise herum. Sie können einfach ersetzen Sie diese Zeile mit: var input = input.replace(/\-/g, '+').replace(/_/g, '/');
Danke, ich habe es behoben in der Antwort jetzt
Vielen Dank für die Beispiele. Ich wurde empfangen von einem "falschen letzten block length" Fehler mit komplexen input, und ich fand ein update beschrieben in das SO ein post, die mein problem gelöst. Ich habe die oben genannten änderungen.
In Python ist3 ich bemerkt, dass Sie benötigen, ändern Sie diese Zeile aus "' pad = ord(gepolstert[-1]) "' zu "' pad = ord(chr(gepolstert[-1])) "'
vielen Dank für das Beispiel, hat mir sehr geholfen. Eine kleine änderung musste ich vornehmen: in JavaScript zu verschlüsseln(), nach var data = new Buffer(input, 'utf8').toString('binary'); man sollte nicht angeben, 'utf8' zu erstellen encrypted aber halten Sie sich stattdessen mit 'binären'
Dieses python-code funktioniert nicht in version 3.5, können Sie mir bitte helfen ?

InformationsquelleAutor dave

Nur für eine, die ähnlich ist zu mir, wer war auf der Suche nach einem einfachen Weg, um die Verschlüsselung und Entschlüsselung bei AES in python, das tun die gleiche Sache in node.js. Die Klasse hier unterstützt verschiedene bits des AES und die beiden hex-und base64-Kodierung erzeugt dasselbe Ergebnis in node.js.

Bemerkte auch, dass wenn Sie fehlen, das Paket Crypto, können Sie einfach installieren Sie es, indem

pip install pycrypto

Den code für python ist wie folgt:

import base64
import hashlib
from Crypto.Cipher import AES

class AESCrypto(object):
    def __init__(self, algorithm, password):
        self.algorithm = filter(lambda x: not x.isdigit(), algorithm).lower()
        self.bits = int(filter(str.isdigit, algorithm))
        self.bs = 16
        if not self.algorithm == 'aes':
            raise Exception('Only AES crypto is supported')
        if not self.bits % 8 == 0:
            raise Exception('Bits of crypto must be a multiply of 8.')
        self.bytes = self.bits / 8
        self.password = password
        self.generateKeyAndIv()

    def generateKeyAndIv(self):
        last = ''
        allBytes = ''
        maxBytes = self.bytes + self.bs
        while len(allBytes) < maxBytes:
            last = hashlib.md5(last + self.password).digest()
            allBytes += last
        self.key = allBytes[:self.bytes]
        self.iv = allBytes[self.bytes:maxBytes]

    def encrypt(self, raw, outputEncoding):
        outputEncoding = outputEncoding.lower()
        raw = self._pad(raw)
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        encrypted = cipher.encrypt(raw)
        if outputEncoding == 'hex':
            return encrypted.encode('hex')
        elif outputEncoding == 'base64':
            return base64.b64encode(encrypted)
        else:
            raise Exception('Encoding is not supported.')

    def decrypt(self, data, inputEncoding):
        inputEncoding = inputEncoding.lower()
        if inputEncoding == 'hex':
            data = ''.join(map(chr, bytearray.fromhex(data)))
        elif inputEncoding == 'base64':
            data = base64.b64decode(data)
        cipher = AES.new(self.key, AES.MODE_CBC, self.iv)
        return self._unpad(cipher.decrypt(data))

    def _pad(self, data):
        padding = self.bs - len(data) % self.bs
        return data + padding * chr(padding)

    @staticmethod
    def _unpad(data):
        return data[0:-ord(data[-1])]

Im folgenden finden Sie Beispiele zur Verwendung der Klasse:

Verschlüsselung Beispiel:

password = 'some_random_password'
content = 'content_to_be_encrypted'
cipher = AESCrypto('aes192', password)
encrypted = cipher.encrypt(content, 'hex')

Entschlüsselung Beispiel:

password = 'some_random_password'
content = 'encrypted_content'
cipher = AESCrypto('aes192', password)
decrypted = cipher.decrypt(content, 'hex')

InformationsquelleAutor Kenneth Tang

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.