Documentation

const { hash, SECURITY_PRESETS } = require('inslash');

// Use a named preset
const result = await hash('myPassword', secret, { preset: 'strong' });

// Or access preset values directly
console.log(SECURITY_PRESETS.paranoid);
// { iterations: 400000, saltLength: 32, hashLength: 64, algorithm: 'sha512' }

const { batchVerify } = require('inslash');

const results = await batchVerify(
    ['guess1', 'guess2', 'correctPassword'],
    storedPassport,
    secret,
    { concurrency: 4 }
);
// [{ value: 'guess1', valid: false }, { value: 'correctPassword', valid: true, needsUpgrade: false }]

const { inspectPassport } = require('inslash');

const info = inspectPassport(storedPassport);
console.log(info.algorithm);  // 'sha384'
console.log(info.iterations); // 200000
console.log(info.history);    // [{ date, algorithm, event }]

const { comparePassports } = require('inslash');

const cmp = comparePassports(passportA, passportB);
console.log(cmp.sameAlgorithm); // true
console.log(cmp.identical);     // false (different salts)

const { estimateSecurity } = require('inslash');

const { score, level, recommendations } = estimateSecurity(storedPassport);
console.log(score);           // 78
console.log(level);           // 'Strong'
console.log(recommendations); // ['Consider upgrading to sha512']

const { generateApiKey } = require('inslash');

const key = generateApiKey({ prefix: 'myapp', byteLength: 32 });
console.log(key); // 'myapp_a3f9b2c1...'

const { deriveKey } = require('inslash');
const crypto = require('crypto');

const salt = crypto.randomBytes(16).toString('hex');
const keyBuffer = await deriveKey('userPassword', salt, {
    iterations: 200_000,
    keyLength: 32,       // 256-bit AES key
    algorithm: 'sha512'
});

// Use keyBuffer with AES-256-GCM for encryption

const express = require('express');
const session = require('express-session');
const { hash, verify } = require('inslash');
const User = require('./models/User');

const app = express();
app.use(express.json());
app.use(session({
    secret: 'your-session-secret',
    resave: false,
    saveUninitialized: false
}));

// Login endpoint
app.post('/login', async (req, res) => {
    const { email, password } = req.body;

    // Find user
    const user = await User.findOne({ email });
    if (!user) {
        return res.status(401).json({ error: 'Invalid credentials' });
    }

    // Verify password
    const result = await verify(password, user.passport, process.env.HASH_PEPPER);

    if (!result.valid) {
        return res.status(401).json({ error: 'Invalid credentials' });
    }

    // Automatic security upgrade
    if (result.needsUpgrade) {
        user.passport = result.upgradedPassport;
        await user.save();
        console.log('Password hash upgraded for user:', user.email);
    }

    // Create session
    req.session.userId = user._id;
    res.json({ success: true, user: { id: user._id, email: user.email } });
});

// Protected route middleware
function requireAuth(req, res, next) {
    if (!req.session.userId) {
        return res.status(401).json({ error: 'Unauthorized' });
    }
    next();
}

app.get('/dashboard', requireAuth, (req, res) => {
    res.json({ message: 'Welcome to your dashboard!' });
});

app.listen(3000);

const { hash } = require('inslash');
const User = require('./models/User');

app.post('/signup', async (req, res) => {
    const { username, email, password, confirmPassword } = req.body;

    // Validation
    if (!username || !email || !password) {
        return res.status(400).json({ error: 'All fields required' });
    }

    if (password !== confirmPassword) {
        return res.status(400).json({ error: 'Passwords do not match' });
    }

    if (password.length < 8) {
        return res.status(400).json({ error: 'Password must be at least 8 characters' });
    }

    // Check if user exists
    const existingUser = await User.findOne({ $or: [{ username }, { email }] });
    if (existingUser) {
        return res.status(400).json({ error: 'Username or email already exists' });
    }

    // Hash password with strong settings
    const hashResult = await hash(password, process.env.HASH_PEPPER, {
        algorithm: 'sha512',
        iterations: 150000
    });

    // Create user
    const user = new User({
        username,
        email,
        passport: hashResult.passport,
        createdAt: new Date()
    });

    await user.save();

    // Auto-login after registration
    req.session.userId = user._id;
    res.status(201).json({ success: true, user: { id: user._id, username: user.username, email: user.email } });
});

const crypto = require('crypto');
const { hash } = require('inslash');
const User = require('./models/User');
const sendEmail = require('./utils/email');

// Request password reset
app.post('/forgot-password', async (req, res) => {
    const { email } = req.body;

    // Find user
    const user = await User.findOne({ email });
    if (!user) {
        // Don't reveal if email exists
        return res.json({ message: 'If email exists, reset link sent' });
    }

    // Generate reset token
    const resetToken = crypto.randomBytes(32).toString('hex');
    const resetTokenHash = crypto.createHash('sha256').update(resetToken).digest('hex');

    user.resetPasswordToken = resetTokenHash;
    user.resetPasswordExpires = Date.now() + 3600000; // 1 hour
    await user.save();

    // Send email
    const resetUrl = \`https://yourapp.com/reset-password/\${resetToken}\`;
    await sendEmail({
        to: user.email,
        subject: 'Password Reset Request',
        html: \`Click here to reset: \${resetUrl}\`
    });

    res.json({ message: 'If email exists, reset link sent' });
});

// Reset password with token
app.post('/reset-password/:token', async (req, res) => {
    const { password } = req.body;

    // Hash the token to compare
    const resetTokenHash = crypto.createHash('sha256')
        .update(req.params.token)
        .digest('hex');

    // Find user with valid token
    const user = await User.findOne({
        resetPasswordToken: resetTokenHash,
        resetPasswordExpires: { $gt: Date.now() }
    });

    if (!user) {
        return res.status(400).json({ error: 'Invalid or expired token' });
    }

    // Hash new password
    const hashResult = await hash(password, process.env.HASH_PEPPER, {
        algorithm: 'sha512',
        iterations: 150000
    });

    // Update user
    user.passport = hashResult.passport;
    user.resetPasswordToken = undefined;
    user.resetPasswordExpires = undefined;
    await user.save();

    res.json({ success: true, message: 'Password reset successful' });
});

// Production configuration
const productionConfig = {
    algorithm: 'sha512', // Strongest algorithm
    iterations: 150000, 
    saltLength: 16,     
    hashLength: 64      
};

// Use it
const result = await hash(password, process.env.HASH_PEPPER, productionConfig);