API inicial

node_modules/mariadb/lib/cmd/handshake/auth/caching-sha2-password-auth.js

@@ -0,0 +1,167 @@
+const PluginAuth = require('./plugin-auth');
+const fs = require('fs');
+const crypto = require('crypto');
+const Errors = require('../../../misc/errors');
+const NativePasswordAuth = require('./native-password-auth');
+const Sha256PasswordAuth = require('./sha256-password-auth');
+
+const State = {
+  INIT: 'INIT',
+  FAST_AUTH_RESULT: 'FAST_AUTH_RESULT',
+  REQUEST_SERVER_KEY: 'REQUEST_SERVER_KEY',
+  SEND_AUTH: 'SEND_AUTH'
+};
+
+/**
+ * Use caching Sha2 password authentication
+ */
+class CachingSha2PasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.pluginData = pluginData;
+    this.sequenceNo = packSeq;
+    this.counter = 0;
+    this.state = State.INIT;
+  }
+
+  start(out, opts, info) {
+    this.exchange(this.pluginData, out, opts, info);
+    this.onPacketReceive = this.response;
+  }
+
+  exchange(buffer, out, opts, info) {
+    switch (this.state) {
+      case State.INIT:
+        const truncatedSeed = this.pluginData.slice(0, this.pluginData.length - 1);
+        const encPwd = NativePasswordAuth.encryptPassword(opts.password, truncatedSeed, 'sha256');
+        out.startPacket(this);
+        if (encPwd.length > 0) {
+          out.writeBuffer(encPwd, 0, encPwd.length);
+          out.flushBuffer(true);
+        } else {
+          out.writeEmptyPacket(true);
+        }
+        this.state = State.FAST_AUTH_RESULT;
+        return;
+
+      case State.FAST_AUTH_RESULT:
+        // length encoded numeric : 0x01 0x03/0x04
+        const fastAuthResult = buffer[1];
+        switch (fastAuthResult) {
+          case 0x03:
+            // success authentication
+            this.emit('send_end');
+            return this.successSend(packet, out, opts, info);
+
+          case 0x04:
+            if (opts.ssl) {
+              // using SSL, so sending password in clear
+              out.startPacket(this);
+              out.writeString(opts.password);
+              out.writeInt8(0);
+              out.flushBuffer(true);
+              return;
+            }
+
+            // retrieve public key from configuration or from server
+            if (opts.cachingRsaPublicKey) {
+              try {
+                let key = opts.cachingRsaPublicKey;
+                if (!key.includes('-----BEGIN')) {
+                  // rsaPublicKey contain path
+                  key = fs.readFileSync(key, 'utf8');
+                }
+                this.publicKey = Sha256PasswordAuth.retreivePublicKey(key);
+              } catch (err) {
+                return this.throwError(err, info);
+              }
+              // send Sha256Password Packet
+              Sha256PasswordAuth.sendSha256PwdPacket(
+                this,
+                this.pluginData,
+                this.publicKey,
+                opts.password,
+                out
+              );
+            } else {
+              if (!opts.allowPublicKeyRetrieval) {
+                return this.throwError(
+                  Errors.createError(
+                    'RSA public key is not available client side. Either set option `cachingRsaPublicKey` to indicate' +
+                      ' public key path, or allow public key retrieval with option `allowPublicKeyRetrieval`',
+                    true,
+                    info,
+                    '08S01',
+                    Errors.ER_CANNOT_RETRIEVE_RSA_KEY
+                  ),
+                  info
+                );
+              }
+              this.state = State.REQUEST_SERVER_KEY;
+              // ask caching public Key Retrieval
+              out.startPacket(this);
+              out.writeInt8(0x02);
+              out.flushBuffer(true);
+            }
+            return;
+        }
+
+      case State.REQUEST_SERVER_KEY:
+        this.publicKey = Sha256PasswordAuth.retreivePublicKey(buffer.toString('utf8', 1));
+        this.state = State.SEND_AUTH;
+        Sha256PasswordAuth.sendSha256PwdPacket(
+          this,
+          this.pluginData,
+          this.publicKey,
+          opts.password,
+          out
+        );
+    }
+  }
+
+  static retreivePublicKey(key) {
+    return key.replace('(-+BEGIN PUBLIC KEY-+\\r?\\n|\\n?-+END PUBLIC KEY-+\\r?\\n?)', '');
+  }
+
+  static sendSha256PwdPacket(cmd, pluginData, publicKey, password, out) {
+    const truncatedSeed = pluginData.slice(0, pluginData.length - 1);
+    out.startPacket(cmd);
+    const enc = Sha256PasswordAuth.encrypt(truncatedSeed, password, publicKey);
+    out.writeBuffer(enc, 0, enc.length);
+    out.flushBuffer(cmd);
+  }
+
+  // encrypt password with public key
+  static encrypt(seed, password, publicKey) {
+    const nullFinishedPwd = Buffer.from(password + '\0');
+    const xorBytes = Buffer.allocUnsafe(nullFinishedPwd.length);
+    const seedLength = seed.length;
+    for (let i = 0; i < xorBytes.length; i++) {
+      xorBytes[i] = nullFinishedPwd[i] ^ seed[i % seedLength];
+    }
+    return crypto.publicEncrypt(
+      { key: publicKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
+      xorBytes
+    );
+  }
+
+  response(packet, out, opts, info) {
+    const marker = packet.peek();
+    switch (marker) {
+      //*********************************************************************************************************
+      //* OK_Packet and Err_Packet ending packet
+      //*********************************************************************************************************
+      case 0x00:
+      case 0xff:
+        this.emit('send_end');
+        return this.successSend(packet, out, opts, info);
+
+      default:
+        let promptData = packet.readBufferRemaining();
+        this.exchange(promptData, out, opts, info);
+        this.onPacketReceive = this.response;
+    }
+  }
+}
+
+module.exports = CachingSha2PasswordAuth;

node_modules/mariadb/lib/cmd/handshake/auth/clear-password-auth.js

@@ -0,0 +1,23 @@
+const PluginAuth = require('./plugin-auth');
+
+/**
+ * Send password in clear.
+ * (used only when SSL is active)
+ */
+class ClearPasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.sequenceNo = packSeq;
+  }
+
+  start(out, opts, info) {
+    out.startPacket(this);
+    if (opts.password) out.writeString(opts.password);
+    out.writeInt8(0);
+    out.flushBuffer(true);
+    this.emit('send_end');
+    this.onPacketReceive = this.successSend;
+  }
+}
+
+module.exports = ClearPasswordAuth;

node_modules/mariadb/lib/cmd/handshake/auth/ed25519-password-auth.js

