Elysia Tools

Explora herramientas, ejemplos, explicaciones visuales y guías temáticas en un solo espacio claro.

Categorías populares

Temas

Idioma
ZHDERUPTENFRES

Elysia Tools

Navegación

Autenticación y autorización

Middleware de Autenticación Passport.js

Middleware de autenticación Node.js con Passport.js y varias estrategias

Ejemplos

Entradas de esta colección

CódigojavascriptIntermedio

Estrategia Local de Passport.js

Autenticación local con Passport.js

Dificultad

5/10

Tiempo estimado

15 min

Etiquetas

passport, authentication, local, security

Requisitos previos

Node.js, Express.js, Passport.js

javascript
// 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 = {
  'john@example.com': {
    id: 1,
    email: 'john@example.com',
    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'));
CódigojavascriptIntermedio

Passport.js Google OAuth 2.0

Autenticación Google OAuth 2.0 con Passport.js

Dificultad

6/10

Tiempo estimado

20 min

Etiquetas

passport, google, oauth2, social, authentication

Requisitos previos

Node.js, Google Console, OAuth 2.0

javascript
// 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('/');
};
CódigojavascriptIntermedio

Estrategia JWT de Passport.js

Autenticación JWT con Passport.js para APIs

Dificultad

6/10

Tiempo estimado

15 min

Etiquetas

passport, jwt, authentication, api, security

Requisitos previos

Node.js, JWT concepts, APIs

javascript
// 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 });
});
CódigojavascriptComplejo

Estrategia Personalizada de Passport

Crear estrategias personalizadas con Passport.js

Dificultad

7/10

Tiempo estimado

20 min

Etiquetas

passport, custom, api key, advanced

Requisitos previos

Node.js, Passport.js, Custom strategies

javascript
// 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 });
  }
);

Herramientas

Herramientas que suelen usarse con este ejemplo

Relacionado

Colecciones de ejemplos relacionadas

Relacionado

Temas relacionados

Tema

Inferir JSON Schema desde muestras y hojas de cálculo

Obtén un borrador revisable de JSON Schema a partir de muestras JSON representativas o filas XLSX, y revisa tipos, obligatoriedad, nulos y valores atípicos antes de usarlo como contrato.

Tema

Extraccion, transformacion y linaje de campos JSON

Extrae campos JSON por ruta, remodela el payload con JSONata y registra el origen y el recorrido de cada campo sin afirmar validacion semantica de negocio.

Tema

Flujo de normalización e intercambio JSON

Convierte una fuente estructurada en una representación JSON revisada y expórtala como tabla, configuración, documento, API, XML, CSON, EDN, BSON o UBJSON según el consumidor.

Tema

Revisión de dependencias y licencias de una versión Node.js

Fija el inventario de una versión Node.js, revisa un SBOM externo con una política de licencias aprobada y entrega cambios, excepciones y pruebas de aprobación trazables.

Inicio
Herramientas3212
Ejemplos593
Visualizaciones471
Visores de archivos103
Temas239
Etiquetas333
Imágenes, audio y video657

Herramientas de procesamiento, conversión y optimización de imágenes, audio y video

Matemáticas, fechas y finanzas647

Calculadoras, herramientas numéricas, lógica de fechas, estadística y finanzas

Diseño y color298

Herramientas de color, maquetación, gráficos, estilo visual y apoyo al diseño

Texto y redacción209

Herramientas de redacción, limpieza, formato, extracción y análisis de texto

Desarrollo y Web193

Utilidades para desarrolladores, red, depuración web y automatización

Conversión y codificación175

Herramientas de conversión de formatos, archivos, unidades, archivos comprimidos y codificación

Lanzamiento de un cuestionario de captación y entrega de contactos
Textos conmemorativos: revisión familiar y entrega para impresión
Hábitos privados: copia, restauración y revisión antes de compartir
De artículo a borradores de X y LinkedIn: revisión factual y entrega
Revisión de una lección Markdown interactiva y entrega sin conexión

© 2026 Elysia Tools. Todos los derechos reservados.

DocumentaciónPreciosAcerca deTérminos de servicioPolítica de privacidadCookiesContacto

Validation

Validador de Pasaporte

Valida números de pasaporte de diferentes países (China, EE.UU., Japón, etc.)

Autenticación y autorización

Ejemplos OAuth 2.0 & OpenID Connect

Ejemplos del framework de autorización OAuth 2.0 y protocolo de autenticación OpenID Connect

Autenticación y autorización

Ejemplos OAuth 2.0

Ejemplos de implementación OAuth 2.0 incluyendo flujos de autorización, configuraciones de cliente y mejores prácticas de seguridad

Seguridad

Muestras JWT

Ejemplos completos de JWT desde la estructura básica de tokens hasta implementaciones de seguridad avanzadas

Seguridad

Muestras de Arquitectura Zero Trust

Muestras comprensivas de arquitectura Zero Trust cubriend autenticación, segmentación de red y control de acceso seguro

Frameworks web

Ejemplos de Koa

Ejemplos del framework de middleware Node.js Koa incluyendo encadenamiento de middleware, manejo de contexto, patrones async/await e integración con el ecosistema

Autenticación y autorización

Biblioteca de Control de Acceso Casbin

Biblioteca de control de acceso de código abierto potente y eficiente