ehbp 0.0.1

package/dist/test/identity.test.js

@@ -0,0 +1,39 @@
+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');
+    });
+});
+//# sourceMappingURL=identity.test.js.map

package/dist/test/identity.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"identity.test.js","sourceRoot":"","sources":["../../src/test/identity.test.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,EAAE,EAAE,MAAM,WAAW,CAAC;AACzC,OAAO,MAAM,MAAM,aAAa,CAAC;AACjC,OAAO,EAAE,QAAQ,EAAE,MAAM,gBAAgB,CAAC;AAE1C,QAAQ,CAAC,UAAU,EAAE,GAAG,EAAE;IACxB,EAAE,CAAC,gCAAgC,EAAE,KAAK,IAAI,EAAE;QAC9C,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAE3C,MAAM,CAAC,QAAQ,CAAC,YAAY,EAAE,YAAY,SAAS,EAAE,kCAAkC,CAAC,CAAC;QACzF,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,YAAY,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAC3F,MAAM,YAAY,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAC;QACtD,MAAM,CAAC,YAAY,CAAC,MAAM,GAAG,CAAC,EAAE,oCAAoC,CAAC,CAAC;IACxE,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,2CAA2C,EAAE,KAAK,IAAI,EAAE;QACzD,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAC3C,MAAM,IAAI,GAAG,MAAM,QAAQ,CAAC,MAAM,EAAE,CAAC;QACrC,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;QAE/C,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAC;QACrD,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAC;QACrD,MAAM,CAAC,WAAW,KAAK,WAAW,EAAE,0BAA0B,CAAC,CAAC;QAChE,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,YAAY,SAAS,EAAE,mCAAmC,CAAC,CAAC;QAC3F,MAAM,CAAC,QAAQ,CAAC,aAAa,EAAE,YAAY,SAAS,EAAE,mCAAmC,CAAC,CAAC;IAC7F,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,8BAA8B,EAAE,KAAK,IAAI,EAAE;QAC5C,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,aAAa,EAAE,CAAC;QAE9C,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,EAAE,4BAA4B,CAAC,CAAC;QACxD,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,CAAC,EAAE,oBAAoB,CAAC,CAAC;QAC9C,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,iCAAiC,CAAC,CAAC;QAC9D,MAAM,CAAC,MAAM,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,gCAAgC,CAAC,CAAC;IAC/D,CAAC,CAAC,CAAC;IAEH,EAAE,CAAC,uCAAuC,EAAE,KAAK,IAAI,EAAE;QACrD,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,QAAQ,EAAE,CAAC;QAC3C,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,aAAa,EAAE,CAAC;QAC9C,MAAM,QAAQ,GAAG,MAAM,QAAQ,CAAC,qBAAqB,CAAC,MAAM,CAAC,CAAC;QAE9D,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAC;QACrD,MAAM,WAAW,GAAG,MAAM,QAAQ,CAAC,eAAe,EAAE,CAAC;QACrD,MAAM,CAAC,WAAW,KAAK,WAAW,EAAE,0BAA0B,CAAC,CAAC;IAClE,CAAC,CAAC,CAAC;AACL,CAAC,CAAC,CAAC"}

package/dist/test/streaming.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=streaming.test.d.ts.map

package/dist/test/streaming.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.test.d.ts","sourceRoot":"","sources":["../../src/test/streaming.test.ts"],"names":[],"mappings":""}

package/dist/test/streaming.test.js

@@ -0,0 +1,71 @@
+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');
+    });
+});
+//# sourceMappingURL=streaming.test.js.map

package/dist/test/streaming.test.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"streaming.test.js","sourceRoot":"","sources":["../../src/test/streaming.test.ts"],"names":[],"mappings":"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"}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "ehbp",
+  "version": "0.0.1",
+  "description": "JavaScript client for Encrypted HTTP Body Protocol (EHBP)",
+  "main": "dist/index.js",
+  "type": "module",
+  "scripts": {
+    "build": "tsc",
+    "build:browser": "node build-browser.js",
+    "build:all": "npm run build && npm run build:browser",
+    "dev": "tsc --watch",
+    "test": "node --test dist/test/*.test.js",
+    "example": "node dist/example.js",
+    "streaming": "node dist/streaming-test.js",
+    "serve": "node serve.js"
+  },
+  "keywords": [
+    "hpke",
+    "encryption",
+    "http",
+    "security",
+    "ehbp"
+  ],
+  "author": "Tinfoil",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/tinfoilsh/encrypted-http-body-protocol.git"
+  },
+  "license": "MIT",
+  "dependencies": {
+    "@hpke/core": "^1.7.4",
+    "@hpke/dhkem-x25519": "^1.6.4"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "esbuild": "^0.25.9",
+    "typescript": "^5.0.0"
+  },
+  "engines": {
+    "node": ">=20.0.0"
+  }
+}

