1. User logs in with credentials
2. Server verifies credentials
3. Server creates a signed JWT containing user info
4. Client stores the token (localStorage, cookie)
5. Client sends token with every request
6. Server verifies token signature and extracts user info

header.payload.signature

npm install jsonwebtoken bcryptjs

const bcrypt = require('bcryptjs');

// ... inside your register route
const { username, password } = req.body;

// Check if user exists...

// Generate a salt with cost factor 10 (2^10 = 1024 rounds of hashing).
// Higher cost = slower hashing = harder to brute-force, but also slower registration.
// 10 is a good default; bump to 12 for high-security apps.
const salt = await bcrypt.genSalt(10);
const hashedPassword = await bcrypt.hash(password, salt);

// Save user with hashedPassword...
// The original plaintext password should NEVER be stored or logged.

// bcrypt.compare() hashes the plaintext password using the salt embedded
// in user.password, then compares the two hashes. Returns true or false.
const validPassword = await bcrypt.compare(password, user.password);

if (!validPassword) {
  // Security best practice: use the same error message for "user not found"
  // and "wrong password." If you say "wrong password," an attacker learns
  // that the email exists -- that is information leakage.
  return res.status(400).json({ msg: 'Invalid credentials' });
}

const jwt = require('jsonwebtoken');

// The payload contains claims -- data about the user that will be
// embedded in the token. Keep it minimal: only the user ID and role.
// Every byte in the payload is sent with EVERY request as an HTTP header.
const payload = {
  user: {
    id: user.id
  }
};

// jwt.sign() creates the three-part token (header.payload.signature).
// The secret key is used to create the signature -- anyone with the key
// can create valid tokens, so guard it carefully.
jwt.sign(
  payload,
  process.env.JWT_SECRET,
  { expiresIn: '1h' },  // Token becomes invalid after 1 hour
  (err, token) => {
    if (err) throw err;
    res.json({ token });
  }
);

const jwt = require('jsonwebtoken');

module.exports = function(req, res, next) {
  // Get token from header -- the client sends it as 'x-auth-token'.
  // In production, many teams prefer the 'Authorization: Bearer <token>' header instead.
  const token = req.header('x-auth-token');

  // No token means the user is not logged in (or forgot to send it)
  if (!token) {
    return res.status(401).json({ msg: 'No token, authorization denied' });
  }

  // jwt.verify() does two things:
  // 1. Checks the signature to ensure the token was not tampered with
  // 2. Checks the expiration date to ensure the token is still valid
  // If either check fails, it throws an error.
  try {
    const decoded = jwt.verify(token, process.env.JWT_SECRET);
    // Attach the user payload to the request object so downstream
    // route handlers can access req.user.id without re-parsing the token
    req.user = decoded.user;
    next();
  } catch (err) {
    // This catches both expired tokens (TokenExpiredError) and
    // tampered tokens (JsonWebTokenError). Do not distinguish between
    // them in the response -- that would leak information to attackers.
    res.status(401).json({ msg: 'Token is not valid' });
  }
};

const auth = require('./middleware/auth');

// Protected route -- 'auth' runs first, then the async handler.
// By the time the handler executes, req.user is guaranteed to be populated.
app.get('/api/auth/user', auth, async (req, res) => {
  try {
    // req.user.id was set by the auth middleware after verifying the token
    const user = await User.findById(req.user.id).select('-password');
    // .select('-password') excludes the password hash from the response --
    // never send password hashes to the client, even to the authenticated user
    res.json(user);
  } catch (err) {
    res.status(500).send('Server Error');
  }
});

// Generate both tokens -- note the different secrets and lifetimes.
// Using separate secrets means a stolen access token cannot be used
// as a refresh token (and vice versa).
const generateTokens = (userId) => {
  const accessToken = jwt.sign(
    { userId },
    process.env.ACCESS_TOKEN_SECRET,
    { expiresIn: '15m' }  // Short-lived: limits damage if stolen
  );
  
  const refreshToken = jwt.sign(
    { userId },
    process.env.REFRESH_TOKEN_SECRET,
    { expiresIn: '7d' }   // Long-lived: stored securely in httpOnly cookie
  );
  
  return { accessToken, refreshToken };
};

// Login endpoint
app.post('/api/auth/login', async (req, res) => {
  const { email, password } = req.body;
  
  const user = await User.findOne({ email });
  if (!user || !await bcrypt.compare(password, user.password)) {
    return res.status(401).json({ error: 'Invalid credentials' });
  }
  
  const { accessToken, refreshToken } = generateTokens(user._id);
  
  // Store refresh token in database or Redis so we can revoke it on logout.
  // Without server-side storage, there is no way to invalidate a refresh token
  // before it expires -- a stolen token remains valid indefinitely.
  await RefreshToken.create({ token: refreshToken, userId: user._id });
  
  // Send refresh token as httpOnly cookie -- this is critical:
  // httpOnly: JavaScript cannot read it (prevents XSS theft)
  // secure: only sent over HTTPS (prevents man-in-the-middle)
  // sameSite: only sent to same origin (prevents CSRF)
  res.cookie('refreshToken', refreshToken, {
    httpOnly: true,
    secure: process.env.NODE_ENV === 'production',
    sameSite: 'strict',
    maxAge: 7 * 24 * 60 * 60 * 1000 // 7 days
  });
  
  res.json({ accessToken });
});

