ehbp 0.0.2 → 0.0.4

package/src/protocol.ts

@@ -1,19 +0,0 @@
-/**
- * Protocol constants for EHBP (Encrypted HTTP Body Protocol)
- */
-export const PROTOCOL = {
-  ENCAPSULATED_KEY_HEADER: 'Ehbp-Encapsulated-Key',
-  CLIENT_PUBLIC_KEY_HEADER: 'Ehbp-Client-Public-Key',
-  KEYS_MEDIA_TYPE: 'application/ohttp-keys',
-  KEYS_PATH: '/.well-known/hpke-keys',
-  FALLBACK_HEADER: 'Ehbp-Fallback'
-} as const;
-
-/**
- * HPKE suite configuration matching the Go implementation
- */
-export const HPKE_CONFIG = {
-  KEM: 0x0020, // X25519 HKDF SHA256
-  KDF: 0x0001, // HKDF SHA256
-  AEAD: 0x0002 // AES-256-GCM
-} as const;

package/src/streaming-test.ts

@@ -1,118 +0,0 @@
-#!/usr/bin/env node
-
-import { Identity, createTransport } from './index.js';
-
-async function streamingTest() {
-  console.log('EHBP Streaming Test');
-  console.log('===================');
-
-  try {
-    // Create client identity
-    console.log('Creating client identity...');
-    const clientIdentity = await Identity.generate();
-    console.log('Client identity created');
-
-    // Create transport
-    console.log('Creating transport...');
-    const serverURL = 'http://localhost:8080';
-    const transport = await createTransport(serverURL, clientIdentity);
-    console.log('Transport created');
-
-    // Test 1: Basic streaming request
-    console.log('\n--- Test 1: Basic Streaming ---');
-    const streamResponse = await transport.get(`${serverURL}/stream`);
-    console.log('Stream request sent, status:', streamResponse.status);
-
-    if (streamResponse.ok) {
-      console.log('Reading stream data...');
-      const reader = streamResponse.body?.getReader();
-      if (reader) {
-        const decoder = new TextDecoder();
-
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-
-          const text = decoder.decode(value, { stream: true });
-          process.stdout.write(text);
-        }
-
-        console.log('\nStream completed');
-      } else {
-        console.log('No readable stream available');
-      }
-    } else {
-      console.log('Stream request failed with status:', streamResponse.status);
-    }
-
-    // Test 2: Multiple concurrent streams
-    console.log('\n--- Test 2: Concurrent Streams ---');
-    const concurrentStreams = 3;
-    const streamPromises = [];
-
-    for (let i = 0; i < concurrentStreams; i++) {
-      streamPromises.push(
-        (async (streamId: number) => {
-          const response = await transport.get(`${serverURL}/stream`);
-          if (response.ok && response.body) {
-            const reader = response.body.getReader();
-            const decoder = new TextDecoder();
-
-            while (true) {
-              const { done, value } = await reader.read();
-              if (done) break;
-
-              const text = decoder.decode(value, { stream: true });
-              
-              // Prefix with stream ID to show concurrency
-              process.stdout.write(`[Stream ${streamId}] ${text}`);
-            }
-
-            return { streamId };
-          }
-          return { streamId };
-        })(i + 1)
-      );
-    }
-
-    const results = await Promise.all(streamPromises);
-    console.log('\nConcurrent streams completed:');
-    results.forEach(result => {
-      console.log(`  - Stream ${result.streamId}: completed`);
-    });
-
-    // Test 3: Large data streaming (if server supports it)
-    console.log('\n--- Test 3: Large Data Stream ---');
-    try {
-      const largeStreamResponse = await transport.get(`${serverURL}/stream`);
-      if (largeStreamResponse.ok) {
-        console.log('Reading large data stream...');
-        const reader = largeStreamResponse.body?.getReader();
-        if (reader) {
-          const decoder = new TextDecoder();
-
-          while (true) {
-            const { done, value } = await reader.read();
-            if (done) break;
-
-            const text = decoder.decode(value, { stream: true });
-            process.stdout.write(text);
-          }
-        }
-      }
-    } catch (error) {
-      console.log('Large data stream test failed:', error instanceof Error ? error.message : String(error));
-    }
-
-    console.log('\nAll streaming tests completed successfully!');
-
-  } catch (error) {
-    console.error('Streaming test failed:', error);
-    process.exit(1);
-  }
-}
-
-// Run the streaming test
-if (import.meta.url === `file://${process.argv[1]}`) {
-  streamingTest().catch(console.error);
-}

