SHA-1

const crypto = require('crypto');

// ⚠️ ATTENTION : SHA-1 EST OBSOLÈTE - À MIGRER VERS SHA-256
const generateSHA1 = (input) => {
  console.warn('🚨 SHA-1 EST DÉPRÉCIÉ - MIGRATION RECOMMANDÉE');
  
  const hash = crypto.createHash('sha1');
  hash.update(input);
  return hash.digest('hex');
};

// Usage (OBSOLÈTE - Pour référence uniquement)
const input = "Hello World";
const sha1Hash = generateSHA1(input);
console.log('SHA-1 Hash:', sha1Hash);
// Sortie: 0a4d55a8d778e5022fab701977c5d840bbc486d0

// ✅ MIGRATION RECOMMANDÉE vers SHA-256
const generateSHA256 = (input) => {
  const hash = crypto.createHash('sha256');
  hash.update(input);
  return hash.digest('hex');
};

const secureHash = generateSHA256(input);
console.log('SHA-256 Hash:', secureHash);

// Migration pattern recommandé
function migrateFromSHA1(input) {
  // Legacy SHA-1 (pour compatibilité temporaire)
  const oldHash = generateSHA1(input);
  
  // Nouveau SHA-256 (sécurisé)
  const newHash = generateSHA256(input);
  
  return {
    legacy: oldHash,
    secure: newHash,
    recommendation: 'Utilisez uniquement secure pour nouvelles implémentations'
  };
}

import hashlib
import warnings

# Configuration migration SHA-1
warnings.filterwarnings('default')

def generate_sha1(data: str) -> str:
    """
    ⚠️ OBSOLÈTE : SHA-1 est cryptographiquement cassé
    Utilisez uniquement pour compatibilité legacy
    """
    warnings.warn(
        "SHA-1 est obsolète depuis 2017. Migrez vers SHA-256 immédiatement!",
        DeprecationWarning,
        stacklevel=2
    )
    
    sha1_hash = hashlib.sha1()
    sha1_hash.update(data.encode('utf-8'))
    return sha1_hash.hexdigest()

def generate_sha256(data: str) -> str:
    """✅ SÉCURISÉ : SHA-256 recommandé 2024"""
    sha256_hash = hashlib.sha256()
    sha256_hash.update(data.encode('utf-8'))
    return sha256_hash.hexdigest()

def detect_and_migrate(hash_value: str):
    """Détection et recommandations migration"""
    
    if len(hash_value) == 40 and all(c in '0123456789abcdefABCDEF' for c in hash_value):
        return {
            'algorithm': 'SHA-1',
            'status': 'OBSOLÈTE',
            'risk': 'CRITIQUE',
            'action': 'MIGRATION IMMÉDIATE REQUISE',
            'replacement': 'SHA-256 ou SHA-384',
            'timeline': 'Avant 31 décembre 2030 (NIST)'
        }
    
    return {'algorithm': 'Non-SHA-1', 'status': 'À analyser'}

# Exemple comparatif (éducatif uniquement)
if __name__ == "__main__":
    test_input = "Hello World"
    
    # SHA-1 (OBSOLÈTE)
    sha1_result = generate_sha1(test_input)
    print(f"SHA-1 (OBSOLÈTE): {sha1_result}")
    
    # SHA-256 (SÉCURISÉ)
    sha256_result = generate_sha256(test_input)
    print(f"SHA-256 (SÉCURISÉ): {sha256_result}")
    
    # Analyse sécurité
    analysis = detect_and_migrate(sha1_result)
    print(f"Analyse: {analysis}")

// Guide de Migration SHA-1 vers SHA-256
// Pattern industriel éprouvé

class LegacyHashManager {
  constructor() {
    this.migrationLog = [];
    this.deprecationDate = new Date('2017-01-01');
    this.endOfLife = new Date('2030-12-31');
  }

  // Détection automatique SHA-1
  detectSHA1(hash) {
    const isSHA1 = /^[a-f0-9]{40}$/i.test(hash);
    
    if (isSHA1) {
      this.logMigrationWarning(hash);
      return {
        algorithm: 'SHA-1',
        deprecated: true,
        risk: 'CRITIQUE',
        collision: '2^69 operations (BROKEN)',
        action: 'MIGRATION_IMMEDIATE'
      };
    }
    
    return { algorithm: 'Non-SHA-1' };
  }

  // Stratégie migration graduelle
  migrateHashSystem(oldHash, newAlgorithm = 'SHA-256') {
    const detection = this.detectSHA1(oldHash);
    
    if (!detection.deprecated) {
      return { status: 'SECURE', hash: oldHash };
    }

    // Plan de migration
    const migrationPlan = {
      phase1: 'Audit complet systèmes existants',
      phase2: 'Tests compatibilité SHA-256',
      phase3: 'Migration applications critiques',
      phase4: 'Migration applications secondaires',
      phase5: 'Désactivation définitive SHA-1',
      
      timeline: {
        immediate: 'Arrêt nouvelles implémentations',
        urgent: 'Migration signatures numériques',
        priority: 'Migration certificats SSL/TLS',
        normal: 'Migration checksums fichiers',
        final: 'Désactivation complète avant 2030'
      }
    };

    return {
      status: 'MIGRATION_REQUIRED',
      oldAlgorithm: 'SHA-1',
      newAlgorithm: newAlgorithm,
      plan: migrationPlan,
      compliance: 'NIST deadline: December 31, 2030'
    };
  }

  // Audit sécurité automatisé
  auditSecurityCompliance() {
    const currentDate = new Date();
    const daysUntilEOL = Math.ceil(
      (this.endOfLife - currentDate) / (1000 * 60 * 60 * 24)
    );

    return {
      compliance: {
        sha1Status: 'DEPRECATED',
        nistCompliant: false,
        browserSupport: 'BLOCKED',
        industryStandard: 'FORBIDDEN'
      },
      timeline: {
        daysUntilEOL: daysUntilEOL,
        urgency: daysUntilEOL < 365 ? 'CRITICAL' : 'HIGH',
        recommendation: 'Immediate migration to SHA-256+'
      },
      alternatives: [
        'SHA-256 (recommended)',
        'SHA-384 (high security)',
        'SHA-512 (maximum security)',
        'SHA-3 (post-quantum ready)'
      ]
    };
  }

  logMigrationWarning(hash) {
    const warning = {
      timestamp: new Date().toISOString(),
      hash: hash.substring(0, 8) + '...',
      message: '🚨 SHA-1 DETECTED - IMMEDIATE MIGRATION REQUIRED',
      risk: 'COLLISION VULNERABLE',
      action: 'Replace with SHA-256+'
    };
    
    this.migrationLog.push(warning);
    console.error('SECURITY WARNING:', warning);
  }
}

// Usage en production
const hashManager = new LegacyHashManager();

// Exemple détection et migration
const suspiciousHash = "aaf4c61ddcc5e8a2dabede0f3b482cd9aea9434d";
const analysis = hashManager.detectSHA1(suspiciousHash);
const migration = hashManager.migrateHashSystem(suspiciousHash);
const audit = hashManager.auditSecurityCompliance();

console.log('Security Analysis:', { analysis, migration, audit });