Ansonhkg/gist:de54d0b3bdc17448efb1e68a11c0c71a

## gistfile1.txt
#!/usr/bin/env bun

/**
 * TweetNaCl.js ↔ Sodalite Compatibility Test Script
 *
 * This script generates real encrypted payloads using TweetNaCl.js that can be used
 * to test compatibility with the Rust sodalite implementation on the server side.
 *
 * Usage: bun run test_tweetnacl_compat.js
 */

import nacl from 'tweetnacl';
import { createHash } from 'crypto';

// Configuration
const ENCRYPTED_PAYLOAD_CURRENT_VERSION = 1;

// Test message
const testMessage = {
    content: "Hello from TweetNaCl.js!",
    number: 123
};

console.log('🚀 TweetNaCl.js ↔ Sodalite Compatibility Test');
console.log('='.repeat(60));

// Generate key pairs (or use fixed ones for consistent testing)
const senderKeyPair = nacl.box.keyPair();
const receiverKeyPair = nacl.box.keyPair();

console.log('🔑 Key Information:');
console.log(`  Sender Public Key:   ${Buffer.from(senderKeyPair.publicKey).toString('hex')}`);
console.log(`  Sender Secret Key:   ${Buffer.from(senderKeyPair.secretKey).toString('hex')}`);
console.log(`  Receiver Public Key: ${Buffer.from(receiverKeyPair.publicKey).toString('hex')}`);
console.log(`  Receiver Secret Key: ${Buffer.from(receiverKeyPair.secretKey).toString('hex')}`);

// Create random and timestamp (mimicking Rust implementation)
const random = new Uint8Array(16);
crypto.getRandomValues(random);
const timestamp = Math.floor(Date.now() / 1000);
const createdAt = new Date().toISOString();

console.log('\n📦 Payload Metadata:');
console.log(`  Random (16 bytes):   ${Buffer.from(random).toString('hex')}`);
console.log(`  Timestamp:           ${timestamp}`);
console.log(`  Created At:          ${createdAt}`);

// Construct AAD exactly like Rust implementation
const aad = new Uint8Array(1 + 16 + 8 + 32 + 32); // 89 bytes total
let offset = 0;

// Version (1 byte)
aad[offset] = ENCRYPTED_PAYLOAD_CURRENT_VERSION;
offset += 1;

// Random (16 bytes)
aad.set(random, offset);
offset += 16;

// Timestamp as big-endian u64 (8 bytes)
const timestampBuffer = new ArrayBuffer(8);
const timestampView = new DataView(timestampBuffer);
timestampView.setBigUint64(0, BigInt(timestamp), false); // false = big-endian
aad.set(new Uint8Array(timestampBuffer), offset);
offset += 8;

// Receiver public key (32 bytes)
aad.set(receiverKeyPair.publicKey, offset);
offset += 32;

// Sender public key (32 bytes)
aad.set(senderKeyPair.publicKey, offset);
offset += 32;

console.log('\n🔍 AAD Construction:');
console.log(`  AAD Length:          ${aad.length} bytes`);
console.log(`  AAD Hex:             ${Buffer.from(aad).toString('hex')}`);

// Hash AAD to get 24-byte nonce (XSalsa20Poly1305 requirement)
const hash = createHash('sha512').update(aad).digest();
const nonce = hash.subarray(0, 24);

console.log('\n🔢 Nonce Derivation:');
console.log(`  SHA512 Hash:         ${hash.toString('hex')}`);
console.log(`  Nonce (24 bytes):    ${nonce.toString('hex')}`);

// Serialize message to JSON
const messageJson = JSON.stringify(testMessage);
const messageBytes = new TextEncoder().encode(messageJson);

console.log('\n📝 Message Information:');
console.log(`  Original Message:    ${JSON.stringify(testMessage)}`);
console.log(`  JSON String:         ${messageJson}`);
console.log(`  Message Length:      ${messageBytes.length} bytes`);
console.log(`  Message Hex:         ${Buffer.from(messageBytes).toString('hex')}`);

// Encrypt using TweetNaCl.js
console.log('\n🔐 TweetNaCl.js Encryption:');
const encryptedBox = nacl.box(
    messageBytes,
    nonce,
    receiverKeyPair.publicKey,
    senderKeyPair.secretKey
);

