node-firebird 2.3.4 → 2.4.0

package/lib/wire/socket.d.ts

@@ -0,0 +1,59 @@
+import net from "net";
+import zlib from "zlib";
+/**
+ * Arc4 stream cipher for Firebird wire encryption.
+ * Uses the SRP session key to create RC4 encryption/decryption streams.
+ */
+declare class Arc4 {
+    _s: Uint8Array;
+    _i: number;
+    _j: number;
+    constructor(key: Buffer | Uint8Array);
+    /**
+     * Transform (encrypt/decrypt) data in place.
+     * RC4 is symmetric - encrypt and decrypt are the same operation.
+     */
+    transform(data: Buffer | Uint8Array): Buffer;
+}
+/**
+ * Socket proxy.
+ */
+declare class Socket {
+    static Arc4: typeof Arc4;
+    _socket: net.Socket;
+    compress: boolean;
+    compressor: zlib.Deflate | null;
+    compressorBuffer: Buffer[];
+    decompressor: zlib.Inflate | null;
+    decompressorBuffer: Buffer[];
+    buffer: Buffer | null;
+    encrypt: boolean;
+    encryptCipher: any;
+    decryptCipher: any;
+    constructor(port: number, host: string);
+    /**
+     * Decompress and/or decrypt data when received.
+     * Override on data event.
+     */
+    on(event: string, cb: (...args: any[]) => void): void;
+    /**
+     * Compress and/or encrypt data before sending to socket.
+     */
+    write(data: Buffer | Uint8Array, defer?: boolean): void;
+    /**
+     * Enable compression/decompression on the fly.
+     */
+    enableCompression(): void;
+    /**
+     * Enable encryption/decryption.
+     * @param {Buffer} sessionKey - The session key from SRP authentication.
+     * @param {string} [pluginName='Arc4'] - The selected encryption plugin.
+     * @param {Buffer} [iv] - The initialization vector (needed for ChaCha/ChaCha64).
+     */
+    enableEncryption(sessionKey: Buffer, pluginName?: string, iv?: Buffer): void;
+    /**
+     * Proxy trap.
+     */
+    get(target: any, field: string | symbol): any;
+}
+export = Socket;

package/lib/wire/socket.js

