@bbk47/toolbox 1.0.7 → 2.0.0

package/src/encrypt.ts

@@ -0,0 +1,119 @@
+import crypto from 'crypto';
+
+type CipherKey = string;
+interface KeyIVCache {
+    [key: string]: [Buffer, Buffer];
+}
+interface KeyIV {
+    key: Buffer;
+    iv: Buffer;
+}
+
+const bytes_to_key_results: KeyIVCache = {};
+
+const EVP_BytesToKey = function (
+    password: Buffer,
+    key_len: number,
+    iv_len: number
+): [Buffer, Buffer] {
+    const cacheKey = `${password}:${key_len}:${iv_len}`;
+    if (bytes_to_key_results[cacheKey]) {
+        return bytes_to_key_results[cacheKey];
+    }
+    const m: Buffer[] = [];
+    let i = 0;
+    let count = 0;
+    while (count < key_len + iv_len) {
+        const md5hash = crypto.createHash('md5');
+        let data: Buffer = password;
+        if (i > 0) {
+            data = Buffer.concat([m[i - 1], password]);
+        }
+        md5hash.update(data);
+        const d = md5hash.digest();
+        m.push(d);
+        count += d.length;
+        i += 1;
+    }
+    const ms = Buffer.concat(m);
+    const key = ms.slice(0, key_len);
+    const iv = ms.slice(key_len, key_len + iv_len);
+    bytes_to_key_results[cacheKey] = [key, iv];
+    return [key, iv];
+};
+
+export type CipherMethod =
+    | 'aes-128-cfb'
+    | 'aes-192-cfb'
+    | 'aes-256-cfb'
+    | 'bf-cfb'
+    | 'camellia-128-cfb'
+    | 'camellia-192-cfb'
+    | 'camellia-256-cfb'
+    | 'cast5-cfb'
+    | 'des-cfb'
+    | 'idea-cfb'
+    | 'rc2-cfb'
+    | 'rc4'
+    | 'seed-cfb';
+
+const method_supported: Record<CipherMethod, [number, number]> = {
+    'aes-128-cfb': [16, 16],
+    'aes-192-cfb': [24, 16],
+    'aes-256-cfb': [32, 16],
+    'bf-cfb': [16, 8],
+    'camellia-128-cfb': [16, 16],
+    'camellia-192-cfb': [24, 16],
+    'camellia-256-cfb': [32, 16],
+    'cast5-cfb': [16, 8],
+    'des-cfb': [8, 8],
+    'idea-cfb': [16, 8],
+    'rc2-cfb': [16, 8],
+    rc4: [16, 0],
+    'seed-cfb': [16, 16],
+};
+
+export class Encryptor {
+    key: CipherKey;
+    method: CipherMethod;
+    _EVP_KEY: Buffer;
+    _IV: Buffer;
+
+    constructor(key: string = 'MVP123', method: CipherMethod = 'aes-256-cfb') {
+        this.key = key;
+        this.method = method;
+        if (!method_supported[this.method]) {
+            throw new Error('Not support method!');
+        }
+        const keyIV = this.getKeyIV(key, method);
+        this._EVP_KEY = keyIV.key;
+        this._IV = keyIV.iv;
+    }
+
+    get_cipher_len(method: string): [number, number] {
+        const m = method.toLowerCase() as CipherMethod;
+        return method_supported[m];
+    }
+
+    getKeyIV(password: string, method: string): KeyIV {
+        const m = method.toLowerCase() as CipherMethod;
+        const passwordBuf = Buffer.from(password, 'ascii');
+        const [keyLen, ivLen] = this.get_cipher_len(m);
+        const ref = EVP_BytesToKey(passwordBuf, keyLen, ivLen);
+        return { key: ref[0], iv: ref[1] };
+    }
+
+    encrypt(buf: Buffer): Buffer {
+        const cipher = crypto.createCipheriv(this.method, this._EVP_KEY, this._IV);
+        const encrypted = cipher.update(buf);
+        const result = cipher.final();
+        return Buffer.concat([encrypted, result]);
+    }
+
+    decrypt(buf: Buffer): Buffer {
+        const decipher = crypto.createDecipheriv(this.method, this._EVP_KEY, this._IV);
+        const decrypted = decipher.update(buf);
+        const result = decipher.final();
+        return Buffer.concat([decrypted, result]);
+    }
+}