@@ -0,0 +1,833 @@
+'use strict';
+
+const PluginAuth = require('./plugin-auth');
+const Crypto = require('crypto');
+
+/**
+ * Standard authentication plugin
+ */
+class Ed25519PasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.pluginData = pluginData;
+    this.sequenceNo = packSeq;
+  }
+
+  start(out, opts, info) {
+    //seed is ended with a null byte value.
+    const data = this.pluginData;
+
+    const sign = Ed25519PasswordAuth.encryptPassword(opts.password, data);
+    out.startPacket(this);
+    out.writeBuffer(sign, 0, sign.length);
+    out.flushBuffer(true);
+    this.emit('send_end');
+    this.onPacketReceive = this.successSend;
+  }
+
+  static encryptPassword(password, seed) {
+    if (!password) return Buffer.alloc(0);
+
+    let i, j;
+    let p = [gf(), gf(), gf(), gf()];
+    const signedMsg = Buffer.alloc(96);
+    const bytePwd = Buffer.from(password);
+
+    let hash = Crypto.createHash('sha512');
+    const d = hash.update(bytePwd).digest();
+    d[0] &= 248;
+    d[31] &= 127;
+    d[31] |= 64;
+
+    for (i = 0; i < 32; i++) signedMsg[64 + i] = seed[i];
+    for (i = 0; i < 32; i++) signedMsg[32 + i] = d[32 + i];
+
+    hash = Crypto.createHash('sha512');
+    const r = hash.update(signedMsg.slice(32, 96)).digest();
+
+    reduce(r);
+    scalarbase(p, r);
+    pack(signedMsg, p);
+
+    p = [gf(), gf(), gf(), gf()];
+
+    scalarbase(p, d);
+    const tt = Buffer.alloc(32);
+    pack(tt, p);
+
+    for (i = 32; i < 64; i++) signedMsg[i] = tt[i - 32];
+
+    hash = Crypto.createHash('sha512');
+    const h = hash.update(signedMsg).digest();
+
+    reduce(h);
+
+    const x = new Float64Array(64);
+    for (i = 0; i < 64; i++) x[i] = 0;
+    for (i = 0; i < 32; i++) x[i] = r[i];
+    for (i = 0; i < 32; i++) {
+      for (j = 0; j < 32; j++) {
+        x[i + j] += h[i] * d[j];
+      }
+    }
+
+    modL(signedMsg.subarray(32), x);
+
+    return signedMsg.slice(0, 64);
+  }
+}
+
+/*******************************************************
+ *
+ * This plugin uses the following public domain tweetnacl-js code by Dmitry Chestnykh (from https://github.com/dchest/tweetnacl-js/blob/master/nacl-fast.js).
+ * tweetnacl cannot be used directly (secret key mandatory size is 32 in nacl + implementation differ : second scalarbase use hash of secret key, not secret key).
+ *
+ *******************************************************/
+
+const gf = function (init) {
+  const r = new Float64Array(16);
+  if (init) for (let i = 0; i < init.length; i++) r[i] = init[i];
+  return r;
+};
+
+const gf0 = gf(),
+  gf1 = gf([1]),
+  D2 = gf([
+    0xf159,
+    0x26b2,
+    0x9b94,
+    0xebd6,
+    0xb156,
+    0x8283,
+    0x149a,
+    0x00e0,
+    0xd130,
+    0xeef3,
+    0x80f2,
+    0x198e,
+    0xfce7,
+    0x56df,
+    0xd9dc,
+    0x2406
+  ]),
+  X = gf([
+    0xd51a,
+    0x8f25,
+    0x2d60,
+    0xc956,
+    0xa7b2,
+    0x9525,
+    0xc760,
+    0x692c,
+    0xdc5c,
+    0xfdd6,
+    0xe231,
+    0xc0a4,
+    0x53fe,
+    0xcd6e,
+    0x36d3,
+    0x2169
+  ]),
+  Y = gf([
+    0x6658,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666,
+    0x6666
+  ]);
+
+const L = new Float64Array([
+  0xed,
+  0xd3,
+  0xf5,
+  0x5c,
+  0x1a,
+  0x63,
+  0x12,
+  0x58,
+  0xd6,
+  0x9c,
+  0xf7,
+  0xa2,
+  0xde,
+  0xf9,
+  0xde,
+  0x14,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0,
+  0x10
+]);
+
+function reduce(r) {
+  const x = new Float64Array(64);
+  let i;
+  for (i = 0; i < 64; i++) x[i] = r[i];
+  for (i = 0; i < 64; i++) r[i] = 0;
+  modL(r, x);
+}
+
+function modL(r, x) {
+  let carry, i, j, k;
+  for (i = 63; i >= 32; --i) {
+    carry = 0;
+    for (j = i - 32, k = i - 12; j < k; ++j) {
+      x[j] += carry - 16 * x[i] * L[j - (i - 32)];
+      carry = (x[j] + 128) >> 8;
+      x[j] -= carry * 256;
+    }
+    x[j] += carry;
+    x[i] = 0;
+  }
+  carry = 0;
+  for (j = 0; j < 32; j++) {
+    x[j] += carry - (x[31] >> 4) * L[j];
+    carry = x[j] >> 8;
+    x[j] &= 255;
+  }
+  for (j = 0; j < 32; j++) x[j] -= carry * L[j];
+  for (i = 0; i < 32; i++) {
+    x[i + 1] += x[i] >> 8;
+    r[i] = x[i] & 255;
+  }
+}
+
+function scalarbase(p, s) {
+  const q = [gf(), gf(), gf(), gf()];
+  set25519(q[0], X);
+  set25519(q[1], Y);
+  set25519(q[2], gf1);
+  M(q[3], X, Y);
+  scalarmult(p, q, s);
+}
+
+function set25519(r, a) {
+  for (let i = 0; i < 16; i++) r[i] = a[i] | 0;
+}
+
+function M(o, a, b) {
+  let v,
+    c,
+    t0 = 0,
+    t1 = 0,
+    t2 = 0,
+    t3 = 0,
+    t4 = 0,
+    t5 = 0,
+    t6 = 0,
+    t7 = 0,
+    t8 = 0,
+    t9 = 0,
+    t10 = 0,
+    t11 = 0,
+    t12 = 0,
+    t13 = 0,
+    t14 = 0,
+    t15 = 0,
+    t16 = 0,
+    t17 = 0,
+    t18 = 0,
+    t19 = 0,
+    t20 = 0,
+    t21 = 0,
+    t22 = 0,
+    t23 = 0,
+    t24 = 0,
+    t25 = 0,
+    t26 = 0,
+    t27 = 0,
+    t28 = 0,
+    t29 = 0,
+    t30 = 0;
+  const b0 = b[0],
+    b1 = b[1],
+    b2 = b[2],
+    b3 = b[3],
+    b4 = b[4],
+    b5 = b[5],
+    b6 = b[6],
+    b7 = b[7],
+    b8 = b[8],
+    b9 = b[9],
+    b10 = b[10],
+    b11 = b[11],
+    b12 = b[12],
+    b13 = b[13],
+    b14 = b[14],
+    b15 = b[15];
+
+  v = a[0];
+  t0 += v * b0;
+  t1 += v * b1;
+  t2 += v * b2;
+  t3 += v * b3;
+  t4 += v * b4;
+  t5 += v * b5;
+  t6 += v * b6;
+  t7 += v * b7;
+  t8 += v * b8;
+  t9 += v * b9;
+  t10 += v * b10;
+  t11 += v * b11;
+  t12 += v * b12;
+  t13 += v * b13;
+  t14 += v * b14;
+  t15 += v * b15;
+  v = a[1];
+  t1 += v * b0;
+  t2 += v * b1;
+  t3 += v * b2;
+  t4 += v * b3;
+  t5 += v * b4;
+  t6 += v * b5;
+  t7 += v * b6;
+  t8 += v * b7;
+  t9 += v * b8;
+  t10 += v * b9;
+  t11 += v * b10;
+  t12 += v * b11;
+  t13 += v * b12;
+  t14 += v * b13;
+  t15 += v * b14;
+  t16 += v * b15;
+  v = a[2];
+  t2 += v * b0;
+  t3 += v * b1;
+  t4 += v * b2;
+  t5 += v * b3;
+  t6 += v * b4;
+  t7 += v * b5;
+  t8 += v * b6;
+  t9 += v * b7;
+  t10 += v * b8;
+  t11 += v * b9;
+  t12 += v * b10;
+  t13 += v * b11;
+  t14 += v * b12;
+  t15 += v * b13;
+  t16 += v * b14;
+  t17 += v * b15;
+  v = a[3];
+  t3 += v * b0;
+  t4 += v * b1;
+  t5 += v * b2;
+  t6 += v * b3;
+  t7 += v * b4;
+  t8 += v * b5;
+  t9 += v * b6;
+  t10 += v * b7;
+  t11 += v * b8;
+  t12 += v * b9;
+  t13 += v * b10;
+  t14 += v * b11;
+  t15 += v * b12;
+  t16 += v * b13;
+  t17 += v * b14;
+  t18 += v * b15;
+  v = a[4];
+  t4 += v * b0;
+  t5 += v * b1;
+  t6 += v * b2;
+  t7 += v * b3;
+  t8 += v * b4;
+  t9 += v * b5;
+  t10 += v * b6;
+  t11 += v * b7;
+  t12 += v * b8;
+  t13 += v * b9;
+  t14 += v * b10;
+  t15 += v * b11;
+  t16 += v * b12;
+  t17 += v * b13;
+  t18 += v * b14;
+  t19 += v * b15;
+  v = a[5];
+  t5 += v * b0;
+  t6 += v * b1;
+  t7 += v * b2;
+  t8 += v * b3;
+  t9 += v * b4;
+  t10 += v * b5;
+  t11 += v * b6;
+  t12 += v * b7;
+  t13 += v * b8;
+  t14 += v * b9;
+  t15 += v * b10;
+  t16 += v * b11;
+  t17 += v * b12;
+  t18 += v * b13;
+  t19 += v * b14;
+  t20 += v * b15;
+  v = a[6];
+  t6 += v * b0;
+  t7 += v * b1;
+  t8 += v * b2;
+  t9 += v * b3;
+  t10 += v * b4;
+  t11 += v * b5;
+  t12 += v * b6;
+  t13 += v * b7;
+  t14 += v * b8;
+  t15 += v * b9;
+  t16 += v * b10;
+  t17 += v * b11;
+  t18 += v * b12;
+  t19 += v * b13;
+  t20 += v * b14;
+  t21 += v * b15;
+  v = a[7];
+  t7 += v * b0;
+  t8 += v * b1;
+  t9 += v * b2;
+  t10 += v * b3;
+  t11 += v * b4;
+  t12 += v * b5;
+  t13 += v * b6;
+  t14 += v * b7;
+  t15 += v * b8;
+  t16 += v * b9;
+  t17 += v * b10;
+  t18 += v * b11;
+  t19 += v * b12;
+  t20 += v * b13;
+  t21 += v * b14;
+  t22 += v * b15;
+  v = a[8];
+  t8 += v * b0;
+  t9 += v * b1;
+  t10 += v * b2;
+  t11 += v * b3;
+  t12 += v * b4;
+  t13 += v * b5;
+  t14 += v * b6;
+  t15 += v * b7;
+  t16 += v * b8;
+  t17 += v * b9;
+  t18 += v * b10;
+  t19 += v * b11;
+  t20 += v * b12;
+  t21 += v * b13;
+  t22 += v * b14;
+  t23 += v * b15;
+  v = a[9];
+  t9 += v * b0;
+  t10 += v * b1;
+  t11 += v * b2;
+  t12 += v * b3;
+  t13 += v * b4;
+  t14 += v * b5;
+  t15 += v * b6;
+  t16 += v * b7;
+  t17 += v * b8;
+  t18 += v * b9;
+  t19 += v * b10;
+  t20 += v * b11;
+  t21 += v * b12;
+  t22 += v * b13;
+  t23 += v * b14;
+  t24 += v * b15;
+  v = a[10];
+  t10 += v * b0;
+  t11 += v * b1;
+  t12 += v * b2;
+  t13 += v * b3;
+  t14 += v * b4;
+  t15 += v * b5;
+  t16 += v * b6;
+  t17 += v * b7;
+  t18 += v * b8;
+  t19 += v * b9;
+  t20 += v * b10;
+  t21 += v * b11;
+  t22 += v * b12;
+  t23 += v * b13;
+  t24 += v * b14;
+  t25 += v * b15;
+  v = a[11];
+  t11 += v * b0;
+  t12 += v * b1;
+  t13 += v * b2;
+  t14 += v * b3;
+  t15 += v * b4;
+  t16 += v * b5;
+  t17 += v * b6;
+  t18 += v * b7;
+  t19 += v * b8;
+  t20 += v * b9;
+  t21 += v * b10;
+  t22 += v * b11;
+  t23 += v * b12;
+  t24 += v * b13;
+  t25 += v * b14;
+  t26 += v * b15;
+  v = a[12];
+  t12 += v * b0;
+  t13 += v * b1;
+  t14 += v * b2;
+  t15 += v * b3;
+  t16 += v * b4;
+  t17 += v * b5;
+  t18 += v * b6;
+  t19 += v * b7;
+  t20 += v * b8;
+  t21 += v * b9;
+  t22 += v * b10;
+  t23 += v * b11;
+  t24 += v * b12;
+  t25 += v * b13;
+  t26 += v * b14;
+  t27 += v * b15;
+  v = a[13];
+  t13 += v * b0;
+  t14 += v * b1;
+  t15 += v * b2;
+  t16 += v * b3;
+  t17 += v * b4;
+  t18 += v * b5;
+  t19 += v * b6;
+  t20 += v * b7;
+  t21 += v * b8;
+  t22 += v * b9;
+  t23 += v * b10;
+  t24 += v * b11;
+  t25 += v * b12;
+  t26 += v * b13;
+  t27 += v * b14;
+  t28 += v * b15;
+  v = a[14];
+  t14 += v * b0;
+  t15 += v * b1;
+  t16 += v * b2;
+  t17 += v * b3;
+  t18 += v * b4;
+  t19 += v * b5;
+  t20 += v * b6;
+  t21 += v * b7;
+  t22 += v * b8;
+  t23 += v * b9;
+  t24 += v * b10;
+  t25 += v * b11;
+  t26 += v * b12;
+  t27 += v * b13;
+  t28 += v * b14;
+  t29 += v * b15;
+  v = a[15];
+  t15 += v * b0;
+  t16 += v * b1;
+  t17 += v * b2;
+  t18 += v * b3;
+  t19 += v * b4;
+  t20 += v * b5;
+  t21 += v * b6;
+  t22 += v * b7;
+  t23 += v * b8;
+  t24 += v * b9;
+  t25 += v * b10;
+  t26 += v * b11;
+  t27 += v * b12;
+  t28 += v * b13;
+  t29 += v * b14;
+  t30 += v * b15;
+
+  t0 += 38 * t16;
+  t1 += 38 * t17;
+  t2 += 38 * t18;
+  t3 += 38 * t19;
+  t4 += 38 * t20;
+  t5 += 38 * t21;
+  t6 += 38 * t22;
+  t7 += 38 * t23;
+  t8 += 38 * t24;
+  t9 += 38 * t25;
+  t10 += 38 * t26;
+  t11 += 38 * t27;
+  t12 += 38 * t28;
+  t13 += 38 * t29;
+  t14 += 38 * t30;
+  // t15 left as is
+
+  // first car
+  c = 1;
+  v = t0 + c + 65535;
+  c = Math.floor(v / 65536);
+  t0 = v - c * 65536;
+  v = t1 + c + 65535;
+  c = Math.floor(v / 65536);
+  t1 = v - c * 65536;
+  v = t2 + c + 65535;
+  c = Math.floor(v / 65536);
+  t2 = v - c * 65536;
+  v = t3 + c + 65535;
+  c = Math.floor(v / 65536);
+  t3 = v - c * 65536;
+  v = t4 + c + 65535;
+  c = Math.floor(v / 65536);
+  t4 = v - c * 65536;
+  v = t5 + c + 65535;
+  c = Math.floor(v / 65536);
+  t5 = v - c * 65536;
+  v = t6 + c + 65535;
+  c = Math.floor(v / 65536);
+  t6 = v - c * 65536;
+  v = t7 + c + 65535;
+  c = Math.floor(v / 65536);
+  t7 = v - c * 65536;
+  v = t8 + c + 65535;
+  c = Math.floor(v / 65536);
+  t8 = v - c * 65536;
+  v = t9 + c + 65535;
+  c = Math.floor(v / 65536);
+  t9 = v - c * 65536;
+  v = t10 + c + 65535;
+  c = Math.floor(v / 65536);
+  t10 = v - c * 65536;
+  v = t11 + c + 65535;
+  c = Math.floor(v / 65536);
+  t11 = v - c * 65536;
+  v = t12 + c + 65535;
+  c = Math.floor(v / 65536);
+  t12 = v - c * 65536;
+  v = t13 + c + 65535;
+  c = Math.floor(v / 65536);
+  t13 = v - c * 65536;
+  v = t14 + c + 65535;
+  c = Math.floor(v / 65536);
+  t14 = v - c * 65536;
+  v = t15 + c + 65535;
+  c = Math.floor(v / 65536);
+  t15 = v - c * 65536;
+  t0 += c - 1 + 37 * (c - 1);
+
+  // second car
+  c = 1;
+  v = t0 + c + 65535;
+  c = Math.floor(v / 65536);
+  t0 = v - c * 65536;
+  v = t1 + c + 65535;
+  c = Math.floor(v / 65536);
+  t1 = v - c * 65536;
+  v = t2 + c + 65535;
+  c = Math.floor(v / 65536);
+  t2 = v - c * 65536;
+  v = t3 + c + 65535;
+  c = Math.floor(v / 65536);
+  t3 = v - c * 65536;
+  v = t4 + c + 65535;
+  c = Math.floor(v / 65536);
+  t4 = v - c * 65536;
+  v = t5 + c + 65535;
+  c = Math.floor(v / 65536);
+  t5 = v - c * 65536;
+  v = t6 + c + 65535;
+  c = Math.floor(v / 65536);
+  t6 = v - c * 65536;
+  v = t7 + c + 65535;
+  c = Math.floor(v / 65536);
+  t7 = v - c * 65536;
+  v = t8 + c + 65535;
+  c = Math.floor(v / 65536);
+  t8 = v - c * 65536;
+  v = t9 + c + 65535;
+  c = Math.floor(v / 65536);
+  t9 = v - c * 65536;
+  v = t10 + c + 65535;
+  c = Math.floor(v / 65536);
+  t10 = v - c * 65536;
+  v = t11 + c + 65535;
+  c = Math.floor(v / 65536);
+  t11 = v - c * 65536;
+  v = t12 + c + 65535;
+  c = Math.floor(v / 65536);
+  t12 = v - c * 65536;
+  v = t13 + c + 65535;
+  c = Math.floor(v / 65536);
+  t13 = v - c * 65536;
+  v = t14 + c + 65535;
+  c = Math.floor(v / 65536);
+  t14 = v - c * 65536;
+  v = t15 + c + 65535;
+  c = Math.floor(v / 65536);
+  t15 = v - c * 65536;
+  t0 += c - 1 + 37 * (c - 1);
+
+  o[0] = t0;
+  o[1] = t1;
+  o[2] = t2;
+  o[3] = t3;
+  o[4] = t4;
+  o[5] = t5;
+  o[6] = t6;
+  o[7] = t7;
+  o[8] = t8;
+  o[9] = t9;
+  o[10] = t10;
+  o[11] = t11;
+  o[12] = t12;
+  o[13] = t13;
+  o[14] = t14;
+  o[15] = t15;
+}
+
+function scalarmult(p, q, s) {
+  let b, i;
+  set25519(p[0], gf0);
+  set25519(p[1], gf1);
+  set25519(p[2], gf1);
+  set25519(p[3], gf0);
+  for (i = 255; i >= 0; --i) {
+    b = (s[(i / 8) | 0] >> (i & 7)) & 1;
+    cswap(p, q, b);
+    add(q, p);
+    add(p, p);
+    cswap(p, q, b);
+  }
+}
+
+function pack(r, p) {
+  const tx = gf(),
+    ty = gf(),
+    zi = gf();
+  inv25519(zi, p[2]);
+  M(tx, p[0], zi);
+  M(ty, p[1], zi);
+  pack25519(r, ty);
+  r[31] ^= par25519(tx) << 7;
+}
+
+function inv25519(o, i) {
+  const c = gf();
+  let a;
+  for (a = 0; a < 16; a++) c[a] = i[a];
+  for (a = 253; a >= 0; a--) {
+    S(c, c);
+    if (a !== 2 && a !== 4) M(c, c, i);
+  }
+  for (a = 0; a < 16; a++) o[a] = c[a];
+}
+
+function S(o, a) {
+  M(o, a, a);
+}
+
+function par25519(a) {
+  const d = new Uint8Array(32);
+  pack25519(d, a);
+  return d[0] & 1;
+}
+function car25519(o) {
+  let i,
+    v,
+    c = 1;
+  for (i = 0; i < 16; i++) {
+    v = o[i] + c + 65535;
+    c = Math.floor(v / 65536);
+    o[i] = v - c * 65536;
+  }
+  o[0] += c - 1 + 37 * (c - 1);
+}
+
+function pack25519(o, n) {
+  let i, j, b;
+  const m = gf(),
+    t = gf();
+  for (i = 0; i < 16; i++) t[i] = n[i];
+  car25519(t);
+  car25519(t);
+  car25519(t);
+  for (j = 0; j < 2; j++) {
+    m[0] = t[0] - 0xffed;
+    for (i = 1; i < 15; i++) {
+      m[i] = t[i] - 0xffff - ((m[i - 1] >> 16) & 1);
+      m[i - 1] &= 0xffff;
+    }
+    m[15] = t[15] - 0x7fff - ((m[14] >> 16) & 1);
+    b = (m[15] >> 16) & 1;
+    m[14] &= 0xffff;
+    sel25519(t, m, 1 - b);
+  }
+  for (i = 0; i < 16; i++) {
+    o[2 * i] = t[i] & 0xff;
+    o[2 * i + 1] = t[i] >> 8;
+  }
+}
+
+function cswap(p, q, b) {
+  for (let i = 0; i < 4; i++) {
+    sel25519(p[i], q[i], b);
+  }
+}
+
+function A(o, a, b) {
+  for (let i = 0; i < 16; i++) o[i] = a[i] + b[i];
+}
+
+function Z(o, a, b) {
+  for (let i = 0; i < 16; i++) o[i] = a[i] - b[i];
+}
+
+function add(p, q) {
+  const a = gf(),
+    b = gf(),
+    c = gf(),
+    d = gf(),
+    e = gf(),
+    f = gf(),
+    g = gf(),
+    h = gf(),
+    t = gf();
+
+  Z(a, p[1], p[0]);
+  Z(t, q[1], q[0]);
+  M(a, a, t);
+  A(b, p[0], p[1]);
+  A(t, q[0], q[1]);
+  M(b, b, t);
+  M(c, p[3], q[3]);
+  M(c, c, D2);
+  M(d, p[2], q[2]);
+  A(d, d, d);
+  Z(e, b, a);
+  Z(f, d, c);
+  A(g, d, c);
+  A(h, b, a);
+
+  M(p[0], e, f);
+  M(p[1], h, g);
+  M(p[2], g, f);
+  M(p[3], e, h);
+}
+
+function sel25519(p, q, b) {
+  const c = ~(b - 1);
+  let t;
+  for (let i = 0; i < 16; i++) {
+    t = c & (p[i] ^ q[i]);
+    p[i] ^= t;
+    q[i] ^= t;
+  }
+}
+
+module.exports = Ed25519PasswordAuth;

