node-firebird 0.9.9 → 1.0.0

package/.github/workflows/node.js.yml

@@ -0,0 +1,78 @@
+name: CI
+
+on: [push, pull_request]
+
+jobs:
+  build:
+    runs-on: ${{ matrix.os }}
+
+    strategy:
+      matrix:
+        os: [ubuntu-16.04, ubuntu-18.04, windows-2019, macos-10.15]
+        node-version: [10.x, 12.x, 14.x, 15.x]
+
+    steps:
+    - uses: actions/checkout@v1
+      with:
+        fetch-depth: 10
+
+    - name: Use Node.js ${{ matrix.node-version }}
+      uses: actions/setup-node@v1
+      with:
+        node-version: ${{ matrix.node-version }}
+
+    - name: Firebird install (Linux)
+      if: matrix.os == 'ubuntu-16.04' || matrix.os == 'ubuntu-18.04'
+      run: |
+        if [ `lsb_release -rs` = '16.04' ]
+        then
+            sudo apt-get install libtommath0
+        else
+            sudo apt-get install libtommath1
+            sudo ln -s /usr/lib/x86_64-linux-gnu/libtommath.so.1 /usr/lib/x86_64-linux-gnu/libtommath.so.0
+        fi
+        wget -nv -O Firebird-3.0.7.33374-0.amd64.tar.gz "https://github.com/FirebirdSQL/firebird/releases/download/R3_0_7/Firebird-3.0.7.33374-0.amd64.tar.gz"
+        tar xzvf Firebird-3.0.7.33374-0.amd64.tar.gz
+        (cd Firebird-3.0.7.33374-0.amd64; sudo ./install.sh -silent)
+        sudo usermod -a -G firebird `whoami`
+
+    - name: Firebird install (MacOS)
+      if: matrix.os == 'macos-10.15'
+      run: |
+        wget -nv -O Firebird-3.0.7-33374-x86_64.pkg "https://github.com/FirebirdSQL/firebird/releases/download/R3_0_7/Firebird-3.0.7-33374-x86_64.pkg"
+        sudo installer -verbose -pkg "Firebird-3.0.7-33374-x86_64.pkg" -target /
+        
+    - name: Firebird install (Windows)
+      if: matrix.os == 'windows-2019'
+      shell: cmd
+      run: |
+        set FB_ZIP=Firebird-3.0.7.33374-1_x64.zip
+        powershell Invoke-WebRequest "https://github.com/FirebirdSQL/firebird/releases/download/R3_0_7/$env:FB_ZIP" -OutFile "$env:FB_ZIP"
+        7z x -oC:\Firebird %FB_ZIP%
+
+    - name: Build
+      shell: bash
+      run: |
+        npm ci         
+
+    - name: Test (Linux)
+      if: matrix.os == 'ubuntu-16.04' || matrix.os == 'ubuntu-18.04'
+      run: |
+        sg firebird -c "npx nyc npm test"
+
+    - name: Test (MacOS)
+      if: matrix.os == 'macos-10.15'
+      run: |
+        sudo mkdir `pwd`/tmp-node-fb
+        sudo chmod 777 `pwd`/tmp-node-fb
+        export ISC_USER=sysdba
+        export ISC_PASSWORD=masterkey
+        export NODE_FB_TEST_TMP_DIR=`pwd`/tmp-node-fb
+        npx nyc npm test
+
+    - name: Test (Windows)
+      if: matrix.os == 'windows-2019'
+      shell: cmd
+      run: |
+        set PATH=C:\Firebird;%PATH%
+        call npx nyc npm test

package/README.md

@@ -66,7 +66,8 @@ options.password = 'masterkey';
 options.lowercase_keys = false; // set to true to lowercase keys
 options.role = null;            // default
 options.pageSize = 4096;        // default when creating database
-
+options.pageSize = 4096;        // default when creating database
+options.retryConnectionInterval = 1000; // reconnect interval in case of connection drop
 ```
 
 ### Classic
@@ -183,7 +184,7 @@ Firebird.attach(options, function(err, db) {
 });
 ```
 
-### Reading Blobs (Aasynchronous)
+### Reading Blobs (Asynchronous)
 
 ```js
 Firebird.attach(options, function(err, db) {
@@ -513,7 +514,7 @@ This is why you should use **Firebird 2.5** server at least.
 ### Firebird 3.0 Support
 
 Firebird new wire protocol is not supported yet so
-for Firebird 3.0 you need to add the following in firebird.conf according to Firebird documentation
+for Firebird 3.0 you need to add the following in firebird.conf according to Firebird 3 release notes
 <https://firebirdsql.org/file/documentation/release_notes/html/en/3_0/rnfb30-security-new-authentication.html>
 
 ```bash