package/src/test/client.test.ts

@@ -1,93 +0,0 @@
-import { describe, it, before, after } from 'node:test';
-import assert from 'node:assert';
-import { Identity, Transport, createTransport } from '../index.js';
-import { PROTOCOL } from '../protocol.js';
-
-describe('Transport', () => {
-  let clientIdentity: Identity;
-  let serverIdentity: Identity;
-
-  before(async () => {
-    clientIdentity = await Identity.generate();
-    serverIdentity = await Identity.generate();
-  });
-
-  it('should create transport with server public key', () => {
-    const transport = new Transport(
-      clientIdentity,
-      'localhost:8080',
-      serverIdentity.getPublicKey()
-    );
-    
-    assert(transport instanceof Transport, 'Should create transport instance');
-  });
-
-  it('should encrypt and decrypt request', async () => {
-    const serverPublicKey = serverIdentity.getPublicKey();
-    const originalBody = new TextEncoder().encode('Hello, World!');
-    const request = new Request('http://localhost:8080/test', {
-      method: 'POST',
-      body: originalBody
-    });
-
-    const encryptedRequest = await clientIdentity.encryptRequest(request, serverPublicKey);
-    
-    // Check that headers are set
-    assert(encryptedRequest.headers.get(PROTOCOL.CLIENT_PUBLIC_KEY_HEADER), 'Client public key header should be set');
-    assert(encryptedRequest.headers.get(PROTOCOL.ENCAPSULATED_KEY_HEADER), 'Encapsulated key header should be set');
-    
-    // Check that body is encrypted (different from original)
-    const encryptedBody = await encryptedRequest.arrayBuffer();
-    assert(encryptedBody.byteLength > 0, 'Encrypted body should not be empty');
-    assert(encryptedBody.byteLength !== originalBody.length, 'Encrypted body should have different length');
-  });
-
-  it('should handle request without body', async () => {
-    const serverPublicKey = serverIdentity.getPublicKey();
-    const request = new Request('http://localhost:8080/test', {
-      method: 'GET'
-    });
-
-    const encryptedRequest = await clientIdentity.encryptRequest(request, serverPublicKey);
-    
-    // Check that only client public key header is set
-    assert(encryptedRequest.headers.get(PROTOCOL.CLIENT_PUBLIC_KEY_HEADER), 'Client public key header should be set');
-    assert(!encryptedRequest.headers.get(PROTOCOL.ENCAPSULATED_KEY_HEADER), 'Encapsulated key header should not be set for empty body');
-  });
-
-  it('should connect to actual server and POST to /secure endpoint', async (t) => {
-    const serverURL = 'http://localhost:8080';
-    
-    try {
-      const keysResponse = await fetch(`${serverURL}${PROTOCOL.KEYS_PATH}`);
-      if (!keysResponse.ok) {
-        t.skip('Server not running at localhost:8080');
-        return;
-      }
-    } catch (error) {
-      t.skip('Server not running at localhost:8080');
-      return;
-    }
-
-    // Create transport that will connect to the real server
-    const transport = await createTransport(serverURL, clientIdentity);
-    
-    const testName = 'Integration Test User';
-
-    const serverPubKeyHex = await transport.getServerPublicKeyHex();
-    assert.strictEqual(serverPubKeyHex.length, 64, 'Server public key should be 64 bytes');
-
-    // Make actual POST request to /secure endpoint
-    const response = await transport.post(`${serverURL}/secure`, testName, {
-      headers: { 'Content-Type': 'text/plain' }
-    });
-    
-    // Verify response
-    assert(response.ok, `Response should be ok, got status: ${response.status}`);
-    
-    const responseText = await response.text();
-    assert.strictEqual(responseText, `Hello, ${testName}`, 'Server should respond with Hello, {name}');
-    
-    console.log(`✓ Integration test passed: ${responseText}`);
-  });
-});

package/src/test/identity.test.ts

