Livraison du Code de Carte

const crypto = require('crypto');

// Encryption configuration
const ENCRYPTION_KEY = process.env.ENCRYPTION_KEY; // Must be 32 bytes
const ALGORITHM = 'aes-256-gcm';

function encryptCardCode(code) {
  const iv = crypto.randomBytes(16);
  const cipher = crypto.createCipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY, 'hex'),
    iv
  );
  
  let encrypted = cipher.update(code, 'utf8', 'hex');
  encrypted += cipher.final('hex');
  
  const authTag = cipher.getAuthTag();
  
  return {
    iv: iv.toString('hex'),
    encryptedData: encrypted,
    authTag: authTag.toString('hex')
  };
}

function decryptCardCode(iv, encryptedData, authTag) {
  const decipher = crypto.createDecipheriv(
    ALGORITHM,
    Buffer.from(ENCRYPTION_KEY, 'hex'),
    Buffer.from(iv, 'hex')
  );
  
  decipher.setAuthTag(Buffer.from(authTag, 'hex'));
  
  let decrypted = decipher.update(encryptedData, 'hex', 'utf8');
  decrypted += decipher.final('utf8');
  
  return decrypted;
}

// Store encrypted card
async function storeCardSecurely(topupId, cardData) {
  const encrypted = encryptCardCode(cardData.card_code);
  
  await db.internetOrders.updateOne(
    { topupId },
    {
      $set: {
        status: 'FULFILLED',
        encryptedCard: encrypted,
        numTrans: cardData.num_trans,
        dateTraitement: cardData.date_traitement,
        fulfilledAt: new Date()
      }
    }
  );
}

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

# Encryption key (32 bytes)
ENCRYPTION_KEY = bytes.fromhex(os.getenv('ENCRYPTION_KEY'))

def encrypt_card_code(code):
    aesgcm = AESGCM(ENCRYPTION_KEY)
    nonce = os.urandom(12)
    
    encrypted = aesgcm.encrypt(nonce, code.encode('utf-8'), None)
    
    return {
        'nonce': base64.b64encode(nonce).decode('utf-8'),
        'encryptedData': base64.b64encode(encrypted).decode('utf-8')
    }

def decrypt_card_code(nonce_b64, encrypted_data_b64):
    aesgcm = AESGCM(ENCRYPTION_KEY)
    nonce = base64.b64decode(nonce_b64)
    encrypted = base64.b64decode(encrypted_data_b64)
    
    decrypted = aesgcm.decrypt(nonce, encrypted, None)
    
    return decrypted.decode('utf-8')

# Store encrypted card
def store_card_securely(topup_id, card_data):
    encrypted = encrypt_card_code(card_data['card_code'])
    
    db.internet_orders.update_one(
        {'topupId': topup_id},
        {
            '$set': {
                'status': 'FULFILLED',
                'encryptedCard': encrypted,
                'numTrans': card_data['num_trans'],
                'dateTraitement': card_data['date_traitement'],
                'fulfilledAt': datetime.now()
            }
        }
    )

<?php

// Using OpenSSL for encryption
define('ENCRYPTION_KEY', getenv('ENCRYPTION_KEY')); // 32 bytes hex
define('CIPHER_ALGO', 'aes-256-gcm');

function encryptCardCode($code) {
    $key = hex2bin(ENCRYPTION_KEY);
    $iv = random_bytes(16);
    $tag = '';
    
    $encrypted = openssl_encrypt(
        $code,
        CIPHER_ALGO,
        $key,
        OPENSSL_RAW_DATA,
        $iv,
        $tag,
        '',
        16
    );
    
    return [
        'iv' => bin2hex($iv),
        'encryptedData' => bin2hex($encrypted),
        'authTag' => bin2hex($tag)
    ];
}

function decryptCardCode($ivHex, $encryptedHex, $authTagHex) {
    $key = hex2bin(ENCRYPTION_KEY);
    $iv = hex2bin($ivHex);
    $encrypted = hex2bin($encryptedHex);
    $authTag = hex2bin($authTagHex);
    
    $decrypted = openssl_decrypt(
        $encrypted,
        CIPHER_ALGO,
        $key,
        OPENSSL_RAW_DATA,
        $iv,
        $authTag
    );
    
    if ($decrypted === false) {
        throw new Exception('Decryption failed');
    }
    
    return $decrypted;
}

// Store encrypted card
function storeCardSecurely($topupId, $cardData) {
    $encrypted = encryptCardCode($cardData['card_code']);
    
    updateOrderInDatabase($topupId, [
        'status' => 'FULFILLED',
        'encryptedCard' => $encrypted,
        'numTrans' => $cardData['num_trans'],
        'dateTraitement' => $cardData['date_traitement'],
        'fulfilledAt' => date('Y-m-d H:i:s')
    ]);
}
?>

async function completeOrderDelivery(topupId, userId) {
  // 1. Get order details
  const order = await checkTopupStatus(topupId);
  
  if (order.status !== 'FULFILLED') {
    throw new Error('Order not ready for delivery');
  }
  
  // 2. Store encrypted card
  await storeCardSecurely(topupId, order);
  
  // 3. Deliver to customer
  await deliverCardViaEmail(userId, topupId, order);
  
  // 4. Log delivery (without sensitive data)
  await logCardDelivery(topupId, userId, 'email');
  
  console.log(`✅ Order ${topupId} delivery complete`);
}

async def complete_order_delivery(topup_id, user_id):
    # 1. Get order details
    order = check_topup_status(topup_id)
    
    if order['status'] != 'FULFILLED':
        raise ValueError('Order not ready for delivery')
    
    # 2. Store encrypted card
    store_card_securely(topup_id, order)
    
    # 3. Deliver to customer
    await deliver_card_via_email(user_id, topup_id, order)
    
    # 4. Log delivery (without sensitive data)
    await log_card_delivery(topup_id, user_id, 'email')
    
    print(f"✅ Order {topup_id} delivery complete")

<?php

function completeOrderDelivery($topupId, $userId) {
    // 1. Get order details
    $order = checkTopupStatus($topupId);
    
    if ($order['status'] !== 'FULFILLED') {
        throw new Exception('Order not ready for delivery');
    }
    
    // 2. Store encrypted card
    storeCardSecurely($topupId, $order);
    
    // 3. Deliver to customer
    deliverCardViaEmail($userId, $topupId, $order);
    
    // 4. Log delivery (without sensitive data)
    logCardDelivery($topupId, $userId, 'email');
    
    error_log("✅ Order {$topupId} delivery complete");
}
?>