chiffrement et hachage

- Toute modification de X **change complètement** Y (**effet avalanche**).

- Il est **impossible de retrouver X à partir de Y** (la fonction n'est pas *bijective* mais *surjective*).

Le hachage est un processus qui transforme une entrée (comme un message ou un fichier) en une valeur de longueur fixe appelée empreinte ou digest. Cette empreinte permet de garantir l'intégrité des données, car toute modification de l'entrée entraînera un changement total du hachage. Par exemple, dans le stockage de mots de passe, le mot de passe est haché avant d'être stocké, de sorte qu'il est impossible de récupérer le mot de passe d'origine à partir du hash. Le hachage est également utilisé dans des mécanismes comme les signatures numériques pour garantir l'authenticité des messages sans exposer leur contenu.

Le hachage est un processus qui transforme une entrée (comme un message ou un fichier) en une valeur de longueur fixe appelée *empreinte* (ou *digest*). Cette empreinte permet de garantir l'intégrité des données, car toute modification de l'entrée entraînera un changement total du hachage. Par exemple, dans le stockage de mots de passe, le mot de passe est haché avant d'être stocké, de sorte qu'il est impossible de récupérer le mot de passe d'origine à partir du hash. Le hachage est également utilisé dans des mécanismes comme les signatures numériques pour garantir l'authenticité des messages sans exposer leur contenu.

Voici une liste d'exemples concrets d'utilisation du **hachage** dans différents domaines :

Le hachage est couramment utilisé pour vérifier l'intégrité des fichiers téléchargés. Par exemple, lors du téléchargement d'un fichier depuis Internet, un hash est fourni pour le fichier. Après le téléchargement, le hash du fichier est recalculé pour vérifier qu'il n'a pas été corrompu ou modifié.

#### 3️⃣ **Signatures numériques**

Les signatures numériques reposent sur le hachage pour garantir l'intégrité et l'authenticité d'un message. Avant d'envoyer un message, une personne peut générer un hash du message et le signer avec sa clé privée. Le récepteur peut alors vérifier le message en recalculant le hash et en le comparant avec la signature à l'aide de la clé publique de l'expéditeur.

Les signatures numériques reposent sur le hachage pour garantir l'intégrité et l'authenticité d'un message. Avant d'envoyer un message, une personne peut générer un hash du message et le signer avec sa clé privée. Le récepteur peut alors vérifier le message en recalculant le hash et en le comparant avec la signature à l'aide de la clé de l'expéditeur.

#### 4️⃣ **Détection des doublons dans les bases de données**

Le hachage est utilisé pour détecter les doublons dans des ensembles de données. Par exemple, dans une base de données de fichiers, chaque fichier peut être haché, et les doubles peuvent être détectés en comparant les hashes, ce qui permet d'optimiser l'espace de stockage.

#### 7️⃣ **Blockchain et crypto-monnaies**

Les chaînes de blocs (blockchain), comme celles utilisées par les crypto-monnaies (Bitcoin, Ethereum), reposent sur le hachage pour garantir l'intégrité des transactions et des blocs. Chaque bloc contient le hash du bloc précédent, ce qui rend très difficile la modification d'un bloc sans affecter toute la chaîne.

#### 8️⃣ **Authentification des API via HMAC**

Dans les API sécurisées, l'authentification des requêtes est souvent réalisée en générant un HMAC (Hash-based Message Authentication Code) du corps de la requête, ce qui permet de garantir que la requête n'a pas été altérée et qu'elle provient bien de l'émetteur attendu.

#### 9️⃣ **Checksums de logiciels**

#### 8️⃣ **Checksums de logiciels**

Les développeurs utilisent des **checksums** (comme MD5, SHA-1, ou SHA-256) pour vérifier l'intégrité des logiciels téléchargés. Avant de distribuer un logiciel, un hash du fichier est généré et partagé. Après le téléchargement, l'utilisateur peut vérifier que le hash calculé localement correspond au hash fourni pour confirmer que le fichier n’a pas été modifié ou corrompu.

### **Pourquoi c’est sécurisé ?**  

* **Car on utilise des opérations *complexes*** (rotations, XOR, modulo). Les fonctions de hachage comme SHA-256 utilisent des opérations *bitwise* (*bit à bit* manipulant directement un nombre en effectuant des opérations logiques élémentaires sur chaque bit individuellement). Ces opérations permettent de mélanger les bits de manière difficile à inverser. 

```

✅ Génère un identifiant unique et difficile à deviner.

## 4. Chiffrement ("cryptage" en mauvaise traduction française)  

## 4. Chiffrement (ou "cryptage" 🤮)  

Le **chiffrement** est une technique utilisée pour protéger les données contre les accès non autorisés. Il est basé sur des **problèmes mathématiques complexes** comme la **factorisation des grands nombres premiers**.  

const data = encrypt("Données ultra-secrètes");

console.log(data);

```

Le vecteur d'initialisation (ou IV pour Initialization Vector) est une donnée utilisée dans les systèmes de chiffrement symétrique pour garantir que le même texte clair (donnée à chiffrer) ne produira pas le même texte chiffré à chaque fois. On est ici sur une *fonction surjective* (et plus bijective)(qu'est-ce qu'on s'amuse dans la sécurité)... 

### **4.2. Chiffrement Asymétrique**

**Principe :** Deux clés sont utilisées :

- Signature numérique (authenticité d’un document).

- Échange sécurisé de clés pour le chiffrement symétrique (ex : SSH).

