ไบต์เริ่มต้นไม่ถูกต้องหลังจากถอดรหัส Java AES / CBC

มีอะไรผิดปกติกับตัวอย่างต่อไปนี้?

ปัญหาคือส่วนแรกของสตริงที่ถอดรหัสเป็นเรื่องไร้สาระ อย่างไรก็ตามส่วนที่เหลือไม่เป็นไรฉันเข้าใจ ...

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

ผู้คนจำนวนมากรวมถึงตัวฉันเองประสบปัญหามากมายในการทำงานนี้เนื่องจากข้อมูลบางอย่างขาดหายไปเช่นลืมแปลงเป็น Base64 เวกเตอร์การเริ่มต้นชุดอักขระ ฯลฯ ดังนั้นฉันจึงคิดที่จะสร้างโค้ดที่ใช้งานได้อย่างสมบูรณ์

หวังว่านี่จะเป็นประโยชน์สำหรับคุณทุกคน: ในการคอมไพล์คุณต้องมีโถ Apache Commons Codec เพิ่มเติมซึ่งมีอยู่ที่นี่: 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")));
    }
}

นี่คือวิธีการแก้ปัญหาโดยไม่ต้อง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);
    }
}

ตัวอย่างการใช้งาน:

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

พิมพ์:

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

ดูเหมือนฉันจะจัดการกับ Initialization Vector (IV) ไม่ถูกต้อง เป็นเวลานานแล้วที่ฉันอ่านเกี่ยวกับ AES, IVs และ block chaining แต่เป็นแนวของคุณ

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

ดูเหมือนจะไม่โอเค ในกรณีของ AES คุณสามารถคิดว่าเวกเตอร์เริ่มต้นเป็น "สถานะเริ่มต้น" ของอินสแตนซ์การเข้ารหัสและสถานะนี้เป็นข้อมูลเล็กน้อยที่คุณไม่สามารถหาได้จากคีย์ของคุณ แต่มาจากการคำนวณจริงของการเข้ารหัสการเข้ารหัส (อาจมีคนโต้แย้งว่าถ้า IV สามารถดึงออกมาจากคีย์ได้ก็จะไม่มีประโยชน์เนื่องจากคีย์นั้นถูกมอบให้กับอินสแตนซ์การเข้ารหัสในช่วงเริ่มต้นแล้ว)

ดังนั้นคุณควรได้รับ IV เป็นไบต์ [] จากอินสแตนซ์การเข้ารหัสที่ส่วนท้ายของการเข้ารหัสของคุณ

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

และคุณควรจะเริ่มต้นของคุณCipherในDECRYPT_MODEกับไบต์นี้ []:

  IvParameterSpec ivParameterSpec = new IvParameterSpec(iv);

จากนั้นการถอดรหัสของคุณควรจะใช้ได้ หวังว่านี่จะช่วยได้

IV ที่คุณใช้สำหรับการถอดรหัสไม่ถูกต้อง แทนที่รหัสนี้

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

ด้วยรหัสนี้

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

และควรแก้ปัญหาของคุณ

ด้านล่างนี้มีตัวอย่างของคลาส AES อย่างง่ายใน Java ฉันไม่แนะนำให้ใช้คลาสนี้ในสภาพแวดล้อมการใช้งานจริงเนื่องจากอาจไม่ได้คำนึงถึงความต้องการเฉพาะทั้งหมดของแอปพลิเคชันของคุณ

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

โปรดทราบว่า AES ไม่มีส่วนเกี่ยวข้องกับการเข้ารหัสดังนั้นฉันจึงเลือกที่จะจัดการแยกต่างหากและไม่จำเป็นต้องใช้ไลบรารีของบุคคลที่สาม

ในคำตอบนี้ฉันเลือกที่จะเข้าใกล้ธีมหลัก "Simple Java AES encrypt / decrypt example" ไม่ใช่คำถามเฉพาะสำหรับการดีบักเพราะฉันคิดว่าสิ่งนี้จะเป็นประโยชน์ต่อผู้อ่านส่วนใหญ่

