tests: improve flexibility of auth unit tests

Author: dougwilson

test/FakeServer.js

@@ -12,7 +12,6 @@ var Packets         = common.Packets;
 var PacketWriter    = common.PacketWriter;
 var Parser          = common.Parser;
 var Types           = common.Types;
-var Auth            = require(common.lib + '/protocol/Auth');
 var Errors          = common.Errors;
 var EventEmitter    = require('events').EventEmitter;
 var Util            = require('util');
@@ -75,14 +74,14 @@ function FakeConnection(socket) {
 FakeConnection.prototype.handshake = function(options) {
   this._handshakeOptions = options || {};
 
-  var packetOpiotns = common.extend({
+  var packetOptions = common.extend({
     scrambleBuff1       : Buffer.from('1020304050607080', 'hex'),
     scrambleBuff2       : Buffer.from('0102030405060708090A0B0C', 'hex'),
     serverCapabilities1 : 512, // only 1 flag, PROTOCOL_41
     protocol41          : true
   }, this._handshakeOptions);
 
-  this._handshakeInitializationPacket = new Packets.HandshakeInitializationPacket(packetOpiotns);
+  this._handshakeInitializationPacket = new Packets.HandshakeInitializationPacket(packetOptions);
 
   this._sendPacket(this._handshakeInitializationPacket);
 };
@@ -285,31 +284,14 @@ FakeConnection.prototype._parsePacket = function() {
       this.database = (packet.database || null);
       this.user     = (packet.user || null);
 
-      if (this._handshakeOptions.oldPassword) {
-        this._sendPacket(new Packets.UseOldPasswordPacket());
-      } else if (this._handshakeOptions.authMethodName) {
-        this._sendPacket(new Packets.AuthSwitchRequestPacket(this._handshakeOptions));
-      } else if (this._handshakeOptions.password === 'passwd') {
-        var expected = Buffer.from('3DA0ADA7C9E1BB3A110575DF53306F9D2DE7FD09', 'hex');
-        this._sendAuthResponse(packet.scrambleBuff, expected);
-      } else if (this._handshakeOptions.user || this._handshakeOptions.password) {
-        throw new Error('not implemented');
-      } else {
+      if (!this.emit('clientAuthentication', packet)) {
         this._sendPacket(new Packets.OkPacket());
         this._parser.resetPacketNumber();
       }
       break;
     case Packets.SSLRequestPacket:
       this._startTLS();
       break;
-    case Packets.OldPasswordPacket:
-      var expected = Auth.scramble323(this._handshakeInitializationPacket.scrambleBuff(), this._handshakeOptions.password);
-      this._sendAuthResponse(packet.scrambleBuff, expected);
-      break;
-    case Packets.AuthSwitchResponsePacket:
-      var expected = Auth.token(this._handshakeOptions.password, Buffer.from('00112233445566778899AABBCCDDEEFF01020304', 'hex'));
-      this._sendAuthResponse(packet.data, expected);
-      break;
     case Packets.ComQueryPacket:
       if (!this.emit('query', packet)) {
         this._handleQueryPacket(packet);
@@ -322,6 +304,9 @@ FakeConnection.prototype._parsePacket = function() {
       }
       break;
     case Packets.ComChangeUserPacket:
+      this.database = (packet.database || null);
+      this.user     = (packet.user || null);
+
       if (!this.emit('changeUser', packet)) {
         if (packet.user === 'does-not-exist') {
           this._sendPacket(new Packets.ErrorPacket({
@@ -339,9 +324,6 @@ FakeConnection.prototype._parsePacket = function() {
           break;
         }
 
-        this.database = (packet.database || null);
-        this.user     = (packet.user || null);
-
         this._sendPacket(new Packets.OkPacket());
         this._parser.resetPacketNumber();
       }
@@ -352,7 +334,9 @@ FakeConnection.prototype._parsePacket = function() {
       }
       break;
     default:
-      throw new Error('Unexpected packet: ' + Packet.name);
+      if (!this.emit(packet.constructor.name, packet)) {
+        throw new Error('Unexpected packet: ' + Packet.name);
+      }
   }
 };
 

test/unit/connection/test-auth-switch-native.js

@@ -1,11 +1,13 @@
 var assert     = require('assert');
-var Buffer     = require('safe-buffer').Buffer;
+var Crypto     = require('crypto');
 var common     = require('../../common');
 var connection = common.createConnection({
   port     : common.fakeServerPort,
   password : 'authswitch'
 });
+var Auth       = require(common.lib + '/protocol/Auth');
 
+var random = Crypto.pseudoRandomBytes || Crypto.randomBytes; // Depends on node.js version
 var server = common.createFakeServer();
 
 var connected;
@@ -23,11 +25,21 @@ server.listen(common.fakeServerPort, function (err) {
 });
 
 server.on('connection', function(incomingConnection) {
-  incomingConnection.handshake({
-    user           : connection.config.user,
-    password       : connection.config.password,
-    authMethodName : 'mysql_native_password',
-    authMethodData : Buffer.from('00112233445566778899AABBCCDDEEFF0102030400', 'hex')
+  random(20, function (err, scramble) {
+    assert.ifError(err);
+
+    incomingConnection.on('clientAuthentication', function () {
+      this._sendPacket(new common.Packets.AuthSwitchRequestPacket({
+        authMethodName : 'mysql_native_password',
+        authMethodData : scramble
+      }));
+    });
+
+    incomingConnection.on('AuthSwitchResponsePacket', function (packet) {
+      this._sendAuthResponse(packet.data, Auth.token('authswitch', scramble));
+    });
+
+    incomingConnection.handshake();
   });
 });
 

test/unit/connection/test-auth-switch-unknown.js

@@ -23,10 +23,12 @@ server.listen(common.fakeServerPort, function (err) {
 });
 
 server.on('connection', function(incomingConnection) {
-  incomingConnection.handshake({
-    user           : connection.config.user,
-    password       : connection.config.password,
-    authMethodName : 'foo_plugin_password',
-    authMethodData : Buffer.alloc(0)
+  incomingConnection.on('clientAuthentication', function () {
+    this._sendPacket(new common.Packets.AuthSwitchRequestPacket({
+      authMethodName : 'foo_plugin_password',
+      authMethodData : Buffer.alloc(0)
+    }));
   });
+
+  incomingConnection.handshake();
 });

test/unit/connection/test-insecure-auth-error.js

@@ -21,9 +21,9 @@ server.listen(common.fakeServerPort, function (err) {
 });
 
 server.on('connection', function(incomingConnection) {
-  incomingConnection.handshake({
-    user        : connection.config.user,
-    password    : connection.config.password,
-    oldPassword : true
+  incomingConnection.on('clientAuthentication', function () {
+    this._sendPacket(new common.Packets.UseOldPasswordPacket());
   });
+
+  incomingConnection.handshake();
 });

test/unit/connection/test-old-password.js

@@ -5,7 +5,10 @@ var connection = common.createConnection({
   insecureAuth : true
 });
 var assert     = require('assert');
+var Auth       = require(common.lib + '/protocol/Auth');
+var Crypto     = require('crypto');
 
+var random = Crypto.pseudoRandomBytes || Crypto.randomBytes; // Depends on node.js version
 var server = common.createFakeServer();
 
 var connected;
@@ -23,10 +26,21 @@ server.listen(common.fakeServerPort, function(err) {
 });
 
 server.on('connection', function(incomingConnection) {
-  incomingConnection.handshake({
-    user        : connection.config.user,
-    password    : connection.config.password,
-    oldPassword : true
+  random(8, function (err, scramble) {
+    assert.ifError(err);
+
+    incomingConnection.on('clientAuthentication', function () {
+      this._sendPacket(new common.Packets.UseOldPasswordPacket());
+    });
+
+    incomingConnection.on('OldPasswordPacket', function (packet) {
+      var expected = Auth.scramble323(scramble, 'oldpw');
+      this._sendAuthResponse(packet.scrambleBuff, expected);
+    });
+
+    incomingConnection.handshake({
+      scrambleBuff1: scramble
+    });
   });
 });
 

test/unit/connection/test-password.js

@@ -4,30 +4,33 @@ var connection = common.createConnection({
   password : 'passwd'
 });
 var assert     = require('assert');
+var Auth       = require(common.lib + '/protocol/Auth');
+var Crypto     = require('crypto');
 
+var random = Crypto.pseudoRandomBytes || Crypto.randomBytes; // Depends on node.js version
 var server = common.createFakeServer();
 
-var connected;
 server.listen(common.fakeServerPort, function(err) {
-  if (err) throw err;
-
-  connection.connect(function(err, result) {
-    if (err) throw err;
-
-    connected = result;
+  assert.ifError(err);
 
+  connection.connect(function (err) {
+    assert.ifError(err);
     connection.destroy();
     server.destroy();
   });
 });
 
 server.on('connection', function(incomingConnection) {
-  incomingConnection.handshake({
-    user     : connection.config.user,
-    password : connection.config.password
-  });
-});
+  random(20, function (err, scramble) {
+    assert.ifError(err);
+
+    incomingConnection.on('clientAuthentication', function (packet) {
+      this._sendAuthResponse(packet.scrambleBuff, Auth.token('passwd', scramble));
+    });
 
-process.on('exit', function() {
-  assert.equal(connected.fieldCount, 0);
+    incomingConnection.handshake({
+      scrambleBuff1 : scramble.slice(0, 8),
+      scrambleBuff2 : scramble.slice(8, 20)
+    });
+  });
 });