Bumped version number

omit physical address line from validation email where no physical address provided

.envdev

@@ -1,6 +1,8 @@
 WEB_PROTOCOL=http
 WEB_ADDRESS=localhost
+WEB_RESET_ADDRESS=localhost/reset
 WEB_PORT=3200
+WEB_ORIGIN=http://localhost:3001
 
 DB_HOSTNAME=database
 DB_DATABASE=auth
@@ -29,3 +31,6 @@ SECRET_ACCESS=access
 
 # Make sure this value is kept secret
 SECRET_REFRESH=refresh
+
+# Post-signup hook JSON array (MUST include http:// or https://)
+HOOK_POST_VALIDATION_ARRAY=

.github/FUNDING.yml

@@ -0,0 +1,5 @@
+# These are supported funding model platforms
+
+patreon: krgamestudios
+ko_fi: krgamestudios
+custom: ["https://www.paypal.com/donate/?hosted_button_id=73Q82T2ZHV8AA"]

Dockerfile

@@ -1,9 +1,8 @@
-
+FROM node:18
-FROM node:15
 WORKDIR "/app"
 COPY package*.json ./
-COPY . /app
 RUN npm install --production
+COPY . /app
 EXPOSE 3200
 USER node
 ENTRYPOINT ["bash", "-c"]

README.md

@@ -2,6 +2,8 @@
 
 An API centric auth server. Uses Sequelize and mariaDB by default.
 
+This server is available via docker hub at krgamestudios/auth-server.
+
 # Setup
 
 There are multiple ways to run this app - it can run on it's own via `npm start` (for production) or `npm run dev` (for development). it can also run inside docker using `docker-compose up --build` - run `node configure-script.js` to generate docker-compose.yml and startup.sql.
@@ -19,9 +21,21 @@ Content-Type: application/json
 	"password": "helloworld"
 }
 
-//DOCS: Used for validating the email address above
+
+###
+
+
+//DOCS: Used for validating the email address specified above
 GET /auth/validation?username=example&token=12345678
 
+//DOCS: If the environment variable HOOK_POST_VALIDATION_ARRAY is set to a JSON array of valid URLs, then the server will send a GET message to each URL with the newly created account's index
+//DOCS: The GET requests will have a JWT authorization header
+HOOK_POST_VALIDATION_ARRAY=["http://example.com", "http://example2.com"]
+GET {HOOK_POST_VALIDATION_ARRAY[i]}?accountIndex={index}
+
+###
+
+
 //DOCS: Login after validation
 POST /auth/login
 Content-Type: application/json
@@ -31,43 +45,62 @@ Content-Type: application/json
 	"password": "helloworld"
 }
 
-//Result (access token's value is your authorization key below)
+//DOCS: Result (access token's value is your authorization key below)
+Set-Cookie: refreshToken
+
 {
-	"accessToken": "abcde",
+	"accessToken": "abcde"
-	"refreshToken": "fghij"
 }
 
-//Replace an expired authToken pair with these values
+
+###
+
+
+//DOCS: Replace an expired accessToken with a new value
 POST /auth/token
-Content-Type: application/json
+Cookie: refreshToken
+
+//DOCS: Result
+Set-Cookie: refreshToken
 
 {
-	"token": "refreshToken"
+	"accessToken": "abcde"
 }
 
-//DOCS: After this is called, the refresh route will no longer work
+
+###
+
+
+//DOCS: After this is called, the /auth/token route will no longer work
 DELETE /auth/logout
 Authorization: Bearer accessToken
+Cookie: refreshToken
+
+###
 
-{
-	"token": "refreshToken"
-}
 
 //DOCS: Retreives the private account data, results vary
 GET /auth/account
 Authorization: Bearer accessToken
 
-//Result
-{
-	"accessToken": "abcde",
-	"refreshToken": "fghij"
-}
 
-//DOCS: Update account data, input varies, but is always JSON
+###
+
+
+//DOCS: Update account data
 PATCH /auth/account
 Content-Type: application/json
 Authorization: Bearer accessToken
 
+{
+	"password": "helloworld",
+	"contact": true
+}
+
+
+###
+
+
 //DOCS: Sets the timer, account will be deleted after 2 days
 DELETE /auth/account
 Authorization: Bearer accessToken
@@ -76,4 +109,40 @@ Content-Type: application/json
 {
 	"password": "helloworld"
 }
+
+
+###
+
+
+//DOCS: Send the link to recover a forgotten password
+POST /auth/recover
+Content-Type: application/json
+
+{
+	"email": "example@example.com"
+}
+
+
+###
+
+
+//DOCS: Redirect the link to recover a password to the front-end
+GET /auth/reset?token=<token>
+
+//DOCS: Result
+301 -> ${WEB_RESET_ADDRESS}?email=<email>&token=<token>
+
+
+###
+
+
+//DOCS: Resets a password for the given email, correct token is required
+PATCH /auth/reset?email=<email>&token=<token>
+
+{
+	"password": "password"
+}
+
+
+###
 ```

configure-script.js

@@ -29,11 +29,15 @@ const question = (prompt, def = null) => {
 (async () => {
 	//project configuration
 	const appName = await question('App Name', 'auth');
+	const appWebProtocol = await question('Web Protocol', 'https');
 	const appWebAddress = await question('Web Addr', `${appName}.example.com`);
+	const appWebOrigin = await question('Web Origin', `${appWebProtocol}://example.com`); //TODO: clean these up properly
+	const postValidationHookArray = await question('Post Validation Hook Array', '');
+	const resetAddress = await question('Reset Addr', `example.com/reset`);
 	const appPort = await question('App Port', '3200');
 
 	const appDBUser = await question('DB User', appName);