package/src/client.ts

@@ -0,0 +1,170 @@
+import { Identity } from './identity.js';
+import { PROTOCOL } from './protocol.js';
+
+/**
+ * HTTP transport for EHBP
+ */
+export class Transport {
+  private clientIdentity: Identity;
+  private serverHost: string;
+  private serverPublicKey: CryptoKey;
+
+  constructor(clientIdentity: Identity, serverHost: string, serverPublicKey: CryptoKey) {
+    this.clientIdentity = clientIdentity;
+    this.serverHost = serverHost;
+    this.serverPublicKey = serverPublicKey;
+  }
+
+  /**
+   * Create a new transport by fetching server public key
+   */
+  static async create(serverURL: string, clientIdentity: Identity): Promise<Transport> {
+    const url = new URL(serverURL);
+    const serverHost = url.host;
+
+    // Fetch server public key
+    const keysURL = new URL(PROTOCOL.KEYS_PATH, serverURL);
+    const response = await fetch(keysURL.toString());
+
+    if (!response.ok) {
+      throw new Error(`Failed to get server public key: ${response.status}`);
+    }
+
+    const contentType = response.headers.get('content-type');
+    if (contentType !== PROTOCOL.KEYS_MEDIA_TYPE) {
+      throw new Error(`Invalid content type: ${contentType}`);
+    }
+
+    const keysData = new Uint8Array(await response.arrayBuffer());
+    const serverIdentity = await Identity.unmarshalPublicConfig(keysData);
+    const serverPublicKey = serverIdentity.getPublicKey();
+
+    return new Transport(clientIdentity, serverHost, serverPublicKey);
+  }
+
+  /**
+   * Get the server public key
+   */
+  async getServerPublicKey(): Promise<CryptoKey> {
+    return this.serverPublicKey;
+  }
+
+  /**
+   * Get the client public key
+   */
+  async getClientPublicKey(): Promise<CryptoKey> {
+    return this.clientIdentity.getPublicKey();
+  }
+
+  /**
+   * Make an encrypted HTTP request
+   */
+  async request(input: RequestInfo | URL, init?: RequestInit): Promise<Response> {
+    // Extract body from init or original request before creating Request object
+    let requestBody: BodyInit | null = null;
+    
+    if (input instanceof Request) {
+      // If input is a Request, extract its body
+      if (input.body) {
+        requestBody = await input.arrayBuffer();
+      }
+    } else {
+      // If input is URL/string, get body from init
+      requestBody = init?.body || null;
+    }
+
+    // Create the URL with correct host
+    let url: URL;
+    let method: string;
+    let headers: HeadersInit;
+
+    if (input instanceof Request) {
+      url = new URL(input.url);
+      method = input.method;
+      headers = input.headers;
+    } else {
+      url = new URL(input);
+      method = init?.method || 'GET';
+      headers = init?.headers || {};
+    }
+
+    url.host = this.serverHost;
+    
+    let request = new Request(url.toString(), {
+      method,
+      headers,
+      body: requestBody,
+      duplex: 'half'
+    } as RequestInit);
+
+    // Encrypt request body if present (check the original requestBody, not request.body)
+    if (requestBody !== null && requestBody !== undefined) {
+      request = await this.clientIdentity.encryptRequest(request, this.serverPublicKey);
+    } else {
+      // No body, just set client public key header
+      const headers = new Headers(request.headers);
+      headers.set(PROTOCOL.CLIENT_PUBLIC_KEY_HEADER, await this.clientIdentity.getPublicKeyHex());
+      request = new Request(request.url, {
+        method: request.method,
+        headers,
+        body: null
+      });
+    }
+
+    // Make the request
+    const response = await fetch(request);
+
+    if (!response.ok) {
+      console.warn(`Server returned non-OK status: ${response.status}`);
+    }
+
+    // Check for encapsulated key header
+    const encapKeyHeader = response.headers.get(PROTOCOL.ENCAPSULATED_KEY_HEADER);
+    if (!encapKeyHeader) {
+      throw new Error(`Missing ${PROTOCOL.ENCAPSULATED_KEY_HEADER} encapsulated key header`);
+    }
+
+    // Decode encapsulated key
+    const serverEncapKey = new Uint8Array(
+      encapKeyHeader.match(/.{2}/g)!.map(byte => parseInt(byte, 16))
+    );
+
+    // Decrypt response
+    return await this.clientIdentity.decryptResponse(response, serverEncapKey);
+  }
+
+  /**
+   * Convenience method for GET requests
+   */
+  async get(url: string | URL, init?: RequestInit): Promise<Response> {
+    return this.request(url, { ...init, method: 'GET' });
+  }
+
+  /**
+   * Convenience method for POST requests
+   */
+  async post(url: string | URL, body?: BodyInit, init?: RequestInit): Promise<Response> {
+    return this.request(url, { ...init, method: 'POST', body });
+  }
+
+  /**
+   * Convenience method for PUT requests
+   */
+  async put(url: string | URL, body?: BodyInit, init?: RequestInit): Promise<Response> {
+    return this.request(url, { ...init, method: 'PUT', body });
+  }
+
+  /**
+   * Convenience method for DELETE requests
+   */
+  async delete(url: string | URL, init?: RequestInit): Promise<Response> {
+    return this.request(url, { ...init, method: 'DELETE' });
+  }
+}
+
+/**
+ * Create a new transport instance
+ */
+export async function createTransport(serverURL: string, clientIdentity: Identity): Promise<Transport> {
+  return Transport.create(serverURL, clientIdentity);
+}

