package com.example.encryp_decryp;
 import org.springframework.boot.SpringApplication;
 import org.springframework.boot.autoconfigure.SpringBootApplication;
 import org.springframework.stereotype.Service;
 import javax.crypto.Cipher;
 import javax.crypto.KeyGenerator;
 import javax.crypto.SecretKey;
 import javax.crypto.spec.IvParameterSpec;
 import javax.crypto.spec.SecretKeySpec;
 import java.security.SecureRandom;
 import java.util.Arrays;
 import org.apache.commons.codec.binary.Base64;
 import com.example.demo.service.EncryptionService;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.web.bind.annotation.GetMapping;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestParam;
 import org.springframework.web.bind.annotation.RestController;
 @SpringBootApplication
 public class EncrypDecrypApplication {
       public static void main(String[] args) {
             SpringApplication.run(EncrypDecrypApplication.class, args);
       }
 }
 @Service
 public class EncryptionService {
       private static final int AES_KEY_SIZE = 256;
       private static final int AES_BLOCK_SIZE = 16;
       public String encryptResponse(byte[] responseBody, String key) throws Exception {
             byte[] iv = new byte[AES_BLOCK_SIZE];
             SecureRandom random = new SecureRandom();
             random.nextBytes(iv);
             byte[] decodedKey = Base64.decodeBase64(key);
             SecretKeySpec secretKeySpec = new SecretKeySpec(decodedKey, "AES");
             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
             cipher.init(Cipher.ENCRYPT_MODE, secretKeySpec, new IvParameterSpec(iv));
             byte[] paddedData = pkcs7Padding(responseBody, AES_BLOCK_SIZE);
             byte[] encrypted = cipher.doFinal(paddedData);
             byte[] result = new byte[iv.length + encrypted.length];
             System.arraycopy(iv, 0, result, 0, iv.length);
             System.arraycopy(encrypted, 0, result, iv.length, encrypted.length);
             return Base64.encodeBase64String(result);
       }
  public String decryptRequest(String encryptedString, String key) throws Exception {
             byte[] byteCipherText = Base64.decodeBase64(encryptedString);
             byte[] iv = Arrays.copyOfRange(byteCipherText, 0, AES_BLOCK_SIZE);
             byte[] cipherText = Arrays.copyOfRange(byteCipherText, AES_BLOCK_SIZE, 
byteCipherText.length);
             byte[] decodedKey = Base64.decodeBase64(key);
             SecretKeySpec secretKeySpec = new SecretKeySpec(decodedKey, "AES");
             Cipher cipher = Cipher.getInstance("AES/CBC/PKCS5Padding");
             cipher.init(Cipher.DECRYPT_MODE, secretKeySpec, new IvParameterSpec(iv));
             byte[] decrypted = cipher.doFinal(cipherText);
             String decryptedString = new String(decrypted).trim();
             return rmNoise(decryptedString);
       }
       private byte[] pkcs7Padding(byte[] data, int blockSize) {
             int padding = blockSize - (data.length % blockSize);
             byte[] padText = new byte[padding];
             Arrays.fill(padText, (byte) padding);
             byte[] paddedData = new byte[data.length + padding];
             System.arraycopy(data, 0, paddedData, 0, data.length);
             System.arraycopy(padText, 0, paddedData, data.length, padding);
             return paddedData;
       }
       private String rmNoise(String data) {
             for (int i = data.length() - 1; i >= 0; i--) {
                    if (data.charAt(i) == '}') {
                           return data.substring(0, i + 1);
                    }
             }
             return data;
       }
 }
 @RestController
 @RequestMapping("/api")
 public class EncryptionController {
       @Autowired
       private EncryptionService encryptionService;
       @GetMapping("/encrypt")
       public String encrypt(@RequestParam String responseBody, @RequestParam String key) 
throws Exception {
             return encryptionService.encryptResponse(responseBody.getBytes(), key);
       }
       @GetMapping("/decrypt")
       public String decrypt(@RequestParam String encryptedString, @RequestParam String key) 
throws Exception {
             return encryptionService.decryptRequest(encryptedString, key);
       }
 }

   <?php
 function generateEncryptedTokendata() {
 // Current epoch timestamp (seconds)
 $timestamp = time();
 // Encryption key (Base64 encoded)
 $key = 'awrNYcJKripBxUeEkr1IUuk01WVDUwxayfN4ORAQBug=';
 // Decode the Base64 key
 $decodedKey = base64_decode($key);
 // JSON request data
 $enreq = json_encode([
 "client_id" => "AdOZaGcsQqq38Dk5RA4VU1sMbxTeYXtAEPbcobapuu9MhGij",
 "client_secret" => 
"VDJMKviTuHO12VAd5e4d7X6nZltrFkWsBlXxPhs2iN5Rmv66JG3KhfMQzGMDRycD",
 "epoch" => strval($timestamp)
 ]);
 // Generate a random 16-byte IV (same as CryptoJS.lib.WordArray.random(16))
 $iv = openssl_random_pseudo_bytes(16);
 // Encrypt using AES-256-CBC with PKCS7 padding
 $encrypted = openssl_encrypt(
 $enreq,
 'AES-256-CBC',
 $decodedKey,
 OPENSSL_RAW_DATA, // get raw binary ciphertext
 $iv
 );
 // Combine IV + ciphertext
 $combined = $iv . $encrypted;
 // Encode to Base64 (same as CryptoJS.enc.Base64.stringify)
 $encryptedToken = base64_encode($combined);
 // Print the result
 echo $encryptedToken . " encrypted token\n";
 }
 // Run the function
 generateEncryptedTokendata();
 ?>