node-firebird 2.3.4 → 2.4.0

package/src/pool.ts

@@ -0,0 +1,209 @@
+/***************************************
+ *
+ *   Simple Pooling
+ *
+ ***************************************/
+
+import type { Callback } from './callback';
+
+type AttachFn = (options: any, callback: Callback) => void;
+
+class Pool {
+    attach: AttachFn;
+    internaldb: any[];
+    pooldb: any[];
+    dbinuse: number;
+    _creating: number;
+    max: number;
+    pending: Callback[];
+    options: any;
+    _destroyed: boolean;
+
+    constructor(attach: AttachFn, max: number, options: any) {
+        this.attach    = attach;
+        this.internaldb = []; // connections created by the pool (for destroy)
+        this.pooldb    = []; // connections available in the pool (idle)
+        this.dbinuse   = 0;  // connections currently handed out to callers
+        this._creating = 0;  // connections currently being created (attach in flight)
+        this.max       = max || 4;
+        this.pending   = []; // callbacks waiting for a free slot
+        this.options   = options;
+        this._destroyed = false; // true after destroy() — prevents further use
+    }
+
+    get(callback: Callback): this {
+        // [Fix 2] Reject immediately if the pool has already been destroyed.
+        if (this._destroyed) {
+            callback(new Error('Pool has been destroyed'), null);
+            return this;
+        }
+        var self = this;
+        self.pending.push(callback);
+        self.check();
+        return self;
+    }
+
+    check(): this {
+        var self = this;
+
+        // [Fix 2] Do not serve requests on a destroyed pool.
+        if (self._destroyed) return self;
+
+        if ((self.dbinuse + self._creating) >= self.max)
+            return self;
+
+        var cb = self.pending.shift();
+        if (!cb)
+            return self;
+        if (self.pooldb.length) {
+            var db = self.pooldb.shift();
+            // Discard connections that have been closed or destroyed while idle
+            if (db.connection && (db.connection._isClosed || db.connection._isDetach || !db.connection._socket || db.connection._socket.destroyed)) {
+                var idx = self.internaldb.indexOf(db);
+                if (idx !== -1) self.internaldb.splice(idx, 1);
+                self.pending.unshift(cb);
+                setImmediate(function () { self.check(); });
+                return self;
+            }
+            // Idle connection available — hand it out immediately.
+            self.dbinuse++;
+            cb(null, db);
+        } else {
+            // No idle connection — create a new one via attach().
+            self._creating++;
+
+            var timedOut = false;
+            var timer: NodeJS.Timeout | null = null;
+
+            // [Fix 1] Optional per-attach timeout.
+            // If attach() does not call back within connectTimeout ms (e.g. because
+            // the server accepted TCP but stalled on the Firebird wire protocol), we
+            // free the slot and notify the caller. Any connection that arrives late
+            // is discarded in the attach() callback below.
+            if (self.options.connectTimeout > 0) {
+                timer = setTimeout(function () {
+                    timedOut = true;
+                    self._creating--;
+                    cb(new Error(
+                        'Connection timeout after ' + self.options.connectTimeout + 'ms'
+                    ), null);
+                    // Free the slot so the next pending request can be served.
+                    setImmediate(function () { self.check(); });
+                }, self.options.connectTimeout);
+            }
+
+            this.attach(self.options, function (err, db) {
+
+                // [Fix 1] Timeout already fired — discard this late connection.
+                // Without this guard the socket would stay open until the OS-level
+                // TCP timeout (potentially minutes), leaking a file descriptor.
+                if (timedOut) {
+                    if (db) {
+                        try {
+                            // _pooled = false forces a real op_detach / socket close
+                            // instead of a silent pool-return emit.
+                            if (db.connection) db.connection._pooled = false;
+                            db.detach();
+                        } catch (e) { /* ignore cleanup errors */ }
+                    }
+                    return;
+                }
+
+                if (timer) clearTimeout(timer);
+                self._creating--;
+
+                // [Fix 3] Pool was destroyed while attach() was in flight.
+                if (self._destroyed) {
+                    if (db) {
+                        try {
+                            if (db.connection) db.connection._pooled = false;
+                            db.detach();
+                        } catch (e) { /* ignore cleanup errors */ }
+                    }
+                    cb(new Error('Pool has been destroyed'), null);
+                    return;
+                }
+
+                if (!err) {
+                    self.dbinuse++;
+                    self.internaldb.push(db);
+                    db.on('detach', function () {
+                        // also in pool (could be a twice call to detach)
+                        if (self.pooldb.indexOf(db) !== -1 || self.internaldb.indexOf(db) === -1)
+                            return;
+                        // if not usable don't put it back in the pool
+                        if (db.connection._isClosed || db.connection._isDetach || db.connection._pooled === false)
+                            self.internaldb.splice(self.internaldb.indexOf(db), 1);
+                        else
+                            self.pooldb.push(db);
+
+                        self.dbinuse--;
+                        self.check();
+                    });
+                }
+
+                cb(err, db);
+            });
+        }
+        setImmediate(function() {
+            self.check();
+        });
+
+        return self;
+    }
+
+    destroy(callback?: (err?: any) => void): void {
+        var self = this;
+        self._destroyed = true;
+
+        // [Fix 4] Drain pending callbacks so callers are not left hanging.
+        // This is critical when destroy() is called as a recovery measure after
+        // a timeout: without draining, every concurrent pool.get() that had not
+        // yet received a slot would hang until the process exits.
+        var draining = self.pending.splice(0);
+        draining.forEach(function (cb) {
+            try { cb(new Error('Pool is being destroyed'), null); } catch (e) { /* ignore */ }
+        });
+
+        var connectionCount = this.internaldb.length;
+
+        if (connectionCount === 0 && callback) {
+            callback();
+        }
+
+        function detachCallback(err?: any) {
+            if (err) {
+                if (callback) {
+                    callback(err);
+                }
+                return;
+            }
+
+            connectionCount--;
+            if (connectionCount === 0 && callback) {
+                callback();
+            }
+        }
+
+        this.internaldb.forEach(function(db) {
+            if (db.connection._pooled === false) {
+                detachCallback();
+                return;
+            }
+            // check if the db is not free into the pool otherwise user should manual detach it
+            var _db_in_pool = self.pooldb.indexOf(db);
+            if (_db_in_pool !== -1) {
+                self.pooldb.splice(_db_in_pool, 1);
+                db.connection._pooled = false;
+                db.detach(detachCallback);
+            } else {
+                // [Fix 5] Connection is currently in use (dbinuse > 0).
+                // The caller is responsible for releasing it via detach().
+                // Count it down here so the destroy() callback is not blocked forever.
+                detachCallback();
+            }
+        });
+    }
+}
+
+export = Pool;