package/src/example.ts

@@ -0,0 +1,126 @@
+#!/usr/bin/env node
+
+/**
+ * Example usage of the EHBP JavaScript client
+ */
+
+import { Identity, createTransport } from './index.js';
+
+async function main() {
+  console.log('EHBP JavaScript Client Example');
+  console.log('==============================');
+
+  try {
+    // Create client identity
+    console.log('Creating client identity...');
+    const clientIdentity = await Identity.generate();
+    console.log('Client public key:', await clientIdentity.getPublicKeyHex());
+
+    // Create transport (this will fetch server public key)
+    console.log('Creating transport...');
+    const serverURL = 'http://localhost:8080'; // Adjust as needed
+    const transport = await createTransport(serverURL, clientIdentity);
+    console.log('Transport created successfully');
+
+    // Example 1: GET request to secure endpoint
+    console.log('\n--- GET Request ---');
+    try {
+      const getResponse = await transport.get(`${serverURL}/secure`);
+      console.log('GET Response status:', getResponse.status);
+      if (getResponse.ok) {
+        const getData = await getResponse.text();
+        console.log('GET Response:', getData);
+      } else {
+        console.log('GET Request failed with status:', getResponse.status);
+      }
+    } catch (error) {
+      console.log('GET Request failed:', error instanceof Error ? error.message : String(error));
+    }
+
+    // Example 2: POST request with JSON data
+    console.log('\n--- POST Request ---');
+    try {
+      const postData = { message: 'Hello from JavaScript client!', timestamp: new Date().toISOString() };
+      const postResponse = await transport.post(
+        `${serverURL}/secure`,
+        JSON.stringify(postData),
+        { headers: { 'Content-Type': 'application/json' } }
+      );
+      console.log('POST Response status:', postResponse.status);
+      if (postResponse.ok) {
+        const responseData = await postResponse.text();
+        console.log('POST Response:', responseData);
+      } else {
+        console.log('POST Request failed with status:', postResponse.status);
+      }
+    } catch (error) {
+      console.log('POST Request failed:', error instanceof Error ? error.message : String(error));
+    }
+
+    // Example 3: PUT request
+    console.log('\n--- PUT Request ---');
+    try {
+      const putData = { id: 1, name: 'Updated Item' };
+      const putResponse = await transport.put(
+        `${serverURL}/secure`,
+        JSON.stringify(putData),
+        { headers: { 'Content-Type': 'application/json' } }
+      );
+      console.log('PUT Response status:', putResponse.status);
+      if (putResponse.ok) {
+        const putResponseData = await putResponse.text();
+        console.log('PUT Response:', putResponseData);
+      } else {
+        console.log('PUT Request failed with status:', putResponse.status);
+      }
+    } catch (error) {
+      console.log('PUT Request failed:', error instanceof Error ? error.message : String(error));
+    }
+
+    // Example 4: Streaming request
+    console.log('\n--- Streaming Request ---');
+    try {
+      const streamResponse = await transport.get(`${serverURL}/stream`);
+      console.log('Stream Response status:', streamResponse.status);
+      if (streamResponse.ok) {
+        console.log('Streaming response (should show numbers 1-20):');
+        const reader = streamResponse.body?.getReader();
+        if (reader) {
+          const decoder = new TextDecoder();
+          let chunkCount = 0;
+          
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            
+            const text = decoder.decode(value, { stream: true });
+            process.stdout.write(text);
+            chunkCount++;
+          }
+          
+          console.log(`\nStream completed with ${chunkCount} chunks`);
+        } else {
+          console.log('No readable stream available');
+        }
+      } else {
+        console.log('Stream Request failed with status:', streamResponse.status);
+      }
+    } catch (error) {
+      console.log('Stream Request failed:', error instanceof Error ? error.message : String(error));
+    }
+
+    console.log('\nExample completed successfully!');
+    console.log('\nTo test with a real server:');
+    console.log('1. Start the Go server: go run pkg/server/main.go');
+    console.log('2. Run this example: npm run example');
+
+  } catch (error) {
+    console.error('Error:', error);
+    process.exit(1);
+  }
+}
+
+// Run the example
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(console.error);
+}