Card Encryption

Flow

Encryption Code

Golang

package main

import (
	"crypto/aes"
	"crypto/cipher"
	"crypto/rand"
	"encoding/base64"
	"fmt"
	"io"
)

func AesGcmEncryptToBase64String(plaintext, key string) (string, error) {
	block, err := aes.NewCipher([]byte(key))
	if err != nil {
		return "", err
	}

	gcm, err := cipher.NewGCM(block)
	if err != nil {
		return "", err
	}

	nonce := make([]byte, gcm.NonceSize())
	if _, err := io.ReadFull(rand.Reader, nonce); err != nil {
		return "", err
	}

	ciphertext := gcm.Seal(nonce, nonce, []byte(plaintext), nil)
	return base64.StdEncoding.EncodeToString(ciphertext), nil
}

func main() {
	strJSON := `
{
  "clientReferenceId": "1751336752",
  "card": {
    "number": "5123456789012346",
    "expiryMonth": "01",
    "expiryYear": "39",
    "nameOnCard": "Tralalero Tralala"
  },
  "deviceInformations": {
    "type": "",
    "userAgent": "XYXYY",
    "ipAddress": "172.168.10.1",
    "acceptLanguage": "EN",
    "cookieToken": "XOOKXOKXO",
    "deviceId": "uuid",
    "browserWidth": "1234",
    "browserHeight": "1234",
    "country": "ID"
  },
  "metadata": {}
}
`

	secret := "L6VzRddFCwEga3274YDfS2PaQKkVdsUY" // encryptionKey
	encryptedCard, err := AesGcmEncryptToBase64String(strJSON, secret)
	if err != nil {
		fmt.Println("Encryption error:", err)
		return
	}

	fmt.Println("Encrypted base64:", encryptedCard)
}

Typescript / Javascript

async function aesGcmEncryptToBase64String(plaintext: string, secret: string): Promise<string> {
  const enc = new TextEncoder();

  // Ensure the key is 32 bytes (AES-256)
  const keyBytes = enc.encode(secret.padEnd(32, '0').slice(0, 32));

  const key = await crypto.subtle.importKey(
    'raw',
    keyBytes,
    { name: 'AES-GCM' },
    false,
    ['encrypt']
  );

  const iv = crypto.getRandomValues(new Uint8Array(12)); // 12-byte nonce
  const ciphertext = await crypto.subtle.encrypt(
    {
      name: 'AES-GCM',
      iv: iv
    },
    key,
    enc.encode(plaintext)
  );

  // Concatenate IV + ciphertext
  const combined = new Uint8Array(iv.length + ciphertext.byteLength);
  combined.set(iv, 0);
  combined.set(new Uint8Array(ciphertext), iv.length);

  // Convert to base64
  return btoa(String.fromCharCode(...combined));
}

// Example usage
const strJSON = `
{
  "clientReferenceId": "1751337392",
  "card": {
    "number": "5123456789012346",
    "expiryMonth": "01",
    "expiryYear": "39",
    "nameOnCard": "Tralalero Tralala"
  },
  "deviceInformations": {
    "type": "",
    "userAgent": "XYXYY",
    "ipAddress": "172.168.10.1",
    "acceptLanguage": "EN",
    "cookieToken": "XOOKXOKXO",
    "deviceId": "uuid",
    "browserWidth": "1234",
    "browserHeight": "1234",
    "country": "ID"
  },
  "metadata": {}
}
`;

const secret = "5GSzGQz3L1DAqgFIz7I4tyffmcby7jnY";

aesGcmEncryptToBase64String(strJSON, secret)
  .then((encrypted) => console.log("Encrypted base64:", encrypted))
  .catch(console.error);

PHP

<?php

function aesGcmEncryptToBase64String(string $plaintext, string $key): string
{
    $ivLength = 12; // 12-byte nonce for GCM
    $iv = random_bytes($ivLength);
    $tag = '';

    // Ensure key is 32 bytes for AES-256
    if (strlen($key) !== 32) {
        throw new Exception("Key must be 32 bytes long for AES-256-GCM");
    }

    $ciphertext = openssl_encrypt(
        $plaintext,
        'aes-256-gcm',
        $key,
        OPENSSL_RAW_DATA,
        $iv,
        $tag
    );

    if ($ciphertext === false) {
        throw new Exception("Encryption failed");
    }

    // Combine: IV + ciphertext + tag
    $result = $iv . $ciphertext . $tag;

    return base64_encode($result);
}

// Sample JSON input
$strJSON = '
{
  "clientReferenceId": "1751337533",
  "card": {
    "number": "5123456789012346",
    "expiryMonth": "01",
    "expiryYear": "39",
    "nameOnCard": "Tralalero Tralala"
  },
  "deviceInformations": {
    "type": "",
    "userAgent": "XYXYY",
    "ipAddress": "172.168.10.1",
    "acceptLanguage": "EN",
    "cookieToken": "XOOKXOKXO",
    "deviceId": "uuid",
    "browserWidth": "1234",
    "browserHeight": "1234",
    "country": "ID"
  },
  "metadata": {}
}
';