@@ -1,46 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-import { Identity } from '../identity.js';
-
-describe('Identity', () => {
-  it('should generate a new identity', async () => {
-    const identity = await Identity.generate();
-    
-    assert(identity.getPublicKey() instanceof CryptoKey, 'Public key should be a CryptoKey');
-    assert(identity.getPrivateKey() instanceof CryptoKey, 'Private key should be a CryptoKey');
-    const publicKeyHex = await identity.getPublicKeyHex();
-    assert(publicKeyHex.length > 0, 'Public key hex should not be empty');
-  });
-
-  it('should serialize and deserialize identity', async () => {
-    const original = await Identity.generate();
-    const json = await original.toJSON();
-    const restored = await Identity.fromJSON(json);
-    
-    const originalHex = await original.getPublicKeyHex();
-    const restoredHex = await restored.getPublicKeyHex();
-    assert(originalHex === restoredHex, 'Public keys should match');
-    assert(original.getPrivateKey() instanceof CryptoKey, 'Private key should be a CryptoKey');
-    assert(restored.getPrivateKey() instanceof CryptoKey, 'Private key should be a CryptoKey');
-  });
-
-  it('should marshal configuration', async () => {
-    const identity = await Identity.generate();
-    const config = await identity.marshalConfig();
-    
-    assert(config.length > 0, 'Config should not be empty');
-    assert(config[0] === 0, 'Key ID should be 0');
-    assert(config[1] === 0x00, 'KEM ID high byte should be 0x00');
-    assert(config[2] === 0x20, 'KEM ID low byte should be 0x20');
-  });
-
-  it('should unmarshal public configuration', async () => {
-    const identity = await Identity.generate();
-    const config = await identity.marshalConfig();
-    const restored = await Identity.unmarshalPublicConfig(config);
-    
-    const originalHex = await identity.getPublicKeyHex();
-    const restoredHex = await restored.getPublicKeyHex();
-    assert(restoredHex === originalHex, 'Public keys should match');
-  });
-});

package/src/test/streaming.test.ts

@@ -1,85 +0,0 @@
-import { describe, it } from 'node:test';
-import assert from 'node:assert';
-
-describe('Streaming', () => {
-
-  it('should handle streaming responses', async () => {
-    // Create a mock streaming response
-    const mockStreamData = 'Number: 1\nNumber: 2\nNumber: 3\n';
-    const mockResponse = new Response(mockStreamData, {
-      status: 200,
-      headers: {
-        'Content-Type': 'text/plain',
-        'Ehbp-Encapsulated-Key': 'abcd1234' // Mock encapsulated key
-      }
-    });
-
-    // Test that we can read from a stream
-    const reader = mockResponse.body?.getReader();
-    assert(reader, 'Response should have a readable stream');
-
-    const decoder = new TextDecoder();
-    let receivedData = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      const text = decoder.decode(value, { stream: true });
-      receivedData += text;
-    }
-
-    assert(receivedData === mockStreamData, 'Should receive all stream data');
-  });
-
-  it('should handle empty streams', async () => {
-    const emptyResponse = new Response('', {
-      status: 200,
-      headers: {
-        'Ehbp-Encapsulated-Key': 'abcd1234'
-      }
-    });
-
-    const reader = emptyResponse.body?.getReader();
-    assert(reader, 'Response should have a readable stream');
-
-    const { done } = await reader.read();
-    assert(done, 'Empty stream should be done immediately');
-  });
-
-  it('should handle chunked data correctly', async () => {
-    // Simulate chunked data
-    const chunks = ['Hello', ' ', 'World', '!'];
-    const stream = new ReadableStream({
-      start(controller) {
-        chunks.forEach(chunk => {
-          controller.enqueue(new TextEncoder().encode(chunk));
-        });
-        controller.close();
-      }
-    });
-
-    const response = new Response(stream, {
-      status: 200,
-      headers: {
-        'Ehbp-Encapsulated-Key': 'abcd1234'
-      }
-    });
-
-    const reader = response.body?.getReader();
-    assert(reader, 'Response should have a readable stream');
-
-    const decoder = new TextDecoder();
-    let receivedData = '';
-
-    while (true) {
-      const { done, value } = await reader.read();
-      if (done) break;
-
-      const text = decoder.decode(value, { stream: true });
-      receivedData += text;
-    }
-
-    assert(receivedData === 'Hello World!', 'Should receive all chunks correctly');
-  });
-});

