it-swarm.com.de

Einfaches Java-AES-Verschlüsselungs-/Entschlüsselungsbeispiel

Was ist los mit dem folgenden Beispiel?

Das Problem ist, dass der erste Teil der entschlüsselten Zeichenfolge Unsinn ist. Der Rest ist jedoch in Ordnung, ich bekomme ...

Result: `£eB6O�geS��i are you? Have a Nice day.
@Test
public void testEncrypt() {
  try {
    String s = "Hello there. How are you? Have a Nice day.";

    // Generate key
    KeyGenerator kgen = KeyGenerator.getInstance("AES");
    kgen.init(128);
    SecretKey aesKey = kgen.generateKey();

    // Encrypt cipher
    Cipher encryptCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    encryptCipher.init(Cipher.ENCRYPT_MODE, aesKey);

    // Encrypt
    ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
    CipherOutputStream cipherOutputStream = new CipherOutputStream(outputStream, encryptCipher);
    cipherOutputStream.write(s.getBytes());
    cipherOutputStream.flush();
    cipherOutputStream.close();
    byte[] encryptedBytes = outputStream.toByteArray();

    // Decrypt cipher
    Cipher decryptCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
    IvParameterSpec ivParameterSpec = new IvParameterSpec(aesKey.getEncoded());
    decryptCipher.init(Cipher.DECRYPT_MODE, aesKey, ivParameterSpec);

    // Decrypt
    outputStream = new ByteArrayOutputStream();
    ByteArrayInputStream inStream = new ByteArrayInputStream(encryptedBytes);
    CipherInputStream cipherInputStream = new CipherInputStream(inStream, decryptCipher);
    byte[] buf = new byte[1024];
    int bytesRead;
    while ((bytesRead = cipherInputStream.read(buf)) >= 0) {
        outputStream.write(buf, 0, bytesRead);
    }

    System.out.println("Result: " + new String(outputStream.toByteArray()));

  } 
  catch (Exception ex) {
    ex.printStackTrace();
  }
}
100
TedTrippin

Viele Leute, darunter auch ich, sehen sich vielen Problemen gegenüber, weil sie einige Informationen wie das Vergessen der Konvertierung in Base64, Initialisierungsvektoren, Zeichensatz usw. vergessen. Ich dachte daran, einen voll funktionsfähigen Code zu erstellen.

Ich hoffe, dass dies für alle von Nutzen sein wird: Zum Kompilieren benötigen Sie zusätzliche Apache-Commons-Codec-Jar, die hier verfügbar sind: 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")));
    }
}
225

Hier eine Lösung ohne Apache Commons Codec s Base64:

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

public class AdvancedEncryptionStandard
{
    private byte[] key;

    private static final String ALGORITHM = "AES";

    public AdvancedEncryptionStandard(byte[] key)
    {
        this.key = key;
    }

    /**
     * Encrypts the given plain text
     *
     * @param plainText The plain text to encrypt
     */
    public byte[] encrypt(byte[] plainText) throws Exception
    {
        SecretKeySpec secretKey = new SecretKeySpec(key, ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.ENCRYPT_MODE, secretKey);

        return cipher.doFinal(plainText);
    }

    /**
     * Decrypts the given byte array
     *
     * @param cipherText The data to decrypt
     */
    public byte[] decrypt(byte[] cipherText) throws Exception
    {
        SecretKeySpec secretKey = new SecretKeySpec(key, ALGORITHM);
        Cipher cipher = Cipher.getInstance(ALGORITHM);
        cipher.init(Cipher.DECRYPT_MODE, secretKey);

        return cipher.doFinal(cipherText);
    }
}

Anwendungsbeispiel:

byte[] encryptionKey = "MZygpewJsCpRrfOr".getBytes(StandardCharsets.UTF_8);
byte[] plainText = "Hello world!".getBytes(StandardCharsets.UTF_8);
AdvancedEncryptionStandard advancedEncryptionStandard = new AdvancedEncryptionStandard(
        encryptionKey);
byte[] cipherText = advancedEncryptionStandard.encrypt(plainText);
byte[] decryptedCipherText = advancedEncryptionStandard.decrypt(cipherText);

System.out.println(new String(plainText));
System.out.println(new String(cipherText));
System.out.println(new String(decryptedCipherText));

Drucke:

Hello world!
դ;��LA+�ߙb*
Hello world!
38
BullyWiiPlaza

Sieht aus, als würden Sie mit Ihrem Initialisierungsvektor (IV) nicht richtig umgehen. Es ist lange her, seit ich das letzte Mal über AES, IVs und Blockverkettung gelesen habe, aber über Ihre Zeile 

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

scheint nicht in Ordnung zu sein. Im Fall von AES können Sie sich den Initialisierungsvektor als den "Anfangszustand" einer Verschlüsselungsinstanz vorstellen. Dieser Status ist eine Information, die Sie nicht aus Ihrem Schlüssel, sondern aus der tatsächlichen Berechnung der Verschlüsselungsverschlüsselung erhalten können. (Man könnte argumentieren, dass, wenn die IV aus dem Schlüssel extrahiert werden könnte, dies keinen Nutzen hat, da der Schlüssel bereits während der Init-Phase an die Verschlüsselungsinstanz übergeben wird.).

Daher sollten Sie die IV als Byte [] von der Verschlüsselungsinstanz am Ende Ihrer Verschlüsselung erhalten

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

und Sie sollten Ihre Cipher in DECRYPT_MODE mit diesem Byte [] initialisieren:

  IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

Dann sollte Ihre Entschlüsselung in Ordnung sein. Hoffe das hilft.

23
GPI

Die IV, die Sie zur Entschlüsselung verwenden, ist falsch. Diesen Code ersetzen

//Decrypt cipher
Cipher decryptCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec ivParameterSpec = new IvParameterSpec(aesKey.getEncoded());
decryptCipher.init(Cipher.DECRYPT_MODE, aesKey, ivParameterSpec);

Mit diesem Code

//Decrypt cipher
Cipher decryptCipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
IvParameterSpec ivParameterSpec = new IvParameterSpec(encryptCipher.getIV());
decryptCipher.init(Cipher.DECRYPT_MODE, aesKey, ivParameterSpec);

Und das sollte dein Problem lösen. 


Unten finden Sie ein Beispiel für eine einfache AES-Klasse in Java. Es wird nicht empfohlen, diese Klasse in Produktionsumgebungen zu verwenden, da möglicherweise nicht alle spezifischen Anforderungen Ihrer Anwendung berücksichtigt werden. 

import Java.nio.charset.StandardCharsets;
import Java.security.InvalidAlgorithmParameterException;
import Java.security.InvalidKeyException;
import Java.security.NoSuchAlgorithmException;
import Java.security.SecureRandom;
import javax.crypto.BadPaddingException;
import javax.crypto.Cipher;
import javax.crypto.IllegalBlockSizeException;
import javax.crypto.NoSuchPaddingException;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import Java.util.Base64;

public class AES 
{
    public static byte[] encrypt(final byte[] keyBytes, final byte[] ivBytes, final byte[] messageBytes) throws InvalidKeyException, InvalidAlgorithmParameterException
    {       
        return AES.transform(Cipher.ENCRYPT_MODE, keyBytes, ivBytes, messageBytes);
    }

    public static byte[] decrypt(final byte[] keyBytes, final byte[] ivBytes, final byte[] messageBytes) throws InvalidKeyException, InvalidAlgorithmParameterException
    {       
        return AES.transform(Cipher.DECRYPT_MODE, keyBytes, ivBytes, messageBytes);
    }

    private static byte[] transform(final int mode, final byte[] keyBytes, final byte[] ivBytes, final byte[] messageBytes) throws InvalidKeyException, InvalidAlgorithmParameterException
    {
        final SecretKeySpec keySpec = new SecretKeySpec(keyBytes, "AES");
        final IvParameterSpec ivSpec = new IvParameterSpec(ivBytes);
        byte[] transformedBytes = null;

        try
        {
            final Cipher cipher = Cipher.getInstance("AES/CTR/NoPadding");

            cipher.init(mode, keySpec, ivSpec);

            transformedBytes = cipher.doFinal(messageBytes);
        }        
        catch (NoSuchAlgorithmException | NoSuchPaddingException | IllegalBlockSizeException | BadPaddingException e) 
        {
            e.printStackTrace();
        }
        return transformedBytes;
    }

    public static void main(final String[] args) throws InvalidKeyException, InvalidAlgorithmParameterException
    {
        //Retrieved from a protected local file.
        //Do not hard-code and do not version control.
        final String base64Key = "ABEiM0RVZneImaq7zN3u/w==";

        //Retrieved from a protected database.
        //Do not hard-code and do not version control.
        final String shadowEntry = "AAECAwQFBgcICQoLDA0ODw==:ZtrkahwcMzTu7e/WuJ3AZmF09DE=";

        //Extract the iv and the ciphertext from the shadow entry.
        final String[] shadowData = shadowEntry.split(":");        
        final String base64Iv = shadowData[0];
        final String base64Ciphertext = shadowData[1];

        //Convert to raw bytes.
        final byte[] keyBytes = Base64.getDecoder().decode(base64Key);
        final byte[] ivBytes = Base64.getDecoder().decode(base64Iv);
        final byte[] encryptedBytes = Base64.getDecoder().decode(base64Ciphertext);

        //Decrypt data and do something with it.
        final byte[] decryptedBytes = AES.decrypt(keyBytes, ivBytes, encryptedBytes);

        //Use non-blocking SecureRandom implementation for the new IV.
        final SecureRandom secureRandom = new SecureRandom();

        //Generate a new IV.
        secureRandom.nextBytes(ivBytes);

        //At this point instead of printing to the screen, 
        //one should replace the old shadow entry with the new one.
        System.out.println("Old Shadow Entry      = " + shadowEntry);
        System.out.println("Decrytped Shadow Data = " + new String(decryptedBytes, StandardCharsets.UTF_8));
        System.out.println("New Shadow Entry      = " + Base64.getEncoder().encodeToString(ivBytes) + ":" + Base64.getEncoder().encodeToString(AES.encrypt(keyBytes, ivBytes, decryptedBytes)));
    }
}

Beachten Sie, dass AES nichts mit Codierung zu tun hat. Aus diesem Grund habe ich mich dazu entschieden, es separat und ohne die Verwendung von Bibliotheken von Drittanbietern zu behandeln. 

16
k170

In dieser Antwort nähere ich mich dem Hauptthema "Simple Java AES encrypt/decrypt example" und nicht der spezifischen Debugging-Frage, da ich denke, dass dies den meisten Lesern nützen wird.

Dies ist eine einfache Zusammenfassung meines Blogeintrag über AES-Verschlüsselung in Java Ich empfehle daher, ihn vor der Implementierung durchzulesen. Ich werde jedoch noch ein einfaches Beispiel geben und einige Hinweise geben, auf die zu achten ist.

In diesem Beispiel verwende ich authentifizierte Verschlüsselung mit Galois/Counter Mode oder GCM . Der Grund dafür ist, dass Sie in den meisten Fällen Integrität und Authentizität in Kombination mit Vertraulichkeit (lesen Sie mehr im Blog ).

AES-GCM-Lernprogramm zur Verschlüsselung/Entschlüsselung

Hier sind die Schritte zum Ver-/Entschlüsseln mit AES-GCM mit Java Cryptography Architecture (JCA) . Mischen Sie nicht mit anderen Beispielen , da subtile Unterschiede Ihren Code äußerst unsicher machen können.

1. Schlüssel erstellen

Da es von Ihrem Anwendungsfall abhängt, nehme ich den einfachsten Fall an: einen zufälligen geheimen Schlüssel.

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

Wichtig:

2. Erstellen Sie den Initialisierungsvektor

Ein Initialisierungsvektor (IV) wird verwendet, damit derselbe geheime Schlüssel unterschiedliche Verschlüsselungstexte erzeugt.

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

Wichtig:

3. Mit IV und Schlüssel verschlüsseln

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:

  • verwenden Sie 16 Byte/128 Bit Authentifizierungs-Tag (zur Überprüfung der Integrität/Authentizität)
  • das Authentifizierungs-Tag wird automatisch an den Chiffretext angehängt (in der JCA-Implementierung).
  • da sich GCM wie eine Stream-Verschlüsselung verhält, ist kein Auffüllen erforderlich
  • verwenden Sie CipherInputStream , um große Datenmengen zu verschlüsseln
  • möchten Sie, dass zusätzliche (nicht geheime) Daten überprüft werden, wenn sie geändert wurden? Möglicherweise möchten Sie zugehörige Daten mit cipher.updateAAD(associatedData);Mehr hier. verwenden

3. Serialize to Single Message

Einfach IV und Chiffretext anhängen. Wie oben erwähnt, muss die IV 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 können Sie mit Base64 codieren, wenn Sie eine String-Darstellung benötigen. Verwenden Sie entweder für Android oder für Java 8 (verwenden Sie nicht den Apache Commons Codec - es ist eine schreckliche Implementierung). Die Codierung wird verwendet, um Byte-Arrays in eine Zeichenfolgendarstellung "umzuwandeln", um sie ASCII sicher zu machen, z. B .:

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

4. Entschlüsselung vorbereiten: Deserialisieren

Wenn Sie die Nachricht verschlüsselt haben, dekodieren Sie sie zunächst in ein Byte-Array:

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

dekonstruieren Sie dann 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:

  • achten Sie darauf, Eingabeparameter zu validieren, um Denial-of-Service-Angriffe zu vermeiden, indem Sie zu viel Speicher zuweisen (z. B. kann ein Angreifer den Längenwert auf z. B. 2³¹ ändern, um 2 GB Heap zuzuweisen).

5. Entschlüsseln

Initialisieren Sie die Verschlüsselung und stellen Sie die gleichen Parameter wie bei der Verschlüsselung ein:

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, zugehörige Daten mit cipher.updateAAD(associatedData); hinzuzufügen, wenn Sie es während der Verschlüsselung hinzugefügt haben.

Beachten Sie, dass die neuesten Android (SDK 21+) und Java (7+)) Implementierungen AES-GCM haben sollten. Ältere Versionen haben möglicherweise keine. Ich wähle immer noch Dieser Modus ist einfacher zu implementieren und effizienter als der ähnliche Modus von Encrypt-then-Mac (mit zB AES-CBC + HMAC ). In diesem Artikel erfahren Sie, wie Sie AES-CBC mit HMAC implementieren. .

15
patrickf

Es ist oft eine gute Idee, sich auf eine standardisierte Bibliothekslösung zu verlassen:

private static void stackOverflow15554296()
    throws
        NoSuchAlgorithmException, NoSuchPaddingException,        
        InvalidKeyException, IllegalBlockSizeException,
        BadPaddingException
{

    // prepare key
    KeyGenerator keygen = KeyGenerator.getInstance("AES");
    SecretKey aesKey = keygen.generateKey();
    String aesKeyForFutureUse = Base64.getEncoder().encodeToString(
            aesKey.getEncoded()
    );

    // cipher engine
    Cipher aesCipher = Cipher.getInstance("AES/ECB/PKCS5Padding");

    // cipher input
    aesCipher.init(Cipher.ENCRYPT_MODE, aesKey);
    byte[] clearTextBuff = "Text to encode".getBytes();
    byte[] cipherTextBuff = aesCipher.doFinal(clearTextBuff);

    // recreate key
    byte[] aesKeyBuff = Base64.getDecoder().decode(aesKeyForFutureUse);
    SecretKey aesDecryptKey = new SecretKeySpec(aesKeyBuff, "AES");

    // decipher input
    aesCipher.init(Cipher.DECRYPT_MODE, aesDecryptKey);
    byte[] decipheredBuff = aesCipher.doFinal(cipherTextBuff);
    System.out.println(new String(decipheredBuff));
}

Dies druckt "Text zum Kodieren".

Die Lösung basiert auf Referenzhandbuch für die Java Cryptography Architecture und https://stackoverflow.com/a/20591539/146745 answer.

2
andrej

Dies ist eine Verbesserung gegenüber der akzeptierten Antwort.

Änderungen:

(1) Zufällige IV verwenden und dem verschlüsselten Text voranstellen

(2) Verwenden von SHA-256 zum Generieren eines Schlüssels 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);
}
1
wvdz

Eine andere Lösung mit Java.util.Base64 mit Spring Boot

Encryptor Class

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);
    }
}

application.properties

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

1

Eventuell ist die Verschlüsselung in Java mit Java Simplified Encryption (Jasypt) so einfach zu verwenden. Auf andere Weise können Sie Cypher verwenden. Oben finden Sie ein Codebeispiel zum Ver- und Entschlüsseln:

import Java.security.spec.KeySpec;
import Java.util.Base64;

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.SecretKeyFactory;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.PBEKeySpec;
import javax.crypto.spec.SecretKeySpec;

public class CypherUtils {

    private static final String AES_CBC_PKCS5_PADDING = "AES/CBC/PKCS5Padding";
    private static final String PBKDF2_WITH_HMAC_SHA256 = "PBKDF2WithHmacSHA256";

    public static String decrypt(String strToDecrypt, String keyCode, String salt) {
        try {
            byte[] iv = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
            IvParameterSpec ivspec = new IvParameterSpec(iv);

            SecretKeyFactory factory = SecretKeyFactory.getInstance(PBKDF2_WITH_HMAC_SHA256);
            KeySpec spec = new PBEKeySpec(keyCode.toCharArray(), salt.getBytes(), 65536, 256);
            SecretKey tmp = factory.generateSecret(spec);
            SecretKeySpec secretKey = new SecretKeySpec(tmp.getEncoded(), "AES");

            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            cipher.init(Cipher.DECRYPT_MODE, secretKey, ivspec);
            return new String(cipher.doFinal(Base64.getDecoder().decode(strToDecrypt)));
        } catch (Exception e) {
            System.out.println("Error while decrypting: " + e.toString());
        }
        return null;
    }

    public static String encrypt(String strToEncrypt, String keyCode, String salt) {
        try {
            byte[] iv = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 };
            IvParameterSpec ivspec = new IvParameterSpec(iv);

            SecretKeyFactory factory = SecretKeyFactory.getInstance(PBKDF2_WITH_HMAC_SHA256);
            KeySpec spec = new PBEKeySpec(keyCode.toCharArray(), salt.getBytes(), 65536, 256);
            SecretKey tmp = factory.generateSecret(spec);
            SecretKeySpec secretKey = new SecretKeySpec(tmp.getEncoded(), "AES");

            Cipher cipher = Cipher.getInstance(AES_CBC_PKCS5_PADDING);
            cipher.init(Cipher.ENCRYPT_MODE, secretKey, ivspec);
            return Base64.getEncoder().encodeToString(cipher.doFinal(strToEncrypt.getBytes("UTF-8")));
        } catch (Exception e) {
            System.out.println("Error while encrypting: " + e.toString());
        }
        return null;
    }
}
0
Tiago Medici

Online Editor Runable Version: -

import javax.crypto.Cipher;
import javax.crypto.spec.IvParameterSpec;
import javax.crypto.spec.SecretKeySpec;
//import org.Apache.commons.codec.binary.Base64;
import Java.util.Base64;

public class Encryptor {
    public static String encrypt(String key, String initVector, String value) {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            IvParameterSpec iv = new IvParameterSpec(initVector.getBytes("UTF-8"));

            SecretKeySpec skeySpec = new SecretKeySpec(key.getBytes("UTF-8"), "AES");
            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);
            String s = new String(Base64.getEncoder().encode(encrypted));
            return s;
        } 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.getDecoder().decode(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(encrypt(key, initVector, "Hello World"));
        System.out.println(decrypt(key, initVector, encrypt(key, initVector, "Hello World")));
    }
}
0
Bhupesh Pant