package/src/index.ts

@@ -0,0 +1,29 @@
+export { default as deferred } from './deferred';
+export type { Deferred } from './deferred';
+
+export * as encrypt from './encrypt';
+export type { CipherMethod } from './encrypt';
+
+export { default as logger } from './logger';
+export type { LogLevel, Logger } from './logger';
+
+export { default as md5 } from './md5';
+
+export { default as merge } from './merge';
+
+export * as proxy from './proxy';
+export type { OnConnect, ConnectCallback } from './proxy';
+
+export { default as retry } from './retry';
+export type { RetryOptions } from './retry';
+
+export * as server from './server';
+
+export * as socks5 from './socks5';
+export type { Socks5AddrInfo } from './socks5';
+
+export * as timeout from './timeout';
+
+export * as transport from './transport';
+
+export { default as uuid } from './uuid';

package/src/logger.ts

@@ -0,0 +1,59 @@
+export type LogLevel = 'fatal' | 'error' | 'warn' | 'info' | 'log' | 'debug';
+
+export interface Logger {
+    fatal: (msg: string) => void;
+    error: (msg: string) => void;
+    warn: (msg: string) => void;
+    info: (msg: string) => void;
+    log: (msg: string) => void;
+    debug: (msg: string) => void;
+}
+
+interface LevelConfig {
+    piv: number;
+    colour: string;
+}
+
+const levelVal: Record<LogLevel, LevelConfig> = {
+    fatal: { piv: 1, colour: '\x1b[31m%s\x1b[0m' },
+    error: { piv: 2, colour: '\x1b[31m%s\x1b[0m' },
+    warn: { piv: 3, colour: '\x1b[33m%s\x1b[0m' },
+    info: { piv: 4, colour: '\x1b[32m%s\x1b[0m' },
+    log: { piv: 5, colour: '\x1b[37m%s\x1b[0m' },
+    debug: { piv: 6, colour: '\x1b[35m%s\x1b[0m' },
+};
+
+function formatDate(date: Date): string {
+    const pad = (n: number) => String(n).padStart(2, '0');
+    return `${date.getFullYear()}/${pad(date.getMonth() + 1)}/${pad(date.getDate())} ${pad(date.getHours())}:${pad(date.getMinutes())}:${pad(date.getSeconds())}`;
+}
+
+export default function getCustomLogger(
+    label: string,
+    level: LogLevel,
+    _logFile?: string
+): Logger {
+    const noop = () => undefined;
+    const setPiv = levelVal[level].piv;
+
+    function makeLogFn(key: LogLevel): (msg: string) => void {
+        if (levelVal[key].piv <= setPiv) {
+            const colour = levelVal[key].colour;
+            return (msg: string) => {
+                const date = formatDate(new Date());
+                const prefix = `${date} [${key[0].toUpperCase()}] ${label} `;
+                console.log(colour, prefix, msg);
+            };
+        }
+        return noop;
+    }
+
+    return {
+        fatal: makeLogFn('fatal'),
+        error: makeLogFn('error'),
+        warn: makeLogFn('warn'),
+        info: makeLogFn('info'),
+        log: makeLogFn('log'),
+        debug: makeLogFn('debug'),
+    };
+}

package/src/md5.ts

@@ -0,0 +1,5 @@
+import crypto from 'crypto';
+
+export default function md5(s: string | number): string {
+    return crypto.createHash('md5').update(String(s)).digest('hex');
+}