console.log(`  Encrypted Length:    ${encryptedBox.length} bytes`);
console.log(`  Encrypted Hex:       ${Buffer.from(encryptedBox).toString('hex')}`);

// Analyze TweetNaCl.js format
console.log('\n🔍 TweetNaCl.js Format Analysis:');
console.log(`  Total Length:        ${encryptedBox.length} bytes`);
if (encryptedBox.length >= 16) {
    const mac = encryptedBox.subarray(0, 16);
    const encryptedData = encryptedBox.subarray(16);

    console.log(`  MAC (first 16):      ${Buffer.from(mac).toString('hex')}`);
    console.log(`  Encrypted Data:      ${Buffer.from(encryptedData).toString('hex')}`);
    console.log(`  Encrypted Data Len:  ${encryptedData.length} bytes`);

    // Show sodalite format conversion
    const sodaliteFormat = new Uint8Array(encryptedData.length + mac.length);
    sodaliteFormat.set(encryptedData, 0);
    sodaliteFormat.set(mac, encryptedData.length);

    console.log('\n🔄 Sodalite Format Conversion:');
    console.log(`  Sodalite Format:     ${Buffer.from(sodaliteFormat).toString('hex')}`);
    console.log(`  Format: encrypted_data(${encryptedData.length}) + mac(${mac.length})`);
}

// Test decryption with TweetNaCl.js to verify
console.log('\n✅ TweetNaCl.js Decryption Verification:');
try {
    const decryptedBytes = nacl.box.open(
        encryptedBox,
        nonce,
        senderKeyPair.publicKey,
        receiverKeyPair.secretKey
    );

    if (decryptedBytes) {
        const decryptedJson = new TextDecoder().decode(decryptedBytes);
        const decryptedMessage = JSON.parse(decryptedJson);

        console.log(`  ✅ Decryption Success!`);
        console.log(`  Decrypted JSON:      ${decryptedJson}`);
        console.log(`  Matches Original:    ${JSON.stringify(decryptedMessage) === JSON.stringify(testMessage)}`);
    } else {
        console.log(`  ❌ Decryption failed!`);
    }
} catch (error) {
    console.log(`  ❌ Decryption error: ${error.message}`);
}

// Generate Rust test data
console.log('\n🦀 Rust Test Data Generation:');
console.log('Copy this data for Rust testing:');
console.log('-'.repeat(50));

const rustTestData = {
    sender_public_key: Buffer.from(senderKeyPair.publicKey).toString('hex'),
    sender_secret_key: Buffer.from(senderKeyPair.secretKey).toString('hex'),
    receiver_public_key: Buffer.from(receiverKeyPair.publicKey).toString('hex'),
    receiver_secret_key: Buffer.from(receiverKeyPair.secretKey).toString('hex'),
    random: Buffer.from(random).toString('hex'),
    timestamp: timestamp,
    created_at: createdAt,
    aad: Buffer.from(aad).toString('hex'),
    nonce: nonce.toString('hex'),
    message_json: messageJson,
    message_bytes: Buffer.from(messageBytes).toString('hex'),
    tweetnacl_ciphertext: Buffer.from(encryptedBox).toString('hex'),
    expected_decrypted: messageJson
};

console.log(JSON.stringify(rustTestData, null, 2));

// Generate payload in Rust EncryptedPayloadV1 format
console.log('\n📋 Rust EncryptedPayloadV1 Format:');
const payloadV1 = {
    verification_key: Buffer.from(senderKeyPair.publicKey).toString('hex'),
    random: Buffer.from(random).toString('hex'),
    created_at: createdAt,
    ciphertext_and_tag: Buffer.from(encryptedBox).toString('hex')
};

console.log(JSON.stringify(payloadV1, null, 2));

console.log('\n🎯 Next Steps:');
console.log('1. Use the Rust test data above in your Rust unit tests');
console.log('2. Test sodalite decryption with the provided keys and ciphertext');
console.log('3. Verify AAD and nonce derivation matches exactly');
console.log('4. Debug format conversion if decryption fails');

