signalling server update

SignallingWebServer/modules/authentication/db/index.js

@@ -0,0 +1,2 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+exports.users = require('./users');

SignallingWebServer/modules/authentication/db/store_password.js

@@ -0,0 +1,80 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+//
+// Usage: npm run store_password -- --username <USERNAME> --password <PASSWORD>
+// 	or from ./modules/authentication/db dir: node store_password.js --username <USERNAME> --password <PASSWORD>
+//
+// --usersFile is an optional parameter that can be used to specify a different location for the users database file
+// 		use this if running the command from a different working dir. The default location is './users.json'
+// 		e.g. If running from the SignallingWebServer dir use: --usersFile ./modules/authentication/db/users.json 
+
+const argv = require('yargs').argv;
+const fs = require('fs');
+const bcrypt = require('bcryptjs');
+
+var username, password;
+var usersFile = './users.json'
+
+const STORE_PLAINTEXT_PASSWORD = false;
+
+try {
+	if(typeof argv.username != 'undefined'){
+		username = argv.username.toString();
+    }
+	
+	if(typeof argv.password != 'undefined'){
+		password = argv.password;
+    }
+
+    if(typeof argv.usersFile != 'undefined'){
+		usersFile = argv.usersFile;
+    }
+} catch (e) {
+    console.error(e);
+    process.exit(2);
+}
+
+if(username && password){
+	let existingAccounts = [];
+	if (fs.existsSync(usersFile)) {
+		console.log(`File '${usersFile}' exists, reading file`)
+		var content = fs.readFileSync(usersFile, 'utf8');
+		try{
+			existingAccounts = JSON.parse(content);
+		}
+		catch(e){
+			console.error(`Existing file '${usersFile}', has invalid JSON: ${e}`);
+		}
+	}
+
+	var existingUser = existingAccounts.find( u => u.username == username)
+	if(existingUser){
+		console.log(`User '${username}', already exists, updating password`)
+		existingUser.passwordHash = generatePasswordHash(password)
+		if(STORE_PLAINTEXT_PASSWORD)
+			existingUser.password = password;
+		else if (existingUser.password)
+			delete existingUser.password;
+
+	} else {
+		console.log(`Adding new user '${username}'`)
+		let newUser = {
+			id: existingAccounts.length + 1,
+			username: username,
+			passwordHash: generatePasswordHash(password)
+		}
+		if(STORE_PLAINTEXT_PASSWORD)
+			newUser.password = password;
+
+		existingAccounts.push(newUser);
+	}
+
+	console.log(`Writing updated users to '${usersFile}'`);
+	var newContent = JSON.stringify(existingAccounts);
+	fs.writeFileSync(usersFile, newContent);
+} else {
+	console.log(`Please pass in both username (${username}) and password (${password}) please`);
+}
+
+function generatePasswordHash(pass){
+	return bcrypt.hashSync(pass, 12)
+}

SignallingWebServer/modules/authentication/db/users.js

@@ -0,0 +1,35 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+const fs = require('fs');
+const path = require('path');
+
+// Read in users from file
+let records = [];
+let usersFile = path.join(__dirname, './users.json');
+if (fs.existsSync(usersFile)) {
+  console.log(`Reading users from '${usersFile}'`)
+  var content = fs.readFileSync(usersFile, 'utf8');
+  try {
+    records = JSON.parse(content);
+  } catch(e) {
+    console.log(`ERROR: Failed to parse users from file '${usersFile}'`)
+  }
+}
+
+exports.findById = function(id, cb) {
+    var idx = id - 1;
+    if (records[idx]) {
+      cb(null, records[idx]);
+    } else {
+      cb(new Error('User ' + id + ' does not exist'));
+    }
+}
+
+exports.findByUsername = function(username, cb) {
+    for (var i = 0, len = records.length; i < len; i++) {
+      var record = records[i];
+      if (record.username === username) {
+        return cb(null, record);
+      }
+    }
+    return cb(null, null);
+}

SignallingWebServer/modules/authentication/index.js

@@ -0,0 +1,4 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+module.exports = {
+	init: require('./init')
+}

SignallingWebServer/modules/authentication/init.js

@@ -0,0 +1,109 @@
+// Copyright Epic Games, Inc. All Rights Reserved.
+// Adapted from 
+// * https://blog.risingstack.com/node-hero-node-js-authentication-passport-js/
+// * https://github.com/RisingStack/nodehero-authentication/tree/master/app
+// * https://github.com/passport/express-4.x-local-example
+
+
+const passport = require('passport');
+const session = require('express-session');
+const bcrypt = require('bcryptjs');
+const LocalStrategy = require('passport-local').Strategy;
+const path = require('path');
+const fs = require('fs');
+var db = require('./db');
+
+function initPassport (app) {
+
+	// Generate session secret if it doesn't already exist and save it to file for use next time
+	let config = {};
+	let configPath = path.join(__dirname, './config.json');
+	if (fs.existsSync(configPath)) {
+		let content = fs.readFileSync(configPath, 'utf8');
+		try {
+			config = JSON.parse(content);
+		} catch (e) {
+			console.log(`Error with config file '${configPath}': ${e}`);
+		}
+	}
+
+	if(!config.sessionSecret){
+		config.sessionSecret = bcrypt.genSaltSync(12);
+		let content = JSON.stringify(config);
+		fs.writeFileSync(configPath, content);
+	}
+
+	// Setup session id settings
+	app.use(session({
+		secret: config.sessionSecret,
+		resave: false,
+		saveUninitialized: false,
+		cookie: {
+			secure: true,
+			maxAge: 24 * 60 * 60 * 1000 /* 1 day */
+			//maxAge: 5 * 1000 /* 5 seconds */
+		}
+	}));
+	
+	app.use(passport.initialize());
+	app.use(passport.session());
+	
+	passport.serializeUser(function(user, cb) {
+	 	cb(null, user.id);
+	});
+
+	passport.deserializeUser(function(id, cb) {
+	 	db.users.findById(id, function (err, user) {
+			if (err) { return cb(err); }
+			cb(null, user);
+		});
+	});
+
+	console.log('Setting up auth');
+	passport.use(new LocalStrategy(
+		(username, password, callback) => {
+			db.users.findByUsername(username, (err, user) => {
+				if (err) {
+					console.log(`Unable to login '${username}', error ${err}`);
+					return callback(err);
+				}
+			
+				// User not found
+				if (!user) {
+					console.log(`User '${username}' not found`);
+					return callback(null, false);
+				}
+
+				// Always use hashed passwords and fixed time comparison
+				bcrypt.compare(password, user.passwordHash, (err, isValid) => {
+					if (err) {
+						console.log(`Error comparing password for user '${username}': ${err}`);
+						return callback(err);
+					}
+					if (!isValid) {
+						console.log(`Password incorrect for user '${username}'`)
+						return callback(null, false);
+					}
+
+					console.log(`User '${username}' logged in`);
+					return callback(null, user);
+				});
+			})
+		}
+	));
+	
+	passport.authenticationMiddleware = function authenticationMiddleware (redirectUrl) {
+		return function (req, res, next) {
+		    if (req.isAuthenticated()) {
+		      return next();
+		    }
+
+		    // Set redirectTo property so that user can be redirected back there after logging in
+		    //console.log(`Original request path '${req.originalUrl}'`);
+		    req.session.redirectTo = req.originalUrl;
+		    res.redirect(redirectUrl);
+		}
+	}
+}
+
+module.exports = initPassport;