TypeScript bcryptjs.hashSync函数代码示例

        handler: async function (req, res, next) {
            const payload: Requests.UpdatePassword = req.validatedBody;
            let user = await UserDb.get(req.user._id);

            // Ensure the user's current password is correct
            if (!compareSync(payload.old_password, user.hashed_password)) {
                return next(boom.forbidden(`Your current password is incorrect.`));
            }

            // Change the user's password
            user.hashed_password = hashSync(payload.new_password);

            try {
                const updateResult = await UserDb.put(user._id, user, user._rev);
                user._rev = updateResult.rev
            } catch (e) {
                inspect("Failed to update user's password.", e);

                return next(e);
            }

            await res.withSessionToken(user);

            return next();
        }

function hashPassword(password: string): string {
  if (!password) {
    return null;
  }

  return Bcrypt.hashSync(password, Bcrypt.genSaltSync(8));
}

    /**
	 * Initializes the comms controller
	 */
    async initialize( db: mongodb.Db ): Promise<void> {
        let cfg = this._cfg;

        // Throw error if no socket api key
        if ( !cfg.websocket.socketApiKey )
            throw new Error( 'The socketApiKey was not set in the config file. Make sure it exists (Check the example-config.json) ' );

        this._hashedApiKey = bcrypt.hashSync( cfg.websocket.socketApiKey );

        // dummy request processing - this is not actually called as its handed off to the socket api
        const processRequest = function( req, res ) {
            req; // Suppress compiler warning
            res.writeHead( 200 );
            res.end( 'All glory to WebSockets!\n' );
        };

        // Create the web socket server
        if ( cfg.ssl ) {
            winston.info( 'Creating secure socket connection', { process: process.pid } );
            let httpsServer: https.Server;
            const caChain = [ fs.readFileSync( cfg.sslIntermediate ), fs.readFileSync( cfg.sslRoot ) ];
            const privkey = cfg.sslKey ? fs.readFileSync( cfg.sslKey ) : null;
            const theCert = cfg.sslCert ? fs.readFileSync( cfg.sslCert ) : null;

            winston.info( `Attempting to start Websocket server with SSL...`, { process: process.pid } );
            httpsServer = https.createServer( { key: privkey, cert: theCert, passphrase: cfg.sslPassPhrase, ca: caChain }, processRequest );
            httpsServer.listen( cfg.websocket.port );
            this._server = new ws.Server( { server: httpsServer } );
        }
        else {
            winston.info( 'Creating regular socket connection', { process: process.pid } );
            this._server = new ws.Server( { port: cfg.websocket.port } );
        }

        winston.info( 'Websockets attempting to listen on HTTP port ' + this._cfg.websocket.port, { process: process.pid } );

        // Handle errors
        this._server.on( 'error', ( err ) => {
            winston.error( 'Websocket error: ' + err.toString() );
            this._server.close();
        } );

        // A client has connected to the server
        this._server.on( 'connection', ( ws: ws ) => {
            this.onWsConnection( ws );
        } );

        // Setup the socket API
        new SocketAPI( this );
    }

export async function postSettings(server: Server, request: Request, reply: IReply)
{
    function view(error: string, success?: boolean)
    {
        const props: SettingsProps = {
            title: "Account Settings.",
            success: !!success,
        }

        return reply.view("account/settings.js", props);
    }

    const validation = joi.validate<{newPassword: string, oldPassword: string, confirmPassword: string}>(request.payload, JoiValidation.postSettings);

    if (validation.error)
    {
        return view(humanizeError(validation.error));
    }

    const payload = validation.value;

    if (payload.confirmPassword !== payload.newPassword)
    {
        return view("New Password does not match the confirmation.");
    }

    const user = await Users.get<User>(request.auth.credentials.userId);

    // Ensure the user's current password is correct
    if(! compareSync(payload.oldPassword, user.hashedPassword))
    {
        return view("Old Password does not match.");
    }
    
    // Change the user's password
    user.hashedPassword = hashSync(payload.newPassword, 10);

    const update = await Users.put(user);

    if (!update.ok)
    {
        console.error("Failed to update user's password.", update);

        return reply(boom.expectationFailed("Failed to update user's password.", update));
    }

    await setUserAuth(request, user);

    return view(undefined, true);
}

export async function postResetPassword(server: Server, request: Request, reply: IReply): Promise<IBoom | Response>
{
    const payload: {password: string, token: string, confirmPassword: string} = request.payload;
    const validation = joi.validate(payload, JoiValidation.resetPassword);
    const props: ResetPasswordProps = {
        title: "Reset your password.",
        token: payload.token,
    }

    if (validation.error)
    {
        props.error = humanizeError(validation.error);

        return reply.view("auth/reset_password.js", props);
    }

    if (payload.confirmPassword !== payload.password)
    {
        props.error = "Passwords do not match.";

        return reply.view("auth/reset_password.js", props);
    }

    // Ensure the user's password token is still valid
    const user = await findUserByPasswordResetToken(payload.token);

    if (!user || user.passwordResetToken !== payload.token || new Date(user.passwordResetRequestedAt as string) < new Date(new Date().getTime() - (30 * 60 * 1000) /* 30 minutes */))
    {
        props.error = "Your password reset request has expired.";

        return reply.view("auth/reset_password.js", props);
    }

    // Reset user's password
    user.passwordResetToken = undefined;
    user.passwordResetRequestedAt = undefined;
    user.hashedPassword = hashSync(payload.password, 10);

    const update = await Users.put(user);

    if (!update.ok)
    {
        console.error("Failed to save user's new password during password reset request.", update);

        return reply(boom.expectationFailed("Failed to save user's new password during password reset request.")); 
    }

    return reply.redirect(Routes.GetLogin);
}

	fromJSON(o: any): void
		{
			this.ns = o.ns;
			this.id = o.id;
			this.token = o.token;
			this.name = o.name;
			this.email = o.email;
			if (o.hash)
				this.hash = o.hash;
			if (o.password)
				this.hash = bcrypt.hashSync(o.password, 8);
			this.sessions = o.sessions;
			if (this.sessions == null)
				this.sessions = {};
		}

export async function setUserAuth(request: Request, user: User)
{
    const hash = bcrypt.hashSync(EncryptionSignature, 10);
    const cookie: AuthCookie = {
        encryptionSignature: hash,
        userId: user._id.toLowerCase(),
        username: user.username,
    }

    try
    {
        await setUserCache(user);
    }
    catch (e)
    {
        console.error("Error setting user cache data.");

        throw e;
    }
    
    return request.yar.set(cookieName, cookie);
}

export function hashPasswd(password: string): string {
  const salt = bcrypt.genSaltSync(10);
  const hash = bcrypt.hashSync(password, salt);
  return hash;
}