package/src/merge.ts

@@ -0,0 +1,16 @@
+export default function merge<T extends Record<string, any>>(
+    target: T,
+    ...sources: (Record<string, any> | null | undefined)[]
+): T & Record<string, any> {
+    target = target || ({} as T);
+    sources.forEach((temp) => {
+        if (temp) {
+            Object.keys(temp).forEach((key) => {
+                if (temp[key] !== null && temp[key] !== undefined) {
+                    (target as Record<string, any>)[key] = temp[key];
+                }
+            });
+        }
+    });
+    return target;
+}

package/src/proxy.ts

@@ -0,0 +1,65 @@
+import net from 'net';
+import { buildSocks5Addr } from './socks5';
+
+export type ConnectCallback = (err?: Error | null) => void;
+export type OnConnect = (addr: Buffer, callback: ConnectCallback) => void;
+
+export function createSocks5Proxy(cSock: net.Socket, onConnect: OnConnect): void {
+    let stage = 'INIT';
+    cSock.on('data', function dataListener(data: Buffer) {
+        if (stage === 'INIT') {
+            cSock.write('\x05\x00');
+            stage = 'ADDR';
+            return;
+        } else if (stage === 'ADDR') {
+            onConnect(data.slice(3), (err) => {
+                if (!err) {
+                    stage = 'STREAM';
+                    cSock.write('\x05\x00\x00\x01\x00\x00\x00\x00\x00\x00');
+                    cSock.removeAllListeners('data');
+                    cSock.pause();
+                } else {
+                    cSock.destroy();
+                }
+            });
+            return;
+        }
+    });
+
+    cSock.on('error', () => {
+        cSock.destroy();
+    });
+}
+
+export function createConnectProxy(cSock: net.Socket, onConnect: OnConnect): void {
+    let stage = 'INIT';
+    cSock.on('data', (data: Buffer) => {
+        if (stage === 'INIT') {
+            const str = data.toString('ascii');
+            const lines = str.split(/\s/g);
+            if (lines[0] !== 'CONNECT') {
+                cSock.destroy();
+                return;
+            }
+            const hoststr = lines[1];
+            const reqhost = hoststr.split(':');
+            const hostname = reqhost[0];
+            const port = Number(reqhost[1]);
+            const socksAddrInfo = buildSocks5Addr(hostname, port);
+            onConnect(socksAddrInfo, (err) => {
+                if (!err) {
+                    cSock.write(Buffer.from('HTTP/1.1 200 Connection Established\r\n\r\n'));
+                    stage = 'STREAM';
+                    cSock.removeAllListeners('data');
+                    cSock.pause();
+                } else {
+                    cSock.destroy();
+                }
+            });
+        }
+    });
+
+    cSock.on('error', () => {
+        cSock.destroy();
+    });
+}

package/src/retry.ts

@@ -0,0 +1,32 @@
+const delay = (time: number): Promise<void> =>
+    new Promise((resolve) => setTimeout(resolve, time));
+
+export interface RetryOptions {
+    times?: number;
+    interval?: number;
+}
+
+export default function retryPromise<T>(
+    fn: () => Promise<T>,
+    opts: RetryOptions = {},
+    errcall?: (err: Error) => void
+): Promise<T> {
+    const retryCount = opts.times !== undefined ? opts.times : 5;
+
+    function invoker(idx: number): Promise<T> {
+        if (idx >= retryCount) {
+            return Promise.reject(
+                new Error(`expect retryCount ${retryCount} is attached!`)
+            );
+        }
+        return fn().catch((err: Error) => {
+            errcall && errcall(err);
+            if (opts.interval) {
+                return delay(opts.interval).then(() => invoker(idx + 1));
+            } else {
+                return invoker(idx + 1);
+            }
+        });
+    }
+    return invoker(0);
+}

package/src/server.ts

