Client Encryption

const crypto = require('crypto');

// Safe charset: alphanumeric only — no colon, no non-ASCII
const SAFE_CHARS = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';

function randomAsciiString(length) {
  const bytes = crypto.randomBytes(length);
  return Array.from(bytes, b => SAFE_CHARS[b % SAFE_CHARS.length]).join('');
}

function encryptPayload(jsonPayload, serverPublicKeyPem, appIdentifier) {
  // Step 1: Serialize JSON
  const plaintext = JSON.stringify(jsonPayload);

  // Steps 2 & 3: Generate 32-char AES key and 12-char IV (safe ASCII, no colon)
  const aesKeyStr = randomAsciiString(32);
  const ivStr = randomAsciiString(12);
  const aesKey = Buffer.from(aesKeyStr, 'utf8'); // 32 bytes
  const iv = Buffer.from(ivStr, 'utf8');          // 12 bytes

  // Step 4: AES-256-GCM encrypt
  const cipher = crypto.createCipheriv('aes-256-gcm', aesKey, iv);
  const ciphertext = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
  const authTag = cipher.getAuthTag(); // 16 bytes

  const encryptedPayload = ciphertext.toString('base64') + authTag.toString('base64');

  // Step 5: Combine key:iv as plain UTF-8 string
  const keyIvString = aesKeyStr + ':' + ivStr;

  // Step 6: RSA-OAEP encrypt the raw UTF-8 bytes of key:iv
  const kekBytes = crypto.publicEncrypt(
    { key: serverPublicKeyPem, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
    Buffer.from(keyIvString, 'utf8')
  );

  // Step 7: Base64 encode KEK
  const kek = kekBytes.toString('base64');

  return {
    headers: { 'Content-Type': 'application/json', kek, appIdentifier },
    body: { RequestEncryptedValue: encryptedPayload },
    // Store these to decrypt the response:
    _aesKey: aesKey,
    _iv: iv,
  };
}

function decryptResponse(responseBody, aesKey, iv) {
  const payload = responseBody.ResponseOfEncryptedValue;
  const tag_b64 = payload.slice(-24);
  const ct_b64 = payload.slice(0, -24);

  const ciphertext = Buffer.from(ct_b64, 'base64');
  const authTag = Buffer.from(tag_b64, 'base64');

  const decipher = crypto.createDecipheriv('aes-256-gcm', aesKey, iv);
  decipher.setAuthTag(authTag);
  const plaintext = Buffer.concat([decipher.update(ciphertext), decipher.final()]);
  return JSON.parse(plaintext.toString('utf8'));
}

import json
import base64
import secrets
import string
from cryptography.hazmat.primitives.ciphers.aead import AESGCM
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes, serialization

# Safe charset: alphanumeric only — no colon, guaranteed ASCII
SAFE_CHARS = string.ascii_letters + string.digits

def random_ascii_string(length):
    return ''.join(secrets.choice(SAFE_CHARS) for _ in range(length))

def encrypt_payload(json_payload, server_public_key_pem, app_identifier):
    plaintext = json.dumps(json_payload).encode('utf-8')

    # Generate 32-char AES key and 12-char IV (safe ASCII, no colon)
    aes_key_str = random_ascii_string(32)
    iv_str = random_ascii_string(12)
    aes_key = aes_key_str.encode('utf-8')  # 32 bytes
    iv = iv_str.encode('utf-8')            # 12 bytes

    # AES-256-GCM encrypt (cryptography lib appends 16-byte tag)
    aesgcm = AESGCM(aes_key)
    ct_with_tag = aesgcm.encrypt(iv, plaintext, None)
    ciphertext = ct_with_tag[:-16]
    auth_tag = ct_with_tag[-16:]

    encrypted_payload = base64.b64encode(ciphertext).decode() + base64.b64encode(auth_tag).decode()

    # Combine key:iv as plain UTF-8 string
    key_iv_string = aes_key_str + ':' + iv_str

    # RSA-OAEP encrypt the raw UTF-8 bytes of key:iv
    public_key = serialization.load_pem_public_key(server_public_key_pem.encode())
    kek_bytes = public_key.encrypt(
        key_iv_string.encode('utf-8'),
        padding.OAEP(mgf=padding.MGF1(algorithm=hashes.SHA1()), algorithm=hashes.SHA1(), label=None)
    )
    kek = base64.b64encode(kek_bytes).decode()

    return {
        'headers': {'Content-Type': 'application/json', 'kek': kek, 'appIdentifier': app_identifier},
        'body': {'RequestEncryptedValue': encrypted_payload},
        '_aes_key': aes_key,
        '_iv': iv,
    }

def decrypt_response(response_body, aes_key, iv):
    payload = response_body['ResponseOfEncryptedValue']
    tag_b64 = payload[-24:]
    ct_b64 = payload[:-24]

    ciphertext = base64.b64decode(ct_b64)
    auth_tag = base64.b64decode(tag_b64)

    aesgcm = AESGCM(aes_key)
    plaintext = aesgcm.decrypt(iv, ciphertext + auth_tag, None)
    return json.loads(plaintext.decode('utf-8'))