Chiffrer dans le front-end JS et déchiffrer dans le backend python à l'aide d'AES GCM

GCM est un mode de chiffrement de flux et ne nécessite donc pas de remplissage. Lors du cryptage, une balise d'authentification est implicitement générée, qui est utilisée pour l'authentification lors du décryptage. De plus, un IV/nonce de 12 octets est recommandé pour GCM.

Le code Python posté remplit inutilement et ne prend pas en compte la balise d'authentification, contrairement au code JavaScript, qui peut être la principale raison des différents textes chiffrés. Il est difficile de dire si c'est la seule raison et si le code JavaScript implémente correctement GCM, car la getMessageEncoding()méthode n'a pas été publiée, il n'a donc pas été possible de tester cela.

De plus, les deux codes appliquent un IV/nonce de 16 octets au lieu des 12 octets IV/nonce recommandés.

La cryptographie offre deux implémentations possibles pour GCM. Une implémentation utilise l'architecture des modes de non-authentification comme CBC. Le code Python publié applique cette conception, mais ne prend pas en compte l'authentification et implémente donc GCM de manière incomplète. Un exemple correct pour cette conception peut être trouvé ici .
La cryptographie recommande généralement l'autre approche pour GCM (voir la note de danger ), à savoir la AESGCMclasse, qui effectue une authentification implicite afin que cela ne puisse pas être accidentellement oublié ou mal implémenté.

L'implémentation suivante utilise la AESGCMclasse (et prend également en compte les données authentifiées supplémentaires facultatives ) :

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import base64
#import os

#key = AESGCM.generate_key(bit_length=256)    
#nonce = os.urandom(12)
key = base64.b64decode('MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE=') # fix for testing, AES-256
nonce = base64.b64decode('MDEyMzQ1Njc4OTAx') # fix for testing, 12 bytes

plaintext = b'The quick brown fox jumps over the lazy dog'
aad = b'the aad' # aad = None without additional authenticated data

aesgcm = AESGCM(key)
ciphertext = aesgcm.encrypt(nonce, plaintext, aad)
print('Ciphertext (B64): ' + base64.b64encode(ciphertext).decode('utf8'))
decrypted = aesgcm.decrypt(nonce, ciphertext, aad)
print('Decrypted:        ' + decrypted.decode('utf8'))

avec la sortie :

Output
Ciphertext (B64): JOetStCANhPISvQ6G6IcRBauqbtC8fzRooblayHqkqSPKzLbidx/gBWfLNzBC+ZpcAGnGnHXaI7CB1U=
Decrypted:        The quick brown fox jumps over the lazy dog

La balise d'authentification est ajoutée au texte chiffré, de sorte que le résultat (décodé en Base64) a la longueur du texte en clair (43 octets) plus la longueur de la balise (16 octets, par défaut), ce qui donne un total de 59 octets.

Pour les tests, une clé prédéfinie et IV/nonce sont utilisés en vue d'une comparaison avec le résultat du code JavaScript. Notez qu'en pratique une paire clé/IV ne peut être utilisée qu'une seule fois pour des raisons de sécurité, ce qui est particulièrement important pour le mode GCM, par exemple ici . Par conséquent, un IV/nonce aléatoire est généralement généré pour chaque chiffrement.

L' API WebCrypto est une API de bas niveau pour la cryptographie et ne fournit pas de méthodes pour l'encodage/décodage Base64. Dans ce qui suit, js-base64 est utilisé pour plus de simplicité. Tout comme le code Python, la balise est ajoutée au texte chiffré.

Une implémentation possible pour AES-GCM en utilisant la clé et IV/nonce du code Python qui est fonctionnellement essentiellement le même que le code JavaScript publié est :

(async () => {      
    var key = Base64.toUint8Array('MDEyMzQ1Njc4OTAxMjM0NTY3ODkwMTIzNDU2Nzg5MDE='); // fix for testing, AES-256
    var nonce = Base64.toUint8Array('MDEyMzQ1Njc4OTAx'); // fix for testing, 12 bytes

    var plaintext = new TextEncoder().encode("The quick brown fox jumps over the lazy dog");
    var aad = new TextEncoder().encode('the aad');
                
    var keyImported = await await crypto.subtle.importKey(
        "raw",
        key,
        { name: "AES-GCM" },
        true,
        ["decrypt", "encrypt"]
    );
                
    var ciphertext = await await crypto.subtle.encrypt(
        { name: "AES-GCM", iv: nonce, additionalData: aad }, // { name: "AES-GCM", iv: nonce } without additional authenticated data
        keyImported,
        plaintext
    );
    console.log('Ciphertext (Base64):\n', Base64.fromUint8Array(new Uint8Array(ciphertext)).replace(/(.{48})/g,'$1\n'));
              
    var decrypted = await await crypto.subtle.decrypt(
        { name: "AES-GCM", iv: nonce, additionalData: aad }, // { name: "AES-GCM", iv: nonce } without additional authenticated data
        keyImported,
        ciphertext
    );
    console.log('Plaintext:\n', new TextDecoder().decode(decrypted).replace(/(.{48})/g,'$1\n'));
})();

<script src="https://cdn.jsdelivr.net/npm/[email protected]/base64.min.js"></script>

avec la sortie :

Ciphertext (Base64):
 JOetStCANhPISvQ6G6IcRBauqbtC8fzRooblayHqkqSPKzLbidx/gBWfLNzBC+ZpcAGnGnHXaI7CB1U=
Plaintext:
 The quick brown fox jumps over the lazy dog

où le texte chiffré est le même que celui du code Python.