गोलंग में एईएस एन्क्रिप्शन और जावा में इसका डिक्रिप्शन

प्रश्न में दिए गए एईएस के लिए गोलांग एन्क्रिप्शन फ़ंक्शन उन्नत एन्क्रिप्शन मानक (एईएस) एल्गोरिदम का उपयोग करके एक स्ट्रिंग को एन्क्रिप्ट करता है, बेस64 एन्कोडिंग में एक सिफरटेक्स्ट तैयार करना। जावा में इस सिफरटेक्स्ट को डिक्रिप्ट करने के लिए, हमें एक उपयुक्त डिक्रिप्शन फ़ंक्शन की आवश्यकता होती है।

Java डिक्रिप्शन फ़ंक्शन

import java.util.Base64;
import javax.crypto.*;
import javax.crypto.spec.*;

public class AESDecryption {

    public static String decode(String base64Text, byte[] key)
            throws NoSuchPaddingException, NoSuchAlgorithmException, InvalidAlgorithmParameterException, InvalidKeyException, BadPaddingException, IllegalBlockSizeException {
        byte[] inputArr = Base64.getUrlDecoder().decode(base64Text);
        SecretKeySpec skSpec = new SecretKeySpec(key, "AES");
        Cipher cipher = Cipher.getInstance("AES/CFB/NoPadding");
        int blockSize = cipher.getBlockSize();
        IvParameterSpec iv = new IvParameterSpec(Arrays.copyOf(inputArr, blockSize));
        byte[] dataToDecrypt = Arrays.copyOfRange(inputArr, blockSize, inputArr.length);
        cipher.init(Cipher.DECRYPT_MODE, skSpec, iv);
        byte[] result = cipher.doFinal(dataToDecrypt);
        return new String(result, StandardCharsets.UTF_8);
    }

    public static void main(String[] args) {
        // Encryption result from the Go function.
        String base64Text = "c1bpFhxn74yzHQs-vgLcW6E5yL8zJfgceEQgYl0=";
        // The encryption key (same as in Go).
        byte[] key = "0123456789abcdef".getBytes();

        try {
            // Decrypt the ciphertext.
            String decrypted = decode(base64Text, key);
            // Print the decrypted text.
            System.out.println(decrypted);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

स्कैला डिक्रिप्शन फ़ंक्शन

import java.nio.charset.StandardCharsets
import javax.crypto._
import javax.crypto.spec.{IvParameterSpec, SecretKeySpec}
import java.util.Base64

object AESDecryption {

  def decode(input: String, key: String): String = {
    val cipher = Cipher.getInstance("AES/CFB/NoPadding")
    val blockSize = cipher.getBlockSize
    val keyBytes = key.getBytes
    val inputArr = Base64.getUrlDecoder.decode(input)
    val skSpec = new SecretKeySpec(keyBytes, "AES")
    val iv = new IvParameterSpec(inputArr.slice(0, blockSize).toArray)
    val dataToDecrypt = inputArr.slice(blockSize, inputArr.size)
    cipher.init(Cipher.DECRYPT_MODE, skSpec, iv)
    new String(cipher.doFinal(dataToDecrypt.toArray), StandardCharsets.UTF_8)
  }

  def main(args: Array[String]): Unit = {
    // Encryption result from the Go function.
    val base64Text = "c1bpFhxn74yzHQs-vgLcW6E5yL8zJfgceEQgYl0="
    // The encryption key (same as in Go).
    val key = "0123456789abcdef"

    // Decrypt the ciphertext.
    val decrypted = decode(base64Text, key)
    // Print the decrypted text.
    println(decrypted)
  }
}

जावा और स्काला दोनों डिक्रिप्शन फ़ंक्शन सिफरटेक्स्ट और कुंजी को इनपुट के रूप में लेते हैं, एईएस/सीएफबी/नोपैडिंग एल्गोरिदम का उपयोग करके सिफरटेक्स्ट को डिक्रिप्ट करते हैं, और डिक्रिप्टेड प्लेनटेक्स्ट को एक स्ट्रिंग के रूप में लौटाते हैं।