function card_encrypt($payload, $key) {
    $iv = openssl_random_pseudo_bytes(16);
    $cipher_text = openssl_encrypt(
        $payload, 
        "aes-256-gcm", 
        $key, 
        OPENSSL_RAW_DATA, 
        $iv, 
        $tag
    );
    return implode(':', [
        bin2hex($iv),
        bin2hex($cipher_text),
        bin2hex($tag)
    ]);
}

// Example usage
$card_data = json_encode([
    'card_number' => '4111111111111111',
    'expiry_month' => '12',
    'expiry_year' => '2025',
    'cvv' => '123'
]);
$encrypted = card_encrypt($card_data, $encryption_key);

const cardEncrypt = async (payload, encKey) => {
  const _iv = crypto.getRandomValues(new Uint8Array(12));
  const encodedPlaintext = new TextEncoder().encode(payload);
  
  const secretKey = await crypto.subtle.importKey(
    "raw",
    Buffer.from(encKey, "utf8"),
    {
      name: "AES-GCM",
      length: 256,
    },
    true,
    ["encrypt", "decrypt"],
  );

  const cipherText = await crypto.subtle.encrypt(
    {
      name: "AES-GCM",
      iv: _iv,
    },
    secretKey,
    encodedPlaintext,
  );

  const [value, auth_tag] = [
    cipherText.slice(0, cipherText.byteLength - 16),
    cipherText.slice(cipherText.byteLength - 16),
  ];

  const cipher = Buffer.from(value).toString("hex");
  const iv = Buffer.from(_iv).toString("hex");
  const tag = Buffer.from(auth_tag).toString("hex");
  
  return [iv, cipher, tag].join(":");
};

// Example usage
const cardData = JSON.stringify({
  card_number: '4111111111111111',
  expiry_month: '12',
  expiry_year: '2025',
  cvv: '123'
});
const encrypted = await cardEncrypt(cardData, encryptionKey);

from cryptography.hazmat.primitives.ciphers.aead import AESGCM
import os
import json
import binascii

def card_encrypt(payload, key):
    # Convert hex key to bytes
    key_bytes = bytes.fromhex(key)
    
    # Generate random IV
    iv = os.urandom(12)
    
    # Create AESGCM instance
    aesgcm = AESGCM(key_bytes)
    
    # Encrypt the payload
    payload_bytes = payload.encode()
    cipher_text = aesgcm.encrypt(iv, payload_bytes, None)
    
    # Split cipher text and auth tag
    auth_tag = cipher_text[-16:]
    encrypted_data = cipher_text[:-16]
    
    # Format result
    return ':'.join([
        binascii.hexlify(iv).decode(),
        binascii.hexlify(encrypted_data).decode(),
        binascii.hexlify(auth_tag).decode()
    ])

# Example usage
card_data = json.dumps({
    'card_number': '4111111111111111',
    'expiry_month': '12',
    'expiry_year': '2025',
    'cvv': '123'
})
encrypted = card_encrypt(card_data, encryption_key)

require 'openssl'
require 'json'

def card_encrypt(payload, key)
  # Convert hex key to binary
  key_bin = [key].pack('H*')
  
  # Generate random IV
  iv = OpenSSL::Random.random_bytes(12)
  
  # Create cipher
  cipher = OpenSSL::Cipher.new('aes-256-gcm')
  cipher.encrypt
  cipher.key = key_bin
  cipher.iv = iv
  
  # Encrypt
  cipher.auth_data = ""
  encrypted = cipher.update(payload) + cipher.final
  tag = cipher.auth_tag
  
  # Format result
  [
    iv.unpack('H*')[0],
    encrypted.unpack('H*')[0],
    tag.unpack('H*')[0]
  ].join(':')
end

# Example usage
card_data = JSON.generate({
  card_number: '4111111111111111',
  expiry_month: '12',
  expiry_year: '2025',
  cvv: '123'
})
encrypted = card_encrypt(card_data, encryption_key)