นี่คือสรุปง่ายๆในบล็อกโพสต์ของฉันเกี่ยวกับการเข้ารหัส AES ใน Javaดังนั้นฉันขอแนะนำให้อ่านก่อนที่จะนำไปใช้ อย่างไรก็ตามฉันจะยังคงให้ตัวอย่างง่ายๆในการใช้งานและให้คำแนะนำในสิ่งที่ต้องระวัง

ในตัวอย่างนี้ฉันจะเลือกใช้การเข้ารหัสที่ผ่านการรับรองความถูกต้องกับGalois / Counter Mode หรือโหมดGCM เหตุผลก็คือในกรณีส่วนใหญ่คุณต้องการ ความสมบูรณ์และความถูกต้องร่วมกับการรักษาความลับ (อ่านเพิ่มเติมในบล็อก )

การสอนการเข้ารหัส / ถอดรหัส AES-GCM

นี่เป็นขั้นตอนที่จำเป็นในการเข้ารหัส / ถอดรหัสกับAES-GCMกับJava Cryptography Architecture (JCA) อย่าผสมกับตัวอย่างอื่น ๆเนื่องจากความแตกต่างเล็กน้อยอาจทำให้โค้ดของคุณไม่ปลอดภัยอย่างที่สุด

1. สร้างคีย์

เนื่องจากขึ้นอยู่กับกรณีการใช้งานของคุณฉันจะถือว่ากรณีที่ง่ายที่สุดนั่นคือคีย์ลับแบบสุ่ม

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

สำคัญ:

• ใช้ตัวสร้างหมายเลขหลอกที่แข็งแกร่งเสมอเช่นSecureRandom
• ใช้คีย์ยาว 16 ไบต์ / 128 บิต (หรือมากกว่า - แต่ไม่ค่อยจำเป็น )
• หากคุณต้องการคีย์ที่มาจากรหัสผ่านผู้ใช้ให้ดูที่ฟังก์ชันแฮชรหัสผ่าน (หรือ KDF) ที่มีคุณสมบัติการยืดเช่นPBKDF2หรือbcrypt
• หากคุณต้องการคีย์ที่มาจากแหล่งอื่นให้ใช้ฟังก์ชันการหาคีย์ที่เหมาะสม(KDF)เช่นHKDF ( การใช้งาน Java ที่นี่ ) อย่าได้ใช้ง่ายhashes การเข้ารหัสลับสำหรับการที่ (เช่นSHA-256 )

2. สร้างเวกเตอร์เริ่มต้น

เวกเตอร์เริ่มต้น (IV)ถูกนำมาใช้เพื่อให้คีย์ลับเดียวกันจะสร้างที่แตกต่างกันตำราตัวเลข

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

สำคัญ:

• อย่าใช้ IV เดียวกันซ้ำกับคีย์เดียวกัน ( สำคัญมากในโหมดGCM / CTR )
• IV ต้องไม่ซ้ำกัน (เช่นใช้ IV แบบสุ่มหรือตัวนับ)
• IV ไม่จำเป็นต้องเป็นความลับ
• ใช้ตัวสร้างหมายเลขหลอกที่แข็งแกร่งเสมอเช่นSecureRandom
• 12 ไบต์ IV เป็นตัวเลือกที่ถูกต้องสำหรับโหมด AES-GCM

3. เข้ารหัสด้วย IV และ 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);

สำคัญ:

• ใช้แท็กการตรวจสอบความถูกต้อง16 ไบต์ / 128 บิต(ใช้เพื่อตรวจสอบความสมบูรณ์ / ความถูกต้อง)
• แท็กการตรวจสอบความถูกต้องจะต่อท้ายข้อความเข้ารหัสโดยอัตโนมัติ (ในการใช้งาน JCA)
• เนื่องจาก GCM ทำงานเหมือนรหัสของสตรีมจึงไม่จำเป็นต้องมีช่องว่างภายใน
• ใช้CipherInputStreamเมื่อเข้ารหัสข้อมูลจำนวนมาก
• ต้องการตรวจสอบข้อมูลเพิ่มเติม (ไม่เป็นความลับ) ว่ามีการเปลี่ยนแปลงหรือไม่ คุณอาจต้องการใช้ข้อมูลที่เกี่ยวข้องกับcipher.updateAAD(associatedData); More here

3. จัดลำดับเป็นข้อความเดียว

เพียงต่อท้าย IV และ ciphertext ตามที่ระบุไว้ข้างต้น IV ไม่จำเป็นต้องเป็นความลับ

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

เลือกที่จะเข้ารหัสด้วยBase64หากคุณต้องการการแสดงสตริง ใช้การติดตั้งในตัวของ AndroidหรือJava 8 (อย่าใช้ Apache Commons Codec - เป็นการใช้งานที่แย่มาก) การเข้ารหัสใช้เพื่อ "แปลง" ไบต์อาร์เรย์เป็นการแสดงสตริงเพื่อให้ ASCII ปลอดภัยเช่น:

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

4. เตรียมถอดรหัส: Deserialize

หากคุณเข้ารหัสข้อความก่อนอื่นให้ถอดรหัสเป็นไบต์อาร์เรย์:

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

สำคัญ:

• ระมัดระวังในการตรวจสอบพารามิเตอร์อินพุตดังนั้นเพื่อหลีกเลี่ยงการปฏิเสธการโจมตีบริการโดยการจัดสรรหน่วยความจำมากเกินไป

5. ถอดรหัส

เริ่มต้นการเข้ารหัสและตั้งค่าพารามิเตอร์เดียวกันกับการเข้ารหัส:

final Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
//use first 12 bytes for iv
AlgorithmParameterSpec gcmIv = new GCMParameterSpec(128, cipherMessage, 0, 12);
cipher.init(Cipher.DECRYPT_MODE, secretKey, gcmIv);
//use everything from 12 bytes on as ciphertext
byte[] plainText = cipher.doFinal(cipherMessage, 12, cipherMessage.length - 12);

สำคัญ:

• ไม่ลืมที่จะเพิ่มข้อมูลที่เกี่ยวข้องกับcipher.updateAAD(associatedData);ถ้าคุณเพิ่มมันในระหว่างการเข้ารหัส

คุณสามารถดูข้อมูลโค้ดที่ใช้งานได้ในส่วนสำคัญนี้

โปรดทราบว่าการใช้งาน Android (SDK 21+) และ Java (7+) ล่าสุดควรมี AES-GCM รุ่นเก่าอาจขาดมัน ฉันยังคงเลือกโหมดนี้เนื่องจากใช้งานได้ง่ายกว่านอกจากจะมีประสิทธิภาพมากกว่าเมื่อเทียบกับโหมดเข้ารหัสที่คล้ายกันของMac (เช่นAES-CBC + HMAC ) ดูบทความนี้เกี่ยวกับวิธีใช้ AES-CBC กับ HMAC

เวอร์ชันออนไลน์ Editor Runnable: -

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

มักเป็นความคิดที่ดีที่จะพึ่งพาโซลูชันมาตรฐานที่ให้มา:

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

สิ่งนี้จะพิมพ์ "ข้อความที่จะเข้ารหัส"

โซลูชันเป็นไปตามคู่มืออ้างอิงสถาปัตยกรรมการเข้ารหัส Javaและคำตอบhttps://stackoverflow.com/a/20591539/146745

นี่เป็นการปรับปรุงคำตอบที่ได้รับการยอมรับ

การเปลี่ยนแปลง:

(1) ใช้ IV แบบสุ่มและนำหน้าไปไว้ข้างหน้าข้อความที่เข้ารหัส

(2) การใช้ SHA-256 เพื่อสร้างคีย์จากข้อความรหัสผ่าน

