Documentation

const inslash=require('inslash'); require("dotenv").config(); //
          1. Configure (Global) inslash.configure({ apiKey: process.env.INSLASH_API_KEY,
          apiUrl: 'https://inslash.antqr.xyz' // Hosted Instance }); // 2. Destructure after configuration (optional,
          but cleaner) const { hash, verify }=inslash; async function example() { // This now automatically uses the
          API! const result=await hash('password123', process.env.HASH_PEPPER); console.log(result.passport); const
          isValid=await verify('password123', result.passport, process.env.HASH_PEPPER); console.log(isValid.valid); //
          true } example();

const { hash, verify }=require('inslash'); // Hash a password
          const result=await hash('userPassword123', process.env.HASH_PEPPER); console.log(result.passport); // Store
          this in your database // Verify a password const isValid=await verify('userPassword123', result.passport,
          process.env.HASH_PEPPER); console.log(isValid.valid); // true

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;

          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, // High iteration count saltLength: 16, //
          Default is fine hashLength: 64 // Larger for SHA-512 }; const result=await hash(password,
          process.env.HASH_PEPPER, productionConfig);