package/{poc/node_modules/node-firebird/lib/srp.js → src/srp.ts}

@@ -1,4 +1,14 @@
-var crypto = require('crypto');
+import crypto from 'crypto';
+
+export interface KeyPair {
+    public: bigint;
+    private: bigint;
+}
+
+export interface ClientProof {
+    clientSessionKey: bigint;
+    authData: bigint;
+}
 
 const SRP_KEY_SIZE = 128,
   SRP_KEY_MAX = BigInt('340282366920938463463374607431768211456'), // 1 << SRP_KEY_SIZE
@@ -18,13 +28,25 @@ const PRIME = {
     k: BigInt('1277432915985975349439481660349303019122249719989')
 };
 
+const kCache: Record<string, bigint> = {};
+function getK(hashAlgo: string): bigint {
+    if (!kCache[hashAlgo]) {
+        kCache[hashAlgo] = BigInt('0x' + getHash(hashAlgo, pad(PRIME.N), pad(PRIME.g)));
+    }
+    return kCache[hashAlgo];
+}
+
 /**
  * Generate a client key pair.
  *
  * @param a BigInt Client private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
+export function clientSeed(a: bigint = toBigInt(crypto.randomBytes(SRP_KEY_SIZE)) % PRIME.N): KeyPair {
+    // a must be in [0, N): clientSession() reduces the exponent (a + ux) mod N
+    // to match the Firebird engine, but A = g^a is computed from the raw a.
+    // When random a >= N (~10% of 1024-bit values), the proof diverges from
+    // the server's session key, causing sporadic auth failures.
     var A = modPow(PRIME.g, a, PRIME.N);
 
     dump('a', a);
@@ -45,21 +67,29 @@ exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
  * @param b BigInt Server private key.
  * @returns {{private: BigInt, public: BigInt}}
  */