node_modules/mariadb/lib/cmd/handshake/auth/native-password-auth.js

@@ -0,0 +1,55 @@
+'use strict';
+
+const PluginAuth = require('./plugin-auth');
+const Crypto = require('crypto');
+
+/**
+ * Standard authentication plugin
+ */
+class NativePasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.pluginData = pluginData;
+    this.sequenceNo = packSeq;
+    this.compressSequenceNo = compressPackSeq;
+  }
+
+  start(out, opts, info) {
+    //seed is ended with a null byte value.
+    const data = this.pluginData.slice(0, 20);
+    let authToken = NativePasswordAuth.encryptPassword(opts.password, data, 'sha1');
+
+    out.startPacket(this);
+    if (authToken.length > 0) {
+      out.writeBuffer(authToken, 0, authToken.length);
+      out.flushBuffer(true);
+    } else {
+      out.writeEmptyPacket(true);
+    }
+    this.emit('send_end');
+    this.onPacketReceive = this.successSend;
+  }
+
+  static encryptPassword(password, seed, algorithm) {
+    if (!password) return Buffer.alloc(0);
+
+    let hash = Crypto.createHash(algorithm);
+    let stage1 = hash.update(password, 'utf8').digest();
+    hash = Crypto.createHash(algorithm);
+
+    let stage2 = hash.update(stage1).digest();
+    hash = Crypto.createHash(algorithm);
+
+    hash.update(seed);
+    hash.update(stage2);
+
+    let digest = hash.digest();
+    let returnBytes = Buffer.allocUnsafe(digest.length);
+    for (let i = 0; i < digest.length; i++) {
+      returnBytes[i] = stage1[i] ^ digest[i];
+    }
+    return returnBytes;
+  }
+}
+
+module.exports = NativePasswordAuth;

