react-native-nitro-net 0.1.5 → 0.3.0

package/cpp/NetBindings.hpp

@@ -21,11 +21,34 @@ void net_init_with_config(NetCallback callback, void *context,
 // Socket
 uint32_t net_create_socket();
 void net_connect(uint32_t id, const char *host, int port);
+void net_connect_tls(uint32_t id, const char *host, int port,
+                     const char *server_name, int reject_unauthorized);
+void net_connect_tls_with_context(uint32_t id, const char *host, int port,
+                                  const char *server_name,
+                                  int reject_unauthorized,
+                                  uint32_t secure_context_id);
+size_t net_get_authorization_error(uint32_t id, char *buf, size_t len);
+size_t net_get_protocol(uint32_t id, char *buf, size_t len);
+size_t net_get_cipher(uint32_t id, char *buf, size_t len);
+size_t net_get_alpn(uint32_t id, char *buf, size_t len);
+size_t net_get_peer_certificate_json(uint32_t id, char *buf, size_t len);
+void net_socket_enable_keylog(uint32_t id);
 void net_write(uint32_t id, const uint8_t *data, size_t len);
 void net_close(uint32_t id);
 void net_destroy_socket(uint32_t id);
 void net_socket_reset_and_destroy(uint32_t id);
 
+// Phase 13: Advanced TLS inspection
+size_t net_get_ephemeral_key_info(uint32_t id, char *buf, size_t len);
+size_t net_get_shared_sigalgs(uint32_t id, char *buf, size_t len);
+
+// TLS Features: enableTrace and exportKeyingMaterial
+void net_socket_enable_trace(uint32_t id);
+int net_socket_export_keying_material(uint32_t id, size_t length,
+                                      const char *label, const uint8_t *context,
+                                      size_t context_len, uint8_t *buf,
+                                      size_t buf_len);
+
 // New Options
 void net_set_nodelay(uint32_t id, bool enable);
 void net_set_keepalive(uint32_t id, bool enable, uint64_t delay_ms);
@@ -41,28 +64,71 @@ void net_pause(uint32_t id);
 void net_resume(uint32_t id);
 void net_shutdown(uint32_t id);
 
-// IPC
+// IPC / Unix Domain Sockets
 void net_connect_unix(uint32_t id, const char *path);
 void net_listen_unix(uint32_t id, const char *path, int backlog);
+void net_listen_tls_unix(uint32_t id, const char *path, int backlog,
+                         uint32_t secure_context_id);
+
+#if !defined(__ANDROID__)
+// Unix-only TLS functions (not available on Android)
+void net_connect_unix_tls(uint32_t id, const char *path,
+                          const char *server_name, int reject_unauthorized);
+void net_connect_unix_tls_with_context(uint32_t id, const char *path,
+                                       const char *server_name,
+                                       int reject_unauthorized,
+                                       uint32_t secure_context_id);
+#endif
 
 // Server
 uint32_t net_create_server();
 void net_listen(uint32_t id, int port, int backlog, bool ipv6_only,
                 bool reuse_port);
+void net_listen_tls(uint32_t id, int port, int backlog, bool ipv6_only,
+                    bool reuse_port, uint32_t secure_context_id);
 void net_server_close(uint32_t id);
 void net_destroy_server(uint32_t id);
 void net_server_set_max_connections(uint32_t id, int max_connections);
 size_t net_get_server_local_address(uint32_t id, char *buf, size_t len);
+uint32_t net_create_secure_context(const char *cert_pem, const char *key_pem,
+                                   const char *passphrase);
+uint32_t net_secure_context_create();
+void net_secure_context_add_ca(uint32_t sc_id, const char *ca_pem);
+void net_secure_context_set_cert_key(uint32_t sc_id, const char *cert_pem,
+                                     const char *key_pem,
+                                     const char *passphrase);
+void net_secure_context_add_context(uint32_t sc_id, const char *hostname,
+                                    const char *cert_pem, const char *key_pem,
+                                    const char *passphrase);
+void net_secure_context_set_pfx(uint32_t sc_id, const uint8_t *data, size_t len,
+                                const char *passphrase);
+void net_secure_context_set_ocsp_response(uint32_t sc_id, const uint8_t *data,
+                                          size_t len);
 /// Listen on an existing file descriptor (handle)
 /// @param id Server ID
 /// @param fd File descriptor of an already-bound TCP listener
 /// @param backlog Listen backlog
 void net_listen_handle(uint32_t id, int fd, int backlog);
 
+// Session
+bool net_is_session_reused(uint32_t id);
+size_t net_get_session(uint32_t id, uint8_t *buf, size_t len);
+void net_set_session(uint32_t id, const uint8_t *ticket, size_t ticket_len);
+size_t net_server_get_ticket_keys(uint32_t id, uint8_t *buf, size_t len);
+void net_server_set_ticket_keys(uint32_t id, const uint8_t *keys, size_t len);
+
+// HTTP Parser
+uint32_t net_http_parser_create(int mode);
+int net_http_parser_feed(uint32_t id, const uint8_t *data, size_t len,
+                         char *buf, size_t buf_len);
+void net_http_parser_destroy(uint32_t id);
+
 // Event Types
 #define NET_EVENT_CONNECT 1
 #define NET_EVENT_DATA 2
 #define NET_EVENT_ERROR 3
 #define NET_EVENT_CLOSE 4
 #define NET_EVENT_CONNECTION 6
+#define NET_EVENT_KEYLOG 10
+#define NET_EVENT_OCSP 11
 }