(3) ไม่มีการพึ่งพา 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);
}

อีกวิธีหนึ่งโดยใช้ java.util.Base64 พร้อม Spring Boot

คลาสเข้ารหัส

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

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

ตัวอย่าง

http: // localhost: 8082 / ตัวเลข / เข้ารหัส / jmendoza

2h41HH8Shzc4BRU3hVDOXA ==

http: // localhost: 8082 / การเข้ารหัส / ถอดรหัส / 2h41HH8Shzc4BRU3hVDOXA ==

jmendoza

คำตอบที่ยอมรับในเวอร์ชันที่ปรับให้เหมาะสม

• ไม่มี libs ของบุคคลที่สาม

• รวม IV ลงในข้อความที่เข้ารหัส (สามารถเป็นสาธารณะ)

• รหัสผ่านสามารถมีความยาวเท่าใดก็ได้

รหัส:

import java.io.UnsupportedEncodingException;
import java.security.SecureRandom;
import java.util.Base64;

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

public class Encryptor {
    public static byte[] getRandomInitialVector() {
        try {
            Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5PADDING");
            SecureRandom randomSecureRandom = SecureRandom.getInstance("SHA1PRNG");
            byte[] initVector = new byte[cipher.getBlockSize()];
            randomSecureRandom.nextBytes(initVector);
            return initVector;
        } catch (Exception ex) {
            ex.printStackTrace();
        }
        return null;
    }

    public static byte[] passwordTo16BitKey(String password) {
        try {
            byte[] srcBytes = password.getBytes("UTF-8");
            byte[] dstBytes = new byte[16];

            if (srcBytes.length == 16) {
                return srcBytes;
            }

            if (srcBytes.length < 16) {
                for (int i = 0; i < dstBytes.length; i++) {
                    dstBytes[i] = (byte) ((srcBytes[i % srcBytes.length]) * (srcBytes[(i + 1) % srcBytes.length]));
                }
            } else if (srcBytes.length > 16) {
                for (int i = 0; i < srcBytes.length; i++) {
                    dstBytes[i % dstBytes.length] += srcBytes[i];
                }
            }

            return dstBytes;
        } catch (UnsupportedEncodingException ex) {
            ex.printStackTrace();
        }

        return null;
    }

    public static String encrypt(String key, String value) {
        return encrypt(passwordTo16BitKey(key), value);
    }

    public static String encrypt(byte[] key, String value) {
        try {
            byte[] initVector = Encryptor.getRandomInitialVector();
            IvParameterSpec iv = new IvParameterSpec(initVector);
            SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");

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

            byte[] encrypted = cipher.doFinal(value.getBytes());
            return Base64.getEncoder().encodeToString(encrypted) + " " + Base64.getEncoder().encodeToString(initVector);
        } catch (Exception ex) {
            ex.printStackTrace();
        }

        return null;
    }

    public static String decrypt(String key, String encrypted) {
        return decrypt(passwordTo16BitKey(key), encrypted);
    }

    public static String decrypt(byte[] key, String encrypted) {
        try {
            String[] encryptedParts = encrypted.split(" ");
            byte[] initVector = Base64.getDecoder().decode(encryptedParts[1]);
            if (initVector.length != 16) {
                return null;
            }

            IvParameterSpec iv = new IvParameterSpec(initVector);
            SecretKeySpec skeySpec = new SecretKeySpec(key, "AES");

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

            byte[] original = cipher.doFinal(Base64.getDecoder().decode(encryptedParts[0]));

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

        return null;
    }
}

การใช้งาน:

String key = "Password of any length.";
String encrypted = Encryptor.encrypt(key, "Hello World");
String decrypted = Encryptor.decrypt(key, encrypted);
System.out.println(encrypted);
System.out.println(decrypted);

ตัวอย่างผลลัพธ์:

QngBg+Qc5+F8HQsksgfyXg== yDfYiIHTqOOjc0HRNdr1Ng==
Hello World