node_modules/mariadb/lib/cmd/handshake/auth/pam-password-auth.js

@@ -0,0 +1,58 @@
+const PluginAuth = require('./plugin-auth');
+
+/**
+ * Use PAM authentication
+ */
+class PamPasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.pluginData = pluginData;
+    this.sequenceNo = packSeq;
+    this.counter = 0;
+  }
+
+  start(out, opts, info) {
+    this.exchange(this.pluginData, out, opts, info);
+    this.onPacketReceive = this.response;
+  }
+
+  exchange(buffer, out, opts, info) {
+    //conversation is :
+    // - first byte is information tell if question is a password (4) or clear text (2).
+    // - other bytes are the question to user
+
+    out.startPacket(this);
+
+    let pwd;
+    if (Array.isArray(opts.password)) {
+      pwd = opts.password[this.counter];
+      this.counter++;
+    } else {
+      pwd = opts.password;
+    }
+
+    if (pwd) out.writeString(pwd);
+    out.writeInt8(0);
+    out.flushBuffer(true);
+  }
+
+  response(packet, out, opts, info) {
+    const marker = packet.peek();
+    switch (marker) {
+      //*********************************************************************************************************
+      //* OK_Packet and Err_Packet ending packet
+      //*********************************************************************************************************
+      case 0x00:
+      case 0xff:
+        this.emit('send_end');
+        return this.successSend(packet, out, opts, info);
+
+      default:
+        let promptData = packet.readBuffer();
+        this.exchange(promptData, out, opts, info);
+        this.onPacketReceive = this.response;
+    }
+  }
+}
+
+module.exports = PamPasswordAuth;