// Refresh endpoint
app.post('/api/auth/refresh', async (req, res) => {
  const { refreshToken } = req.cookies;
  
  if (!refreshToken) {
    return res.status(401).json({ error: 'No refresh token' });
  }
  
  try {
    const decoded = jwt.verify(refreshToken, process.env.REFRESH_TOKEN_SECRET);
    
    // Check if refresh token exists in database
    const storedToken = await RefreshToken.findOne({ token: refreshToken });
    if (!storedToken) {
      return res.status(401).json({ error: 'Invalid refresh token' });
    }
    
    // Generate new access token
    const accessToken = jwt.sign(
      { userId: decoded.userId },
      process.env.ACCESS_TOKEN_SECRET,
      { expiresIn: '15m' }
    );
    
    res.json({ accessToken });
  } catch (error) {
    res.status(401).json({ error: 'Invalid refresh token' });
  }
});

// Logout endpoint
app.post('/api/auth/logout', async (req, res) => {
  const { refreshToken } = req.cookies;
  
  // Remove from database
  await RefreshToken.deleteOne({ token: refreshToken });
  
  // Clear cookie
  res.clearCookie('refreshToken');
  res.json({ message: 'Logged out successfully' });
});

// User model with roles
const UserSchema = new mongoose.Schema({
  email: String,
  password: String,
  role: {
    type: String,
    enum: ['user', 'admin', 'moderator'],
    default: 'user'
  }
});

// Role middleware -- a higher-order function that returns middleware.
// The ...roles spread operator lets you pass multiple allowed roles.
const authorize = (...roles) => {
  return (req, res, next) => {
    // 403 Forbidden (not 401 Unauthorized) -- the user IS authenticated
    // but does not have sufficient privileges. This distinction matters.
    if (!roles.includes(req.user.role)) {
      return res.status(403).json({
        error: 'Not authorized to access this resource'
      });
    }
    next();
  };
};

// Usage -- note the middleware chain: auth first (who are you?),
// then authorize (are you allowed?). Order matters.
app.get('/api/admin/users', auth, authorize('admin'), (req, res) => {
  // Only admins can access
});

app.delete('/api/posts/:id', auth, authorize('admin', 'moderator'), (req, res) => {
  // Admins and moderators can delete
});

npm install passport passport-google-oauth20

const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;

// The Google strategy handles the OAuth 2.0 dance:
// 1. Your app redirects the user to Google's login page
// 2. User authorizes your app
// 3. Google redirects back to your callbackURL with a temporary code
// 4. Passport exchanges that code for the user's profile (this callback fires)
passport.use(new GoogleStrategy({
    clientID: process.env.GOOGLE_CLIENT_ID,
    clientSecret: process.env.GOOGLE_CLIENT_SECRET,
    callbackURL: '/auth/google/callback'
  },
  async (accessToken, refreshToken, profile, done) => {
    try {
      // Check if this Google account is already linked to a user in our DB
      let user = await User.findOne({ googleId: profile.id });
      
      if (!user) {
        // First time logging in with Google -- create a new user record.
        // No password is stored because Google handles authentication.
        user = await User.create({
          googleId: profile.id,
          email: profile.emails[0].value,
          name: profile.displayName,
          avatar: profile.photos[0].value
        });
      }
      
      // done(error, user) -- pass null for error and the user object on success
      return done(null, user);
    } catch (error) {
      return done(error, null);
    }
  }
));

// Routes
app.get('/auth/google',
  passport.authenticate('google', { scope: ['profile', 'email'] })
);

app.get('/auth/google/callback',
  passport.authenticate('google', { session: false }),
  (req, res) => {
    const { accessToken, refreshToken } = generateTokens(req.user._id);
    res.redirect(`/auth-success?token=${accessToken}`);
  }
);

const crypto = require('crypto');
const nodemailer = require('nodemailer');

// Request password reset
app.post('/api/auth/forgot-password', async (req, res) => {
  const user = await User.findOne({ email: req.body.email });
  
  if (!user) {
    // CRITICAL: Return the same response whether or not the email exists.
    // Saying "email not found" tells attackers which emails are registered.
    return res.json({ message: 'If email exists, reset link sent' });
  }
  
  // Generate a cryptographically random token (32 bytes = 256 bits of entropy).
  // This goes in the email link and is the user's proof of identity.
  const resetToken = crypto.randomBytes(32).toString('hex');
  
  // Store only the HASH of the token in the database.
  // If the DB is compromised, attackers cannot use the hashed tokens
  // to reset anyone's password -- they would need the original plaintext.
  const hashedToken = crypto
    .createHash('sha256')
    .update(resetToken)
    .digest('hex');
  
  user.resetPasswordToken = hashedToken;
  user.resetPasswordExpires = Date.now() + 3600000; // 1 hour
  await user.save();
  
  // Send email
  const resetUrl = `${process.env.FRONTEND_URL}/reset-password/${resetToken}`;
  
  await transporter.sendMail({
    to: user.email,
    subject: 'Password Reset',
    html: `Click <a href="${resetUrl}">here</a> to reset your password.`
  });
  
  res.json({ message: 'If email exists, reset link sent' });
});

// Reset password
app.post('/api/auth/reset-password/:token', async (req, res) => {
  const hashedToken = crypto
    .createHash('sha256')
    .update(req.params.token)
    .digest('hex');
  
  const user = await User.findOne({
    resetPasswordToken: hashedToken,
    resetPasswordExpires: { $gt: Date.now() }
  });
  
  if (!user) {
    return res.status(400).json({ error: 'Invalid or expired token' });
  }
  
  user.password = await bcrypt.hash(req.body.password, 10);
  user.resetPasswordToken = undefined;
  user.resetPasswordExpires = undefined;
  await user.save();
  
  res.json({ message: 'Password reset successful' });
});