Ersten bytes fehlerhaft nach Java AES/CBC-Entschlüsselung

Viele Menschen, einschließlich mir Gesicht viele Probleme, die in dieser Arbeit aufgrund fehlender Informationen, wie, vergessen zu konvertieren, Base64 -, Initialisierungs-Vektoren, Zeichensatz, etc. Also habe ich darüber nachgedacht, eine voll funktionsfähige code.

Hoffe, das wird hilfreich sein für Euch alle:
Zum kompilieren benötigt man zusätzliche Apache-Commons-Codec-Glas, die hier verfügbar ist:
http://commons.apache.org/proper/commons-codec/download_codec.cgi

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;

import org.apache.commons.codec.binary.Base64;

public class Encryptor {
    public static String encrypt(String key, String initVector, String value) {
        try {
            IvParameterSpec iv = new IvParameterSpec(initVector.getBytes("UTF-8"));
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");

            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.ENCRYPT_MODE, skeySpec, iv);

            byte[] encrypted = cipher.doFinal(value.getBytes());
            System.out.println("encrypted string: "
                    + Base64.encodeBase64String(encrypted));

            return Base64.encodeBase64String(encrypted);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return null;
    }

    public static String decrypt(String key, String initVector, String encrypted) {
        try {
            IvParameterSpec iv = new IvParameterSpec(initVector.getBytes("UTF-8"));
            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");

            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.DECRYPT_MODE, skeySpec, iv);

            byte[] original = cipher.doFinal(Base64.decodeBase64(encrypted));

            return new String(original);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args) {
        String key = "Bar12345Bar12345"; //128 bit key
        String initVector = "RandomInitVector"; //16 bytes IV

        System.out.println(decrypt(key, initVector,
                encrypt(key, initVector, "Hello World")));
    }
}

Sieht für mich wie Sie haben es nicht ordnungsgemäß mit dem Initialisierungsvektor (IV).
Es ist schon eine lange Zeit, seit ich zuletzt gelesen über die AES -, IVs-und block-chaining, aber Ihre Linie

IvParameterSpec ivParameterSpec = new IvParameterSpec(aesKey.getEncoded());

scheint nicht OK zu sein. Im Falle von AES, kann man sich den Initialisierungsvektor als "Anfangszustand" eines cipher-Instanz, und dieser Zustand ist ein bisschen von Informationen, die Sie können nicht aus Ihrer Schlüssel, aber von der eigentlichen Berechnung des zu verschlüsseln, chiffrieren. (Man könnte argumentieren, dass, wenn der IV gewonnen werden können, aus dem Schlüssel, dann wäre es nicht von nutzen, da der Schlüssel bereits an den Chiffre-Instanz während der init-phase).

Daher sollte man die IV als byte[] aus dem cipher-Instanz am Ende Ihrer Verschlüsselung

  cipherOutputStream.close();
  byte[] iv = encryptCipher.getIV();

und sollten Sie initialisieren Ihre Cipher im DECRYPT_MODE mit diesem byte[] :

  IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

Dann, Ihr die Entschlüsselung sollte OK sein.
Hoffe, das hilft.

In dieser Antwort, die ich wählen, um den Ansatz der "Einfache Java-AES-verschlüsseln/entschlüsseln-Beispiel" main theme und nicht das spezifische debugging Frage, weil ich denke, dass dies ein Gewinn für die meisten Leser.

Dies ist eine einfache Zusammenfassung meiner blog post über die AES-Verschlüsselung in Java so empfehle ich das Lesen durch, bevor Sie Sie implementieren nichts. Ich werde jedoch noch ein einfaches Beispiel verwenden und einige Hinweise geben, was zu beachten.

In diesem Beispiel werde ich wählen, zu verwenden authentifizierte Verschlüsselung mit Galois/Counter-Modus oder GCM - Modus. Der Grund dafür ist, dass in den meisten Fällen Sie Integrität und Authentizität in Kombination mit der Vertraulichkeit (Lesen Sie mehr in der blog).

AES-GCM-Verschlüsselung/Entschlüsselung Tutorial

Hier sind die Schritte, die erforderlich sind, um zu verschlüsseln/entschlüsseln mit AES-GCM mit der Java Cryptography Architecture (JCA). Nicht mischen mit anderen Beispielen, da subtile Unterschiede möglicherweise Ihren code völlig unsicher.

1. Key

Als es hängt von deinem use-case, gehe ich davon aus einfachsten Fall: einen zufälligen geheimen Schlüssel.

SecureRandom secureRandom = new SecureRandom();
byte[] key = new byte[16];
secureRandom.nextBytes(key);
SecretKey secretKey = SecretKeySpec(key, "AES");

Wichtig:

• verwenden Sie immer eine starke Pseudo-zufälligen Nummern-generator wie SecureRandom
• 16 byte /128-bit-langer Schlüssel - (oder mehr - aber mehr ist selten nötig)
• wenn Sie möchten, dass ein Schlüssel abgeleitet von einem Benutzer, Passwort, Blick in die Kennwort-hash-Funktion (oder KDF) mit stretching Eigenschaft wie PBKDF2 oder bcrypt
• wenn Sie möchten, dass ein Schlüssel von anderen Quellen abgeleitet, mit einem richtigen key derivation function (KDF) wie HKDF (Die Java-Implementierung hier). Tun nicht Verwendung einfacher kryptographische hashes für die, die es (wie SHA-256).

2. Erstellen der Initialisierungsvektor

Einer die Initialisierung vector (IV) verwendet wird, so dass der gleiche geheime Schlüssel erstellen verschiedene Chiffre Texte.

byte[] IV = new byte[12]; //NEVER REUSE THIS IV WITH SAME KEY
secureRandom.nextBytes(IV);

Wichtig:

• nie die Wiederverwendung der gleichen IV mit dem gleichen Schlüssel (sehr wichtig in GCM /CTR - Modus)
• die IV muss eindeutig sein (dh. die Verwendung zufälliger IV oder counter)
• die IV ist nicht erforderlich, um sein Geheimnis
• verwenden Sie immer eine starke Pseudo-zufälligen Nummern-generator wie SecureRandom
• 12 byte IV ist die richtige Wahl für AES-GCM-Modus

3. Verschlüsseln mit IV und Key

final Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
GCMParameterSpec parameterSpec = new GCMParameterSpec(128, IV); //128 bit auth tag length
cipher.init(Cipher.ENCRYPT_MODE, secretKey, parameterSpec);
byte[] cipherText = cipher.doFinal(plainText);

Wichtig:

• 16 byte /128-bit - authentication tag (dient zur überprüfung der Integrität/Authentizität)
• die Authentifizierungs-Tags werden automatisch an den Chiffre-text (in der JCA-Implementierung)
• seit GCM verhält sich wie eine Stromchiffre, keine Polsterung erforderlich ist
• verwenden CipherInputStream beim verschlüsseln von großen Blöcken von Daten
• wollen zusätzliche (nicht geheimen) Daten überprüft, ob es verändert wurde? Sie verwenden möchten, können die zugehörigen Daten mit cipher.updateAAD(associatedData); Mehr hier.

3. Serialisieren, um Einzelne Nachricht

Nur Anhängen IV und ciphertext. Wie oben gesagt, der IV muss nicht geheim sein.

ByteBuffer byteBuffer = ByteBuffer.allocate(4 + IV.length + cipherText.length);
byteBuffer.putInt(IV.length);
byteBuffer.put(IV);
byteBuffer.put(cipherText);
byte[] cipherMessage = byteBuffer.array();

Optional Kodieren mit Base64 wenn Sie eine string-Darstellung. Entweder Android oder Java 8 ist built-in Umsetzung (verwenden Sie nicht die Apache-Commons-Codec - es ist eine schreckliche Umsetzung). Die Codierung wird verwendet, um den "convert" byte-arrays in string-Darstellung zu machen, es ASCII-safe z.B.:

String base64CipherMessage = Base64.getEncoder().encodeToString(cipherMessage);

4. Bereiten Entschlüsselung: Deserialisieren

Wenn Sie verschlüsselt die Nachricht zunächst entschlüsseln, um byte-array:

byte[] cipherMessage = Base64.getDecoder().decode(base64CipherMessage)

dann dekonstruieren die Nachricht

ByteBuffer byteBuffer = ByteBuffer.wrap(cipherMessage);
int ivLength = byteBuffer.getInt();
if(ivLength < 12 || ivLength >= 16) { //check input parameter
    throw new IllegalArgumentException("invalid IV length");
}
byte[] IV = new byte[ivLength];
byteBuffer.get(IV);
byte[] cipherText = new byte[byteBuffer.remaining()];
byteBuffer.get(cipherText);

Wichtig:

• vorsichtig sein, zu überprüfen input-Parameter, um zu vermeiden, denial-of-service-Angriffe durch Zuweisung von zu viel Speicher (z.B. ein Angreifer kann sich ändern, die Länge-Wert auf z.B. 231 Zuteilung von 2GB heap)

5. Entschlüsseln

Initialisieren den Algorithmus (cipher) und die gleichen Parameter wie bei der Verschlüsselung:

final Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
cipher.init(Cipher.DECRYPT_MODE, new SecretKeySpec(key, "AES"), new GCMParameterSpec(128, IV));
byte[] plainText= cipher.doFinal(cipherText);

Wichtig:

• vergessen Sie nicht, fügen Sie die zugehörigen Daten mit cipher.updateAAD(associatedData); wenn Sie es während der Verschlüsselung.

Beachten Sie, dass die meisten der jüngsten Android-SDK (21+) und Java (7+) - Implementierung AES-GCM. Ältere Versionen kann es fehlt. Ich noch wählen Sie diesen Modus aus, da es einfacher zu implementieren ist zudem effizienter im Vergleich zu ähnlichen Modus der Encrypt-dann-Mac (z.B. AES-CBC + HMAC). Finden Sie in diesem Artikel auf, wie zu implementieren AES-CBC mit HMAC.

Dies ist eine Verbesserung gegenüber der akzeptierten Antwort.

Änderungen:

(1) Mit zufälligen IV und voranzustellen, um den verschlüsselten text

(2) Mit SHA-256 zu erzeugen, einen Schlüssel aus einer passphrase

(3) Keine Abhängigkeit von Apache Commons

public static void main(String[] args) throws GeneralSecurityException {
    String plaintext = "Hello world";
    String passphrase = "My passphrase";
    String encrypted = encrypt(passphrase, plaintext);
    String decrypted = decrypt(passphrase, encrypted);
    System.out.println(encrypted);
    System.out.println(decrypted);
}

private static SecretKeySpec getKeySpec(String passphrase) throws NoSuchAlgorithmException {
    MessageDigest digest = MessageDigest.getInstance("SHA-256");
    return new SecretKeySpec(digest.digest(passphrase.getBytes(UTF_8)), "AES");
}

private static Cipher getCipher() throws NoSuchPaddingException, NoSuchAlgorithmException {
    return Cipher.getInstance("AES/CBC/PKCS5PADDING");
}

public static String encrypt(String passphrase, String value) throws GeneralSecurityException {
    byte[] initVector = new byte[16];
    SecureRandom.getInstanceStrong().nextBytes(initVector);
    Cipher cipher = getCipher();
    cipher.init(Cipher.ENCRYPT_MODE, getKeySpec(passphrase), new IvParameterSpec(initVector));
    byte[] encrypted = cipher.doFinal(value.getBytes());
    return DatatypeConverter.printBase64Binary(initVector) +
            DatatypeConverter.printBase64Binary(encrypted);
}

public static String decrypt(String passphrase, String encrypted) throws GeneralSecurityException {
    byte[] initVector = DatatypeConverter.parseBase64Binary(encrypted.substring(0, 24));
    Cipher cipher = getCipher();
    cipher.init(Cipher.DECRYPT_MODE, getKeySpec(passphrase), new IvParameterSpec(initVector));
    byte[] original = cipher.doFinal(DatatypeConverter.parseBase64Binary(encrypted.substring(24)));
    return new String(original);
}

Andere Lösung, die mit java.util.Base64 mit Spring Boot

Encryptor Klasse

package com.jmendoza.springboot.crypto.cipher;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Component;

import javax.crypto.Cipher;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Base64;

@Component
public class Encryptor {

    @Value("${security.encryptor.key}")
    private byte[] key;
    @Value("${security.encryptor.algorithm}")
    private String algorithm;

    public String encrypt(String plainText) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key, algorithm);
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);
        return new String(Base64.getEncoder().encode(cipher.doFinal(plainText.getBytes(StandardCharsets.UTF_8))));
    }

    public String decrypt(String cipherText) throws Exception {
        SecretKeySpec secretKey = new SecretKeySpec(key, algorithm);
        Cipher cipher = Cipher.getInstance(algorithm);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);
        return new String(cipher.doFinal(Base64.getDecoder().decode(cipherText)));
    }
}

EncryptorController Klasse

package com.jmendoza.springboot.crypto.controller;

import com.jmendoza.springboot.crypto.cipher.Encryptor;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RequestMapping("/cipher")
public class EncryptorController {

    @Autowired
    Encryptor encryptor;

    @GetMapping(value = "encrypt/{value}")
    public String encrypt(@PathVariable("value") final String value) throws Exception {
        return encryptor.encrypt(value);
    }

    @GetMapping(value = "decrypt/{value}")
    public String decrypt(@PathVariable("value") final String value) throws Exception {
        return encryptor.decrypt(value);
    }
}

Anwendung.Eigenschaften

server.port=8082
security.encryptor.algorithm=AES
security.encryptor.key=M8jFt46dfJMaiJA0

Beispiel

http://localhost:8082/cipher/encrypt/jmendoza

2h41HH8Shzc4BRU3hVDOXA==

http://localhost:8082/cipher/decrypt/2h41HH8Shzc4BRU3hVDOXA==

jmendoza

Github: https://github.com/JonathanM2ndoza/Spring-Boot-Crypto