@@ -0,0 +1,77 @@
+import net from 'net';
+import http from 'http';
+import tls from 'tls';
+import http2 from 'http2';
+import url from 'url';
+import WebSocket from 'ws';
+
+export type HttpHandler = (req: http.IncomingMessage, res: http.ServerResponse) => void;
+export type WsHandler = (ws: WebSocket) => void;
+export type StreamHandler = (stream: net.Socket | http2.ServerHttp2Stream) => void;
+export type ConnHandler = (conn: net.Socket | tls.TLSSocket) => void;
+
+export function createWsServer(
+    workPath: string,
+    handler: WsHandler,
+    httpHandler?: HttpHandler
+): http.Server {
+    const server = http.createServer(function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    // ws 2.x exposes Server as WebSocket.Server
+    const WsServer = (WebSocket as any).Server as typeof WebSocket;
+    const wss: any = new (WsServer as any)({ noServer: true, clientTracking: false });
+    wss.on('connection', function (wsconn: WebSocket) {
+        handler(wsconn);
+    });
+    server.on('upgrade', function (request, socket, head) {
+        const pathname = url.parse(request.url || '').pathname;
+        if (pathname === workPath) {
+            wss.handleUpgrade(request, socket as net.Socket, head, function done(ws: WebSocket) {
+                wss.emit('connection', ws, request);
+            });
+        } else {
+            socket.destroy();
+        }
+    });
+    return server;
+}
+
+export function createHttp2Server(
+    tlsOpts: tls.TlsOptions,
+    workPath: string,
+    handler: (stream: http2.ServerHttp2Stream) => void,
+    httpHandler?: (req: http2.Http2ServerRequest, res: http2.Http2ServerResponse) => void
+): http2.Http2SecureServer {
+    const http2Opts = Object.assign({ allowHTTP1: true }, tlsOpts);
+    const server = http2.createSecureServer(http2Opts, function (req, res) {
+        if (httpHandler) {
+            httpHandler(req, res);
+        }
+    });
+    server.on('stream', function (stream: http2.ServerHttp2Stream, headers: http2.IncomingHttpHeaders) {
+        const path = headers[':path'];
+        if (path === workPath) {
+            handler(stream);
+        } else {
+            stream.destroy();
+        }
+    });
+    return server;
+}
+
+export function createTcpServer(handler: ConnHandler): net.Server {
+    const server = net.createServer(function (conn) {
+        handler(conn);
+    });
+    return server;
+}
+
+export function createTlsServer(tlsOpts: tls.TlsOptions, handler: ConnHandler): tls.Server {
+    const server = tls.createServer(tlsOpts, function (conn) {
+        handler(conn);
+    });
+    return server;
+}

package/src/socks5.ts

@@ -0,0 +1,46 @@
+export interface Socks5AddrInfo {
+    dstAddr: string;
+    dstPort: number;
+}
+
+export function parseSocks5Addr(buf: Buffer, offset = 0): Socks5AddrInfo {
+    if (offset > 0) {
+        buf = buf.slice(offset);
+    }
+    const type = buf.readUInt8(0);
+    const addrData = buf.slice(1);
+    let dstAddr = '';
+    let dstPort = 0;
+
+    if (type === 0x01) {
+        const IP = addrData.slice(0, -2);
+        const PORT = addrData.slice(-2);
+        dstAddr = Array.from(IP)
+            .map((temp) => Number(temp).toString(10))
+            .join('.');
+        dstPort = PORT[0] * 256 + PORT[1];
+    } else if (type === 0x03) {
+        const addrLen = addrData.readUInt8(0);
+        const domain = addrData.slice(1, addrLen + 1);
+        const port = addrData.slice(addrLen + 1);
+        dstAddr = domain.toString();
+        dstPort = port[0] * 256 + port[1];
+    }
+    return { dstAddr, dstPort };
+}
+
+export function buildSocks5Addr(hostname: string, port: number): Buffer {
+    if (/^(\d+\.){3}\d+$/.test(hostname)) {
+        const parts = hostname.split('.').map((p) => Number(p));
+        const portBuf = Buffer.from([Math.floor(port / 256), port % 256]);
+        const preBuf = Buffer.from([0x01, parts[0], parts[1], parts[2], parts[3]]);
+        return Buffer.concat([preBuf, portBuf]);
+    } else {
+        const preBuf = Buffer.from([0x03, hostname.length]);
+        const domainBuf = Buffer.from(hostname);
+        const portBuf = Buffer.from([Math.floor(port / 256), port % 256]);
+        return Buffer.concat([preBuf, domainBuf, portBuf]);
+    }
+}
+
+export const parseAddrInfo = parseSocks5Addr;

package/src/timeout.ts

@@ -0,0 +1,3 @@
+export function timeoutPromise(time: number): Promise<string> {
+    return new Promise((resolve) => setTimeout(() => resolve('timeout:' + time), time));
+}

package/src/transport/creater.ts

@@ -0,0 +1,88 @@
+import WebSocket from 'ws';
+import net from 'net';
+import http2 from 'http2';
+import tls from 'tls';
+import { Transport, TransportConn } from './transport';
+
+export interface TransportParams {
+    host: string;
+    port: number;
+    path?: string;
+    secure?: boolean;
+}
+
+export function createWebsocketTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const tunnelWsUrl = `${params.secure ? 'wss' : 'ws'}://${params.host}:${params.port}${params.path || ''}`;
+    const ws = new WebSocket(tunnelWsUrl, {
+        perMessageDeflate: false,
+        handshakeTimeout: 3000,
+    } as any);
+    const ts = new Transport({ type: 'ws', conn: ws as unknown as TransportConn });
+    ws.on('open', onOpen);
+    return ts;
+}
+
+export function createHttp2Transport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const http2Url = `https://${params.host}:${params.port}`;
+    const client = http2.connect(http2Url, {
+        rejectUnauthorized: false,
+        requestCert: true,
+    });
+    const http2stream = client.request({
+        ':method': 'POST',
+        ':path': params.path || '/',
+        'Content-Type': 'octet-stream',
+    });
+    http2stream.on('response', onOpen);
+    const ts = new Transport({ type: 'h2', conn: http2stream as unknown as TransportConn });
+    return ts;
+}
+
+export function createTlsTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const tlsOpts: tls.ConnectionOptions = {
+        rejectUnauthorized: false,
+        host: params.host,
+        port: params.port,
+    };
+    const tlsConn = tls.connect(tlsOpts, function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'tls', conn: tlsConn as unknown as TransportConn });
+    return ts;
+}
+
+export function createTcpTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const socket = new net.Socket();
+    socket.connect(params.port, params.host, function () {
+        onOpen();
+    });
+    return new Transport({ type: 'tcp', conn: socket as unknown as TransportConn });
+}
+
+export function createUnixsocketTransport(
+    params: TransportParams,
+    onOpen: () => void
+): Transport {
+    const socket = new net.Socket();
+    socket.connect(params.path || '', function () {
+        onOpen();
+    });
+    const ts = new Transport({ type: 'domainsocket', conn: socket as unknown as TransportConn });
+    return ts;
+}
+
+export function wrapSocket(type: string, conn: TransportConn): Transport {
+    return new Transport({ type: type as any, conn });
+}

