node-firebird 1.1.9 → 2.0.0

package/lib/wire/socket.js

@@ -0,0 +1,175 @@
+const net = require("net");
+const zlib = require("zlib");
+
+/**
+ * Arc4 stream cipher for Firebird wire encryption.
+ * Uses the SRP session key to create RC4 encryption/decryption streams.
+ */
+class Arc4 {
+    constructor(key) {
+        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;
+            // Swap
+            var tmp = this._s[i];
+            this._s[i] = this._s[j];
+            this._s[j] = tmp;
+        }
+    }
+
+    /**
+     * Transform (encrypt/decrypt) data in place.
+     * RC4 is symmetric - encrypt and decrypt are the same operation.
+     */
+    transform(data) {
+        var out = Buffer.alloc(data.length);
+        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;
+    }
+}
+
+/**
+ * Socket proxy.
+ */
+class Socket {
+    constructor(port, host) {
+        this._socket = net.createConnection(port, host);
+        this._socket.setNoDelay(true);
+        this.compressor = null;
+        this.compressorBuffer = [];
+        this.decompressor = null;
+        this.decompressorBuffer = [];
+        this.buffer = null;
+        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.
+     */
+    on(event, cb) {
+        if (event === 'data') {
+            const mainCb = cb;
+            cb = (data) => {
+                // Decrypt first if encryption is enabled
+                if (this.encrypt) {
+                    data = this.decryptCipher.transform(data);
+                }
+
+                if (this.compress) {
+                    this.decompressor.write(data, () => {
+                        mainCb(Buffer.concat(this.decompressorBuffer));
+                        this.decompressorBuffer = []; // Reset buffer
+                    });
+                } else {
+                    mainCb(data);
+                }
+            };
+        }
+
+        this._socket.on(event, cb);
+    }
+
+    /**
+     * Compress and/or encrypt data before sending to socket.
+     */
+    write(data, defer = false) {
+        if (defer) {
+            this.buffer = 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 {
+            this._socket.write(data);
+        }
+    }
+
+    /**
+     * Enable compression/decompression on the fly.
+     */
+    enableCompression() {
+        this.compress = true;
+
+        // Create decompressor instance
+        this.decompressor = zlib.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.on('data', (deflate) => {
+            this.compressorBuffer.push(deflate);
+        });
+    }
+
+    /**
+     * Enable encryption/decryption using Arc4 cipher.
+     * @param {Buffer} sessionKey - The session key from SRP authentication.
+     */
+    enableEncryption(sessionKey) {
+        this.encrypt = true;
+        this.encryptCipher = new Arc4(sessionKey);
+        this.decryptCipher = new Arc4(sessionKey);
+    }
+
+    /**
+     * Proxy trap.
+     */
+    get(target, field) {
+        if (field in this) {
+            return this[field].bind(this);
+        }
+
+        return target[field];
+    }
+}
+
+module.exports = Socket;
+module.exports.Arc4 = Arc4;

package/lib/wire/statement.js

@@ -4,44 +4,45 @@
  *
  ***************************************/
 
-function Statement(connection) {
-    this.connection = connection;
-}
-
-Statement.prototype.close = function(callback) {
-    this.connection.closeStatement(this, callback);
-};
-
-Statement.prototype.drop = function(callback) {
-    this.connection.dropStatement(this, callback);
-};
+class Statement {
+    constructor(connection) {
+        this.connection = connection;
+    }
 
-Statement.prototype.release = function(callback) {
-    var cache_query = this.connection.getCachedQuery(this.query);
-    if (cache_query)
+    close(callback) {
         this.connection.closeStatement(this, callback);
-    else
-        this.connection.dropStatement(this, callback);
-};
+    }
 
-Statement.prototype.execute = function(transaction, params, callback, custom) {
+    drop(callback) {
+        this.connection.dropStatement(this, callback);
+    }
 
-    if (params instanceof Function) {
-        custom = callback;
-        callback = params;
-        params = undefined;
+    release(callback) {
+        var cache_query = this.connection.getCachedQuery(this.query);
+        if (cache_query)
+            this.connection.closeStatement(this, callback);
+        else
+            this.connection.dropStatement(this, callback);
     }
 
-    this.custom = custom;
-    this.connection.executeStatement(transaction, this, params, callback, custom);
-};
+    execute(transaction, params, callback, custom) {
+        if (params instanceof Function) {
+            custom = callback;
+            callback = params;
+            params = undefined;
+        }
+
+        this.custom = custom;
+        this.connection.executeStatement(transaction, this, params, callback, custom);
+    }
 
-Statement.prototype.fetch = function(transaction, count, callback) {
-    this.connection.fetch(this, transaction, count, callback);
-};
+    fetch(transaction, count, callback) {
+        this.connection.fetch(this, transaction, count, callback);
+    }
 
-Statement.prototype.fetchAll = function(transaction, callback) {
-    this.connection.fetchAll(this, transaction, callback);
-};
+    fetchAll(transaction, callback) {
+        this.connection.fetchAll(this, transaction, callback);
+    }
+}
 
 module.exports = Statement;

package/lib/wire/transaction.js

@@ -7,77 +7,53 @@ const Const = require('./const');
  *
  ***************************************/
 
-function Transaction(connection) {
-    this.connection = connection;
-    this.db = connection.db;
-}
-
-Transaction.prototype.newStatement = function(query, callback) {
-    var cnx = this.connection;
-    var self = this;
-    var query_cache = cnx.getCachedQuery(query);
-
-    if (query_cache) {
-        callback(null, query_cache);
-    } else {
-        cnx.prepare(self, query, false, callback);
+class Transaction {
+    constructor(connection) {
+        this.connection = connection;
+        this.db = connection.db;
     }
-};
 
-Transaction.prototype.execute = function(query, params, callback, custom) {
+    newStatement(query, callback) {
+        var cnx = this.connection;
+        var self = this;
+        var query_cache = cnx.getCachedQuery(query);
 
-    if (params instanceof Function) {
-        custom = callback;
-        callback = params;
-        params = undefined;
+        if (query_cache) {
+            callback(null, query_cache);
+        } else {
+            cnx.prepare(self, query, false, callback);
+        }
     }
 
-    var self = this;
-    this.newStatement(query, function(err, statement) {
-
-        if (err) {
-            doError(err, callback);
-            return;
+    execute(query, params, callback, custom) {
+        if (params instanceof Function) {
+            custom = callback;
+            callback = params;
+            params = undefined;
         }
 
-        function dropError(err) {
-            statement.release();
-            doCallback(err, callback);
-        }
+        var self = this;
+        this.newStatement(query, function(err, statement) {
 
-        statement.execute(self, params, function(err, ret) {
             if (err) {
-                dropError(err);
+                doError(err, callback);
                 return;
             }
 
-            switch (statement.type) {
-                case Const.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:
-                    if (ret && ret.data && ret.data.length > 0) {
-                        statement.release();
+            function dropError(err) {
+                statement.release();
+                doCallback(err, callback);
+            }
 
-                        if (callback)
-                            callback(undefined, ret.data[0], statement.output, true);
+            statement.execute(self, params, function(err, ret) {
+                if (err) {
+                    dropError(err);
+                    return;
+                }
 
-                        break;
-                    } else if (statement.output.length) {
-                        statement.fetch(self, 1, function(err, ret) {
+                switch (statement.type) {
+                    case Const.isc_info_sql_stmt_select:
+                        statement.fetchAll(self, function(err, r) {
                             if (err) {
                                 dropError(err);
                                 return;
@@ -86,75 +62,127 @@ Transaction.prototype.execute = function(query, params, callback, custom) {
                             statement.release();
 
                             if (callback)
-                                callback(undefined, ret.data[0], statement.output, false);
+                                callback(undefined, r, statement.output, true);
+
                         });
 
                         break;
-                    }
-
-                // Fall through is normal
-                default:
-                    statement.release();
-                    if (callback)
-                        callback()
-                    break;
-            }
 
-        }, custom);
-    });
-};
+                    case Const.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);
 
-Transaction.prototype.sequentially = function (query, params, on, callback, asArray) {
+                            break;
+                        } else if (statement.output.length) {
+                            statement.fetch(self, 1, function(err, ret) {
+                                if (err) {
+                                    dropError(err);
+                                    return;
+                                }
 
-    if (params instanceof Function) {
-        asArray = callback;
-        callback = on;
-        on = params;
-        params = undefined;
-    }
+                                statement.release();
 
-    if (on === undefined){
-        throw new Error('Expected "on" delegate.');
-    }
+                                if (callback)
+                                    callback(undefined, ret.data[0], statement.output, false);
+                            });
 
-    if (callback instanceof Boolean) {
-        asArray = callback;
-        callback = undefined;
+                            break;
+                        }
+
+                    // Fall through is normal
+                    default:
+                        statement.release();
+                        if (callback)
+                            callback()
+                        break;
+                }
+
+            }, custom);
+        });
     }
 
-    var self = this;
-    self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: on });
-    return self;
-};
+    sequentially(query, params, on, callback, asArray) {
+        if (params instanceof Function) {
+            asArray = callback;
+            callback = on;
+            on = params;
+            params = undefined;
+        }
+
+        if (on === undefined){
+            throw new Error('Expected "on" delegate.');
+        }
+
+        if (callback instanceof Boolean) {
+            asArray = callback;
+            callback = undefined;
+        }
 
-Transaction.prototype.query = function(query, params, callback) {
+        var self = this;
+        var _on = function(row, i, meta, next) {
+            var done = false;
+            var finish = function(err) {
+                if (done) {
+                    return;
+                }
+                done = true;
+                next(err);
+            };
+
+            try {
+                var ret;
+                if (on.length >= 3) {
+                    ret = on(row, i, finish);
+                } else {
+                    ret = on(row, i);
+                }
+
+                if (ret && typeof ret.then === 'function') {
+                    ret.then(function() {
+                        finish();
+                    }).catch(finish);
+                } else if (on.length < 3) {
+                    finish();
+                }
+            } catch (err) {
+                finish(err);
+            }
+        };
 
-    if (params instanceof Function) {
-        callback = params;
-        params = undefined;
+        self.execute(query, params, callback, { asObject: !asArray, asStream: true, on: _on });
+        return self;
     }
 
-    if (callback === undefined)
-        callback = noop;
+    query(query, params, callback) {
+        if (params instanceof Function) {
+            callback = params;
+            params = undefined;
+        }
 
-    this.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
+        if (callback === undefined)
+            callback = noop;
 
-};
+        this.execute(query, params, callback, { asObject: true, asStream: callback === undefined || callback === null });
+    }
 
-Transaction.prototype.commit = function(callback) {
-    this.connection.commit(this, callback);
-};
+    commit(callback) {
+        this.connection.commit(this, callback);
+    }
 
-Transaction.prototype.rollback = function(callback) {
-    this.connection.rollback(this, callback);
-};
+    rollback(callback) {
+        this.connection.rollback(this, callback);
+    }
 
-Transaction.prototype.commitRetaining = function(callback) {
-    this.connection.commitRetaining(this, callback);
-};
+    commitRetaining(callback) {
+        this.connection.commitRetaining(this, callback);
+    }
 
-Transaction.prototype.rollbackRetaining = function(callback) {
-    this.connection.rollbackRetaining(this, callback);
-};
+    rollbackRetaining(callback) {
+        this.connection.rollbackRetaining(this, callback);
+    }
+}
 
 module.exports = Transaction;