**Exemple : Envoi sécurisé d'un mot de passe via une API (authentification)

📩 **Bonne pratique : Ne jamais envoyer un mot de passe en clair**  

❌ Mauvais :

```http

POST /login

Content-Type: application/json

Voici un exemple complet de **cryptage asymétrique** pour générer un identifiant unique, avec une partie côté client (utilisant la clé publique pour chiffrer) et une partie côté serveur (utilisant la clé privée pour déchiffrer et hacher).

{

    "username": "alice",

    "password": "monMotDePasse123"

#### Côté client : chiffrement avec la clé publique

⚠ **ERREUR à ne pas faire :**  

🚫 **Envoyer l'email en clair au serveur**

```javascript

// Exemple côté client

const email = "alice@example.com";

// Envoi de l'email en clair (ce qui est risqué)

fetch('/generate-user-id', {

  method: 'POST',

  headers: {

    'Content-Type': 'application/json',

  },

  body: JSON.stringify({ email }),

});

```

❌ L'email est envoyé en clair, ce qui expose la donnée à des risques de fuite ou d'altération.

✅ **Bonne pratique : Chiffrement de l'email avec la clé publique avant l'envoi (Côté client - JavaScript)**

```javascript

const crypto = window.crypto.subtle;

// Clé publique (en général, elle est obtenue via une API ou un fichier)

const publicKeyPem = `-----BEGIN PUBLIC KEY-----

... (clé publique) ...

-----END PUBLIC KEY-----`;

// Fonction pour importer la clé publique au format JWK

async function importPublicKey(pem) {

  const binaryDer = str2ab(pem);

  return await crypto.importKey(

    'spki', 

    binaryDer, 

    { name: 'RSA-OAEP', hash: { name: 'SHA-256' } }, 

    false, 

    ['encrypt']

  );

}

// Fonction pour convertir la clé PEM en ArrayBuffer

function str2ab(str) {

  const binary = atob(str.replace(/-----BEGIN PUBLIC KEY-----/g, '').replace(/-----END PUBLIC KEY-----/g, '').replace(/\s/g, ''));

  const buffer = new ArrayBuffer(binary.length);

  const view = new Uint8Array(buffer);

  for (let i = 0; i < binary.length; i++) {

    view[i] = binary.charCodeAt(i);

  }

  return buffer;

}

// Fonction pour chiffrer l'email

async function encryptEmail(email) {

  const publicKey = await importPublicKey(publicKeyPem);

  const encodedEmail = new TextEncoder().encode(email);

  const encryptedEmail = await crypto.encrypt({ name: 'RSA-OAEP' }, publicKey, encodedEmail);

  return encryptedEmail;

}

// Exemple d'utilisation

const email = "alice@example.com";

encryptEmail(email).then((encryptedEmail) => {

  // Envoi de l'email chiffré au serveur

  fetch('/generate-user-id', {

    method: 'POST',

    headers: {

      'Content-Type': 'application/json',

    },

    body: JSON.stringify({ encryptedEmail: Array.from(new Uint8Array(encryptedEmail)) }),

  });

});

```

✅ Meilleur : Utilisation de **HTTPS + token JWT**

```http

POST /login

Content-Type: application/json

**Explication côté client :**

- L'email est chiffré avec la **clé publique** avant d'être envoyé au serveur. Cette méthode garantit que seule la partie qui possède la **clé privée** (le serveur) pourra déchiffrer et lire l'email.

#### Côté serveur : déchiffrement et hachage pour générer l'identifiant unique

```javascript

const crypto = require('crypto');

// Clé privée du serveur (elle est stockée en toute sécurité)

const privateKey = `-----BEGIN PRIVATE KEY-----

... (clé privée) ...

-----END PRIVATE KEY-----`;

// Fonction pour déchiffrer l'email

function decryptEmail(encryptedEmail) {

  const buffer = Buffer.from(encryptedEmail);

  return crypto.privateDecrypt(

    {

    "username": "alice",

    "password": "mot_de_passe_haché",

    "2FA_code": "123456"

      key: privateKey,

      padding: crypto.constants.RSA_PKCS1_OAEP_PADDING,

    },

    buffer

  ).toString('utf8');

}

// Fonction pour générer un identifiant unique à partir de l'email déchiffré

function generateUserId(email) {

  const hash = crypto.createHash('sha256').update(email).digest('hex');

  return hash;

}

// Endpoint pour recevoir l'email chiffré et générer l'ID

const express = require('express');

const app = express();

app.use(express.json());

app.post('/generate-user-id', (req, res) => {

  const encryptedEmail = req.body.encryptedEmail;

  // Déchiffrement de l'email côté serveur

  const email = decryptEmail(encryptedEmail);

  // Génération de l'ID utilisateur unique

  const userId = generateUserId(email);

  // Envoi de l'ID généré

  res.json({ userId });

});

app.listen(3000, () => {

  console.log('Server is running on port 3000');

});

```

Le serveur retourne un **token JWT** qui sera utilisé pour les requêtes suivantes.

**Explication côté serveur :**

- Le serveur reçoit l'email chiffré, le **décrypte** avec la **clé privée**, puis **hache** l'email déchiffré pour générer un identifiant unique basé sur l'email. L'ID est ensuite envoyé au client.

Cette méthode assure la confidentialité des données sensibles en transit et permet de générer des identifiants uniques tout en protégeant les informations personnelles.

### **4.3. Différences entre Symétrique et Asymétrique**