@push.rocks/smartproxy 3.10.4 → 3.11.0

package/dist_ts/00_commitinfo_data.js

@@ -3,7 +3,7 @@
  */
 export const commitinfo = {
     name: '@push.rocks/smartproxy',
-    version: '3.10.4',
+    version: '3.11.0',
     description: 'a proxy for handling high workloads of proxying'
 };
 //# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx3QkFBd0I7SUFDOUIsT0FBTyxFQUFFLFFBQVE7SUFDakIsV0FBVyxFQUFFLGlEQUFpRDtDQUMvRCxDQUFBIn0=

package/dist_ts/classes.networkproxy.d.ts

@@ -0,0 +1,31 @@
+import * as plugins from './plugins.js';
+import { ProxyRouter } from './classes.router.js';
+export interface INetworkProxyOptions {
+    port: number;
+}
+export declare class NetworkProxy {
+    options: INetworkProxyOptions;
+    proxyConfigs: plugins.tsclass.network.IReverseProxyConfig[];
+    httpsServer: plugins.https.Server;
+    router: ProxyRouter;
+    socketMap: plugins.lik.ObjectMap<plugins.net.Socket>;
+    defaultHeaders: {
+        [key: string]: string;
+    };
+    heartbeatInterval: NodeJS.Timeout;
+    private defaultCertificates;
+    alreadyAddedReverseConfigs: {
+        [hostName: string]: plugins.tsclass.network.IReverseProxyConfig;
+    };
+    constructor(optionsArg: INetworkProxyOptions);
+    start(): Promise<void>;
+    /**
+     * Internal async handler for processing HTTP/HTTPS requests.
+     */
+    private handleRequest;
+    updateProxyConfigs(proxyConfigsArg: plugins.tsclass.network.IReverseProxyConfig[]): Promise<void>;
+    addDefaultHeaders(headersArg: {
+        [key: string]: string;
+    }): Promise<void>;
+    stop(): Promise<void>;
+}

package/dist_ts/classes.networkproxy.js