// 32-byte key for AES-256
$secret = 'NY7qoCCmGYgCsZDMcMqVtwVac8nzaVDI';

try {
    $encrypted = aesGcmEncryptToBase64String($strJSON, $secret);
    echo "Encrypted base64: " . $encrypted . PHP_EOL;
} catch (Exception $e) {
    echo "Error: " . $e->getMessage() . PHP_EOL;
}

Java

import javax.crypto.Cipher;
import javax.crypto.SecretKey;
import javax.crypto.spec.GCMParameterSpec;
import javax.crypto.spec.SecretKeySpec;
import java.security.SecureRandom;
import java.util.Base64;

public class AESGCMEncryptor {

    public static String encryptToBase64(String plaintext, String key) throws Exception {
        // Ensure key is 32 bytes (AES-256)
        byte[] keyBytes = key.getBytes("UTF-8");
        if (keyBytes.length != 32) {
            throw new IllegalArgumentException("Key must be 32 bytes for AES-256-GCM");
        }

        SecretKey secretKey = new SecretKeySpec(keyBytes, "AES");

        byte[] iv = new byte[12]; // 12 bytes nonce for GCM
        SecureRandom random = new SecureRandom();
        random.nextBytes(iv);

        Cipher cipher = Cipher.getInstance("AES/GCM/NoPadding");
        GCMParameterSpec spec = new GCMParameterSpec(128, iv); // 128-bit auth tag
        cipher.init(Cipher.ENCRYPT_MODE, secretKey, spec);

        byte[] ciphertext = cipher.doFinal(plaintext.getBytes("UTF-8"));

        // Combine IV + ciphertext
        byte[] combined = new byte[iv.length + ciphertext.length];
        System.arraycopy(iv, 0, combined, 0, iv.length);
        System.arraycopy(ciphertext, 0, combined, iv.length, ciphertext.length);

        return Base64.getEncoder().encodeToString(combined);
    }

    public static void main(String[] args) {
        String json = "{\n" +
                "  \"clientReferenceId\": \"1751337699\",\n" +
                "  \"card\": {\n" +
                "    \"number\": \"5123456789012346\",\n" +
                "    \"expiryMonth\": \"01\",\n" +
                "    \"expiryYear\": \"39\",\n" +
                "    \"nameOnCard\": \"Tralalero Tralala\"\n" +
                "  },\n" +
                "  \"deviceInformations\": {\n" +
                "    \"type\": \"\",\n" +
                "    \"userAgent\": \"XYXYY\",\n" +
                "    \"ipAddress\": \"172.168.10.1\",\n" +
                "    \"acceptLanguage\": \"EN\",\n" +
                "    \"cookieToken\": \"XOOKXOKXO\",\n" +
                "    \"deviceId\": \"uuid\",\n" +
                "    \"browserWidth\": \"1234\",\n" +
                "    \"browserHeight\": \"1234\",\n" +
                "    \"country\": \"ID\"\n" +
                "  },\n" +
                "  \"metadata\": {}\n" +
                "}";

        String secret = "rBAtrIESpBNGadfyDmZTgsB9vCzR1dSP"; // encryptionKey

        try {
            String encrypted = encryptToBase64(json, secret);
            System.out.println("Encrypted base64: " + encrypted);
        } catch (Exception e) {
            System.err.println("Encryption failed: " + e.getMessage());
        }
    }
}

Python

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
import base64

def aes_gcm_encrypt_to_base64_string(plaintext: str, key: str) -> str:
    # Ensure key is 32 bytes (AES-256)
    key_bytes = key.encode('utf-8')
    if len(key_bytes) != 32:
        raise ValueError("Key must be 32 bytes for AES-256-GCM")

    aesgcm = AESGCM(key_bytes)
    nonce = os.urandom(12)  # 12-byte nonce for AES-GCM
    ciphertext = aesgcm.encrypt(nonce, plaintext.encode('utf-8'), None)

    combined = nonce + ciphertext
    return base64.b64encode(combined).decode('utf-8')


if __name__ == "__main__":
    json_data = '''
{
  "clientReferenceId": "1751337853",
  "card": {
    "number": "5123456789012346",
    "expiryMonth": "01",
    "expiryYear": "39",
    "nameOnCard": "Tralalero Tralala"
  },
  "deviceInformations": {
    "type": "",
    "userAgent": "XYXYY",
    "ipAddress": "172.168.10.1",
    "acceptLanguage": "EN",
    "cookieToken": "XOOKXOKXO",
    "deviceId": "uuid",
    "browserWidth": "1234",
    "browserHeight": "1234",
    "country": "ID"
  },
  "metadata": {}
}
'''

    secret = "4bEC63a4d2YEWY9iCmOsQLEk1h9GVIvi"  # encryptionKey
    try:
        encrypted = aes_gcm_encrypt_to_base64_string(json_data, secret)
        print("Encrypted base64:", encrypted)
    except Exception as e:
        print("Encryption failed:", str(e))