package/src/transport/helper.ts

@@ -0,0 +1,73 @@
+import WebSocket from 'ws';
+import net from 'net';
+import stream from 'stream';
+
+export type DataCallback = (data: Buffer) => void;
+export type ErrorCallback = (err: Error) => void;
+export type CloseCallback = (code?: number) => void;
+
+export function bindStreamSocket(
+    s: stream.Readable & { on: Function; destroy: Function },
+    onData: DataCallback,
+    onError: ErrorCallback,
+    onClose: CloseCallback
+): void {
+    let buffcache = Buffer.from([]);
+    s.on('data', function (data: Buffer) {
+        buffcache = Buffer.concat([buffcache, data]);
+        while (true) {
+            if (buffcache.length <= 2) {
+                return;
+            }
+            const datalen = buffcache[0] * 256 + buffcache[1];
+            if (buffcache.length < datalen + 2) {
+                return;
+            }
+            const pack = buffcache.slice(2, datalen + 2);
+            buffcache = buffcache.slice(datalen + 2);
+            onData(pack);
+        }
+    });
+    s.on('close', function (code?: number) {
+        onClose(code);
+    });
+    s.on('error', function (err: Error) {
+        (s as any).destroy();
+        onError(err);
+    });
+}
+
+export function bindWebsocket(
+    ws: WebSocket,
+    onData: DataCallback,
+    onError: ErrorCallback,
+    onClose: CloseCallback
+): void {
+    ws.on('message', onData);
+    ws.on('close', (code: number) => {
+        onClose(code);
+    });
+    ws.on('error', (err: Error) => {
+        ws.close();
+        onError(err);
+    });
+}
+
+export function tcpsocketSend(socket: net.Socket, data: Buffer): void {
+    const datalen = data.length;
+    if (socket.writable) {
+        socket.write(
+            Buffer.concat([Buffer.from([datalen >> 8, datalen % 256]), data])
+        );
+    } else {
+        throw new Error('socket cannot writeable!');
+    }
+}
+
+export function websocketSend(ws: WebSocket, data: Buffer): void {
+    if (ws.readyState === WebSocket.OPEN) {
+        ws.send(data, { binary: true });
+    } else {
+        throw new Error('ws socket not open!' + ws.readyState);
+    }
+}