@@ -1,6 +1,10 @@
-const net = require("net");
-const zlib = require("zlib");
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const net_1 = __importDefault(require("net"));
+const zlib_1 = __importDefault(require("zlib"));
+const crypto_1 = __importDefault(require("crypto"));
 /**
  * Arc4 stream cipher for Firebird wire encryption.
  * Uses the SRP session key to create RC4 encryption/decryption streams.
@@ -10,12 +14,10 @@ class Arc4 {
         this._s = new Uint8Array(256);
         this._i = 0;
         this._j = 0;
-
         // KSA (Key-Scheduling Algorithm)
         for (var i = 0; i < 256; i++) {
             this._s[i] = i;
         }
-
         var j = 0;
         for (var i = 0; i < 256; i++) {
             j = (j + this._s[i] + key[i % key.length]) & 0xFF;
@@ -25,7 +27,6 @@ class Arc4 {
             this._s[j] = tmp;
         }
     }
-
     /**
      * Transform (encrypt/decrypt) data in place.
      * RC4 is symmetric - encrypt and decrypt are the same operation.
@@ -35,25 +36,54 @@ class Arc4 {
         for (var n = 0; n < data.length; n++) {
             this._i = (this._i + 1) & 0xFF;
             this._j = (this._j + this._s[this._i]) & 0xFF;
-
             // Swap
             var tmp = this._s[this._i];
             this._s[this._i] = this._s[this._j];
             this._s[this._j] = tmp;
-
             var k = this._s[(this._s[this._i] + this._s[this._j]) & 0xFF];
             out[n] = data[n] ^ k;
         }
         return out;
     }
 }
-
+/**
+ * ChaChaCipher wrapper around Node.js crypto.createCipheriv / createDecipheriv.
+ */
+class ChaChaCipher {
+    constructor(key, iv, ivlen, isEncrypt) {
+        const opensslIv = Buffer.alloc(16);
+        if (ivlen === 8) {
+            iv.copy(opensslIv, 8, 0, 8);
+        }
+        else if (ivlen === 16) {
+            const ctr = (iv[12] << 24) + (iv[13] << 16) + (iv[14] << 8) + iv[15];
+            opensslIv.writeUInt32LE(ctr, 0);
+            iv.copy(opensslIv, 4, 0, 12);
+        }
+        else if (ivlen === 12) {
+            iv.copy(opensslIv, 4, 0, 12);
+        }
+        else {
+            throw new Error('Wrong IV length: ' + ivlen);
+        }
+        if (isEncrypt) {
+            this._cipher = crypto_1.default.createCipheriv('chacha20', key, opensslIv);
+        }
+        else {
+            this._cipher = crypto_1.default.createDecipheriv('chacha20', key, opensslIv);
+        }
+    }
+    transform(data) {
+        return this._cipher.update(data);
+    }
+}
 /**
  * Socket proxy.
  */
 class Socket {
+    static { this.Arc4 = Arc4; }
     constructor(port, host) {
-        this._socket = net.createConnection(port, host);
+        this._socket = net_1.default.createConnection(port, host);
         this._socket.setNoDelay(true);
         this._socket.setKeepAlive(true, 60000); // 1 minute delay to detect dead/stale connections
         this.compressor = null;
@@ -64,10 +94,8 @@ class Socket {
         this.encrypt = false;
         this.encryptCipher = null;
         this.decryptCipher = null;
-
         return new Proxy(this._socket, this);
     }
-
     /**
      * Decompress and/or decrypt data when received.
      * Override on data event.
@@ -79,26 +107,31 @@ class Socket {
                 // Decrypt first if encryption is enabled
                 if (this.encrypt) {
                     data = this.decryptCipher.transform(data);
+                    if (process.env.FIREBIRD_DEBUG) {
+                        console.log('[fb-debug] socket.read decrypted: length=%d RX-cipher-offset=%d', data.length, this.decryptCipher._i);
+                        console.log('[fb-debug] socket.read decrypted hex: %s', data.toString('hex'));
+                    }
                 }
-
                 if (this.compress) {
                     this.decompressor.write(data, () => {
                         mainCb(Buffer.concat(this.decompressorBuffer));
                         this.decompressorBuffer = []; // Reset buffer
                     });
-                } else {
+                }
+                else {
                     mainCb(data);
                 }
             };
         }
-
         this._socket.on(event, cb);
     }
-
     /**
      * Compress and/or encrypt data before sending to socket.
      */
     write(data, defer = false) {
+        if (process.env.FIREBIRD_DEBUG) {
+            console.log('[fb-debug] socket.write: length=%d bytes=%s encrypt=%s defer=%s', data.length, Buffer.from(data).toString('hex'), this.encrypt, defer);
+        }
         if (defer) {
             // Accumulate deferred packets instead of overwriting.  Multiple
             // deferred ops (e.g. op_close_blob followed immediately by
@@ -110,63 +143,73 @@ class Socket {
                 : Buffer.from(data);
             return;
         }
-
         if (!defer && this.buffer) {
             data = Buffer.concat([this.buffer, data]);
             this.buffer = null;
         }
-
         if (this.compress) {
             this.compressor.write(data, () => {
                 var compressedData = Buffer.concat(this.compressorBuffer);
                 this.compressorBuffer = []; // Reset buffer
-
                 // Encrypt after compression if encryption is enabled
                 if (this.encrypt) {
                     compressedData = this.encryptCipher.transform(compressedData);
                 }
-
                 this._socket.write(compressedData);
             });
-        } else if (this.encrypt) {
-            this._socket.write(this.encryptCipher.transform(data));
-        } else {
+        }
+        else if (this.encrypt) {
+            const out = this.encryptCipher.transform(data);
+            if (process.env.FIREBIRD_DEBUG) {
+                console.log('[fb-debug] socket.write encrypted: length=%d TX-cipher-offset=%d', out.length, this.encryptCipher._i);
+            }
+            this._socket.write(out);
+        }
+        else {
             this._socket.write(data);
         }
     }
-
     /**
      * Enable compression/decompression on the fly.
      */
     enableCompression() {
         this.compress = true;
-
         // Create decompressor instance
-        this.decompressor = zlib.createInflate();
+        this.decompressor = zlib_1.default.createInflate();
         this.decompressor.on('data', (inflate) => {
             this.decompressorBuffer.push(inflate);
         });
-
         // Create compressor instance
-        this.compressor = zlib.createDeflate({
-            flush: zlib.constants.Z_FULL_FLUSH,
-            finishFlush: zlib.constants.Z_SYNC_FLUSH
+        this.compressor = zlib_1.default.createDeflate({
+            flush: zlib_1.default.constants.Z_FULL_FLUSH,
+            finishFlush: zlib_1.default.constants.Z_SYNC_FLUSH
         });
         this.compressor.on('data', (deflate) => {
             this.compressorBuffer.push(deflate);
         });
     }
-
     /**
-     * Enable encryption/decryption using Arc4 cipher.
+     * Enable encryption/decryption.
      * @param {Buffer} sessionKey - The session key from SRP authentication.
+     * @param {string} [pluginName='Arc4'] - The selected encryption plugin.
+     * @param {Buffer} [iv] - The initialization vector (needed for ChaCha/ChaCha64).
      */
-    enableEncryption(sessionKey) {
+    enableEncryption(sessionKey, pluginName = 'Arc4', iv) {
         this.encrypt = true;
-        this.encryptCipher = new Arc4(sessionKey);
-        this.decryptCipher = new Arc4(sessionKey);
+        if (pluginName === 'Arc4') {
+            this.encryptCipher = new Arc4(sessionKey);
+            this.decryptCipher = new Arc4(sessionKey);
+        }
+        else if (pluginName === 'ChaCha' || pluginName === 'ChaCha64') {
+            const stretchedKey = crypto_1.default.createHash('sha256').update(sessionKey).digest();
+            const ivlen = pluginName === 'ChaCha64' ? 8 : (iv ? iv.length : 16);
+            this.encryptCipher = new ChaChaCipher(stretchedKey, iv, ivlen, true);
+            this.decryptCipher = new ChaChaCipher(stretchedKey, iv, ivlen, false);
+        }
+        else {
+            throw new Error('Unsupported encryption plugin: ' + pluginName);
+        }
     }
-
     /**
      * Proxy trap.
      */
@@ -174,14 +217,10 @@ class Socket {
         if (field in this) {
             return this[field].bind(this);
         }
-
         if (typeof target[field] === 'function') {
             return target[field].bind(target);
         }
-
         return target[field];
     }
 }
-
 module.exports = Socket;
-module.exports.Arc4 = Arc4;

package/lib/wire/statement.d.ts

@@ -0,0 +1,25 @@
+/***************************************
+ *
+ *   Statement
+ *
+ ***************************************/
+declare class Statement {
+    connection: any;
+    query: string;
+    type: number;
+    output: any[];
+    input: any[];
+    options: any;
+    handle: number;
+    plan: string;
+    [key: string]: any;
+    constructor(connection: any);
+    close(callback?: (err?: any) => void): void;
+    drop(callback?: (err?: any) => void): void;
+    release(callback?: (err?: any) => void): void;
+    execute(transaction: any, params?: any, callback?: any, options?: any): void;
+    fetch(transaction: any, count: number | string, callback: (err: any, result?: any) => void): void;
+    fetchScroll(transaction: any, direction: string | number, offset?: any, count?: any, callback?: any): void;
+    fetchAll(transaction: any, callback: (err: any, result?: any) => void): void;
+}
+export = Statement;

package/lib/wire/statement.js

@@ -1,22 +1,19 @@
+"use strict";
 /***************************************
  *
  *   Statement
  *
  ***************************************/
-
 class Statement {
     constructor(connection) {
         this.connection = connection;
     }
-
     close(callback) {
         this.connection.closeStatement(this, callback);
     }
-
     drop(callback) {
         this.connection.dropStatement(this, callback);
     }
-
     release(callback) {
         var cache_query = this.connection.getCachedQuery(this.query);
         if (cache_query)
@@ -24,25 +21,32 @@ class Statement {
         else
             this.connection.dropStatement(this, callback);
     }
-
     execute(transaction, params, callback, options) {
         if (params instanceof Function) {
             options = callback;
             callback = params;
             params = undefined;
         }
-
         this.options = options;
         this.connection.executeStatement(transaction, this, params, callback, options);
     }
-
     fetch(transaction, count, callback) {
         this.connection.fetch(this, transaction, count, callback);
     }
-
+    fetchScroll(transaction, direction, offset, count, callback) {
+        if (typeof count === 'function') {
+            callback = count;
+            count = undefined;
+        }
+        if (typeof offset === 'function') {
+            callback = offset;
+            offset = undefined;
+            count = undefined;
+        }
+        this.connection.fetchScroll(this, transaction, direction, offset, count, callback);
+    }
     fetchAll(transaction, callback) {
         this.connection.fetchAll(this, transaction, callback);
     }
 }
-
 module.exports = Statement;

package/lib/wire/transaction.d.ts

@@ -0,0 +1,21 @@
+/***************************************
+ *
+ *   Transaction
+ *
+ ***************************************/
+declare class Transaction {
+    connection: any;
+    db: any;
+    handle: number;
+    [key: string]: any;
+    constructor(connection: any);
+    newStatement(query: string, callback: (err: any, statement?: any) => void): void;
+    execute(query: string, params?: any, callback?: any, options?: any): void;
+    sequentially(query: string, params?: any, on?: any, callback?: any, options?: any): this;
+    query(query: string, params?: any, callback?: any, options?: any): void;
+    commit(callback?: (err?: any) => void): void;
+    rollback(callback?: (err?: any) => void): void;
+    commitRetaining(callback?: (err?: any) => void): void;
+    rollbackRetaining(callback?: (err?: any) => void): void;
+}
+export = Transaction;

package/lib/wire/transaction.js

@@ -1,109 +1,93 @@
-const {doCallback, doError} = require('../callback');
-const Const = require('./const');
-
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const callback_1 = require("../callback");
+const utils_1 = require("../utils");
+const const_1 = __importDefault(require("./const"));
 /***************************************
  *
  *   Transaction
  *
  ***************************************/
-
 class Transaction {
     constructor(connection) {
         this.connection = connection;
         this.db = connection.db;
     }
-
     newStatement(query, callback) {
         var cnx = this.connection;
         var self = this;
         var query_cache = cnx.getCachedQuery(query);
-
         if (query_cache) {
             callback(null, query_cache);
-        } else {
+        }
+        else {
             cnx.prepare(self, query, false, callback);
         }
     }
-
     execute(query, params, callback, options) {
         if (params instanceof Function) {
             options = callback;
             callback = params;
             params = undefined;
         }
-
         var self = this;
-        this.newStatement(query, function(err, statement) {
-
+        this.newStatement(query, function (err, statement) {
             if (err) {
-                doError(err, callback);
+                (0, callback_1.doError)(err, callback);
                 return;
             }
-
             function dropError(err) {
                 statement.release();
-                doCallback(err, callback);
+                (0, callback_1.doCallback)(err, callback);
             }
-
-            statement.execute(self, params, function(err, ret) {
+            statement.execute(self, params, function (err, ret) {
                 if (err) {
                     dropError(err);
                     return;
                 }
-
                 switch (statement.type) {
-                    case Const.isc_info_sql_stmt_select:
-                        statement.fetchAll(self, function(err, r) {
+                    case const_1.default.isc_info_sql_stmt_select:
+                        statement.fetchAll(self, function (err, r) {
                             if (err) {
                                 dropError(err);
                                 return;
                             }
-
                             statement.release();
-
                             if (callback)
                                 callback(undefined, r, statement.output, true);
-
                         });
-
                         break;
-
-                    case Const.isc_info_sql_stmt_exec_procedure:
+                    case const_1.default.isc_info_sql_stmt_exec_procedure:
                         if (ret && ret.data && ret.data.length > 0) {
                             statement.release();
-
                             if (callback)
                                 callback(undefined, ret.data[0], statement.output, true);
-
                             break;
-                        } else if (statement.output.length) {
-                            statement.fetch(self, 1, function(err, ret) {
+                        }
+                        else if (statement.output.length) {
+                            statement.fetch(self, 1, function (err, ret) {
                                 if (err) {
                                     dropError(err);
                                     return;
                                 }
-
                                 statement.release();
-
                                 if (callback)
                                     callback(undefined, ret.data[0], statement.output, false);
                             });
-
                             break;
                         }
-
                     // Fall through is normal
                     default:
                         statement.release();
                         if (callback)
-                            callback()
+                            callback();
                         break;
                 }
-
             }, options);
         });
     }
-
     sequentially(query, params, on, callback, options = {}) {
         if (params instanceof Function) {
             options = callback;
@@ -111,51 +95,49 @@ class Transaction {
             on = params;
             params = undefined;
         }
-
-        if (on === undefined){
+        if (on === undefined) {
             throw new Error('Expected "on" delegate.');
         }
-
         if (callback instanceof Boolean) {
             options = callback;
             callback = undefined;
         }
-
         var self = this;
-        var _on = function(row, i, meta, next) {
+        var _on = function (row, i, meta, next) {
             var done = false;
-            var finish = function(err) {
+            var finish = function (err) {
                 if (done) {
                     return;
                 }
                 done = true;
                 next(err);
             };
-
             try {
                 var ret;
                 if (on.length >= 3) {
                     ret = on(row, i, finish);
-                } else {
+                }
+                else {
                     ret = on(row, i);
                 }
-
                 if (ret && typeof ret.then === 'function') {
-                    ret.then(function() {
+                    ret.then(function () {
                         finish();
                     }).catch(finish);
-                } else if (on.length < 3) {
+                }
+                else if (on.length < 3) {
                     finish();
                 }
-            } catch (err) {
+            }
+            catch (err) {
                 finish(err);
             }
         };
-
         // back compatibility - options parameter is a boolean
         if (typeof options === 'boolean') {
             options = { asObject: !options, asStream: true, on: _on };
-        } else {
+        }
+        else {
             options = {
                 asStream: true,
                 asObject: true,
@@ -163,44 +145,34 @@ class Transaction {
                 ...options,
             };
         }
-
         self.execute(query, params, callback, options);
         return self;
     }
-
     query(query, params, callback, options = {}) {
         if (params instanceof Function) {
             callback = params;
             params = undefined;
         }
-
         if (callback === undefined)
-            callback = noop;
-
+            callback = utils_1.noop;
         options = {
             asObject: true,
             asStream: callback === undefined || callback === null,
             ...options,
         };
-
         this.execute(query, params, callback, options);
     }
-
     commit(callback) {
         this.connection.commit(this, callback);
     }
-
     rollback(callback) {
         this.connection.rollback(this, callback);
     }
-
     commitRetaining(callback) {
         this.connection.commitRetaining(this, callback);
     }
-
     rollbackRetaining(callback) {
         this.connection.rollbackRetaining(this, callback);
     }
 }
-
 module.exports = Transaction;