node_modules/mariadb/lib/cmd/handshake/auth/plugin-auth.js

@@ -0,0 +1,19 @@
+'use strict';
+
+const Command = require('../../command');
+
+/**
+ * Base authentication plugin
+ */
+class PluginAuth extends Command {
+  constructor(resolve, reject, multiAuthResolver) {
+    super(resolve, reject);
+    this.multiAuthResolver = multiAuthResolver;
+  }
+
+  successSend(packet, out, opts, info) {
+    this.multiAuthResolver(packet, out, opts, info);
+  }
+}
+
+module.exports = PluginAuth;

node_modules/mariadb/lib/cmd/handshake/auth/sha256-password-auth.js

@@ -0,0 +1,142 @@
+const PluginAuth = require('./plugin-auth');
+const fs = require('fs');
+const crypto = require('crypto');
+const Errors = require('../../../misc/errors');
+
+/**
+ * Use Sha256 authentication
+ */
+class Sha256PasswordAuth extends PluginAuth {
+  constructor(packSeq, compressPackSeq, pluginData, resolve, reject, multiAuthResolver) {
+    super(resolve, reject, multiAuthResolver);
+    this.pluginData = pluginData;
+    this.sequenceNo = packSeq;
+    this.counter = 0;
+    this.initialState = true;
+  }
+
+  start(out, opts, info) {
+    this.exchange(this.pluginData, out, opts, info);
+    this.onPacketReceive = this.response;
+  }
+
+  exchange(buffer, out, opts, info) {
+    if (this.initialState) {
+      if (!opts.password) {
+        out.startPacket(this);
+        out.writeEmptyPacket(true);
+        return;
+      } else if (opts.ssl) {
+        // using SSL, so sending password in clear
+        out.startPacket(this);
+        if (opts.password) {
+          out.writeString(opts.password);
+        }
+        out.writeInt8(0);
+        out.flushBuffer(true);
+        return;
+      } else {
+        // retrieve public key from configuration or from server
+        if (opts.rsaPublicKey) {
+          try {
+            let key = opts.rsaPublicKey;
+            if (!key.includes('-----BEGIN')) {
+              // rsaPublicKey contain path
+              key = fs.readFileSync(key, 'utf8');
+            }
+            this.publicKey = Sha256PasswordAuth.retreivePublicKey(key);
+          } catch (err) {
+            return this.throwError(err, info);
+          }
+        } else {
+          if (!opts.allowPublicKeyRetrieval) {
+            return this.throwError(
+              Errors.createError(
+                'RSA public key is not available client side. Either set option `rsaPublicKey` to indicate' +
+                  ' public key path, or allow public key retrieval with option `allowPublicKeyRetrieval`',
+
+                true,
+                info,
+                '08S01',
+                Errors.ER_CANNOT_RETRIEVE_RSA_KEY
+              ),
+              info
+            );
+          }
+          this.initialState = false;
+
+          // ask public Key Retrieval
+          out.startPacket(this);
+          out.writeInt8(0x01);
+          out.flushBuffer(true);
+          return;
+        }
+      }
+
+      // send Sha256Password Packet
+      Sha256PasswordAuth.sendSha256PwdPacket(
+        this,
+        this.pluginData,
+        this.publicKey,
+        opts.password,
+        out
+      );
+    } else {
+      // has request public key
+      this.publicKey = Sha256PasswordAuth.retreivePublicKey(buffer.toString('utf8', 1));
+      Sha256PasswordAuth.sendSha256PwdPacket(
+        this,
+        this.pluginData,
+        this.publicKey,
+        opts.password,
+        out
+      );
+    }
+  }
+
+  static retreivePublicKey(key) {
+    return key.replace('(-+BEGIN PUBLIC KEY-+\\r?\\n|\\n?-+END PUBLIC KEY-+\\r?\\n?)', '');
+  }
+
+  static sendSha256PwdPacket(cmd, pluginData, publicKey, password, out) {
+    const truncatedSeed = pluginData.slice(0, pluginData.length - 1);
+    out.startPacket(cmd);
+    const enc = Sha256PasswordAuth.encrypt(truncatedSeed, password, publicKey);
+    out.writeBuffer(enc, 0, enc.length);
+    out.flushBuffer(cmd);
+  }
+
+  // encrypt password with public key
+  static encrypt(seed, password, publicKey) {
+    const nullFinishedPwd = Buffer.from(password + '\0');
+    const xorBytes = Buffer.allocUnsafe(nullFinishedPwd.length);
+    const seedLength = seed.length;
+    for (let i = 0; i < xorBytes.length; i++) {
+      xorBytes[i] = nullFinishedPwd[i] ^ seed[i % seedLength];
+    }
+    return crypto.publicEncrypt(
+      { key: publicKey, padding: crypto.constants.RSA_PKCS1_OAEP_PADDING },
+      xorBytes
+    );
+  }
+
+  response(packet, out, opts, info) {
+    const marker = packet.peek();
+    switch (marker) {
+      //*********************************************************************************************************
+      //* OK_Packet and Err_Packet ending packet
+      //*********************************************************************************************************
+      case 0x00:
+      case 0xff:
+        this.emit('send_end');
+        return this.successSend(packet, out, opts, info);
+
+      default:
+        let promptData = packet.readBufferRemaining();
+        this.exchange(promptData, out, opts, info);
+        this.onPacketReceive = this.response;
+    }
+  }
+}
+
+module.exports = Sha256PasswordAuth;