@@ -522,6 +523,21 @@ WireCrypt = Disabled
 UserManager = Legacy_UserManager
 ```
 
+Firebird 4 wire protocol is not supported yet so
+for Firebird 4.0 you need to add the following in firebird.conf according to Firebird release notes
+<https://firebirdsql.org/file/documentation/release_notes/html/en/4_0/rlsnotes40.html#rnfb40-config-srp256>
+
+```bash
+AuthServer = Srp256, Srp, Legacy_Auth
+WireCrypt = Disabled
+UserManager = Legacy_UserManager
+```
+
+Please read also Authorization with Firebird 2.5 client library from Firebird 4 migration guide
+<https://ib-aid.com/download/docs/fb4migrationguide.html#_authorization_with_firebird_2_5_client_library_fbclient_dll>
+
+
+
 ## Contributors
 
 - Henri Gourvest, <https://github.com/hgourvest>

package/lib/index.d.ts

@@ -9,9 +9,23 @@ declare module 'node-firebird' {
     type SimpleCallback = (err: any) => void;
     type SequentialCallback = (row: any, index: number) => void;
 
+    export const AUTH_PLUGIN_LEGACY: string;
+    export const AUTH_PLUGIN_SRP: string;
+    export const AUTH_PLUGIN_SRP256: string;
+
+    export const WIRE_CRYPT_ENABLE: number;
+    export const WIRE_CRYPT_DISABLE: number;
+
+    /** A transaction sees changes done by uncommitted transactions. */
     export const ISOLATION_READ_UNCOMMITTED: number[];
+    /** A transaction sees only data committed before the statement has been executed. */
     export const ISOLATION_READ_COMMITED: number[];
+    /** A transaction sees during its lifetime only data committed before the transaction has been started. */
     export const ISOLATION_REPEATABLE_READ: number[];
+    /**
+     * This is the strictest isolation level, which enforces transaction serialization.
+     * Data accessed in the context of a serializable transaction cannot be accessed by any other transaction.
+     */
     export const ISOLATION_SERIALIZABLE: number[];
     export const ISOLATION_READ_COMMITED_READ_ONLY: number[];
 
@@ -46,6 +60,7 @@ declare module 'node-firebird' {
         lowercase_keys?: boolean;
         role?: string;
         pageSize?: number;
+        retryConnectionInterval?: number;
     }
 
     export interface SvcMgrOptions extends Options {
@@ -54,12 +69,12 @@ declare module 'node-firebird' {
 
     export interface ConnectionPool {
         get(callback: DatabaseCallback): void;
-        destroy(): void;
+        destroy(callback?: SimpleCallback): void;
     }
 
     export function attach(options: Options, callback: DatabaseCallback): void;
     export function attach(options: SvcMgrOptions, callback: ServiceManagerCallback): void;
-    export function escape(value: any, protocolVersion: number /*PROTOCOL_VERSION13*/): string;
+    export function escape(value: any, protocolVersion?: number /*PROTOCOL_VERSION13*/): string;
     export function create(options: Options, callback: DatabaseCallback): void;
     export function attachOrCreate(options: Options, callback: DatabaseCallback): void;
     export function pool(max: number, options: Options): ConnectionPool;
@@ -207,18 +222,18 @@ declare module 'node-firebird' {
         backup(options: BackupOptions, callback: ReadableCallback): void;
         nbackup(options: BackupOptions, callback: ReadableCallback): void;
         restore(options: NRestoreOptions, callback: ReadableCallback): void;
-        nrestore(options, callback): void;
+        nrestore(options: any, callback: Function): void;
         setDialect(db: string, dialect: 1 | 3, callback: ReadableCallback): void;
-        setSweepinterval(db: string, interval: number, callback): void; // gfix -h INTERVAL
-        setCachebuffer(db: string, nbpages, callback: ReadableCallback): void; // gfix -b NBPAGES
+        setSweepinterval(db: string, interval: number, callback: Function): void; // gfix -h INTERVAL
+        setCachebuffer(db: string, nbpages: any, callback: ReadableCallback): void; // gfix -b NBPAGES
         BringOnline(db: string, callback: ReadableCallback): void; // gfix -o
         Shutdown(db: string, kind: ShutdownKind, delay: number, mode: ShutdownMode, callback: ReadableCallback): void; // server version >= 2.0
         Shutdown(db: string, kind: ShutdownKind, delay: number, callback: ReadableCallback): void; // server version < 2.0
         setShadow(db: string, val: boolean, callback: ReadableCallback): void;
         setForcewrite(db: string, val: boolean, callback: ReadableCallback): void; // gfix -write
         setReservespace(db: string, val: boolean, callback: ReadableCallback): void; // true: gfix -use reserve, false: gfix -use full
-        setReadonlyMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_only 
-        setReadwriteMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_write 
+        setReadonlyMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_only
+        setReadwriteMode(db: string, callback: ReadableCallback): void; //  gfix -mode read_write
         validate(options: ValidateOptions, callback: ReadableCallback): void; // gfix -validate
         commit(db: string, transactid: number, callback: ReadableCallback): void; // gfix -commit
         rollback(db: string, transactid: number, callback: ReadableCallback): void;

package/lib/index.js

@@ -11,7 +11,9 @@ var
 	BitSet = serialize.BitSet,
     messages = require('./messages.js'),
     crypt = require('./unix-crypt.js'),
-    path = require('path');
+    path = require('path'),
+	srp = require('./srp'),
+	BigInt = require('big-integer');
 
 if (typeof(setImmediate) === 'undefined') {
     global.setImmediate = function(cb) {
@@ -274,7 +276,9 @@ const
 	ptype_rpc = 2, 			 // Simple remote procedure call
     ptype_batch_send = 3,    // Batch sends, no asynchrony
 	ptype_out_of_band = 4,   // Batch sends w/ out of band notification
-	ptype_lazy_send = 5;     // Deferred packets delivery;
+	ptype_lazy_send = 5,     // Deferred packets delivery;
+	ptype_mask = 0xFF,       // Mask - up to 255 types of protocol
+	pflag_compress = 0x100;  // Turn on compression if possible
 
 const SUPPORTED_PROTOCOL = [
 	[PROTOCOL_VERSION10, ARCHITECTURE_GENERIC, ptype_rpc, ptype_batch_send, 1],
@@ -790,11 +794,25 @@ const
     DEFAULT_PAGE_SIZE = 4096,
     DEFAULT_SVC_NAME = 'service_mgr';
 
-const AUTH_PLUGIN_LEGACY = 'Legacy_Auth';
+const AUTH_PLUGIN_LEGACY = 'Legacy_Auth',
+ 	  AUTH_PLUGIN_SRP = 'Srp';
+	  // AUTH_PLUGIN_SRP256 = 'Srp256';
 
 const
-	AUTH_PLUGIN_LIST = [AUTH_PLUGIN_LEGACY],
-    LEGACY_AUTH_SALT = '9z';
+	// AUTH_PLUGIN_LIST = [AUTH_PLUGIN_SRP256, AUTH_PLUGIN_SRP, AUTH_PLUGIN_LEGACY],
+	AUTH_PLUGIN_LIST = [AUTH_PLUGIN_SRP, AUTH_PLUGIN_LEGACY],
+	// AUTH_PLUGIN_SRP_LIST = [AUTH_PLUGIN_SRP256, AUTH_PLUGIN_SRP],
+	AUTH_PLUGIN_SRP_LIST = [AUTH_PLUGIN_SRP],
+    LEGACY_AUTH_SALT = '9z',
+	WIRE_CRYPT_DISABLE = 0,
+	WIRE_CRYPT_ENABLE = 1;
+
+exports.AUTH_PLUGIN_LEGACY = AUTH_PLUGIN_LEGACY;
+exports.AUTH_PLUGIN_SRP = AUTH_PLUGIN_SRP;
+// exports.AUTH_PLUGIN_SRP256 = AUTH_PLUGIN_SRP256;
+
+exports.WIRE_CRYPT_DISABLE = WIRE_CRYPT_DISABLE;
+exports.WIRE_CRYPT_ENABLE = WIRE_CRYPT_ENABLE;
 
 exports.ISOLATION_READ_UNCOMMITTED = ISOLATION_READ_UNCOMMITTED;
 exports.ISOLATION_READ_COMMITED = ISOLATION_READ_COMMITED;
@@ -1284,7 +1302,9 @@ SQLParamBool.prototype.calcBlr = function(blr) {
  ***************************************/
 
 function isError(obj) {
-    return (obj instanceof Object && obj.status);
+    return Boolean(
+      obj != null && typeof obj === "object" && !Array.isArray(obj) && obj.status
+    );
 }
 
 function doCallback(obj, callback) {
@@ -2885,17 +2905,40 @@ Pool.prototype.check = function() {
     return self;
 };
 
-Pool.prototype.destroy = function() {
+Pool.prototype.destroy = function(callback) {
     var self = this;
+
+    var connectionCount = this.internaldb.length;
+
+    if (connectionCount === 0 && callback) {
+        callback();
+    }
+
+    function detachCallback(err) {
+        if (err) {
+            if (callback) {
+                callback(err);
+            }
+            return;
+        }
+
+        connectionCount--;
+        if (connectionCount === 0 && callback) {
+            callback();
+        }
+    }
+
     this.internaldb.forEach(function(db) {
-        if (db.connection._pooled === false)
+        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();
+            db.detach(detachCallback);
         }
     });
 };
@@ -2918,6 +2961,7 @@ var Connection = exports.Connection = function (host, port, callback, options, d
     this._detachAuto;
     this._socket = net.createConnection(port, host);
     this._pending = [];
+    this._isOpened = false;
     this._isClosed = false;
     this._isDetach = false;
     this._isUsed = false;
@@ -2925,6 +2969,8 @@ var Connection = exports.Connection = function (host, port, callback, options, d
     this.options = options;
     this._bind_events(host, port, callback);
     this.error;
+    this._retry_connection_id;
+    this._retry_connection_interval = options.retryConnectionInterval || 1000;
     this._max_cached_query = options.maxCachedQuery || -1;
     this._cache_query = options.cacheQuery?{}:null;
     this._messageFile = options.messageFile || path.join(__dirname, 'firebird.msg');
@@ -2950,10 +2996,11 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
 
     self._socket.on('close', function() {
 
-        self._isClosed = true;
-
-        if (self._isDetach)
+        if (!self._isOpened || self._isDetach) {
             return;
+        }
+
+        self._isOpened = false;
 
         if (!self.db) {
             if (callback)
@@ -2961,10 +3008,9 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
             return;
         }
 
-        setImmediate(function() {
+       self._retry_connection_id = setTimeout(function() {
+            self._socket.removeAllListeners();
             self._socket = null;
-            self._msg = null;
-            self._blr = null;
 
             var ctx = new Connection(host, port, function(err) {
                 ctx.connect(self.options, function(err) {
@@ -2988,8 +3034,10 @@ exports.Connection.prototype._bind_events = function(host, port, callback) {
                     }, self.db);
                 });
 
+				Object.assign(self, ctx);
+
             }, self.options, self.db);
-        });
+        }, self._retry_connection_interval);
 
     });
 
@@ -3255,22 +3303,77 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                     protocolArchitecture: data.readInt(),
                     protocolMinimumType: data.readInt(),
                     pluginName: '',
-                    authData: ''
+                    authData: '',
+					sessionKey: ''
                 };
 
                 accept.protocolMinimumType = accept.protocolMinimumType & 0xFF;
+				//accept.compress = (accept.acceptType & pflag_compress) !== 0; // TODO Handle zlib compression
                 if (accept.protocolVersion < 0) {
                     accept.protocolVersion = (accept.protocolVersion & FB_PROTOCOL_MASK) | FB_PROTOCOL_FLAG;
                 }
 
                 if (r === op_cond_accept || r === op_accept_data) {
-                    var d = data.readString(DEFAULT_ENCODING);
+                    var d = new BlrReader(data.readArray());
                     accept.pluginName = data.readString(DEFAULT_ENCODING);
                     var is_authenticated = data.readInt();
                     var keys = data.readString(DEFAULT_ENCODING); // keys
 
                     if (is_authenticated === 0) {
-                        if (accept.pluginName === AUTH_PLUGIN_LEGACY) {
+                    	if (cnx.options.pluginName && cnx.options.pluginName !== accept.pluginName) {
+                    		doError(new Error('Server don\'t accept plugin : ' + cnx.options.pluginName + ', but support : ' + accept.pluginName), callback);
+						}
+
+                    	if (AUTH_PLUGIN_SRP_LIST.indexOf(accept.pluginName) !== -1) {
+							var crypto = {
+								Srp: 'sha1',
+								Srp256: 'sha256'
+							};
+							accept.srpAlgo = crypto[accept.pluginName];
+
+							// TODO : Fallback Srp256 to Srp ?
+							/*if (!d.buffer) {
+								cnx.sendOpContAuth(
+									cnx.clientKeys.public.toString(16),
+									DEFAULT_ENCODING,
+									accept.pluginName
+								);
+
+								return cb(new Error('login'));
+							}*/
+
+							// Check buffer contains salt
+							var saltLen = d.buffer.readUInt16LE(0);
+							if (saltLen > 32 * 2) {
+								console.log('salt to long'); // TODO : Throw error
+							}
+
+							// Check buffer contains key
+							var keyLen = d.buffer.readUInt16LE(saltLen + 2);
+							var keyStart = saltLen + 4;
+							if (d.buffer.length - keyStart !== keyLen) {
+								console.log('key error'); // TODO : Throw error
+							}
+
+							// Server keys
+							cnx.serverKeys = {
+								salt: d.buffer.slice(2, saltLen + 2).toString('utf8'),
+								public: BigInt(d.buffer.slice(keyStart, d.buffer.length).toString('utf8'), 16)
+							};
+
+							var proof = srp.clientProof(
+								cnx.options.user.toUpperCase(),
+								cnx.options.password,
+								cnx.serverKeys.salt,
+								cnx.clientKeys.public,
+								cnx.serverKeys.public,
+								cnx.clientKeys.private,
+								accept.srpAlgo
+							);
+
+							accept.authData = proof.authData.toString(16);
+							accept.sessionKey = proof.clientSessionKey;
+						} else if (accept.pluginName === AUTH_PLUGIN_LEGACY) {
                             accept.authData = crypt.crypt(cnx.options.password, LEGACY_AUTH_SALT).substring(2);
                         } else {
                             return cb(new Error('Unknow auth plugin : ' + accept.pluginName));
@@ -3280,7 +3383,35 @@ function decodeResponse(data, callback, cnx, lowercase_keys, cb) {
                         accept.sessionKey = '';
                     }
                 }
+
                 return cb(undefined, accept);
+			case op_cont_auth:
+				var d = new BlrReader(data.readArray());
+				var pluginName = data.readString(DEFAULT_ENCODING);
+				data.readString(DEFAULT_ENCODING); // plist
+				data.readString(DEFAULT_ENCODING); // pkey
+
+				if (!cnx.options.pluginName) {
+					if (cnx.accept.pluginName === pluginName) {
+						// Erreur plugin not able to connect
+						return cb(new Error("Unable to connect with plugin " + cnx.accept.pluginName));
+					}
+
+					if (pluginName === AUTH_PLUGIN_LEGACY) { // Fallback to LegacyAuth
+						cnx.accept.pluginName = pluginName;
+						cnx.accept.authData = crypt.crypt(cnx.options.password, LEGACY_AUTH_SALT).substring(2);
+
+						cnx.sendOpContAuth(
+							cnx.accept.authData,
+							DEFAULT_ENCODING,
+							pluginName
+						);
+
+						return {error: new Error('login')};
+					}
+				}
+
+				return data.accept;
             default:
                 return cb(new Error('Unexpected:' + r));
         }
@@ -3366,6 +3497,20 @@ function parseOpResponse(data, response, cb) {
     }
 }
 
+Connection.prototype.sendOpContAuth = function(authData, authDataEnc, pluginName) {
+	var msg = this._msg;
+	msg.pos = 0;
+
+	msg.addInt(op_cont_auth);
+	msg.addString(authData, authDataEnc);
+	msg.addString(pluginName, DEFAULT_ENCODING)
+	msg.addString(AUTH_PLUGIN_LIST.join(','), DEFAULT_ENCODING);
+	// msg.addInt(0); // p_list
+	msg.addInt(0); // keys
+
+	this._socket.write(msg.getData());
+}
+
 Connection.prototype._queueEvent = function(callback){
     var self = this;
 
@@ -3380,7 +3525,7 @@ Connection.prototype._queueEvent = function(callback){
 };
 
 Connection.prototype.connect = function (options, callback) {
-	var pluginName = AUTH_PLUGIN_LEGACY;
+	var pluginName = options.manager ? AUTH_PLUGIN_LEGACY : options.pluginName || AUTH_PLUGIN_LIST[0]; // TODO Srp for service
     var msg = this._msg;
     var blr = this._blr;
 
@@ -3393,13 +3538,19 @@ Connection.prototype.connect = function (options, callback) {
 	blr.addString(CNCT_plugin_name, pluginName, DEFAULT_ENCODING);
 	blr.addString(CNCT_plugin_list, AUTH_PLUGIN_LIST.join(','), DEFAULT_ENCODING);
 
-	if (pluginName === AUTH_PLUGIN_LEGACY) {
-		var specificData = crypt.crypt(options.password, LEGACY_AUTH_SALT).substring(2);
+	var specificData = '';
+	if (AUTH_PLUGIN_SRP_LIST.indexOf(pluginName) > -1) {
+		this.clientKeys = srp.clientSeed();
+		specificData = this.clientKeys.public.toString(16);
+		blr.addMultiblockPart(CNCT_specific_data, specificData, DEFAULT_ENCODING);
+	} else if (pluginName === AUTH_PLUGIN_LEGACY) {
+		specificData = crypt.crypt(options.password, LEGACY_AUTH_SALT).substring(2);
 		blr.addMultiblockPart(CNCT_specific_data, specificData, DEFAULT_ENCODING);
 	} else {
-		throw new Error('Invalide auth plugin');
+		doError(new Error('Invalide auth plugin \'' + pluginName + '\''), callback);
+		return;
 	}
-	blr.addBytes([CNCT_client_crypt, 4, 0, 0, 0, 0]); // WireCrypt = Disabled
+	blr.addBytes([CNCT_client_crypt, 4, WIRE_CRYPT_DISABLE, 0, 0, 0]); // WireCrypt = Disabled
 	blr.addString(CNCT_user, os.userInfo().username || 'Unknown', DEFAULT_ENCODING);
     blr.addString(CNCT_host, os.hostname(), DEFAULT_ENCODING);
     blr.addBytes([CNCT_user_verification, 0]);
@@ -3456,13 +3607,16 @@ Connection.prototype.attach = function (options, callback, db) {
     blr.addByte(isc_dpb_version1);
     blr.addString(isc_dpb_lc_ctype, 'UTF8', DEFAULT_ENCODING);
     blr.addString(isc_dpb_user_name, user, DEFAULT_ENCODING);
-	if (this.accept.protocolVersion < PROTOCOL_VERSION13) {
-		if (this.accept.protocolVersion === PROTOCOL_VERSION10) {
-			blr.addString(isc_dpb_password, password, DEFAULT_ENCODING);
-		} else {
-			blr.addString(isc_dpb_password_enc, crypt.crypt(password, LEGACY_AUTH_SALT).substring(2), DEFAULT_ENCODING);
+	if (options.password && !this.accept.authData) {
+		if (this.accept.protocolVersion < PROTOCOL_VERSION13) {
+			if (this.accept.protocolVersion === PROTOCOL_VERSION10) {
+				blr.addString(isc_dpb_password, password, DEFAULT_ENCODING);
+			} else {
+				blr.addString(isc_dpb_password_enc, crypt.crypt(password, LEGACY_AUTH_SALT).substring(2), DEFAULT_ENCODING);
+			}
 		}
 	}
+
     if (role)
         blr.addString(isc_dpb_sql_role_name, role, DEFAULT_ENCODING);
 
@@ -3522,6 +3676,7 @@ Connection.prototype.detach = function (callback) {
     msg.addInt(0); // Database Object ID
 
     self._queueEvent(function(err, ret) {
+        clearTimeout(self._retry_connection_id);
         delete(self.dbhandle);
         if (callback)
             callback(err, ret);

package/lib/serialize.js

@@ -111,11 +111,11 @@ BlrWriter.prototype.addBuffer = function (b) {
 
 BlrWriter.prototype.addString2 = function (c, s, encoding) {
     this.addByte(c);
-    
+
     var len = Buffer.byteLength(s, encoding);
     if (len > MAX_STRING_SIZE* MAX_STRING_SIZE)
         throw new Error('blr string is too big');
-    
+
     this.ensure(len + 2);
     this.buffer.writeUInt16LE(len, this.pos);
     this.pos += 2;
@@ -135,6 +135,7 @@ BlrWriter.prototype.addMultiblockPart = function (c, s, encoding) {
         this.addByte(toWrite + 1);
         this.addByte(step);
 
+        this.ensure(toWrite);
         buff.copy(this.buffer, this.pos, step * 254, (step * 254) + toWrite);
 
         step++;

package/lib/srp.js

@@ -0,0 +1,281 @@
+var BigInt = require('big-integer'),
+    crypto = require('crypto');
+
+const SRP_KEY_SIZE = 128,
+  SRP_KEY_MAX = BigInt('340282366920938463463374607431768211456'), // 1 << SRP_KEY_SIZE
+  SRP_SALT_SIZE = 32;
+
+const DEBUG = false;
+const DEBUG_PRIVATE_KEY = BigInt('84316857F47914F838918D5C12CE3A3E7A9B2D7C9486346809E9EEFCE8DE7CD4259D8BE4FD0BCC2D259553769E078FA61EE2977025E4DA42F7FD97914D8A33723DFAFBC00770B7DA0C2E3778A05790F0C0F33C32A19ED88A12928567749021B3FD45DCD1CE259C45325067E3DDC972F87867349BA82C303CCCAA9B207218007B', 16);
+
+/**
+ * Prime values.
+ *
+ * @type {{g: (bigInt.BigInteger), k: (bigInt.BigInteger), N: (bigInt.BigInteger)}}
+ */
+const PRIME = {
+    N: BigInt('E67D2E994B2F900C3F41F08F5BB2627ED0D49EE1FE767A52EFCD565CD6E768812C3E1E9CE8F0A8BEA6CB13CD29DDEBF7A96D4A93B55D488DF099A15C89DCB0640738EB2CBDD9A8F7BAB561AB1B0DC1C6CDABF303264A08D1BCA932D1F1EE428B619D970F342ABA9A65793B8B2F041AE5364350C16F735F56ECBCA87BD57B29E7', 16),
+    g: BigInt(2),
+    k: BigInt('1277432915985975349439481660349303019122249719989')
+};
+
+/**
+ * Generate a client key pair.
+ *
+ * @param a bigInt.BigInteger Client private key.
+ * @returns {{private: bigInt.BigInteger, public: bigInt.BigInteger}}
+ */
+exports.clientSeed = function(a = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
+    var A = PRIME.g.modPow(a, PRIME.N);
+
+    dump('a', a);
+    dump('A', A);
+
+    return {
+        public: A,
+        private: a
+    };
+}
+
+/**
+ * Generate a server key pair.
+ *
+ * @param user string Connection username.
+ * @param password string Connection password.
+ * @param salt bigInt.BigInteger Connection salt.
+ * @param b bigInt.BigInteger Server private key.
+ * @returns {{private: bigInt.BigInteger, public: bigInt.BigInteger}}
+ */
+exports.serverSeed = function(user, password, salt, b = toBigInt(crypto.randomBytes(SRP_KEY_SIZE))) {
+    var v = getVerifier(user, password, salt);
+    var gb = PRIME.g.modPow(b, PRIME.N);
+    var kv = PRIME.k.multiply(v).mod(PRIME.N);
+    var B = kv.add(gb).mod(PRIME.N);
+
+    dump('v', v);
+    dump('b', b);
+    dump('gb', b);
+    dump('kv', v);
+    dump('B', B);
+
+    return {
+        public: B,
+        private: b
+    };
+}
+
+/**
+ * Server session secret.
+ *
+ * @param user string Connection username.
+ * @param password string Connection password.
+ * @param salt bigInt.BigInteger Connection salt.
+ * @param A bigInt.BigInteger Client public key.
+ * @param B bigInt.BigInteger Server public key.
+ * @param b bigInt.BigInteger Server private key.
+ * @returns {bigInt.BigInteger}
+ */
+exports.serverSession = function(user, password, salt, A, B, b) {
+    var u = getScramble(A, B);
+    var v = getVerifier(user, password, salt);
+    var vu = v.modPow(u, PRIME.N);
+    var Avu = A.multiply(vu).mod(PRIME.N);
+    var sessionSecret = Avu.modPow(b, PRIME.N);
+    var K = getHash('sha1', toBuffer(sessionSecret));
+
+    dump('server sessionSecret', sessionSecret);
+    dump('server K', K);
+
+    return BigInt(K, 16);
+};
+
+/**
+ * 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);
+    var n1, n2;
+
+    n1 = toBigInt(getHash('sha1', toBuffer(PRIME.N)));
+    n2 = toBigInt(getHash('sha1', toBuffer(PRIME.g)));
+
+    dump('n1', n1);
+    dump('n2', n2);
+
+    n1 = n1.modPow(n2, PRIME.N);
+    n2 = toBigInt(getHash('sha1', user));
+    var M = toBigInt(getHash(hashAlgo, toBuffer(n1), toBuffer(n2), salt, toBuffer(A), toBuffer(B), toBuffer(K)));
+
+    dump('n1-2', n1);
+    dump('n2-2', n2);
+    dump('proof:M', M);
+
+    return {
+        clientSessionKey: K,
+        authData: M,
+    };
+}
+
+/**
+ *  Pad hex string.
+ */
+function hexPad(hex) {
+    if (hex.length % 2 !== 0) {
+        hex = '0' + hex;
+    }
+
+    return hex;
+}
+exports.hexPad = hexPad;
+
+/**
+ * Pad key with SRP_KEY_SIZE.
+ *
+ * @param n BigInt Key to pad.
+ * @returns Buffer
+ */
+function pad(n) {
+    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);
+    }
+
+    return buff;
+}
+
+/**
+ * Scramble keys.
+ *
+ * @param A bigInt.BigInteger Client public key.
+ * @param B bigInt.BigInteger Server public key.
+ * @returns {bigInt.BigInteger}
+ */
+function getScramble(A, B) {
+    return BigInt(getHash('sha1', pad(A), pad(B)), 16);
+}
+
+/**
+ * Client session secret.
+ *
+ * Both: u = H(A, B)
+ * User: x = H(s, p)                 (user enters password)
+ * User: S = (B - kg^x) ^ (a + ux)   (computes session key)
+ * User: K = H(S)
+ *
+ * @param user string Connection username.
+ * @param password string Connection password.
+ * @param salt bigInt.BigInteger Connection salt.
+ * @param A bigInt.BigInteger Client public key.
+ * @param B bigInt.BigInteger Server public key.
+ * @param a bigInt.BigInteger Client private key.
+ */
+function clientSession(user, password, salt, A, B, a) {
+    var u = getScramble(A, B);
+    var x = getUserHash(user, salt, password);
+    var gx = PRIME.g.modPow(x, PRIME.N);
+    var kgx = PRIME.k.multiply(gx).mod(PRIME.N);
+    var diff = B.subtract(kgx).mod(PRIME.N);
+
+    if (diff.lesser(0)) {
+        diff = diff.add(PRIME.N);
+    }
+
+    var ux = u.multiply(x).mod(PRIME.N);
+    var aux = a.add(ux).mod(PRIME.N);
+    var sessionSecret = diff.modPow(aux, PRIME.N);
+    var K = toBigInt(getHash('sha1', toBuffer(sessionSecret)));
+
+    dump('B', B);
+    dump('u', u);
+    dump('x', x);
+    dump('gx', gx);
+    dump('kgx', kgx);
+    dump('diff', diff);
+    dump('ux', ux);
+    dump('aux', aux);
+    dump('sessionSecret', sessionSecret);
+    dump('sessionKey(K)', K);
+
+    return K;
+}
+
+/**
+ * Compute user hash.
+ *
+ * @param user string Connection username.
+ * @param salt bigInt.BigInteger Connection salt.
+ * @param password string Connection password.
+ * @returns {bigInt.BigInteger}
+ */
+function getUserHash(user, salt, password) {
+    var hash1 = getHash('sha1', user.toUpperCase(), ':', password);
+    var hash2 = getHash('sha1', salt, toBuffer(hash1));
+
+    return toBigInt(hash2);
+}
+
+/**
+ * Verifier of user hash.
+ *
+ * @param user string Connection username.
+ * @param password string Connection password.
+ * @param salt  bigInt.BigInteger Connection salt.
+ * @returns {bigInt.BigInteger}
+ */
+function getVerifier(user, password, salt) {
+    return PRIME.g.modPow(getUserHash(user, salt, password), PRIME.N);
+}
+
+/**
+ * Hash data and return hex string.
+ *
+ * @param algo string Algorithm to use.
+ * @param data any[] Data to hash.
+ * @returns {string}
+ */
+function getHash(algo, ...data) {
+    var hash = crypto.createHash(algo);
+
+    for (var d of data) {
+        hash.update(d);
+    }
+
+    return hash.digest('hex');
+}
+
+/**
+ * Convert BigInt to buffer.
+ *
+ * @param bigInt
+ * @returns {*}
+ */
+function toBuffer(bigInt) {
+    return Buffer.from(BigInt.isInstance(bigInt) ? hexPad(bigInt.toString(16)) : bigInt, 'hex');
+}
+
+/**
+ * Convert hex buffer or string to BigInt.
+ *
+ * @param hex
+ * @returns {bigInt.BigInteger}
+ */
+function toBigInt(hex) {
+    return BigInt(Buffer.isBuffer(hex) ? hex.toString('hex') : hex, 16);
+}
+
+/**
+ * Dump value in debug mode.
+ *
+ * @param key
+ * @param value
+ */
+function dump(key, value) {
+    if (DEBUG) {
+        if (BigInt.isInstance(value)) {
+            value = value.toString(16);
+        }
+
+        console.log(key + '=' + value);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "node-firebird",
-    "version": "0.9.9",
+    "version": "1.0.0",
     "description": "Pure JavaScript and Asynchronous Firebird client for Node.js.",
     "keywords": [
         "firebird",
@@ -33,6 +33,7 @@
         "test": "mocha"
     },
     "dependencies": {
+        "big-integer": "^1.6.48",
         "long": "^4.0.0"
     },
     "devDependencies": {

package/.github/workflows/npmpublish.yml

@@ -1,47 +0,0 @@
-# This workflow will run tests using node and then publish a package to GitHub Packages when a release is created
-# For more information see: https://help.github.com/actions/language-and-framework-guides/publishing-nodejs-packages
-
-name: Node.js Package
-
-on:
-  release:
-    types: [created]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-      - run: npm ci
-      - run: npm test
-
-  publish-npm:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-          registry-url: https://registry.npmjs.org/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.npm_token}}
-
-  publish-gpr:
-    needs: build
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v2
-      - uses: actions/setup-node@v1
-        with:
-          node-version: 12
-          registry-url: https://npm.pkg.github.com/
-      - run: npm ci
-      - run: npm publish
-        env:
-          NODE_AUTH_TOKEN: ${{secrets.GITHUB_TOKEN}}