package/test.html

@@ -1,271 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>EHBP Streaming Test</title>
-    <style>
-        body {
-            font-family: Arial, sans-serif;
-            max-width: 800px;
-            margin: 0 auto;
-            padding: 20px;
-            background-color: #f5f5f5;
-        }
-        .container {
-            background: white;
-            padding: 20px;
-            border-radius: 8px;
-            box-shadow: 0 2px 4px rgba(0,0,0,0.1);
-        }
-        h1 {
-            color: #333;
-            text-align: center;
-        }
-        .test-section {
-            margin: 20px 0;
-            padding: 15px;
-            border: 1px solid #ddd;
-            border-radius: 5px;
-        }
-        .test-section h3 {
-            margin-top: 0;
-            color: #555;
-        }
-        button {
-            background-color: #007bff;
-            color: white;
-            border: none;
-            padding: 10px 20px;
-            border-radius: 4px;
-            cursor: pointer;
-            margin: 5px;
-        }
-        button:hover {
-            background-color: #0056b3;
-        }
-        button:disabled {
-            background-color: #6c757d;
-            cursor: not-allowed;
-        }
-        .output {
-            background-color: #f8f9fa;
-            border: 1px solid #dee2e6;
-            border-radius: 4px;
-            padding: 10px;
-            margin: 10px 0;
-            height: 100px;
-            font-family: monospace;
-            white-space: pre-wrap;
-            overflow-y: auto;
-        }
-        .status {
-            padding: 10px;
-            margin: 10px 0;
-            border-radius: 4px;
-        }
-        .status.success {
-            background-color: #d4edda;
-            color: #155724;
-            border: 1px solid #c3e6cb;
-        }
-        .status.error {
-            background-color: #f8d7da;
-            color: #721c24;
-            border: 1px solid #f5c6cb;
-        }
-        .status.info {
-            background-color: #d1ecf1;
-            color: #0c5460;
-            border: 1px solid #bee5eb;
-        }
-        .clear-btn {
-            background-color: #6c757d;
-        }
-        .clear-btn:hover {
-            background-color: #545b62;
-        }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>EHBP Test</h1>
-        
-        <div class="test-section">
-            <h3>Server Configuration</h3>
-            <label for="serverUrl">Server URL:</label>
-            <input type="text" id="serverUrl" value="http://localhost:8080" style="width: 300px; padding: 5px; margin: 5px;">
-            <div id="serverStatus" class="status info">Ready to test</div>
-        </div>
-
-        <div class="test-section">
-            <h3>Test 1: POST to /secure</h3>
-            <button id="test1Btn" onclick="runTest1()">Run POST Test</button>
-            <button class="clear-btn" onclick="clearOutput('test1Output')">Clear</button>
-            <div id="test1Output" class="output"></div>
-        </div>
-
-        <div class="test-section">
-            <h3>Test 2: Streaming</h3>
-            <button id="test2Btn" onclick="runTest2()">Run Streaming Test</button>
-            <button class="clear-btn" onclick="clearOutput('test2Output')">Clear</button>
-            <div id="test2Output" class="output"></div>
-        </div>
-
-    </div>
-
-    <script type="module">
-        import { Identity, createTransport } from './dist/browser.js';
-
-        let transport = null;
-        let clientIdentity = null;
-
-        async function initializeClient() {
-            try {
-                updateStatus('serverStatus', 'info', 'Initializing client...');
-                clientIdentity = await Identity.generate();
-                const serverUrl = document.getElementById('serverUrl').value;
-                transport = await createTransport(serverUrl, clientIdentity);
-                updateStatus('serverStatus', 'success', `Connected to ${serverUrl}`);
-                return true;
-            } catch (error) {
-                updateStatus('serverStatus', 'error', `Failed to connect: ${error.message}`);
-                return false;
-            }
-        }
-
-        function updateStatus(elementId, type, message) {
-            const element = document.getElementById(elementId);
-            element.className = `status ${type}`;
-            element.textContent = message;
-        }
-
-        function appendOutput(elementId, text) {
-            const element = document.getElementById(elementId);
-            element.textContent += text;
-            element.scrollTop = element.scrollHeight;
-        }
-
-        function clearOutput(elementId) {
-            document.getElementById(elementId).textContent = '';
-        }
-
-        function clearAllOutputs() {
-            clearOutput('test1Output');
-            clearOutput('test2Output');
-        }
-
-        async function runTest1() {
-            const btn = document.getElementById('test1Btn');
-            const output = document.getElementById('test1Output');
-            
-            btn.disabled = true;
-            clearOutput('test1Output');
-
-            let endpoint = '/secure';
-            const exampleName = 'John Doe';
-
-            appendOutput('test1Output', 'Starting POST ' + endpoint + ' test...\n');
-            
-            try {
-                if (!transport) {
-                    const initialized = await initializeClient();
-                    if (!initialized) return;
-                }
-
-                const serverUrl = document.getElementById('serverUrl').value;
-                
-                try {
-                    const testBody = "John Doe";
-                    appendOutput('test1Output', `Sending POST request with body: ${testBody}\n`);
-                    
-                    const response1 = await transport.post(`${serverUrl}${endpoint}`, testBody, {
-                        headers: {
-                            'Content-Type': 'text/plain'
-                        }
-                    });
-                    
-                    appendOutput('test1Output', `Response status: ${response1.status}\n`);
-                    if (response1.ok) {
-                        const responseText = await response1.text();
-                        appendOutput('test1Output', `Response body: ${responseText}\n`);
-                        if (responseText !== "Hello, "+exampleName) {
-                            appendOutput('test1Output', '✗ Basic POST test failed with response: '+responseText+'\n\n');
-                            return;
-                        } else {
-                            appendOutput('test1Output', '✓ Basic POST test passed\n\n');
-                        }
-                    } else {
-                        appendOutput('test1Output', `✗ Basic POST test failed with status: ${response1.status}\n\n`);
-                    }
-                } catch (error) {
-                    appendOutput('test1Output', `✗ Basic POST test failed with error: ${error.message}\n\n`);
-                }
-
-                appendOutput('test1Output', 'POST ' + endpoint + ' test completed!\n');
-            } catch (error) {
-                appendOutput('test1Output', `Error: ${error.message}\n`);
-            } finally {
-                btn.disabled = false;
-            }
-        }
-
-        async function runTest2() {
-            const btn = document.getElementById('test2Btn');
-            const output = document.getElementById('test2Output');
-            
-            btn.disabled = true;
-            clearOutput('test2Output');
-            appendOutput('test2Output', 'Starting basic streaming test...\n');
-            
-            try {
-                if (!transport) {
-                    const initialized = await initializeClient();
-                    if (!initialized) return;
-                }
-
-                const serverUrl = document.getElementById('serverUrl').value;
-                const response = await transport.get(`${serverUrl}/stream`);
-                
-                appendOutput('test2Output', `Stream response status: ${response.status}\n`);
-                
-                if (response.ok) {
-                    appendOutput('test2Output', 'Reading stream data...\n');
-                    const reader = response.body?.getReader();
-                    
-                    if (reader) {
-                        const decoder = new TextDecoder();
-                        
-                        while (true) {
-                            const { done, value } = await reader.read();
-                            if (done) break;
-                            
-                            const text = decoder.decode(value, { stream: true });
-                            appendOutput('test2Output', text);
-                        }
-                        
-                        appendOutput('test2Output', '\nStream completed!\n');
-                    } else {
-                        appendOutput('test2Output', 'No readable stream available\n');
-                    }
-                } else {
-                    appendOutput('test2Output', `Stream request failed with status: ${response.status}\n`);
-                }
-            } catch (error) {
-                appendOutput('test2Output', `Error: ${error.message}\n`);
-            } finally {
-                btn.disabled = false;
-            }
-        }
-
-        window.runTest1 = runTest1;
-        window.runTest2 = runTest2;
-        window.clearOutput = clearOutput;
-        window.clearAllOutputs = clearAllOutputs;
-
-        document.addEventListener('DOMContentLoaded', () => {
-            updateStatus('serverStatus', 'info', 'Ready to test - click a test button to start');
-        });
-    </script>
-</body>
-</html>

package/tsconfig.json

@@ -1,19 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2022",
-    "module": "ESNext",
-    "moduleResolution": "node",
-    "outDir": "./dist",
-    "rootDir": "./src",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "resolveJsonModule": true
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "dist"]
-}