@@ -0,0 +1,305 @@
+import * as plugins from './plugins.js';
+import { ProxyRouter } from './classes.router.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import { fileURLToPath } from 'url';
+export class NetworkProxy {
+    constructor(optionsArg) {
+        this.proxyConfigs = [];
+        this.router = new ProxyRouter();
+        this.socketMap = new plugins.lik.ObjectMap();
+        this.defaultHeaders = {};
+        this.alreadyAddedReverseConfigs = {};
+        this.options = optionsArg;
+        const __dirname = path.dirname(fileURLToPath(import.meta.url));
+        const certPath = path.join(__dirname, '..', 'assets', 'certs');
+        try {
+            this.defaultCertificates = {
+                key: fs.readFileSync(path.join(certPath, 'key.pem'), 'utf8'),
+                cert: fs.readFileSync(path.join(certPath, 'cert.pem'), 'utf8')
+            };
+        }
+        catch (error) {
+            console.error('Error loading certificates:', error);
+            throw error;
+        }
+    }
+    async start() {
+        // Instead of marking the callback async (which Node won't await),
+        // we call our async handler and catch errors.
+        this.httpsServer = plugins.https.createServer({
+            key: this.defaultCertificates.key,
+            cert: this.defaultCertificates.cert
+        }, (originRequest, originResponse) => {
+            this.handleRequest(originRequest, originResponse).catch((error) => {
+                console.error('Unhandled error in request handler:', error);
+                try {
+                    originResponse.end();
+                }
+                catch (err) {
+                    // ignore errors during cleanup
+                }
+            });
+        });
+        // Enable websockets
+        const wsServer = new plugins.ws.WebSocketServer({ server: this.httpsServer });
+        // Set up the heartbeat interval
+        this.heartbeatInterval = setInterval(() => {
+            wsServer.clients.forEach((ws) => {
+                const wsIncoming = ws;
+                if (!wsIncoming.lastPong) {
+                    wsIncoming.lastPong = Date.now();
+                }
+                if (Date.now() - wsIncoming.lastPong > 5 * 60 * 1000) {
+                    console.log('Terminating websocket due to missing pong for 5 minutes.');
+                    wsIncoming.terminate();
+                }
+                else {
+                    wsIncoming.ping();
+                }
+            });
+        }, 60000); // runs every 1 minute
+        wsServer.on('connection', (wsIncoming, reqArg) => {
+            console.log(`wss proxy: got connection for wsc for https://${reqArg.headers.host}${reqArg.url}`);
+            wsIncoming.lastPong = Date.now();
+            wsIncoming.on('pong', () => {
+                wsIncoming.lastPong = Date.now();
+            });
+            let wsOutgoing;
+            const outGoingDeferred = plugins.smartpromise.defer();
+            // --- Improvement 2: Only call routeReq once ---
+            const wsDestinationConfig = this.router.routeReq(reqArg);
+            if (!wsDestinationConfig) {
+                wsIncoming.terminate();
+                return;
+            }
+            try {
+                wsOutgoing = new plugins.wsDefault(`ws://${wsDestinationConfig.destinationIp}:${wsDestinationConfig.destinationPort}${reqArg.url}`);
+                console.log('wss proxy: initiated outgoing proxy');
+                wsOutgoing.on('open', async () => {
+                    outGoingDeferred.resolve();
+                });
+            }
+            catch (err) {
+                console.error('Error initiating outgoing WebSocket:', err);
+                wsIncoming.terminate();
+                return;
+            }
+            wsIncoming.on('message', async (message, isBinary) => {
+                try {
+                    await outGoingDeferred.promise;
+                    wsOutgoing.send(message, { binary: isBinary });
+                }
+                catch (error) {
+                    console.error('Error sending message to wsOutgoing:', error);
+                }
+            });
+            wsOutgoing.on('message', async (message, isBinary) => {
+                try {
+                    wsIncoming.send(message, { binary: isBinary });
+                }
+                catch (error) {
+                    console.error('Error sending message to wsIncoming:', error);
+                }
+            });
+            const terminateWsOutgoing = () => {
+                if (wsOutgoing) {
+                    wsOutgoing.terminate();
+                    console.log('Terminated outgoing ws.');
+                }
+            };
+            wsIncoming.on('error', terminateWsOutgoing);
+            wsIncoming.on('close', terminateWsOutgoing);
+            const terminateWsIncoming = () => {
+                if (wsIncoming) {
+                    wsIncoming.terminate();
+                    console.log('Terminated incoming ws.');
+                }
+            };
+            wsOutgoing.on('error', terminateWsIncoming);
+            wsOutgoing.on('close', terminateWsIncoming);
+        });
+        this.httpsServer.keepAliveTimeout = 600 * 1000;
+        this.httpsServer.headersTimeout = 600 * 1000;
+        this.httpsServer.on('connection', (connection) => {
+            this.socketMap.add(connection);
+            console.log(`Added connection. Now ${this.socketMap.getArray().length} sockets connected.`);
+            const cleanupConnection = () => {
+                if (this.socketMap.checkForObject(connection)) {
+                    this.socketMap.remove(connection);
+                    console.log(`Removed connection. ${this.socketMap.getArray().length} sockets remaining.`);
+                    connection.destroy();
+                }
+            };
+            connection.on('close', cleanupConnection);
+            connection.on('error', cleanupConnection);
+            connection.on('end', cleanupConnection);
+            connection.on('timeout', cleanupConnection);
+        });
+        this.httpsServer.listen(this.options.port);
+        console.log(`NetworkProxy -> OK: now listening for new connections on port ${this.options.port}`);
+    }
+    /**
+     * Internal async handler for processing HTTP/HTTPS requests.
+     */
+    async handleRequest(originRequest, originResponse) {
+        const endOriginReqRes = (statusArg = 404, messageArg = 'This route is not available on this server.', headers = {}) => {
+            originResponse.writeHead(statusArg, messageArg);
+            originResponse.end(messageArg);
+            if (originRequest.socket !== originResponse.socket) {
+                console.log('hey, something is strange.');
+            }
+            originResponse.destroy();
+        };
+        console.log(`got request: ${originRequest.headers.host}${plugins.url.parse(originRequest.url).path}`);
+        const destinationConfig = this.router.routeReq(originRequest);
+        if (!destinationConfig) {
+            console.log(`${originRequest.headers.host} can't be routed properly. Terminating request.`);
+            endOriginReqRes();
+            return;
+        }
+        // authentication
+        if (destinationConfig.authentication) {
+            const authInfo = destinationConfig.authentication;
+            switch (authInfo.type) {
+                case 'Basic': {
+                    const authHeader = originRequest.headers.authorization;
+                    if (!authHeader) {
+                        return endOriginReqRes(401, 'Authentication required', {
+                            'WWW-Authenticate': 'Basic realm="Access to the staging site", charset="UTF-8"',
+                        });
+                    }
+                    if (!authHeader.includes('Basic ')) {
+                        return endOriginReqRes(401, 'Authentication required', {
+                            'WWW-Authenticate': 'Basic realm="Access to the staging site", charset="UTF-8"',
+                        });
+                    }
+                    const authStringBase64 = authHeader.replace('Basic ', '');
+                    const authString = plugins.smartstring.base64.decode(authStringBase64);
+                    const userPassArray = authString.split(':');
+                    const user = userPassArray[0];
+                    const pass = userPassArray[1];
+                    if (user === authInfo.user && pass === authInfo.pass) {
+                        console.log('Request successfully authenticated');
+                    }
+                    else {
+                        return endOriginReqRes(403, 'Forbidden: Wrong credentials');
+                    }
+                    break;
+                }
+                default:
+                    return endOriginReqRes(403, 'Forbidden: unsupported authentication method configured. Please report to the admin.');
+            }
+        }
+        let destinationUrl;
+        if (destinationConfig) {
+            destinationUrl = `http://${destinationConfig.destinationIp}:${destinationConfig.destinationPort}${originRequest.url}`;
+        }
+        else {
+            return endOriginReqRes();
+        }
+        console.log(destinationUrl);
+        try {
+            const proxyResponse = await plugins.smartrequest.request(destinationUrl, {
+                method: originRequest.method,
+                headers: {
+                    ...originRequest.headers,
+                    'X-Forwarded-Host': originRequest.headers.host,
+                    'X-Forwarded-Proto': 'https',
+                },
+                keepAlive: true,
+            }, true, // streaming (keepAlive)
+            (proxyRequest) => {
+                originRequest.on('data', (data) => {
+                    proxyRequest.write(data);
+                });
+                originRequest.on('end', () => {
+                    proxyRequest.end();
+                });
+                originRequest.on('error', () => {
+                    proxyRequest.end();
+                });
+                originRequest.on('close', () => {
+                    proxyRequest.end();
+                });
+                originRequest.on('timeout', () => {
+                    proxyRequest.end();
+                    originRequest.destroy();
+                });
+                proxyRequest.on('error', () => {
+                    endOriginReqRes();
+                });
+            });
+            originResponse.statusCode = proxyResponse.statusCode;
+            console.log(proxyResponse.statusCode);
+            for (const defaultHeader of Object.keys(this.defaultHeaders)) {
+                originResponse.setHeader(defaultHeader, this.defaultHeaders[defaultHeader]);
+            }
+            for (const header of Object.keys(proxyResponse.headers)) {
+                originResponse.setHeader(header, proxyResponse.headers[header]);
+            }
+            proxyResponse.on('data', (data) => {
+                originResponse.write(data);
+            });
+            proxyResponse.on('end', () => {
+                originResponse.end();
+            });
+            proxyResponse.on('error', () => {
+                originResponse.destroy();
+            });
+            proxyResponse.on('close', () => {
+                originResponse.end();
+            });
+            proxyResponse.on('timeout', () => {
+                originResponse.end();
+                originResponse.destroy();
+            });
+        }
+        catch (error) {
+            console.error('Error while processing request:', error);
+            endOriginReqRes(502, 'Bad Gateway: Error processing the request');
+        }
+    }
+    async updateProxyConfigs(proxyConfigsArg) {
+        console.log(`got new proxy configs`);
+        this.proxyConfigs = proxyConfigsArg;
+        this.router.setNewProxyConfigs(proxyConfigsArg);
+        for (const hostCandidate of this.proxyConfigs) {
+            const existingHostNameConfig = this.alreadyAddedReverseConfigs[hostCandidate.hostName];
+            if (!existingHostNameConfig) {
+                this.alreadyAddedReverseConfigs[hostCandidate.hostName] = hostCandidate;
+            }
+            else {
+                if (existingHostNameConfig.publicKey === hostCandidate.publicKey &&
+                    existingHostNameConfig.privateKey === hostCandidate.privateKey) {
+                    continue;
+                }
+                else {
+                    this.alreadyAddedReverseConfigs[hostCandidate.hostName] = hostCandidate;
+                }
+            }
+            this.httpsServer.addContext(hostCandidate.hostName, {
+                cert: hostCandidate.publicKey,
+                key: hostCandidate.privateKey,
+            });
+        }
+    }
+    async addDefaultHeaders(headersArg) {
+        for (const headerKey of Object.keys(headersArg)) {
+            this.defaultHeaders[headerKey] = headersArg[headerKey];
+        }
+    }
+    async stop() {
+        const done = plugins.smartpromise.defer();
+        this.httpsServer.close(() => {
+            done.resolve();
+        });
+        for (const socket of this.socketMap.getArray()) {
+            socket.destroy();
+        }
+        await done.promise;
+        clearInterval(this.heartbeatInterval);
+        console.log('NetworkProxy -> OK: Server has been stopped and all connections closed.');
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.networkproxy.js","sourceRoot":"","sources":["../ts/classes.networkproxy.ts"],"names":[],"mappings":"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"}

package/dist_ts/classes.port80handler.d.ts

@@ -0,0 +1,37 @@
+export declare class Port80Handler {
+    private domainCertificates;
+    private server;
+    private acmeClient;
+    private accountKey;
+    constructor();
+    /**
+     * Adds a domain to be managed.
+     * @param domain The domain to add.
+     */
+    addDomain(domain: string): void;
+    /**
+     * Removes a domain from management.
+     * @param domain The domain to remove.
+     */
+    removeDomain(domain: string): void;
+    /**
+     * Lazy initialization of the ACME client.
+     * Uses Let’s Encrypt’s production directory (for testing you might switch to staging).
+     */
+    private getAcmeClient;
+    /**
+     * Handles incoming HTTP requests on port 80.
+     * If the request is for an ACME challenge, it responds with the key authorization.
+     * If the domain has a certificate, it redirects to HTTPS; otherwise, it initiates certificate issuance.
+     */
+    private handleRequest;
+    /**
+     * Serves the ACME HTTP-01 challenge response.
+     */
+    private handleAcmeChallenge;
+    /**
+     * Uses acme-client to perform a full ACME HTTP-01 challenge to obtain a certificate.
+     * On success, it stores the certificate and key in memory and clears challenge data.
+     */
+    private obtainCertificate;
+}

package/dist_ts/classes.port80handler.js

@@ -0,0 +1,186 @@
+import * as http from 'http';
+import * as acme from 'acme-client';
+export class Port80Handler {
+    constructor() {
+        this.acmeClient = null;
+        this.accountKey = null;
+        this.domainCertificates = new Map();
+        // Create and start an HTTP server on port 80.
+        this.server = http.createServer((req, res) => this.handleRequest(req, res));
+        this.server.listen(80, () => {
+            console.log('Port80Handler is listening on port 80');
+        });
+    }
+    /**
+     * Adds a domain to be managed.
+     * @param domain The domain to add.
+     */
+    addDomain(domain) {
+        if (!this.domainCertificates.has(domain)) {
+            this.domainCertificates.set(domain, { certObtained: false, obtainingInProgress: false });
+            console.log(`Domain added: ${domain}`);
+        }
+    }
+    /**
+     * Removes a domain from management.
+     * @param domain The domain to remove.
+     */
+    removeDomain(domain) {
+        if (this.domainCertificates.delete(domain)) {
+            console.log(`Domain removed: ${domain}`);
+        }
+    }
+    /**
+     * Lazy initialization of the ACME client.
+     * Uses Let’s Encrypt’s production directory (for testing you might switch to staging).
+     */
+    async getAcmeClient() {
+        if (this.acmeClient) {
+            return this.acmeClient;
+        }
+        // Generate a new account key and convert Buffer to string.
+        this.accountKey = (await acme.forge.createPrivateKey()).toString();
+        this.acmeClient = new acme.Client({
+            directoryUrl: acme.directory.letsencrypt.production, // Use production for a real certificate
+            // For testing, you could use:
+            // directoryUrl: acme.directory.letsencrypt.staging,
+            accountKey: this.accountKey,
+        });
+        // Create a new account. Make sure to update the contact email.
+        await this.acmeClient.createAccount({
+            termsOfServiceAgreed: true,
+            contact: ['mailto:admin@example.com'],
+        });
+        return this.acmeClient;
+    }
+    /**
+     * Handles incoming HTTP requests on port 80.
+     * If the request is for an ACME challenge, it responds with the key authorization.
+     * If the domain has a certificate, it redirects to HTTPS; otherwise, it initiates certificate issuance.
+     */
+    handleRequest(req, res) {
+        const hostHeader = req.headers.host;
+        if (!hostHeader) {
+            res.statusCode = 400;
+            res.end('Bad Request: Host header is missing');
+            return;
+        }
+        // Extract domain (ignoring any port in the Host header)
+        const domain = hostHeader.split(':')[0];
+        // If the request is for an ACME HTTP-01 challenge, handle it.
+        if (req.url && req.url.startsWith('/.well-known/acme-challenge/')) {
+            this.handleAcmeChallenge(req, res, domain);
+            return;
+        }
+        if (!this.domainCertificates.has(domain)) {
+            res.statusCode = 404;
+            res.end('Domain not configured');
+            return;
+        }
+        const domainInfo = this.domainCertificates.get(domain);
+        // If certificate exists, redirect to HTTPS on port 443.
+        if (domainInfo.certObtained) {
+            const redirectUrl = `https://${domain}:443${req.url}`;
+            res.statusCode = 301;
+            res.setHeader('Location', redirectUrl);
+            res.end(`Redirecting to ${redirectUrl}`);
+        }
+        else {
+            // Trigger certificate issuance if not already running.
+            if (!domainInfo.obtainingInProgress) {
+                domainInfo.obtainingInProgress = true;
+                this.obtainCertificate(domain).catch(err => {
+                    console.error(`Error obtaining certificate for ${domain}:`, err);
+                });
+            }
+            res.statusCode = 503;
+            res.end('Certificate issuance in progress, please try again later.');
+        }
+    }
+    /**
+     * Serves the ACME HTTP-01 challenge response.
+     */
+    handleAcmeChallenge(req, res, domain) {
+        const domainInfo = this.domainCertificates.get(domain);
+        if (!domainInfo) {
+            res.statusCode = 404;
+            res.end('Domain not configured');
+            return;
+        }
+        // The token is the last part of the URL.
+        const urlParts = req.url?.split('/');
+        const token = urlParts ? urlParts[urlParts.length - 1] : '';
+        if (domainInfo.challengeToken === token && domainInfo.challengeKeyAuthorization) {
+            res.statusCode = 200;
+            res.setHeader('Content-Type', 'text/plain');
+            res.end(domainInfo.challengeKeyAuthorization);
+            console.log(`Served ACME challenge response for ${domain}`);
+        }
+        else {
+            res.statusCode = 404;
+            res.end('Challenge token not found');
+        }
+    }
+    /**
+     * Uses acme-client to perform a full ACME HTTP-01 challenge to obtain a certificate.
+     * On success, it stores the certificate and key in memory and clears challenge data.
+     */
+    async obtainCertificate(domain) {
+        try {
+            const client = await this.getAcmeClient();
+            // Create a new order for the domain.
+            const order = await client.createOrder({
+                identifiers: [{ type: 'dns', value: domain }],
+            });
+            // Get the authorizations for the order.
+            const authorizations = await client.getAuthorizations(order);
+            for (const authz of authorizations) {
+                const challenge = authz.challenges.find(ch => ch.type === 'http-01');
+                if (!challenge) {
+                    throw new Error('HTTP-01 challenge not found');
+                }
+                // Get the key authorization for the challenge.
+                const keyAuthorization = await client.getChallengeKeyAuthorization(challenge);
+                const domainInfo = this.domainCertificates.get(domain);
+                domainInfo.challengeToken = challenge.token;
+                domainInfo.challengeKeyAuthorization = keyAuthorization;
+                // Notify the ACME server that the challenge is ready.
+                // The acme-client examples show that verifyChallenge takes three arguments:
+                // (authorization, challenge, keyAuthorization). However, the official TypeScript
+                // types appear to be out-of-sync. As a workaround, we cast client to 'any'.
+                await client.verifyChallenge(authz, challenge, keyAuthorization);
+                await client.completeChallenge(challenge);
+                // Wait until the challenge is validated.
+                await client.waitForValidStatus(challenge);
+                console.log(`HTTP-01 challenge completed for ${domain}`);
+            }
+            // Generate a CSR and a new private key for the domain.
+            // Convert the resulting Buffers to strings.
+            const [csrBuffer, privateKeyBuffer] = await acme.forge.createCsr({
+                commonName: domain,
+            });
+            const csr = csrBuffer.toString();
+            const privateKey = privateKeyBuffer.toString();
+            // Finalize the order and obtain the certificate.
+            await client.finalizeOrder(order, csr);
+            const certificate = await client.getCertificate(order);
+            const domainInfo = this.domainCertificates.get(domain);
+            domainInfo.certificate = certificate;
+            domainInfo.privateKey = privateKey;
+            domainInfo.certObtained = true;
+            domainInfo.obtainingInProgress = false;
+            delete domainInfo.challengeToken;
+            delete domainInfo.challengeKeyAuthorization;
+            console.log(`Certificate obtained for ${domain}`);
+            // In a production system, persist the certificate and key and reload your TLS server.
+        }
+        catch (error) {
+            console.error(`Error during certificate issuance for ${domain}:`, error);
+            const domainInfo = this.domainCertificates.get(domain);
+            if (domainInfo) {
+                domainInfo.obtainingInProgress = false;
+            }
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist_ts/classes.portproxy.d.ts

@@ -0,0 +1,26 @@
+import * as plugins from './plugins.js';
+export interface IDomainConfig {
+    domain: string;
+    allowedIPs: string[];
+    targetIP?: string;
+}
+export interface IProxySettings extends plugins.tls.TlsOptions {
+    fromPort: number;
+    toPort: number;
+    toHost?: string;
+    domains: IDomainConfig[];
+    sniEnabled?: boolean;
+    defaultAllowedIPs?: string[];
+    preserveSourceIP?: boolean;
+}
+export declare class PortProxy {
+    netServer: plugins.net.Server;
+    settings: IProxySettings;
+    private connectionRecords;
+    private connectionLogger;
+    private terminationStats;
+    constructor(settings: IProxySettings);
+    private incrementTerminationStat;
+    start(): Promise<void>;
+    stop(): Promise<void>;
+}