package/src/transport/index.ts

@@ -0,0 +1,6 @@
+export { Transport } from './transport';
+export type { TransportType, TransportConn } from './transport';
+export * as creater from './creater';
+export * as helper from './helper';
+
+export { wrapSocket } from './creater';

package/src/transport/transport.ts

@@ -0,0 +1,54 @@
+import WebSocket from 'ws';
+import net from 'net';
+import { websocketSend, tcpsocketSend, bindWebsocket, bindStreamSocket } from './helper';
+import type { DataCallback, ErrorCallback, CloseCallback } from './helper';
+
+export type TransportType = 'ws' | 'h2' | 'tcp' | 'tls' | 'domainsocket';
+
+export interface TransportConn {
+    close?: () => void;
+    destroy?: () => void;
+    writable?: boolean;
+    readyState?: number;
+    send?: Function;
+    on: (event: string, listener: Function) => any;
+    write?: (data: Buffer) => void;
+}
+
+export class Transport {
+    type: TransportType;
+    conn: TransportConn;
+
+    constructor(opts: { type: TransportType; conn: TransportConn }) {
+        this.type = opts.type;
+        this.conn = opts.conn;
+    }
+
+    sendPacket(binarydata: Buffer): void {
+        if (this.type === 'ws') {
+            websocketSend(this.conn as unknown as WebSocket, binarydata);
+        } else {
+            tcpsocketSend(this.conn as unknown as net.Socket, binarydata);
+        }
+    }
+
+    bindEvents(onData: DataCallback, onError: ErrorCallback, onClose: CloseCallback): void {
+        if (this.type === 'ws') {
+            bindWebsocket(this.conn as unknown as WebSocket, onData, onError, onClose);
+        } else {
+            bindStreamSocket(this.conn as any, onData, onError, onClose);
+        }
+    }
+
+    close(): void {
+        try {
+            if (this.type === 'ws' || this.type === 'h2') {
+                (this.conn as any).close();
+            } else {
+                (this.conn as any).destroy();
+            }
+        } catch (_err) {
+            // ignore
+        }
+    }
+}