-	const appDBPass = await question('DB Pass', uuid());
+	const appDBPass = await question('DB Pass', 'charizard');
 	const dbRootPass = await question('DB Root Pass');
 
 	const appMailSMTP = await question('Mail SMTP', 'smtp.example.com');
@@ -67,8 +71,11 @@ services:
       - "traefik.http.routers.${appName}router.service=${appName}service@docker"
       - "traefik.http.services.${appName}service.loadbalancer.server.port=${appPort}"
     environment:
-      - WEB_PROTOCOL=https
+      - WEB_PROTOCOL=${appWebProtocol}
+      - WEB_ORIGIN=${appWebOrigin}
       - WEB_ADDRESS=${appWebAddress}
+      - HOOK_POST_VALIDATION_ARRAY=${postValidationHookArray}
+      - WEB_RESET_ADDRESS=${resetAddress}
       - WEB_PORT=${appPort}
       - DB_HOSTNAME=database
       - DB_DATABASE=${appName}
@@ -126,7 +133,7 @@ networks:
 `;
 
 	const dockerfile = `
-FROM node:15
+FROM node:18
 WORKDIR "/app"
 COPY package*.json ./
 RUN npm install --production

package.json

@@ -1,6 +1,6 @@
 {
   "name": "auth-server",
-  "version": "1.3.1",
+  "version": "1.6.5",
   "description": "An API centric auth server. Uses Sequelize and mariaDB by default.",
   "main": "server/server.js",
   "scripts": {
@@ -20,17 +20,18 @@
   "homepage": "https://github.com/krgamestudios/auth-server#readme",
   "dependencies": {
     "bcryptjs": "^2.4.3",
-    "body-parser": "^1.19.0",
+    "cookie-parser": "^1.4.6",
     "cors": "^2.8.5",
-    "dotenv": "^8.6.0",
+    "dotenv": "^16.0.3",
-    "express": "^4.17.1",
+    "express": "^4.18.2",
     "jsonwebtoken": "^8.5.1",
-    "mariadb": "^2.5.4",
+    "mariadb": "^3.0.2",
-    "node-cron": "^2.0.3",
+    "node-cron": "^3.0.2",
-    "nodemailer": "^6.6.3",
+    "node-fetch": "^2.6.7",
-    "sequelize": "^6.6.5"
+    "nodemailer": "^6.8.0",
+    "sequelize": "^6.25.8"
   },
   "devDependencies": {
-    "nodemon": "^2.0.12"
+    "nodemon": "^2.0.20"
   }
 }

server/admin/ban-user.js

@@ -27,7 +27,7 @@ const route = async (req, res) => {
 	//forcibly logout
 	tokens.destroy({
 		where: {
-			username: req.body.username || ''
+			email: req.body.email || ''
 		}
 	});
 

server/admin/default-account.js

@@ -25,7 +25,7 @@ module.exports = async () => {
 	});
 
 	if (adminRecord == null) {
-		const webAddress = process.env.WEB_ADDRESS == 'localhost' ? 'example.com' : process.env.WEB_ADDRESS; //can't log in as "localhost"
+		const webAddress = process.env.WEB_ADDRESS == 'localhost:3000' ? 'example.com' : process.env.WEB_ADDRESS; //can't log in as "localhost"
 		await accounts.create({
 			email: `${process.env.ADMIN_DEFAULT_USERNAME}@${webAddress}`,
 			username: `${process.env.ADMIN_DEFAULT_USERNAME}`,

server/admin/index.js

@@ -12,7 +12,7 @@ router.use(tokenAuth);
 router.use(async (req, res, next) => {
 	const record = await accounts.findOne({
 		where: {
-			username: req.user.username || ''
+			email: req.user.email || ''
 		}
 	});
 

server/auth/account-delete.js

@@ -9,18 +9,26 @@ const { accounts } = require('../database/models');
 
 //auth/deletion
 const route = async (req, res) => {
+	if (!req.body.password) {
+		return res.status(401).end('Missing password');
+	}
+
 	const account = await accounts.findOne({
 		where: {
-			index: req.user.index
+			index: req.user.index || ''
 		}
 	});
 
+	if (!account) {
+		return res.status(401).end('Missing account');
+	}
+
 	//compare the user's password
 	const compare = utils.promisify(bcrypt.compare);
-	const match = await compare(req.body.password || '', account.hash);
+	const match = await compare(req.body.password, account.hash);
 
 	if (!match) {
-		return res.status(401).send('incorrect password');
+		return res.status(401).send('Incorrect password');
 	}
 
 	//set the deletion time (2 days from now)

server/auth/account-query.js

@@ -4,12 +4,12 @@ const { accounts } = require('../database/models');
 const route = async (req, res) => {
 	const account = await accounts.findOne({
 		where: {
-			index: req.user.index
+			index: req.user.index || ''
 		}
 	});
 
 	if (!account) {
-		return res.status(401).send('Unknown account');
+		return res.status(401).end('Unknown account');
 	}
 
 	//respond with the private-facing data

server/auth/account-update.js

@@ -3,13 +3,13 @@ const { accounts } = require('../database/models');
 
 //auth/update
 const route = async (req, res) => {
-	//generate the password hash
+	if (!req.body.password) {
-	let hash;
+		return res.status(401).end('Missing password');
-
-	if (req.body.password) {
-		hash = await bcrypt.hash(req.body.password, await bcrypt.genSalt(11));
 	}
 
+	//generate the password hash
+	let hash = await bcrypt.hash(req.body.password, await bcrypt.genSalt(11));
+
 	//update the account
 	await accounts.update({
 		contact: req.body.contact,

server/auth/index.js

@@ -14,13 +14,21 @@ router.post('/login', require('./login'));
 //refresh token
 router.post('/token', require('./token'));
 
+//password recover and reset
+router.post('/recover', require('./password-recover'));
+router.get('/reset', require('./password-redirect'));
+router.patch('/reset', require('./password-reset'));
+
+//logouts allowed when banned, and when the token itself is invalid
+router.delete('/logout', require('./logout'));
+
 //middleware
 router.use(tokenAuth);
 
 router.use(async (req, res, next) => {
 	const record = await accounts.findOne({
 		where: {
-			username: req.user.username || ''
+			email: req.user.email || ''
 		}
 	});
 
@@ -36,7 +44,6 @@ router.use(async (req, res, next) => {
 });
 
 //basic account management (needs a token)
-router.delete('/logout', require('./logout'));
 router.get('/account', require('./account-query'));
 router.patch('/account', require('./account-update'));
 router.delete('/account', require('./account-delete'));

server/auth/login.js

@@ -3,7 +3,7 @@ const utils = require('util');
 const bcrypt = require('bcryptjs');
 
 const { accounts } = require('../database/models');
-const generate = require('../utilities/token-generate');
+const tokenGenerateRefresh = require('../utilities/token-generate-refresh');
 
 //utilities
 const validateEmail = require('../utilities/validate-email');
@@ -29,6 +29,7 @@ const route = async (req, res) => {
 
 	//compare passwords
 	const compare = utils.promisify(bcrypt.compare);
+
 	const match = await compare(req.body.password, account.hash);
 
 	if (!match) {
@@ -47,21 +48,30 @@ const route = async (req, res) => {
 		return res.status(403).send('this account has been banned');
 	}
 
-	//generate the JWT
+	//generate the JWTs
-	const tokens = generate(account.index, account.username, account.type, account.admin, account.mod);
+	const { accessToken, refreshToken } = tokenGenerateRefresh(account.index, account.email, account.username, account.type, account.admin, account.mod);
+
+	//set the cookie
+	res.cookie('refreshToken', refreshToken, { path: '/', httpOnly: true, secure: true, sameSite: 'none', maxAge: 60 * 60 * 24 * 30 * 1000 }); //30 days
 
 	//finally
-	res.status(200).json(tokens);
+	res.status(200).send(accessToken);
+	return null;
 };
 
 const validateDetails = async (body) => {
-	//basic formatting (with an exception for the default admin account)
+	if (!body.email) {
-	if (!validateEmail(body.email) && body.email != `${process.env.ADMIN_DEFAULT_USERNAME}@${process.env.WEB_ADDRESS}`) {
+		return 'Missing email';
-		return 'invalid email';
 	}
 
-	//check for existing (banned)
+	if (!body.password) {
-	//TODO: restore banning
+		return 'Missing password';
+	}
+
+	//basic formatting (with an exception for the default admin account)
+	if (!validateEmail(body.email) && body.email != `${process.env.ADMIN_DEFAULT_USERNAME}@${process.env.WEB_ADDRESS}`) {
+		return 'Invalid email';
+	}
 
 	return null;
 }

server/auth/logout.js

@@ -1,8 +1,11 @@
-const destroy = require('../utilities/token-destroy');
+const tokenDestroy = require('../utilities/token-destroy');
 
 //auth/logout
 const route = (req, res) => {
-	destroy(req.body.token);
+	//stored in the cookie
+	tokenDestroy(req.cookies.refreshToken);
+
+	res.clearCookie('refreshToken');
 
 	return res.status(200).end();
 };

server/auth/password-recover.js

@@ -0,0 +1,106 @@
+//libraries
+const nodemailer = require('nodemailer');
+
+const { accounts, recovery } = require('../database/models');
+
+//utilities
+const uuid = require('../utilities/uuid');
+const validateEmail = require('../utilities/validate-email');
+
+//auth/recover
+const route = async (req, res) => {
+	//validate details
+	const validateErr = await validateDetails(req.body);
+	if (validateErr) {
+		return res.status(401).end(validateErr);
+	}
+
+	//recovery token
+	const token = uuid(32);
+
+	//send the recovery email
+	const emailErr = await sendRecoveryEmail(req.body.email, token);
+	if (emailErr) {
+		return res.status(500).send(emailErr);
+	}
+
+	//save the token
+	await recovery.upsert({
+		email: req.body.email,
+		token: token
+	});
+
+	//finally
+	res.status(200).send("Recovery email sent!");
+	return null;
+};
+
+const validateDetails = async (body) => {
+	//basic formatting
+	if (!validateEmail(body.email)) {
+		return 'Invalid email';
+	}
+
+	//check for existing email
+	const emailRecord = await accounts.findOne({
+		where: {
+			email: body.email
+		}
+	});
+
+	if (!emailRecord) {
+		return 'Invalid email';
+	}
+
+	//OK
+	return null;
+};
+
+const sendRecoveryEmail = async (email, token) => {
+	const addr = `${process.env.WEB_PROTOCOL}://${process.env.WEB_ADDRESS}/auth/reset?token=${token}`;
+	const msg = `Hello,
+
+Please visit the following link to reset your password: ${addr}
+
+If you did not request a password reset, you can safely ignore this message.
+`;
+
+	let transporter, info;
+
+	//what exactly is a transport?
+	try {
+		transporter = nodemailer.createTransport({
+			host: process.env.MAIL_SMTP,
+			port: 465,
+			secure: true,
+			auth: {
+			  user: process.env.MAIL_USERNAME,
+			  pass: process.env.MAIL_PASSWORD
+			},
+		});
+	}
+	catch(e) {
+		return `failed to create a mail transport: ${e}`;
+	}
+
+	// send mail with defined transport object
+	try {
+		info = await transporter.sendMail({
+			from: `recovery@${process.env.WEB_ADDRESS}`, //WARNING: google overwrites this
+			to: email,
+			subject: 'Password Recovery',
+			text: msg
+		});
+	}
+	catch(e) {
+		return `failed to send validation mail: ${e}`;
+	}
+
+	if (info.accepted[0] != email) {
+		return 'recovery email failed to send';
+	}
+
+	return null;
+};
+
+module.exports = route;

server/auth/password-redirect.js

@@ -0,0 +1,21 @@
+const { accounts, recovery } = require('../database/models');
+
+//auth/reset
+const route = async (req, res) => {
+	//verify the recovery record exists
+	const record = await recovery.findOne({
+		where: {
+			token: req.query.token || ''
+		}
+	});
+
+	if (!record) {
+		return res.status(401).end('Failed to recover a password');
+	}
+
+	//redirect to the front-end
+	res.redirect(`${process.env.WEB_PROTOCOL}://${process.env.WEB_RESET_ADDRESS}?email=${record.email}&token=${record.token}`);
+	return null;
+};
+
+module.exports = route;

server/auth/password-reset.js

@@ -0,0 +1,62 @@
+//libraries
+const bcrypt = require('bcryptjs');
+
+const { accounts, recovery } = require('../database/models');
+
+//auth/reset
+const route = async (req, res) => {
+	//validate the given details
+	const validateErr = await validateDetails(req.query, req.body);
+	if (validateErr) {
+		return res.status(401).send(validateErr);
+	}
+
+	//generate the password hash
+	const hash = await bcrypt.hash(req.body.password, await bcrypt.genSalt(11));
+
+	//update the account data
+	await accounts.update({
+		hash: hash
+	}, {
+		where: {
+			email: req.query.email
+		}
+	})
+
+	//delete from the recovery table
+	await recovery.destroy({
+		where: {
+			email: req.query.email
+		}
+	});
+
+	res.status(200).end();
+	return null;
+};
+
+const validateDetails = async (query, body) => {
+	//verify the recovery record exists
+	const record = await recovery.findOne({
+		where: {
+			email: query.email,
+			token: query.token
+		}
+	});
+
+	if (!record) {
+		return 'Failed to recover a password';
+	}
+
+	//validate password
+	if (!body.password) {
+		return 'Missing password';
+	}
+
+	if (body.password.length < 8) {
+		return 'Password too short';
+	}
+
+	return null;
+};
+
+module.exports = route;

server/auth/signup.js

@@ -6,7 +6,6 @@ const Op = Sequelize.Op;
 
 const { accounts, pendingSignups } = require('../database/models');
 
-
 //utilities
 const uuid = require('../utilities/uuid');
 const validateEmail = require('../utilities/validate-email');
@@ -46,16 +45,13 @@ const route = async (req, res) => {
 const validateDetails = async (body) => {
 	//basic formatting
 	if (!validateEmail(body.email)) {
-		return 'invalid email';
+		return 'Invalid email';
 	}
 
 	if (!validateUsername(body.username)) {
-		return 'invalid username';
+		return 'Invalid username';
 	}
 
-	//check for existing (banned)
-	//TODO: re-add banned email checks
-
 	//check for existing email
 	const emailRecord = await accounts.findOne({
 		where: {
@@ -64,23 +60,31 @@ const validateDetails = async (body) => {
 	});
 
 	if (emailRecord) {
-		return 'email already exists';
+		return 'Email already exists';
+	}
+
+	if (!body.username) {
+		return 'Missing username';
 	}
 
 	//check for existing username
 	const usernameRecord = await accounts.findOne({
 		where: {
-			username: body.username || ''
+			username: body.username
 		}
 	});
 
 	if (usernameRecord) {
-		return 'username already exists';
+		return 'Username already exists';
 	}
 
 	//validate password
+	if (!body.password) {
+		return 'Missing password';
+	}
+
 	if (body.password.length < 8) {
-		return 'password too short';
+		return 'Password too short';
 	}
 
 	return null;
@@ -100,12 +104,12 @@ const registerPendingSignup = async (body, hash, token) => {
 
 const sendValidationEmail = async (email, username, token) => {
 	const addr = `${process.env.WEB_PROTOCOL}://${process.env.WEB_ADDRESS}/auth/validation?username=${username}&token=${token}`;
-	const msg = `Hello ${username}!
+	const msg =
-
+  `Hello ${username}!\n\n` +
-Please visit the following link to validate your account: ${addr}
+  `Please visit the following link to validate your account: ${addr}\n` +
-
+  (process.env.MAIL_PHYSICAL
-You can contact us directly at our physical mailing address here: ${process.env.MAIL_PHYSICAL}
+    ? `\nYou can contact us directly at our physical mailing address here: ${process.env.MAIL_PHYSICAL}\n`
-`;
+    : ``);
 
 	let transporter, info;
 

server/auth/token.js

@@ -1,16 +1,17 @@
 const jwt = require('jsonwebtoken');
 
-const refresh = require('../utilities/token-refresh');
+const tokenRefresh = require('../utilities/token-refresh');
 
 //auth/token
 module.exports = async (req, res) => {
-	const refreshToken = req.body.token;
+	return tokenRefresh(req.cookies.refreshToken || '', (err, accessToken, refreshToken) => {
-
-	return refresh(refreshToken, (err, tokens) => {
 		if (err) {
 			return res.status(err).end();
 		}
 
-		return res.status(200).send(tokens);
+		//set the cookie
+		res.cookie('refreshToken', refreshToken, { path: '/', httpOnly: true, secure: true, sameSite: 'none', maxAge: 60 * 60 * 24 * 30 * 1000 }); //30 days
+
+		return res.status(200).send({ accessToken });
 	});
 };

server/auth/validation.js

@@ -1,4 +1,6 @@
 const { pendingSignups, accounts } = require('../database/models');
+const fetch = require('node-fetch');
+const jwt = require('jsonwebtoken');
 
 //auth/validation
 const route = async (req, res) => {
@@ -11,15 +13,15 @@ const route = async (req, res) => {
 
 	//check the given info
 	if (!info) {
-		return res.status(401).send('validation failed');
+		return res.status(401).send('Validation failed');
 	}
 
 	if (info.token != req.query.token) {
-		return res.status(401).send('tokens do not match');
+		return res.status(401).send('Tokens do not match');
 	}
 
 	//move data to the accounts table
-	accounts.create({
+	const account = await accounts.create({
 		email: info.email,
 		username: info.username,
 		hash: info.hash,
@@ -29,12 +31,51 @@ const route = async (req, res) => {
 	//delete the pending signup
 	pendingSignups.destroy({
 		where: {
-			username: req.query.username || ''
+			username: info.username || ''
 		}
 	});
 
 	//finally
 	res.status(200).send('Validation succeeded!');
+
+	//post-validation hook
+	if (process.env.HOOK_POST_VALIDATION_ARRAY) {
+		try {
+			hooks = JSON.parse(process.env.HOOK_POST_VALIDATION_ARRAY);
+
+			if (!Array.isArray(hooks)) {
+				throw 'isArray() check failed';
+			}
+
+			//authenticate the hooks
+			const bearer = jwt.sign({ type: 'hook authentication' }, process.env.SECRET_ACCESS, { expiresIn: '5m', issuer: 'auth' });
+
+			//promise for each given hook
+			const promises = hooks.map(async hook => {
+				if (typeof hook != 'string') {
+					throw 'hook is not a string';
+				}
+
+				const probe = await fetch(`${hook}?accountIndex=${account.index}`, {
+					method: 'GET',
+					headers: {
+						'Authorization': `Bearer ${bearer}`
+					}
+				});
+
+				if (!probe.ok) {
+					throw `Could not probe the post validation hook: ${hook} with accountIndex = ${account.index}`;
+				}
+
+				//discard the result
+			});
+
+			await Promise.all(promises);
+		}
+		catch(e) {
+			console.error('HOOK_POST_VALIDATION_ARRAY is not a valid array of strings in JSON format: ' + e);
+		}
+	}
 };
 
 module.exports = route;

server/database/models/index.js

@@ -1,5 +1,6 @@
 module.exports = {
 	tokens: require('./tokens'),
 	accounts: require('./accounts'),
-	pendingSignups: require('./pending-signups')
+	pendingSignups: require('./pending-signups'),
+	recovery: require('./recovery')
 };

server/database/models/recovery.js

@@ -0,0 +1,6 @@
+const sequelize = require('..');
+
+module.exports = sequelize.define('recovery', {
+	token: 'varchar(320)',
+	email: 'varchar(320)'
+});

server/database/models/tokens.js

@@ -3,5 +3,5 @@ const sequelize = require('..');
 
 module.exports = sequelize.define('tokens', {
 	token: 'varchar(320)',
-	username: 'varchar(320)' //TODO: why username?
+	email: 'varchar(320)'
 });

server/server.js

@@ -6,10 +6,19 @@ const express = require('express');
 const app = express();
 const server = require('http').Server(app);
 const cors = require('cors');
+const cookieParser = require('cookie-parser');
 
 //config
 app.use(express.json());
-app.use(cors());
+
+app.use(cors({
+	credentials: true,
+	origin: [`${process.env.WEB_ORIGIN}`],
+	allowedHeaders: ['Origin', 'X-Requested-With', 'Content-Type', 'Accept', 'Authorization', 'Set-Cookie'],
+	exposedHeaders: ['Origin', 'X-Requested-With', 'Content-Type', 'Accept', 'Authorization', 'Set-Cookie'],
+}));
+
+app.use(cookieParser());
 
 //database connection
 const database = require('./database');
@@ -27,6 +36,17 @@ app.get('*', (req, res) => {
 
 //startup
 server.listen(process.env.WEB_PORT || 3200, async (err) => {
+	//BUGFIX: clear out old refresh tokens
+	const { Op } = require('sequelize');
+	const { tokens } = require('./database/models');
+	tokens.destroy({
+		where: {
+			createdAt: {
+				[Op.lt]: new Date(new Date().setDate(new Date().getDate() - 30))
+			}
+		}
+	});
+
 	await database.sync();
 	console.log(`listening to localhost:${process.env.WEB_PORT || 3200}`);
 });

server/utilities/token-auth.js

@@ -3,13 +3,13 @@ const jwt = require('jsonwebtoken');
 //middleware to authenticate the JWT token
 module.exports = (req, res, next) => {
 	const authHeader = req.headers['authorization'];
-	const token = authHeader?.split (' ')[1]; //'Bearer token'
+	const accessToken = authHeader?.split(' ')[1]; //'Bearer token'
 
-	if (!token) {
+	if (!accessToken) {
-		return res.status(401).send('No token found');
+		return res.status(401).send('No access token found');
 	}
 
-	return jwt.verify(token, process.env.SECRET_ACCESS, (err, user) => {
+	return jwt.verify(accessToken, process.env.SECRET_ACCESS, (err, user) => {
 		if (err) {
 			return res.status(403).send(err);
 		}

server/utilities/token-destroy.js

@@ -1,9 +1,9 @@
 const { tokens } = require('../database/models');
 
-module.exports = (token) => {
+module.exports = (refreshToken) => {
 	tokens.destroy({
 		where: {
-			token: token || ''
+			token: refreshToken || ''
 		}
 	});
 }

server/utilities/token-generate-refresh.js

@@ -2,19 +2,21 @@ const jwt = require('jsonwebtoken');
 const { tokens } = require('../database/models');
 
 //generates a JWT token based on the given arguments
-module.exports = (index, username, type, admin, mod) => {
+module.exports = (index, email, username, type, admin, mod) => {
 	const content = {
 		index,
+		email,
 		username,
 		type,
 		admin,
 		mod,
 	};
 
-	const accessToken = jwt.sign(content, process.env.SECRET_ACCESS, { expiresIn: '10m' });
+	//these are strings
-	const refreshToken = jwt.sign(content, process.env.SECRET_REFRESH, { expiresIn: '30d' });
+	const accessToken = jwt.sign(content, process.env.SECRET_ACCESS, { expiresIn: '10m', issuer: 'auth' });
+	const refreshToken = jwt.sign(content, process.env.SECRET_REFRESH, { expiresIn: '30d', issuer: 'auth' });
 
-	tokens.create({ token: refreshToken, username: username });
+	tokens.create({ token: refreshToken, email: email });
 
 	return { accessToken, refreshToken };
 };

server/utilities/token-refresh.js

@@ -1,17 +1,17 @@
 const jwt = require('jsonwebtoken');
 const { tokens } = require('../database/models');
 
-const generate = require('./token-generate');
+const generate = require('./token-generate-refresh');
 const destroy = require('./token-destroy');
 
-module.exports = (token, callback) => {
+module.exports = async (oldRefreshToken, callback) => {
-	if (!token) {
+	if (!oldRefreshToken) {
 		return callback(401);
 	}
 
-	const tokenRecord = tokens.findOne({
+	const tokenRecord = await tokens.findOne({
 		where: {
-			token: token || ''
+			token: oldRefreshToken || ''
 		}
 	});
 
@@ -19,15 +19,15 @@ module.exports = (token, callback) => {
 		return callback(403);
 	}
 
-	jwt.verify(token, process.env.SECRET_REFRESH, (err, user) => {
+	jwt.verify(oldRefreshToken, process.env.SECRET_REFRESH, (err, user) => {
 		if (err) {
 			return callback(403);
 		}
 
-		const result = generate(user.index, user.username, user.type, user.admin, user.mod);
+		const { accessToken, refreshToken } = generate(user.index, user.email, user.username, user.type, user.admin, user.mod);
 
-		destroy(token);
+		destroy(oldRefreshToken);
 
-		return callback(null, result);
+		return callback(null, accessToken, refreshToken);
 	});
 };

test/dev-auth-requests.rest

@@ -1,68 +0,0 @@
-#Signup
-POST https://dev-auth.eggtrainer.com/auth/signup HTTP/1.1
-Content-Type: application/json
-
-{
-	"email": "kayneruse@gmail.com",
-	"username": "Ratstail91",
-	"password": "helloworld"
-}
-
-###
-
-#Login
-POST https://dev-auth.eggtrainer.com/auth/login HTTP/1.1
-Content-Type: application/json
-
-{
-	"email": "kayneruse@gmail.com",
-	"password": "helloworld"
-}
-
-###
-
-#Query data
-GET https://dev-auth.eggtrainer.com/auth/account HTTP/1.1
-Authorization: Bearer
-
-###
-
-#Logout
-DELETE https://dev-auth.eggtrainer.com/auth/logout HTTP/1.1
-Authorization: Bearer
-
-{
-	"token": ""
-}
-
-###
-
-#Refresh
-POST https://dev-auth.eggtrainer.com/auth/token HTTP/1.1
-Content-Type: application/json
-
-{
-	"token": ""
-}
-
-###
-
-#Update account data
-PATCH https://dev-auth.eggtrainer.com/auth/update HTTP/1.1
-Content-Type: application/json
-Authorization: Bearer
-
-{
-	"contact": "true"
-}
-
-###
-
-#Delete account
-DELETE https://dev-auth.eggtrainer.com/auth/deletion HTTP/1.1
-Authorization: Bearer
-Content-Type: application/json
-
-{
-	"password": "helloworld"
-}

tools/debug-startup.sql

@@ -1,4 +1,4 @@
 #use this while debugging
 CREATE DATABASE IF NOT EXISTS auth;
-CREATE USER IF NOT EXISTS 'auth'@'%' IDENTIFIED BY 'venusaur';
+CREATE USER IF NOT EXISTS 'auth'@'%' IDENTIFIED BY 'charizard';
 GRANT ALL PRIVILEGES ON auth.* TO 'auth'@'%';

tools/dev-auth-requests.rest

@@ -0,0 +1,68 @@
+#Signup
+POST https://dev-auth.krgamestudios.com/auth/signup HTTP/1.1
+Content-Type: application/json
+
+{
+	"email": "example@example.com",
+	"username": "Example",
+	"password": "helloworld"
+}
+
+###
+
+#Login
+POST https://dev-auth.krgamestudios.com/auth/login HTTP/1.1
+Content-Type: application/json
+
+{
+	"email": "example@example.com",
+	"password": "helloworld"
+}
+
+###
+
+#Query data
+GET https://dev-auth.krgamestudios.com/auth/account HTTP/1.1
+Authorization: Bearer
+
+###
+
+#Logout
+DELETE https://dev-auth.krgamestudios.com/auth/logout HTTP/1.1
+Authorization: Bearer
+
+{
+	"token": ""
+}
+
+###
+
+#Refresh
+POST https://dev-auth.krgamestudios.com/auth/token HTTP/1.1
+Content-Type: application/json
+
+{
+	"token": ""
+}
+
+###
+
+#Update account data
+PATCH https://dev-auth.krgamestudios.com/auth/update HTTP/1.1
+Content-Type: application/json
+Authorization: Bearer
+
+{
+	"contact": "true"
+}
+
+###
+
+#Delete account
+DELETE https://dev-auth.krgamestudios.com/auth/deletion HTTP/1.1
+Authorization: Bearer
+Content-Type: application/json
+
+{
+	"password": "helloworld"
+}

tools/localhost-requests.rest

@@ -3,8 +3,8 @@ POST http://127.0.0.1:3200/auth/signup HTTP/1.1
 Content-Type: application/json
 
 {
-	"email": "kayneruse@gmail.com",
+	"email": "example@example.com",
-	"username": "Ratstail91",
+	"username": "Example",
 	"password": "helloworld"
 }
 
@@ -15,7 +15,7 @@ POST http://127.0.0.1:3200/auth/login HTTP/1.1
 Content-Type: application/json
 
 {
-	"email": "kayneruse@gmail.com",
+	"email": "example@example.com",
 	"password": "helloworld"
 }
 
@@ -66,3 +66,5 @@ Content-Type: application/json
 {
 	"password": "helloworld"
 }
+
+###

tools/migrations/v1.3.1.sql

@@ -0,0 +1 @@
+ALTER TABLE `accounts` CHANGE `id` `index` INT( 11 ) NOT NULL AUTO_INCREMENT;

tools/migrations/v1.4.0.sql

@@ -0,0 +1 @@
+DROP TABLE tokens;

tools/react/README.md

@@ -0,0 +1,53 @@
+# TokenProvider
+
+The MERN-template utilizes React's `useContext()` hook to share the auth-server's access token, effectively globally. Here is a quick rundown of how it works.
+
+# Enabling TokenProvider
+
+To enable the TokenProvider component, wrap your App component with it, like so:
+
+```jsx
+import React from 'react';
+import ReactDOM from 'react-dom';
+
+import App from './pages/app';
+import TokenProvider from './pages/utilities/token-provider';
+
+ReactDOM.render(
+	<TokenProvider>
+		<App />
+	</TokenProvider>,
+	document.querySelector('#root')
+);
+```
+
+# Accessing The Access Token
+
+To access the access token from your app, you simply use the `useContext` hook, like so:
+
+```jsx
+import React, { useContext } from 'react';
+import { TokenContext } from '../utilities/token-provider';
+
+const Component = props => {
+	//context
+	const authTokens = useContext(TokenContext);
+
+	//use the access token
+	console.log(authTokens.accessToken);
+
+	return <div />;
+};
+
+export default Component;
+```
+
+# Most Useful Features Provided
+
+The most useful features provided by TokenProvider are:
+
+* `tokenFetch()`, which wraps the `fetch()` API to ensure that your access token is valid
+* `tokenCallback()`, which passes the accessToken as a parameter to any function passed into it
+* `getPayload()`, which returns the payload of the accessToken (including as "email", "username", "admin", and "mod")
+* `accessToken`, this will be falsy if the user is not logged in
+

tools/react/token-provider.jsx

@@ -0,0 +1,119 @@
+import React, { useState, useEffect, createContext } from 'react';
+import decode from 'jwt-decode';
+
+export const TokenContext = createContext();
+
+//DOCS: tokenFetch() and tokenCallback() are actually closures here
+
+const TokenProvider = props => {
+	//state to be used
+	const [accessToken, setAccessToken] = useState('');
+
+	//force a logout under certain conditions
+	const forceLogout = () => {
+		localStorage.removeItem("accessToken");
+		setAccessToken("");
+	};
+
+	//make the access token persist between reloads
+	useEffect(() => {
+		setAccessToken(localStorage.getItem("accessToken") || '');
+	}, []);
+
+	//update the stored copies
+	useEffect(() => {
+		localStorage.setItem("accessToken", accessToken);
+	}, [accessToken]);
+
+	//wrap the default fetch function
+	const tokenFetch = async (url, options) => {
+		//use this?
+		let bearer = accessToken;
+
+		//if expired (10 minutes, normally)
+		const expired = new Date(decode(accessToken).exp * 1000) < Date.now();
+
+		if (expired) {
+			//BUGFIX: if logging out, just skip over the refresh token
+			if (url === `${process.env.AUTH_URI}/auth/logout`) {
+				return fetch(url, {
+					method: 'DELETE',
+					headers: {
+						'Authorization': `Bearer ${bearer}`
+					},
+					credentials: 'include'
+				});
+			}
+
+			//ping the auth server for a new access token
+			const response = await fetch(`${process.env.AUTH_URI}/auth/token`, {
+				method: 'POST',
+				credentials: 'include'
+			});
+
+			//any errors, throw them
+			if (!response.ok) {
+				if (response.status == 403) {
+					forceLogout();
+				}
+				throw `${response.status}: ${await response.text()}`;
+			}
+
+			//save the new auth stuff (setting bearer as well)
+			const newAuth = await response.json();
+
+			setAccessToken(newAuth.accessToken);
+			bearer = newAuth.accessToken;
+		}
+
+		//finally, delegate to fetch
+		return fetch(url, {
+			...(options || {}),
+			headers: {
+				...(options || { headers: {} }).headers,
+				'Authorization': `Bearer ${bearer}`
+			},
+			credentials: 'include'
+		});
+	};
+
+	//access the refreshed token via callback
+	const tokenCallback = async (cb) => {
+		//if expired (10 minutes, normally)
+		const expired = new Date(decode(accessToken).exp * 1000) < Date.now();
+
+		if (expired) {
+			//ping the auth server for a new token
+			const response = await fetch(`${process.env.AUTH_URI}/auth/token`, {
+				method: 'POST',
+				credentials: 'include'
+			});
+
+			//any errors, throw them
+			if (!response.ok) {
+				if (response.status == 403) {
+					forceLogout();
+				}
+				throw `${response.status}: ${await response.text()}`;
+			}
+
+			//save the new auth stuff (setting bearer as well)
+			const newAuth = await response.json();
+
+			setAccessToken(newAuth.accessToken);
+
+			//finally
+			return cb(newAuth.accessToken);
+		} else {
+			return cb(accessToken);
+		}
+	};
+
+	return (
+		<TokenContext.Provider value={{ accessToken, setAccessToken, tokenFetch, tokenCallback, getPayload: () => decode(accessToken) }}>
+			{props.children}
+		</TokenContext.Provider>
+	)
+};
+
+export default TokenProvider;