-exports.serverSeed = function(user, password, salt, b = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
-    var v = getVerifier(user, password, salt);
-    var gb = modPow(PRIME.g, b, PRIME.N);
-    var kv = (PRIME.k * v) % PRIME.N;
+export function serverSeed(user: string, password: string, salt: Buffer, b?: bigint | string, hashAlgo: string = 'sha1'): KeyPair {
+    if (typeof b === 'string') {
+        hashAlgo = b;
+        b = undefined;
+    }
+    const bKey: bigint = (b === undefined || b === null)
+        ? toBigInt(crypto.randomBytes(SRP_KEY_SIZE))
+        : b as bigint;
+    var v = getVerifier(user, password, salt, 'sha1');
+    var gb = modPow(PRIME.g, bKey, PRIME.N);
+    var k = getK('sha1');
+    var kv = (k * v) % PRIME.N;
     var B = (kv + gb) % PRIME.N;
 
     dump('v', v);
-    dump('b', b);
-    dump('gb', b);
+    dump('b', bKey);
+    dump('gb', bKey);
     dump('kv', v);
     dump('B', B);
 
     return {
         public: B,
-        private: b
+        private: bKey
     };
 }
 
@@ -74,9 +104,9 @@ exports.serverSeed = function(user, password, salt, b = toBigInt(crypto.randomBy
  * @param b BigInt Server private key.
  * @returns {BigInt}
  */
-exports.serverSession = function(user, password, salt, A, B, b) {
-    var u = getScramble(A, B);
-    var v = getVerifier(user, password, salt);
+export function serverSession(user: string, password: string, salt: Buffer, A: bigint, B: bigint, b: bigint, hashAlgo: string = 'sha1'): bigint {
+    var u = getScramble(A, B, 'sha1');
+    var v = getVerifier(user, password, salt, 'sha1');
     var vu = modPow(v, u, PRIME.N);
     var Avu = (A * vu) % PRIME.N;
     var sessionSecret = modPow(Avu, b, PRIME.N);
@@ -91,8 +121,8 @@ exports.serverSession = function(user, password, salt, A, B, b) {
 /**
  * M = H(H(N) xor H(g), H(I), s, A, B, K)
  */
-exports.clientProof = function(user, password, salt, A, B, a, hashAlgo) {
-    var K = clientSession(user, password, salt, A, B, a);
+export function clientProof(user: string, password: string, salt: Buffer, A: bigint, B: bigint, a: bigint, hashAlgo: string = 'sha1'): ClientProof {
+    var K = clientSession(user, password, salt, A, B, a, 'sha1');
     var n1, n2;
 
     n1 = toBigInt(getHash('sha1', toBuffer(PRIME.N)));
@@ -118,14 +148,20 @@ exports.clientProof = function(user, password, salt, A, B, a, hashAlgo) {
 /**
  *  Pad hex string.
  */
-function hexPad(hex) {
+export function hexPad(hex: string): string {
     if (hex.length % 2 !== 0) {
         hex = '0' + hex;
     }
 
     return hex;
 }
-exports.hexPad = hexPad;
+
+/**
+ * The SRP prime modulus N (1024-bit, same value used by Firebird).
+ * Exported so tests and tooling can assert key-size invariants without
+ * duplicating the constant.
+ */
+export const PRIME_N: bigint = PRIME.N;
 
 /**
  * Pad key with SRP_KEY_SIZE.
@@ -133,11 +169,15 @@ exports.hexPad = hexPad;
  * @param n BigInt Key to pad.
  * @returns Buffer
  */
-function pad(n) {
+function pad(n: bigint): Buffer {
     var buff = Buffer.from(hexPad(n.toString(16)), 'hex');
 
     if (buff.length > SRP_KEY_SIZE) {
         buff = buff.slice(buff.length - SRP_KEY_SIZE, buff.length);
+    } else if (buff.length < SRP_KEY_SIZE) {
+        var padded = Buffer.alloc(SRP_KEY_SIZE);
+        buff.copy(padded, SRP_KEY_SIZE - buff.length);
+        buff = padded;
     }
 
     return buff;
@@ -150,8 +190,8 @@ function pad(n) {
  * @param B BigInt Server public key.
  * @returns {BigInt}
  */
-function getScramble(A, B) {
-    return BigInt('0x' + getHash('sha1', pad(A), pad(B)));
+function getScramble(A: bigint, B: bigint, hashAlgo: string = 'sha1'): bigint {
+    return BigInt('0x' + getHash(hashAlgo, pad(A), pad(B)));
 }
 
 /**
@@ -169,11 +209,12 @@ function getScramble(A, B) {
  * @param B BigInt Server public key.
  * @param a BigInt Client private key.
  */
-function clientSession(user, password, salt, A, B, a) {
-    var u = getScramble(A, B);
-    var x = getUserHash(user, salt, password);
+function clientSession(user: string, password: string, salt: Buffer, A: bigint, B: bigint, a: bigint, hashAlgo: string = 'sha1'): bigint {
+    var u = getScramble(A, B, 'sha1');
+    var x = getUserHash(user, salt, password, 'sha1');
     var gx = modPow(PRIME.g, x, PRIME.N);
-    var kgx = (PRIME.k * gx) % PRIME.N;
+    var k = getK('sha1');
+    var kgx = (k * gx) % PRIME.N;
     var diff = (B - kgx) % PRIME.N;
 
     if (diff < 0n) {
@@ -210,9 +251,9 @@ function clientSession(user, password, salt, A, B, a) {
  * @param password string Connection password.
  * @returns {BigInt}
  */
-function getUserHash(user, salt, password) {
-    var hash1 = getHash('sha1', user.toUpperCase(), ':', password);
-    var hash2 = getHash('sha1', salt, toBuffer(hash1));
+function getUserHash(user: string, salt: Buffer, password: string, hashAlgo: string = 'sha1'): bigint {
+    var hash1 = getHash(hashAlgo, user.toUpperCase(), ':', password);
+    var hash2 = getHash(hashAlgo, salt, toBuffer(hash1));
 
     return toBigInt(hash2);
 }
@@ -225,8 +266,8 @@ function getUserHash(user, salt, password) {
  * @param salt  BigInt Connection salt.
  * @returns {BigInt}
  */
-function getVerifier(user, password, salt) {
-    return modPow(PRIME.g, getUserHash(user, salt, password), PRIME.N);
+function getVerifier(user: string, password: string, salt: Buffer, hashAlgo: string = 'sha1'): bigint {
+    return modPow(PRIME.g, getUserHash(user, salt, password, hashAlgo), PRIME.N);
 }
 
 /**
@@ -236,7 +277,7 @@ function getVerifier(user, password, salt) {
  * @param data any[] Data to hash.
  * @returns {string}
  */
-function getHash(algo, ...data) {
+function getHash(algo: string, ...data: (string | Buffer)[]): string {
     var hash = crypto.createHash(algo);
 
     for (var d of data) {
@@ -252,7 +293,7 @@ function getHash(algo, ...data) {
  * @param bigInt
  * @returns {*}
  */
-function toBuffer(bigInt) {
+function toBuffer(bigInt: bigint | string): Buffer {
     return Buffer.from(typeof bigInt === 'bigint' ? hexPad(bigInt.toString(16)) : bigInt, 'hex');
 }
 
@@ -262,7 +303,7 @@ function toBuffer(bigInt) {
  * @param hex
  * @returns {BigInt}
  */
-function toBigInt(hex) {
+function toBigInt(hex: Buffer | string): bigint {
     return BigInt('0x' + (Buffer.isBuffer(hex) ? hex.toString('hex') : hex));
 }
 
@@ -272,7 +313,7 @@ function toBigInt(hex) {
  * @param key
  * @param value
  */
-function dump(key, value) {
+function dump(key: string, value: any): void {
     if (DEBUG) {
         if (typeof value === 'bigint') {
             value = value.toString(16);
@@ -285,7 +326,7 @@ function dump(key, value) {
 /**
  * Calculates (base ^ exp) % mod using native BigInt.
  */
-function modPow(base, exp, mod) {
+function modPow(base: bigint, exp: bigint, mod: bigint): bigint {
     let result = 1n;
     base = base % mod;
     while (exp > 0n) {