node_modules/mariadb/lib/cmd/handshake/client-capabilities.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const Capabilities = require('../../const/capabilities');
+
+/**
+ * Initialize client capabilities according to options and server capabilities
+ *
+ * @param opts                options
+ * @param info                information
+ */
+module.exports.init = function (opts, info) {
+  let capabilities =
+    Capabilities.IGNORE_SPACE |
+    Capabilities.PROTOCOL_41 |
+    Capabilities.TRANSACTIONS |
+    Capabilities.SECURE_CONNECTION |
+    Capabilities.MULTI_RESULTS |
+    Capabilities.PS_MULTI_RESULTS |
+    Capabilities.SESSION_TRACK |
+    Capabilities.PLUGIN_AUTH_LENENC_CLIENT_DATA;
+
+  if ((info.serverCapabilities & Capabilities.MYSQL) === BigInt(0)) {
+    capabilities |= Capabilities.MARIADB_CLIENT_EXTENDED_TYPE_INFO;
+  }
+
+  if (info.serverCapabilities & Capabilities.PLUGIN_AUTH) {
+    capabilities |= Capabilities.PLUGIN_AUTH;
+  }
+
+  if (opts.connectAttributes && info.serverCapabilities & Capabilities.CONNECT_ATTRS) {
+    capabilities |= Capabilities.CONNECT_ATTRS;
+  }
+
+  if (opts.foundRows) {
+    capabilities |= Capabilities.FOUND_ROWS;
+  }
+
+  if (opts.permitLocalInfile) {
+    capabilities |= Capabilities.LOCAL_FILES;
+  }
+
+  if (opts.multipleStatements) {
+    capabilities |= Capabilities.MULTI_STATEMENTS;
+  }
+
+  info.eofDeprecated = (info.serverCapabilities & Capabilities.DEPRECATE_EOF) > 0;
+  if (info.eofDeprecated) {
+    capabilities |= Capabilities.DEPRECATE_EOF;
+  }
+
+  if (opts.database && info.serverCapabilities & Capabilities.CONNECT_WITH_DB) {
+    capabilities |= Capabilities.CONNECT_WITH_DB;
+  }
+
+  // use compression only if requested by client and supported by server
+  if (opts.compress) {
+    if (info.serverCapabilities & Capabilities.COMPRESS) {
+      capabilities |= Capabilities.COMPRESS;
+    } else {
+      opts.compress = false;
+    }
+  }
+
+  if (opts.bulk) {
+    if (info.serverCapabilities & Capabilities.MARIADB_CLIENT_STMT_BULK_OPERATIONS) {
+      capabilities |= Capabilities.MARIADB_CLIENT_STMT_BULK_OPERATIONS;
+    }
+  }
+
+  if (opts.permitConnectionWhenExpired) {
+    capabilities |= Capabilities.CAN_HANDLE_EXPIRED_PASSWORDS;
+  }
+  info.clientCapabilities = capabilities;
+};

node_modules/mariadb/lib/cmd/handshake/client-handshake-response.js

@@ -0,0 +1,126 @@
+'use strict';
+
+const Capabilities = require('../../const/capabilities');
+const Iconv = require('iconv-lite');
+const NativePasswordAuth = require('./auth/native-password-auth');
+const Ed25519PasswordAuth = require('./auth/ed25519-password-auth');
+const driverVersion = require('../../../package.json').version;
+const os = require('os');
+
+/**
+ * Send Handshake response packet
+ * see https://mariadb.com/kb/en/library/1-connecting-connecting/#handshake-response-packet
+ *
+ * @param cmd         current handshake command
+ * @param out         output writer
+ * @param opts        connection options
+ * @param pluginName  plugin name
+ * @param info        connection information
+ */
+module.exports.send = function send(cmd, out, opts, pluginName, info) {
+  out.startPacket(cmd);
+  info.defaultPluginName = pluginName;
+  const pwd = Array.isArray(opts.password) ? opts.password[0] : opts.password;
+  let authToken;
+  let authPlugin;
+  switch (pluginName) {
+    case 'client_ed25519':
+      authToken = Ed25519PasswordAuth.encryptPassword(pwd, info.seed);
+      authPlugin = 'client_ed25519';
+      break;
+
+    case 'mysql_clear_password':
+      authToken = Buffer.from(pwd);
+      authPlugin = 'mysql_clear_password';
+      break;
+
+    default:
+      authToken = NativePasswordAuth.encryptPassword(pwd, info.seed, 'sha1');
+      authPlugin = 'mysql_native_password';
+      break;
+  }
+  out.writeInt32(Number(info.clientCapabilities & BigInt(0xffffffff)));
+  out.writeInt32(1024 * 1024 * 1024); // max packet size
+  out.writeInt8(opts.collation.index);
+  for (let i = 0; i < 19; i++) {
+    out.writeInt8(0);
+  }
+
+  out.writeInt32(Number(info.clientCapabilities >> BigInt(32)));
+
+  //null encoded user
+  out.writeString(opts.user || '');
+  out.writeInt8(0);
+
+  if (info.serverCapabilities & Capabilities.PLUGIN_AUTH_LENENC_CLIENT_DATA) {
+    out.writeLengthCoded(authToken.length);
+    out.writeBuffer(authToken, 0, authToken.length);
+  } else if (info.serverCapabilities & Capabilities.SECURE_CONNECTION) {
+    out.writeInt8(authToken.length);
+    out.writeBuffer(authToken, 0, authToken.length);
+  } else {
+    out.writeBuffer(authToken, 0, authToken.length);
+    out.writeInt8(0);
+  }
+
+  if (info.clientCapabilities & Capabilities.CONNECT_WITH_DB) {
+    out.writeString(opts.database);
+    out.writeInt8(0);
+    info.database = opts.database;
+  }
+
+  if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
+    out.writeString(authPlugin);
+    out.writeInt8(0);
+  }
+
+  if (info.clientCapabilities & Capabilities.CONNECT_ATTRS) {
+    out.writeInt8(0xfc);
+    let initPos = out.pos; //save position, assuming connection attributes length will be less than 2 bytes length
+    out.writeInt16(0);
+
+    const encoding = opts.collation.charset;
+
+    writeParam(out, '_client_name', encoding);
+    writeParam(out, 'MariaDB connector/Node', encoding);
+
+    writeParam(out, '_client_version', encoding);
+    writeParam(out, driverVersion, encoding);
+
+    const address = cmd.getSocket().address().address;
+    if (address) {
+      writeParam(out, '_server_host', encoding);
+      writeParam(out, address, encoding);
+    }
+
+    writeParam(out, '_os', encoding);
+    writeParam(out, process.platform, encoding);
+
+    writeParam(out, '_client_host', encoding);
+    writeParam(out, os.hostname(), encoding);
+
+    writeParam(out, '_node_version', encoding);
+    writeParam(out, process.versions.node, encoding);
+
+    if (opts.connectAttributes !== true) {
+      let attrNames = Object.keys(opts.connectAttributes);
+      for (let k = 0; k < attrNames.length; ++k) {
+        writeParam(out, attrNames[k], encoding);
+        writeParam(out, opts.connectAttributes[attrNames[k]], encoding);
+      }
+    }
+
+    //write end size
+    out.writeInt16AtPos(initPos);
+  }
+
+  out.flushBuffer(true);
+};
+
+function writeParam(out, val, encoding) {
+  let param = Buffer.isEncoding(encoding)
+    ? Buffer.from(val, encoding)
+    : Iconv.encode(val, encoding);
+  out.writeLengthCoded(param.length);
+  out.writeBuffer(param, 0, param.length);
+}

