TermNSI/Sécurité/CORRIGE_EXERCICES.md

# Corrigé des exercices — Sécurité

---

## Exercice : Algorithme ROT13

### Rappel

L'algorithme ROT13 décale chaque lettre de 13 positions dans l'alphabet. Comme l'alphabet a 26 lettres, appliquer ROT13 deux fois revient au message original.

### Solution

```python
def chiffrement_rot13_mot(mot):
    """
    Chiffre un mot avec l'algorithme ROT13.

    :param mot: (str) Le mot à chiffrer (en minuscules)
    :return: (str) Le mot chiffré
    """
    resultat = ""
    for lettre in mot.lower():
        if 'a' <= lettre <= 'z':
            # Calculer la nouvelle position
            code = ord(lettre) - ord('a')  # Position 0-25
            nouveau_code = (code + 13) % 26  # Décalage de 13
            nouvelle_lettre = chr(nouveau_code + ord('a'))
            resultat += nouvelle_lettre
        else:
            # Garder les caractères non alphabétiques
            resultat += lettre
    return resultat


def chiffrement_rot13(message):
    """
    Chiffre un message complet avec l'algorithme ROT13.

    :param message: (str) Le message à chiffrer
    :return: (str) Le message chiffré
    """
    mots = message.split()
    mots_chiffres = [chiffrement_rot13_mot(mot) for mot in mots]
    return " ".join(mots_chiffres)
```

### Version alternative (plus concise)

```python
def rot13(message):
    """Version concise du chiffrement ROT13."""
    resultat = ""
    for car in message.lower():
        if 'a' <= car <= 'z':
            resultat += chr((ord(car) - ord('a') + 13) % 26 + ord('a'))
        else:
            resultat += car
    return resultat
```

### Tests

```python
>>> chiffrement_rot13("bonjour")
'obawbhe'

>>> chiffrement_rot13("python")
'clguba'

>>> chiffrement_rot13("Vive les numériques et sciences informatiques")
'ivir yrf ahzrevdhrf rg fpvraprf vasbezngvdhrf'
```

### Exemples de chiffrement de noms

| Prénom/Nom | ROT13 |
|------------|-------|
| Alice | nyvpr |
| Bob | obo |
| Florian | sybevna |
| Mathieu | znguvrh |

### Propriété remarquable

ROT13 est son propre inverse : appliquer ROT13 deux fois redonne le message original.

```python
>>> rot13(rot13("bonjour"))
'bonjour'
```

Cela s'explique car 13 + 13 = 26, soit un tour complet de l'alphabet.

### Généralisation : Chiffre de César

On peut généraliser avec un décalage variable (chiffre de César) :

```python
def cesar(message, decalage):
    """
    Chiffre un message avec le chiffre de César.

    :param message: (str) Le message à chiffrer
    :param decalage: (int) Le décalage (clé)
    :return: (str) Le message chiffré
    """
    resultat = ""
    for car in message.lower():
        if 'a' <= car <= 'z':
            resultat += chr((ord(car) - ord('a') + decalage) % 26 + ord('a'))
        else:
            resultat += car
    return resultat


def decesar(message, decalage):
    """Déchiffre un message chiffré avec César."""
    return cesar(message, -decalage)
```

```python
>>> cesar("bonjour", 3)  # Décalage de 3 (César classique)
'erqmrxu'

>>> decesar("erqmrxu", 3)
'bonjour'

>>> cesar("bonjour", 13)  # ROT13
'obawbhe'
```

---

Auteur : Florian Mathieu

Licence CC BY NC

<a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/"><img alt="Licence Creative Commons" style="border-width:0" src="https://i.creativecommons.org/l/by-nc-sa/4.0/88x31.png" /></a> <br />Ce cours est mis à disposition selon les termes de la <a rel="license" href="http://creativecommons.org/licenses/by-nc-sa/4.0/">Licence Creative Commons Attribution - Pas d'Utilisation Commerciale - Partage dans les Mêmes Conditions 4.0 International</a>.