Middleware de Autenticación Passport.js

// Passport.js Local Strategy Setup
const passport = require('passport');
const LocalStrategy = require('passport-local').Strategy;
const bcrypt = require('bcrypt');
const express = require('express');

// User database (in production, use a real database)
const users = {
  '[email protected]': {
    id: 1,
    email: '[email protected]',
    password: bcrypt.hashSync('password123', 10),
    name: 'John Doe'
  }
};

// Local Strategy
passport.use(new LocalStrategy(
  {
    usernameField: 'email',
    passwordField: 'password'
  },
  async (email, password, done) => {
    try {
      const user = users[email];
      if (!user) {
        return done(null, false, { message: 'User not found' });
      }

      const isValid = await bcrypt.compare(password, user.password);
      if (!isValid) {
        return done(null, false, { message: 'Invalid password' });
      }

      return done(null, user);
    } catch (error) {
      return done(error);
    }
  }
));

// Serialize/deserialize user
passport.serializeUser((user, done) => done(null, user.id));
passport.deserializeUser((id, done) => {
  const user = Object.values(users).find(u => u.id === id);
  done(null, user);
});

// Express app setup
const app = express();
app.use(express.json());
app.use(require('express-session')({ secret: 'secret' }));
app.use(passport.initialize());
app.use(passport.session());

// Authentication middleware
const authMiddleware = (req, res, next) => {
  if (req.isAuthenticated()) {
    return next();
  }
  res.status(401).json({ error: 'Unauthorized' });
};

// Routes
app.post('/login', passport.authenticate('local'), (req, res) => {
  res.json({ user: req.user });
});

app.get('/profile', authMiddleware, (req, res) => {
  res.json({ user: req.user });
});

app.post('/logout', (req, res) => {
  req.logout();
  res.json({ message: 'Logged out' });
});

app.listen(3000, () => console.log('Server running on port 3000'));

// Passport.js Google OAuth 2.0
const passport = require('passport');
const GoogleStrategy = require('passport-google-oauth20').Strategy;
const express = require('express');
const app = express();

// Google Strategy
passport.use(new GoogleStrategy({
  clientID: process.env.GOOGLE_CLIENT_ID,
  clientSecret: process.env.GOOGLE_CLIENT_SECRET,
  callbackURL: '/auth/google/callback'
}, (accessToken, refreshToken, profile, done) => {
  // Find or create user in your database
  const user = {
    id: profile.id,
    email: profile.emails[0].value,
    name: profile.displayName,
    avatar: profile.photos[0].value
  };

  return done(null, user);
}));

// Routes
app.get('/auth/google', passport.authenticate('google'));

app.get('/auth/google/callback',
  passport.authenticate('google', { failureRedirect: '/' }),
  (req, res) => {
    res.redirect('/dashboard');
  }
);

// Middleware to check authentication
const ensureAuthenticated = (req, res, next) => {
  if (req.isAuthenticated()) return next();
  res.redirect('/');
};

// Passport.js JWT Strategy
const passport = require('passport');
const JwtStrategy = require('passport-jwt').Strategy;
const ExtractJwt = require('passport-jwt').ExtractJwt;
const jwt = require('jsonwebtoken');
const express = require('express');
const app = express();
app.use(express.json());

// JWT Strategy
passport.use(new JwtStrategy({
  jwtFromRequest: ExtractJwt.fromAuthHeaderAsBearerToken(),
  secretOrKey: 'your-secret-key'
}, (payload, done) => {
  // Find user by ID from payload
  const user = { id: payload.sub, email: payload.email };
  return done(null, user);
}));

// Generate JWT token
function generateToken(user) {
  return jwt.sign(
    { sub: user.id, email: user.email },
    'your-secret-key',
    { expiresIn: '1h' }
  );
}

// Login route
app.post('/login', (req, res) => {
  // Validate credentials (simplified)
  const user = { id: 1, email: req.body.email };
  const token = generateToken(user);

  res.json({ token, user });
});

// Protected route middleware
const authMiddleware = passport.authenticate('jwt', { session: false });

// Protected API route
app.get('/api/profile', authMiddleware, (req, res) => {
  res.json({ user: req.user });
});

// Custom Passport Strategy
const passport = require('passport');
const { Strategy } = require('passport-strategy');
const express = require('express');
const app = express();

// Custom API Key Strategy
class ApiKeyStrategy extends Strategy {
  constructor(verifyCallback) {
    super();
    this.name = 'apikey';
    this.verify = verifyCallback;
  }

  authenticate(req, options) {
    const apiKey = req.query.apiKey || req.headers['x-api-key'];
    if (!apiKey) {
      return this.fail({ message: 'API key required' });
    }

    // Validate API key against database
    this.verify(apiKey, (err, user) => {
      if (err) return this.error(err);
      if (!user) return this.fail({ message: 'Invalid API key' });
      return this.success(user);
    });
  }
}

// Use custom strategy
passport.use('apikey', new ApiKeyStrategy(
  (apiKey, done) => {
    // Database lookup
    const validKeys = {
      'key123': { id: 1, name: 'App 1' },
      'key456': { id: 2, name: 'App 2' }
    };

    const user = validKeys[apiKey];
    done(null, user);
  }
));

// API endpoint with custom auth
app.get('/api/data',
  passport.authenticate('apikey', { session: false }),
  (req, res) => {
    res.json({ data: 'Protected data', user: req.user });
  }
);