node_modules/mariadb/lib/cmd/handshake/handshake.js

@@ -0,0 +1,287 @@
+'use strict';
+
+const Command = require('../command');
+const InitialHandshake = require('./initial-handshake');
+const ClientHandshakeResponse = require('./client-handshake-response');
+const SslRequest = require('./ssl-request');
+const ClientCapabilities = require('./client-capabilities');
+const Errors = require('../../misc/errors');
+const Capabilities = require('../../const/capabilities');
+const process = require('process');
+
+/**
+ * Handle handshake.
+ * see https://mariadb.com/kb/en/library/1-connecting-connecting/
+ */
+class Handshake extends Command {
+  constructor(resolve, reject, _createSecureContext, _addCommand, getSocket) {
+    super(resolve, reject);
+    this._createSecureContext = _createSecureContext;
+    this._addCommand = _addCommand;
+    this.getSocket = getSocket;
+    this.onPacketReceive = this.parseHandshakeInit;
+    this.plugin = this;
+  }
+
+  ensureOptionCompatibility(opts, info) {
+    if (
+      opts.multipleStatements &&
+      (info.serverCapabilities & Capabilities.MULTI_STATEMENTS) === 0
+    ) {
+      return this.throwNewError(
+        "Option `multipleStatements` enable, but server doesn'permits multi-statment",
+        true,
+        info,
+        '08S01',
+        Errors.ER_CLIENT_OPTION_INCOMPATIBILITY
+      );
+    }
+
+    if (opts.permitLocalInfile && (info.serverCapabilities & Capabilities.LOCAL_FILES) === 0) {
+      return this.throwNewError(
+        "Option `permitLocalInfile` enable, but server doesn'permits using local file",
+        true,
+        info,
+        '08S01',
+        Errors.ER_CLIENT_OPTION_INCOMPATIBILITY
+      );
+    }
+  }
+
+  parseHandshakeInit(packet, out, opts, info) {
+    if (packet.peek() === 0xff) {
+      //in case that some host is not permit to connect server
+      const authErr = packet.readError(info);
+      authErr.fatal = true;
+      return this.throwError(authErr, info);
+    }
+
+    let handshake = new InitialHandshake(packet, info);
+    this.ensureOptionCompatibility(opts, info);
+    ClientCapabilities.init(opts, info);
+
+    if (opts.ssl) {
+      if (info.serverCapabilities & Capabilities.SSL) {
+        info.clientCapabilities |= Capabilities.SSL;
+        SslRequest.send(this, out, info, opts);
+        this._createSecureContext(
+          function () {
+            ClientHandshakeResponse.send(this, out, opts, handshake.pluginName, info);
+          }.bind(this)
+        );
+      } else {
+        return this.throwNewError(
+          'Trying to connect with ssl, but ssl not enabled in the server',
+          true,
+          info,
+          '08S01',
+          Errors.ER_SERVER_SSL_DISABLED
+        );
+      }
+    } else {
+      ClientHandshakeResponse.send(this, out, opts, handshake.pluginName, info);
+    }
+    this.onPacketReceive = this.handshakeResult;
+  }
+
+  /**
+   * Fast-path handshake results :
+   *  - if plugin was the one expected by server, server will send OK_Packet / ERR_Packet.
+   *  - if not, server send an AuthSwitchRequest packet, indicating the specific PLUGIN to use with this user.
+   *    dispatching to plugin handler then.
+   *
+   * @param packet    current packet
+   * @param out       output buffer
+   * @param opts      options
+   * @param info      connection info
+   * @returns {*}     return null if authentication succeed, depending on plugin conversation if not finished
+   */
+  handshakeResult(packet, out, opts, info) {
+    const marker = packet.peek();
+    switch (marker) {
+      //*********************************************************************************************************
+      //* AuthSwitchRequest packet
+      //*********************************************************************************************************
+      case 0xfe:
+        this.plugin.onPacketReceive = null;
+        this.plugin.emit('send_end');
+        this.plugin.emit('end');
+        this.dispatchAuthSwitchRequest(packet, out, opts, info);
+        return;
+
+      //*********************************************************************************************************
+      //* OK_Packet - authentication succeeded
+      //*********************************************************************************************************
+      case 0x00:
+        packet.skip(1); //skip header
+        packet.skipLengthCodedNumber(); //skip affected rows
+        packet.skipLengthCodedNumber(); //skip last insert id
+        info.status = packet.readUInt16();
+        this.plugin.emit('send_end');
+        return this.plugin.successEnd();
+
+      //*********************************************************************************************************
+      //* ERR_Packet
+      //*********************************************************************************************************
+      case 0xff:
+        const authErr = packet.readError(info, this.displaySql());
+        authErr.fatal = true;
+        return this.plugin.throwError(authErr, info);
+
+      //*********************************************************************************************************
+      //* unexpected
+      //*********************************************************************************************************
+      default:
+        this.throwNewError(
+          'Unexpected type of packet during handshake phase : ' + marker,
+          true,
+          info,
+          '42000',
+          Errors.ER_AUTHENTICATION_BAD_PACKET
+        );
+    }
+  }
+
+  /**
+   * Handle authentication switch request : dispatch to plugin handler.
+   *
+   * @param packet  packet
+   * @param out     output writer
+   * @param opts    options
+   * @param info    connection information
+   */
+  dispatchAuthSwitchRequest(packet, out, opts, info) {
+    let pluginName, pluginData;
+    if (info.clientCapabilities & Capabilities.PLUGIN_AUTH) {
+      packet.skip(1); //header
+      if (packet.remaining()) {
+        //AuthSwitchRequest packet.
+        pluginName = packet.readStringNullEnded();
+        pluginData = packet.readBufferRemaining();
+      } else {
+        //OldAuthSwitchRequest
+        pluginName = 'mysql_old_password';
+        pluginData = info.seed.slice(0, 8);
+      }
+    } else {
+      pluginName = packet.readStringNullEnded('cesu8');
+      pluginData = packet.readBufferRemaining();
+    }
+
+    try {
+      this.plugin = Handshake.pluginHandler(
+        pluginName,
+        this.plugin.sequenceNo,
+        this.plugin.compressSequenceNo,
+        pluginData,
+        info,
+        opts,
+        out,
+        this.resolve,
+        this.reject,
+        this.handshakeResult.bind(this)
+      );
+    } catch (err) {
+      this.reject(err);
+      return;
+    }
+
+    if (!this.plugin) {
+      this.reject(
+        Errors.createError(
+          "Client does not support authentication protocol '" +
+            pluginName +
+            "' requested by server. ",
+          true,
+          info,
+          '08004',
+          Errors.ER_AUTHENTICATION_PLUGIN_NOT_SUPPORTED
+        )
+      );
+    } else {
+      this._addCommand(this.plugin, false);
+    }
+  }
+
+  static pluginHandler(
+    pluginName,
+    packSeq,
+    compressPackSeq,
+    pluginData,
+    info,
+    opts,
+    out,
+    authResolve,
+    authReject,
+    multiAuthResolver
+  ) {
+    let pluginAuth;
+    switch (pluginName) {
+      case 'mysql_native_password':
+        pluginAuth = require('./auth/native-password-auth.js');
+        break;
+
+      case 'mysql_clear_password':
+        pluginAuth = require('./auth/clear-password-auth.js');
+        break;
+
+      case 'client_ed25519':
+        pluginAuth = require('./auth/ed25519-password-auth.js');
+        break;
+
+      case 'dialog':
+        pluginAuth = require('./auth/pam-password-auth.js');
+        break;
+
+      case 'sha256_password':
+        if (!Handshake.ensureNodeVersion(11, 6, 0)) {
+          throw Errors.createError(
+            'sha256_password authentication plugin require node 11.6+',
+            true,
+            info,
+            '08004',
+            Errors.ER_MINIMUM_NODE_VERSION_REQUIRED
+          );
+        }
+        pluginAuth = require('./auth/sha256-password-auth.js');
+        break;
+
+      case 'caching_sha2_password':
+        if (!Handshake.ensureNodeVersion(11, 6, 0)) {
+          throw Errors.createError(
+            'caching_sha2_password authentication plugin require node 11.6+',
+            true,
+            info,
+            '08004',
+            Errors.ER_MINIMUM_NODE_VERSION_REQUIRED
+          );
+        }
+        pluginAuth = require('./auth/caching-sha2-password-auth.js');
+        break;
+
+      //TODO "auth_gssapi_client"
+
+      default:
+        return null;
+    }
+    return new pluginAuth(
+      packSeq,
+      compressPackSeq,
+      pluginData,
+      authResolve,
+      authReject,
+      multiAuthResolver
+    );
+  }
+
+  static ensureNodeVersion(major, minor, patch) {
+    const ver = process.versions.node.split('.');
+    return (
+      ver[0] > major ||
+      (ver[0] === major && ver[1] > minor) ||
+      (ver[0] === major && ver[1] === minor && ver[2] >= patch)
+    );
+  }
+}
+
+module.exports = Handshake;

