bcrypt vs Argon2 : Benchmark Performance Complet 2024

Latence médiane (ms)

Profil d'utilisation CPU

Coût mensuel estimé (1M auth/mois)

Optimisations bcrypt

// Pool de workers pour éviter le blocking
const bcrypt = require('bcrypt');
const { Worker, isMainThread, parentPort, workerData } = require('worker_threads');

class BcryptPool {
  constructor(poolSize = 4) {
    this.workers = [];
    this.queue = [];
    
    for (let i = 0; i < poolSize; i++) {
      this.workers.push(new Worker(__filename));
    }
  }
  
  async hash(password, rounds = 12) {
    return new Promise((resolve, reject) => {
      const worker = this.getAvailableWorker();
      worker.postMessage({ action: 'hash', password, rounds });
      
      worker.once('message', (result) => {
        if (result.error) reject(new Error(result.error));
        else resolve(result.hash);
      });
    });
  }
}

// Cache intelligent pour réduire les calculs
const LRU = require('lru-cache');
const hashCache = new LRU({ max: 1000, ttl: 1000 * 60 * 5 }); // 5 min

async function cachedBcrypt(password, hash) {
  const cacheKey = `${password}:${hash}`;
  
  if (hashCache.has(cacheKey)) {
    return hashCache.get(cacheKey);
  }
  
  const result = await bcrypt.compare(password, hash);
  hashCache.set(cacheKey, result);
  
  return result;
}

Optimisations Argon2

// Configuration adaptative selon la charge
const argon2 = require('argon2');
const os = require('os');

class AdaptiveArgon2 {
  constructor() {
    this.baseConfig = {
      type: argon2.argon2id,
      memoryCost: 2 ** 16, // 64 MB
      timeCost: 3,
      parallelism: 4,
    };
    
    this.currentLoad = 0;
    this.maxConcurrent = Math.floor(os.totalmem() / (64 * 1024 * 1024)); // Limite mémoire
  }
  
  async hash(password) {
    // Réduction des paramètres sous forte charge
    const config = { ...this.baseConfig };
    
    if (this.currentLoad > this.maxConcurrent * 0.8) {
      config.memoryCost = 2 ** 15; // 32 MB
      config.timeCost = 2;
    }
    
    this.currentLoad++;
    
    try {
      const hash = await argon2.hash(password, config);
      return hash;
    } finally {
      this.currentLoad--;
    }
  }
  
  // Pré-allocation mémoire pour éviter la fragmentation
  async warmup() {
    const dummyHashes = [];
    for (let i = 0; i < 10; i++) {
      dummyHashes.push(this.hash('warmup'));
    }
    await Promise.all(dummyHashes);
  }
}