Comment sécuriser l'authentification dans une app générée par IA

L'authentification : le talon d'Achille des apps vibecodées

Dans 70% des apps que nous auditons, l'authentification est la première faille critique. Les outils comme Lovable, Bolt et Cursor génèrent du code d'auth qui "fonctionne" mais qui est rarement sécurisé.

Ce guide te montre comment identifier et corriger les problèmes les plus courants.

Problème #1 : JWT mal configuré

Ce qu'on trouve souvent :

// DANGEREUX - Code généré typique

const jwt = require('jsonwebtoken');

const token = jwt.sign(

{ userId: user.id, email: user.email },

'secret123', // Secret faible et en dur

// Pas d'expiration !

);

La correction :

const jwt = require('jsonwebtoken');

// Access token : courte durée

const accessToken = jwt.sign(

{ userId: user.id }, // Minimum de données

process.env.JWT_SECRET, // Secret en env, minimum 256 bits

{ expiresIn: '15m' } // Expire vite

);

// Refresh token : plus long mais stocké côté serveur

const refreshToken = jwt.sign(

{ userId: user.id, tokenVersion: user.tokenVersion },

process.env.JWT_REFRESH_SECRET,

{ expiresIn: '7d' }

);

Checklist JWT :

Problème #2 : Pas de rate limiting

Ce qu'on trouve :

// N'importe qui peut tester 10000 mots de passe/minute

app.post('/api/login', async (req, res) => {

const { email, password } = req.body;

const user = await User.findOne({ email });

// ...

});

La correction (avec express-rate-limit) :

const rateLimit = require('express-rate-limit');

const loginLimiter = rateLimit({

windowMs: 15 * 60 * 1000, // 15 minutes

max: 5, // 5 tentatives

message: { error: 'Trop de tentatives, réessayez dans 15 minutes' },

standardHeaders: true,

legacyHeaders: false,

});

app.post('/api/login', loginLimiter, async (req, res) => {

// ...

});

Problème #3 : Hashage de mot de passe faible

Ce qu'on trouve :

// CATASTROPHIQUE

const crypto = require('crypto');

const passwordHash = crypto.createHash('md5').update(password).digest('hex');

// Ou pire

const passwordHash = password; // En clair !

La correction (avec bcrypt) :

const bcrypt = require('bcrypt');

const SALT_ROUNDS = 12;

// À l'inscription

const passwordHash = await bcrypt.hash(password, SALT_ROUNDS);

// À la connexion

const isValid = await bcrypt.compare(password, user.passwordHash);

Problème #4 : Session non invalidée

Ce qu'on trouve :

// Le token reste valide même après logout

app.post('/api/logout', (req, res) => {

res.json({ message: 'Logged out' });

// Le JWT est toujours valide côté client...

});

La correction (blacklist ou token version) :

// Solution 1 : Token version en DB

// Dans le schema User

tokenVersion: { type: Number, default: 0 }

// Au logout : incrémenter la version

await User.updateOne({ _id: userId }, { $inc: { tokenVersion: 1 } });

// À la vérification : comparer les versions

const decoded = jwt.verify(token, process.env.JWT_SECRET);

const user = await User.findById(decoded.userId);

if (decoded.tokenVersion !== user.tokenVersion) {

throw new Error('Token invalidated');

}

Problème #5 : Reset password non sécurisé

Ce qu'on trouve :

// Token prévisible

const resetToken = Date.now().toString();

// Ou token qui n'expire jamais

// Ou lien envoyé en HTTP

La correction :

const crypto = require('crypto');

// Générer un token sécurisé

const resetToken = crypto.randomBytes(32).toString('hex');

const resetTokenHash = crypto.createHash('sha256').update(resetToken).digest('hex');

// Stocker avec expiration

await User.updateOne({ email }, {

resetToken: resetTokenHash,

resetTokenExpires: Date.now() + 3600000 // 1 heure

});

// Envoyer le lien (HTTPS obligatoire)

const resetUrl = `https://monapp.com/reset-password?token=${resetToken}`;

Implémentation complète recommandée

Pour une app Next.js vibecodée, voici une stack auth robuste :

1. NextAuth.js ou Lucia pour la gestion de sessions

2. bcrypt pour le hashage

3. zod pour la validation des inputs

4. rate-limiter-flexible pour le rate limiting

5. Cookies HttpOnly plutôt que localStorage

Conclusion

L'authentification générée par IA est presque toujours insuffisante pour la production. Les 5 corrections de cet article couvrent 80% des failles que nous trouvons.

*Tu veux qu'on vérifie ton système d'auth ? [Réserve un audit](/). On identifie toutes les failles et on te donne le code corrigé.*