node_modules/mariadb/lib/cmd/handshake/initial-handshake.js

@@ -0,0 +1,74 @@
+'use strict';
+
+const Capabilities = require('../../const/capabilities');
+const ConnectionInformation = require('../../misc/connection-information');
+
+/**
+ * Parser server initial handshake.
+ * see https://mariadb.com/kb/en/library/1-connecting-connecting/#initial-handshake-packet
+ */
+class InitialHandshake {
+  constructor(packet, info) {
+    //protocolVersion
+    packet.skip(1);
+    info.serverVersion = {};
+    info.serverVersion.raw = packet.readStringNullEnded();
+    info.threadId = packet.readUInt32();
+
+    let seed1 = packet.readBuffer(8);
+    packet.skip(1); //reserved byte
+
+    let serverCapabilities = BigInt(packet.readUInt16());
+    //skip characterSet
+    packet.skip(1);
+    info.status = packet.readUInt16();
+    serverCapabilities += BigInt(packet.readUInt16()) << BigInt(16);
+
+    let saltLength = 0;
+    if (serverCapabilities & Capabilities.PLUGIN_AUTH) {
+      saltLength = Math.max(12, packet.readUInt8() - 9);
+    } else {
+      packet.skip(1);
+    }
+    if (serverCapabilities & Capabilities.MYSQL) {
+      packet.skip(10);
+    } else {
+      packet.skip(6);
+      serverCapabilities += BigInt(packet.readUInt32()) << BigInt(32);
+    }
+
+    if (serverCapabilities & Capabilities.SECURE_CONNECTION) {
+      let seed2 = packet.readBuffer(saltLength);
+      info.seed = Buffer.concat([seed1, seed2]);
+    } else {
+      info.seed = seed1;
+    }
+    packet.skip(1);
+    info.serverCapabilities = serverCapabilities;
+
+    /**
+     * check for MariaDB 10.x replication hack , remove fake prefix if needed
+     * MDEV-4088: in 10.0+, the real version string maybe prefixed with "5.5.5-",
+     * to workaround bugs in Oracle MySQL replication
+     **/
+
+    if (info.serverVersion.raw.startsWith('5.5.5-')) {
+      info.serverVersion.mariaDb = true;
+      info.serverVersion.raw = info.serverVersion.raw.substring('5.5.5-'.length);
+    } else {
+      //Support for MDEV-7780 faking server version
+      info.serverVersion.mariaDb =
+        info.serverVersion.raw.includes('MariaDB') ||
+        (serverCapabilities & Capabilities.MYSQL) === BigInt(0);
+    }
+
+    if (serverCapabilities & Capabilities.PLUGIN_AUTH) {
+      this.pluginName = packet.readStringNullEnded();
+    } else {
+      this.pluginName = '';
+    }
+    ConnectionInformation.parseVersionString(info);
+  }
+}
+
+module.exports = InitialHandshake;

node_modules/mariadb/lib/cmd/handshake/ssl-request.js

@@ -0,0 +1,29 @@
+'use strict';
+const Capabilities = require('../../const/capabilities');
+
+/**
+ * Send SSL Request packet.
+ * see : https://mariadb.com/kb/en/library/1-connecting-connecting/#sslrequest-packet
+ *
+ * @param cmd     current command
+ * @param out     output writer
+ * @param info    client information
+ * @param opts    connection options
+ */
+module.exports.send = function sendSSLRequest(cmd, out, info, opts) {
+  out.startPacket(cmd);
+  out.writeInt32(Number(info.clientCapabilities & BigInt(0xffffffff)));
+  out.writeInt32(1024 * 1024 * 1024); // max packet size
+  out.writeInt8(opts.collation.index);
+  for (let i = 0; i < 19; i++) {
+    out.writeInt8(0);
+  }
+
+  if (info.serverCapabilities & Capabilities.MYSQL) {
+    out.writeInt32(0);
+  } else {
+    out.writeInt32(Number(info.clientCapabilities >> BigInt(32)));
+  }
+
+  out.flushBuffer(true);
+};