console.log('\n✨ Test completed successfully!');
	#!/usr/bin/env bun

	/**
	* TweetNaCl.js ↔ Sodalite Compatibility Test Script
	*
	* This script generates real encrypted payloads using TweetNaCl.js that can be used
	* to test compatibility with the Rust sodalite implementation on the server side.
	*
	* Usage: bun run test_tweetnacl_compat.js
	*/

	import nacl from 'tweetnacl';
	import { createHash } from 'crypto';

	// Configuration
	const ENCRYPTED_PAYLOAD_CURRENT_VERSION = 1;

	// Test message
	const testMessage = {
	content: "Hello from TweetNaCl.js!",
	number: 123
	};

	console.log('🚀 TweetNaCl.js ↔ Sodalite Compatibility Test');
	console.log('='.repeat(60));

	// Generate key pairs (or use fixed ones for consistent testing)
	const senderKeyPair = nacl.box.keyPair();
	const receiverKeyPair = nacl.box.keyPair();

	console.log('🔑 Key Information:');
	console.log(` Sender Public Key: ${Buffer.from(senderKeyPair.publicKey).toString('hex')}`);
	console.log(` Sender Secret Key: ${Buffer.from(senderKeyPair.secretKey).toString('hex')}`);
	console.log(` Receiver Public Key: ${Buffer.from(receiverKeyPair.publicKey).toString('hex')}`);
	console.log(` Receiver Secret Key: ${Buffer.from(receiverKeyPair.secretKey).toString('hex')}`);

	// Create random and timestamp (mimicking Rust implementation)
	const random = new Uint8Array(16);
	crypto.getRandomValues(random);
	const timestamp = Math.floor(Date.now() / 1000);
	const createdAt = new Date().toISOString();

	console.log('\n📦 Payload Metadata:');
	console.log(` Random (16 bytes): ${Buffer.from(random).toString('hex')}`);
	console.log(` Timestamp: ${timestamp}`);
	console.log(` Created At: ${createdAt}`);

	// Construct AAD exactly like Rust implementation
	const aad = new Uint8Array(1 + 16 + 8 + 32 + 32); // 89 bytes total
	let offset = 0;

	// Version (1 byte)
	aad[offset] = ENCRYPTED_PAYLOAD_CURRENT_VERSION;
	offset += 1;

	// Random (16 bytes)
	aad.set(random, offset);
	offset += 16;

	// Timestamp as big-endian u64 (8 bytes)
	const timestampBuffer = new ArrayBuffer(8);
	const timestampView = new DataView(timestampBuffer);
	timestampView.setBigUint64(0, BigInt(timestamp), false); // false = big-endian
	aad.set(new Uint8Array(timestampBuffer), offset);
	offset += 8;

	// Receiver public key (32 bytes)
	aad.set(receiverKeyPair.publicKey, offset);
	offset += 32;

	// Sender public key (32 bytes)
	aad.set(senderKeyPair.publicKey, offset);
	offset += 32;

	console.log('\n🔍 AAD Construction:');
	console.log(` AAD Length: ${aad.length} bytes`);
	console.log(` AAD Hex: ${Buffer.from(aad).toString('hex')}`);

	// Hash AAD to get 24-byte nonce (XSalsa20Poly1305 requirement)
	const hash = createHash('sha512').update(aad).digest();
	const nonce = hash.subarray(0, 24);

	console.log('\n🔢 Nonce Derivation:');
	console.log(` SHA512 Hash: ${hash.toString('hex')}`);
	console.log(` Nonce (24 bytes): ${nonce.toString('hex')}`);

	// Serialize message to JSON
	const messageJson = JSON.stringify(testMessage);
	const messageBytes = new TextEncoder().encode(messageJson);

	console.log('\n📝 Message Information:');
	console.log(` Original Message: ${JSON.stringify(testMessage)}`);
	console.log(` JSON String: ${messageJson}`);
	console.log(` Message Length: ${messageBytes.length} bytes`);
	console.log(` Message Hex: ${Buffer.from(messageBytes).toString('hex')}`);

	// Encrypt using TweetNaCl.js
	console.log('\n🔐 TweetNaCl.js Encryption:');
	const encryptedBox = nacl.box(
	messageBytes,
	nonce,
	receiverKeyPair.publicKey,
	senderKeyPair.secretKey
	);

	console.log(` Encrypted Length: ${encryptedBox.length} bytes`);
	console.log(` Encrypted Hex: ${Buffer.from(encryptedBox).toString('hex')}`);

	// Analyze TweetNaCl.js format
	console.log('\n🔍 TweetNaCl.js Format Analysis:');
	console.log(` Total Length: ${encryptedBox.length} bytes`);
	if (encryptedBox.length >= 16) {
	const mac = encryptedBox.subarray(0, 16);
	const encryptedData = encryptedBox.subarray(16);

	console.log(` MAC (first 16): ${Buffer.from(mac).toString('hex')}`);
	console.log(` Encrypted Data: ${Buffer.from(encryptedData).toString('hex')}`);
	console.log(` Encrypted Data Len: ${encryptedData.length} bytes`);

	// Show sodalite format conversion
	const sodaliteFormat = new Uint8Array(encryptedData.length + mac.length);
	sodaliteFormat.set(encryptedData, 0);
	sodaliteFormat.set(mac, encryptedData.length);

	console.log('\n🔄 Sodalite Format Conversion:');
	console.log(` Sodalite Format: ${Buffer.from(sodaliteFormat).toString('hex')}`);
	console.log(` Format: encrypted_data(${encryptedData.length}) + mac(${mac.length})`);
	}

	// Test decryption with TweetNaCl.js to verify
	console.log('\n✅ TweetNaCl.js Decryption Verification:');
	try {
	const decryptedBytes = nacl.box.open(
	encryptedBox,
	nonce,
	senderKeyPair.publicKey,
	receiverKeyPair.secretKey
	);

	if (decryptedBytes) {
	const decryptedJson = new TextDecoder().decode(decryptedBytes);
	const decryptedMessage = JSON.parse(decryptedJson);

	console.log(` ✅ Decryption Success!`);
	console.log(` Decrypted JSON: ${decryptedJson}`);
	console.log(` Matches Original: ${JSON.stringify(decryptedMessage) === JSON.stringify(testMessage)}`);
	} else {
	console.log(` ❌ Decryption failed!`);
	}
	} catch (error) {
	console.log(` ❌ Decryption error: ${error.message}`);
	}

	// Generate Rust test data
	console.log('\n🦀 Rust Test Data Generation:');
	console.log('Copy this data for Rust testing:');
	console.log('-'.repeat(50));

	const rustTestData = {
	sender_public_key: Buffer.from(senderKeyPair.publicKey).toString('hex'),
	sender_secret_key: Buffer.from(senderKeyPair.secretKey).toString('hex'),
	receiver_public_key: Buffer.from(receiverKeyPair.publicKey).toString('hex'),
	receiver_secret_key: Buffer.from(receiverKeyPair.secretKey).toString('hex'),
	random: Buffer.from(random).toString('hex'),
	timestamp: timestamp,
	created_at: createdAt,
	aad: Buffer.from(aad).toString('hex'),
	nonce: nonce.toString('hex'),
	message_json: messageJson,
	message_bytes: Buffer.from(messageBytes).toString('hex'),
	tweetnacl_ciphertext: Buffer.from(encryptedBox).toString('hex'),
	expected_decrypted: messageJson
	};

	console.log(JSON.stringify(rustTestData, null, 2));

	// Generate payload in Rust EncryptedPayloadV1 format
	console.log('\n📋 Rust EncryptedPayloadV1 Format:');
	const payloadV1 = {
	verification_key: Buffer.from(senderKeyPair.publicKey).toString('hex'),
	random: Buffer.from(random).toString('hex'),
	created_at: createdAt,
	ciphertext_and_tag: Buffer.from(encryptedBox).toString('hex')
	};

	console.log(JSON.stringify(payloadV1, null, 2));

	console.log('\n🎯 Next Steps:');
	console.log('1. Use the Rust test data above in your Rust unit tests');
	console.log('2. Test sodalite decryption with the provided keys and ciphertext');
	console.log('3. Verify AAD and nonce derivation matches exactly');
	console.log('4. Debug format conversion if decryption fails');

	console.log('\n✨ Test completed successfully!');