package/lib/Net.nitro.d.ts

@@ -15,7 +15,9 @@ export declare enum NetSocketEvent {
     DRAIN = 5,
     TIMEOUT = 7,
     LOOKUP = 8,
-    DEBUG = 9
+    SESSION = 9,
+    KEYLOG = 10,
+    OCSP = 11
 }
 export interface NetSocketDriver extends HybridObject<{
     ios: 'swift';
@@ -23,7 +25,21 @@ export interface NetSocketDriver extends HybridObject<{
 }> {
     readonly id: number;
     connect(host: string, port: number): void;
+    connectTLS(host: string, port: number, serverName?: string, rejectUnauthorized?: boolean): void;
+    connectTLSWithContext(host: string, port: number, serverName?: string, rejectUnauthorized?: boolean, secureContextId?: number): void;
+    getAuthorizationError(): string | undefined;
+    getProtocol(): string | undefined;
+    getCipher(): string | undefined;
+    getALPN(): string | undefined;
+    getPeerCertificateJSON(): string | undefined;
+    getEphemeralKeyInfo(): string | undefined;
+    getSharedSigalgs(): string | undefined;
+    isSessionReused(): boolean;
+    getSession(): ArrayBuffer | undefined;
+    setSession(session: ArrayBuffer): void;
     connectUnix(path: string): void;
+    connectUnixTLS(path: string, serverName?: string, rejectUnauthorized?: boolean): void;
+    connectUnixTLSWithContext(path: string, serverName?: string, rejectUnauthorized?: boolean, secureContextId?: number): void;
     write(data: ArrayBuffer): void;
     pause(): void;
     resume(): void;
@@ -31,6 +47,9 @@ export interface NetSocketDriver extends HybridObject<{
     setTimeout(timeout: number): void;
     destroy(): void;
     resetAndDestroy(): void;
+    enableKeylog(): void;
+    enableTrace(): void;
+    exportKeyingMaterial(length: number, label: string, context?: ArrayBuffer): ArrayBuffer | undefined;
     setNoDelay(enable: boolean): void;
     setKeepAlive(enable: boolean, delay: number): void;
     getLocalAddress(): string;
@@ -49,7 +68,9 @@ export interface NetServerDriver extends HybridObject<{
 }> {
     onEvent: (event: number, data: ArrayBuffer) => void;
     listen(port: number, backlog?: number, ipv6Only?: boolean, reusePort?: boolean): void;
+    listenTLS(port: number, secureContextId: number, backlog?: number, ipv6Only?: boolean, reusePort?: boolean): void;
     listenUnix(path: string, backlog?: number): void;
+    listenTLSUnix(path: string, secureContextId: number, backlog?: number): void;
     /**
      * Listen on an existing file descriptor (handle)
      * @param fd File descriptor of an already-bound TCP listener
@@ -60,6 +81,17 @@ export interface NetServerDriver extends HybridObject<{
     maxConnections: number;
     close(): void;
 }
+export interface HttpParser extends HybridObject<{
+    ios: 'swift';
+    android: 'kotlin';
+}> {
+    /**
+     * Feed data to the parser
+     * @param data Raw byte data from the network
+     * @returns JSON string of the parsed message if complete, empty string if partial, or error message starting with 'ERROR:'
+     */
+    feed(data: ArrayBuffer): string;
+}
 /**
  * Runtime configuration for the network module
  */
@@ -69,6 +101,10 @@ export interface NetConfig {
      * 0 = use CPU core count (default)
      */
     workerThreads?: number;
+    /**
+     * Whether to enable verbose debug logging
+     */
+    debug?: boolean;
 }
 export interface NetDriver extends HybridObject<{
     ios: 'swift';
@@ -76,6 +112,15 @@ export interface NetDriver extends HybridObject<{
 }> {
     createSocket(id?: string): NetSocketDriver;
     createServer(): NetServerDriver;
+    createHttpParser(mode: number): HttpParser;
+    createSecureContext(cert: string, key: string, passphrase?: string): number;
+    createEmptySecureContext(): number;
+    addCACertToSecureContext(scId: number, ca: string): void;
+    addContextToSecureContext(scId: number, hostname: string, cert: string, key: string, passphrase?: string): void;
+    setPFXToSecureContext(scId: number, pfx: ArrayBuffer, passphrase?: string): void;
+    setOCSPResponseToSecureContext(scId: number, ocsp: ArrayBuffer): void;
+    getTicketKeys(scId: number): ArrayBuffer | undefined;
+    setTicketKeys(scId: number, keys: ArrayBuffer): void;
     /**
      * Initialize the network module with custom configuration
      * Must be called before any other network operations

package/lib/Net.nitro.js

@@ -10,7 +10,9 @@ var NetSocketEvent;
     NetSocketEvent[NetSocketEvent["DRAIN"] = 5] = "DRAIN";
     NetSocketEvent[NetSocketEvent["TIMEOUT"] = 7] = "TIMEOUT";
     NetSocketEvent[NetSocketEvent["LOOKUP"] = 8] = "LOOKUP";
-    NetSocketEvent[NetSocketEvent["DEBUG"] = 9] = "DEBUG";
+    NetSocketEvent[NetSocketEvent["SESSION"] = 9] = "SESSION";
+    NetSocketEvent[NetSocketEvent["KEYLOG"] = 10] = "KEYLOG";
+    NetSocketEvent[NetSocketEvent["OCSP"] = 11] = "OCSP";
 })(NetSocketEvent || (exports.NetSocketEvent = NetSocketEvent = {}));
 var NetServerEvent;
 (function (NetServerEvent) {

package/lib/http.d.ts

@@ -0,0 +1,203 @@
+import { Writable, Readable } from 'readable-stream';
+import { EventEmitter } from 'eventemitter3';
+import { Socket } from './index';
+export declare const STATUS_CODES: Record<number, string>;
+export declare const METHODS: string[];
+export declare class IncomingMessage extends Readable {
+    httpVersion: string;
+    httpVersionMajor: number;
+    httpVersionMinor: number;
+    method?: string;
+    url?: string;
+    statusCode?: number;
+    statusMessage?: string;
+    headers: Record<string, string | string[]>;
+    rawHeaders: string[];
+    socket: Socket;
+    aborted: boolean;
+    complete: boolean;
+    trailers: Record<string, string>;
+    constructor(socket: Socket);
+    _read(): void;
+    setTimeout(msecs: number, callback?: () => void): this;
+    destroy(error?: Error): this;
+    setNoDelay(noDelay?: boolean): void;
+    setKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+export declare class OutgoingMessage extends Writable {
+    headersSent: boolean;
+    protected _headers: Record<string, any>;
+    protected _headerNames: Record<string, string>;
+    socket: Socket | null;
+    chunkedEncoding: boolean;
+    protected _hasBody: boolean;
+    protected _sendHeadersSent: boolean;
+    aborted: boolean;
+    protected _trailers: Record<string, string> | null;
+    constructor();
+    destroy(error?: Error): this;
+    setHeader(name: string, value: any): this;
+    getHeader(name: string): any;
+    removeHeader(name: string): void;
+    hasHeader(name: string): boolean;
+    getHeaderNames(): string[];
+    setTimeout(ms: number, callback?: () => void): this;
+    protected _renderHeaders(firstLine: string): string;
+    protected _sendHeaders(firstLine: string): void;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    write(chunk: any, encoding?: any, callback?: any): boolean;
+    _final(callback: (error?: Error | null) => void): void;
+    addTrailers(headers: Record<string, string>): void;
+    end(chunk?: any, encoding?: any, callback?: any): this;
+    setNoDelay(noDelay?: boolean): void;
+    setSocketKeepAlive(enable?: boolean, initialDelay?: number): void;
+}
+export declare class ServerResponse extends OutgoingMessage {
+    statusCode: number;
+    statusMessage?: string;
+    socket: Socket;
+    constructor(socket: Socket);
+    writeHead(statusCode: number, statusMessage?: string | Record<string, any>, headers?: Record<string, any>): this;
+    private _sendResponseHeaders;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    write(chunk: any, encoding?: any, callback?: any): boolean;
+    end(chunk?: any, encoding?: any, callback?: any): this;
+}
+export interface ServerOptions {
+    /**
+     * Optionally overrides all net.Server options.
+     */
+    IncomingMessage?: typeof IncomingMessage;
+    ServerResponse?: typeof ServerResponse;
+    /**
+     * Keep-Alive header timeout in milliseconds.
+     */
+    keepAliveTimeout?: number;
+    /**
+     * Request timeout in milliseconds.
+     */
+    requestTimeout?: number;
+    /**
+     * Headers timeout in milliseconds.
+     */
+    headersTimeout?: number;
+    /**
+     * Max header size in bytes.
+     */
+    maxHeaderSize?: number;
+    /**
+     * If defined, sets the maximum number of requests socket can handle.
+     */
+    maxRequestsPerSocket?: number;
+}
+export declare class Server extends EventEmitter {
+    protected _netServer: any;
+    protected _httpConnections: Set<Socket>;
+    maxHeaderSize: number;
+    maxRequestsPerSocket: number;
+    headersTimeout: number;
+    requestTimeout: number;
+    keepAliveTimeout: number;
+    constructor(options?: ServerOptions | ((req: IncomingMessage, res: ServerResponse) => void), requestListener?: (req: IncomingMessage, res: ServerResponse) => void);
+    protected _setupHttpConnection(socket: Socket): void;
+    listen(...args: any[]): this;
+    close(callback?: (err?: Error) => void): this;
+    [Symbol.asyncDispose](): Promise<void>;
+    address(): {
+        port: number;
+        family: string;
+        address: string;
+    } | null;
+    get listening(): boolean;
+    setTimeout(ms: number, callback?: () => void): this;
+}
+export interface AgentOptions {
+    keepAlive?: boolean;
+    keepAliveMsecs?: number;
+    maxSockets?: number;
+    maxTotalSockets?: number;
+    maxFreeSockets?: number;
+    scheduling?: 'fifo' | 'lifo';
+    timeout?: number;
+    maxCachedSessions?: number;
+}
+export declare class Agent extends EventEmitter {
+    maxSockets: number;
+    maxTotalSockets: number;
+    maxFreeSockets: number;
+    keepAlive: boolean;
+    keepAliveMsecs: number;
+    maxCachedSessions: number;
+    scheduling: 'fifo' | 'lifo';
+    requests: Record<string, ClientRequest[]>;
+    sockets: Record<string, Socket[]>;
+    freeSockets: Record<string, Socket[]>;
+    private _totalSockets;
+    proxy: string | null;
+    /**
+     * Gets the proxy URL for the given request options.
+     * Checks HTTP_PROXY, HTTPS_PROXY, and NO_PROXY environment variables.
+     *
+     * @param options Request options to determine if proxy should be used
+     * @returns Proxy URL or null if no proxy should be used
+     */
+    protected getProxy(options: RequestOptions): string | null;
+    constructor(options?: AgentOptions);
+    getName(options: RequestOptions): string;
+    addRequest(req: ClientRequest, options: RequestOptions): void;
+    createConnection(options: RequestOptions, callback: (err: Error | null, socket: Socket) => void): Socket;
+    releaseSocket(socket: Socket, options: RequestOptions): void;
+    keepSocketAlive(_socket: Socket): boolean;
+    reuseSocket(socket: Socket, req: ClientRequest): void;
+    private _removeSocket;
+    destroy(): void;
+}
+export declare const globalAgent: Agent;
+export interface RequestOptions {
+    protocol?: string;
+    host?: string;
+    hostname?: string;
+    family?: number;
+    port?: number;
+    localAddress?: string;
+    socketPath?: string;
+    method?: string;
+    path?: string;
+    headers?: Record<string, any>;
+    auth?: string;
+    agent?: Agent | boolean;
+    timeout?: number;
+    rejectUnauthorized?: boolean;
+}
+export declare class ClientRequest extends OutgoingMessage {
+    method: string;
+    path: string;
+    host: string;
+    private _res?;
+    private _options;
+    private _connected;
+    private _pendingWrites;
+    private _ended;
+    private _expectContinue;
+    private _continueReceived;
+    constructor(options: RequestOptions, callback?: (res: IncomingMessage) => void);
+    /** @internal */
+    onSocket(socket: Socket | null): void;
+    private _connect;
+    private _attachSocketListeners;
+    private _socketCleanup?;
+    private _cleanupSocket;
+    private _finishResponse;
+    private _flushPendingWrites;
+    private _finishRequest;
+    private _sendRequest;
+    _write(chunk: any, encoding: string, callback: (error?: Error | null) => void): void;
+    write(chunk: any, encoding?: any, callback?: any): boolean;
+    end(chunk?: any, encoding?: any, callback?: any): this;
+    abort(): void;
+    flushHeaders(): void;
+}
+export declare function createServer(requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
+export declare function createServer(options: ServerOptions, requestListener?: (req: IncomingMessage, res: ServerResponse) => void): Server;
+export declare function request(urlOrOptions: string | URL | RequestOptions, optionsOrCallback?: RequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void): ClientRequest;
+export declare function get(urlOrOptions: string | URL | RequestOptions, optionsOrCallback?: RequestOptions | ((res: IncomingMessage) => void), callback?: (res: IncomingMessage) => void): ClientRequest;