mirror of
https://github.com/filecoin-project/slate.git
synced 2024-09-11 22:07:08 +03:00
111 lines
3.9 KiB
JavaScript
111 lines
3.9 KiB
JavaScript
import * as Logging from "~/common/logging";
|
|
import * as Environment from "~/node_common/environment";
|
|
import * as Utilities from "~/node_common/utilities";
|
|
import * as Data from "~/node_common/data";
|
|
import * as Strings from "~/common/strings";
|
|
import * as Validations from "~/common/validations";
|
|
|
|
import { encryptPasswordClient } from "~/common/utilities";
|
|
|
|
import JWT from "jsonwebtoken";
|
|
|
|
export default async (req, res) => {
|
|
if (!Strings.isEmpty(Environment.ALLOWED_HOST) && req.headers.host !== Environment.ALLOWED_HOST) {
|
|
return res.status(403).send({ decorator: "SERVER_SIGN_IN_NOT_ALLOWED", error: true });
|
|
}
|
|
|
|
// NOTE(jim): We don't need to validate here.
|
|
if (Strings.isEmpty(req.body.data.username)) {
|
|
return res.status(500).send({ decorator: "SERVER_SIGN_IN_NO_USERNAME", error: true });
|
|
}
|
|
|
|
if (Strings.isEmpty(req.body.data.password)) {
|
|
return res.status(500).send({ decorator: "SERVER_SIGN_IN_NO_PASSWORD", error: true });
|
|
}
|
|
|
|
const username = req.body.data.username.toLowerCase();
|
|
let user;
|
|
if (Validations.email(username)) {
|
|
try {
|
|
user = await Data.getUserByEmail({ email: username });
|
|
} catch (e) {
|
|
Logging.error(e);
|
|
}
|
|
} else {
|
|
try {
|
|
user = await Data.getUserByUsername({
|
|
username: req.body.data.username.toLowerCase(),
|
|
});
|
|
} catch (e) {
|
|
Logging.error(e);
|
|
}
|
|
}
|
|
|
|
if (!user) {
|
|
return res.status(404).send({ decorator: "SERVER_SIGN_IN_USER_NOT_FOUND", error: true });
|
|
}
|
|
|
|
if (user.error) {
|
|
return res.status(500).send({ decorator: "SERVER_SIGN_IN_USER_NOT_FOUND", error: true });
|
|
}
|
|
|
|
// Note(amine): Twitter users won't have a password,
|
|
// we should think in the future how to handle this use case
|
|
if ((!user.salt || !user.password) && user.twitterId) {
|
|
return res.status(403).send({ decorator: "SERVER_TWITTER_LOGIN_ONLY", error: true });
|
|
}
|
|
|
|
let userUpdates = { id: user.id, lastActive: new Date() };
|
|
|
|
let hash = await Utilities.encryptPassword(req.body.data.password, user.salt);
|
|
|
|
let updatePassword = user.authVersion === 1; //NOTE(martina): if they are v1, we may need to update their password
|
|
if (hash !== user.password) {
|
|
//NOTE(martina): this was added to deal with a specific case where the passwords of some v1 users could either be the v1 hashing schema or v2 (so we try both)
|
|
if (user.authVersion === 1) {
|
|
const clientHash = await encryptPasswordClient(req.body.data.password);
|
|
hash = await Utilities.encryptPassword(clientHash, user.salt);
|
|
if (hash !== user.password) {
|
|
return res.status(403).send({ decorator: "SERVER_SIGN_IN_WRONG_CREDENTIALS", error: true });
|
|
}
|
|
updatePassword = false; //NOTE(martina): means the user's password is already v2 hashed, and doesn't need to be updated
|
|
} else {
|
|
return res.status(403).send({ decorator: "SERVER_SIGN_IN_WRONG_CREDENTIALS", error: true });
|
|
}
|
|
}
|
|
|
|
if (user.authVersion === 1) {
|
|
userUpdates.authVersion = 2;
|
|
userUpdates.revertedVersion = false;
|
|
}
|
|
|
|
if (updatePassword) {
|
|
const newHash = await encryptPasswordClient(req.body.data.password);
|
|
const doubledHash = await Utilities.encryptPassword(newHash, user.salt);
|
|
userUpdates.password = doubledHash;
|
|
}
|
|
|
|
await Data.updateUserById(userUpdates);
|
|
|
|
if (!user.email) {
|
|
return res
|
|
.status(200)
|
|
.send({ decorator: "SERVER_SIGN_IN_SHOULD_MIGRATE", shouldMigrate: true });
|
|
}
|
|
const authorization = Utilities.parseAuthHeader(req.headers.authorization);
|
|
if (authorization && !Strings.isEmpty(authorization.value)) {
|
|
const verfied = JWT.verify(authorization.value, Environment.JWT_SECRET);
|
|
|
|
if (user.username === verfied.username) {
|
|
return res.status(200).send({
|
|
message: "You are already authenticated. Welcome back!",
|
|
viewer: user,
|
|
});
|
|
}
|
|
}
|
|
|
|
const token = JWT.sign({ id: user.id, username: user.username }, Environment.JWT_SECRET);
|
|
|
|
return res.status(200).send({ decorator: "SERVER_SIGN_IN", success: true, token });
|
|
};
|