Exemples de code d'accès - Apprendre le code d'accès avec des tutoriels de code interactifs

Découvrez comment le code Atbash fonctionne à travers des exemples interactifs et des exercices pratiques. Pratiquez l'encodage et le décodage des messages avec cette ancienne méthode de substitution hébraïque, de l'écriture de lettres de base aux défis de cryptoanalyse du monde réel.

Exemples interactifs de code Atbash

Apprenez l'Atbash par des exemples étape par étape du niveau débutant au niveau avancé.

Mot simple - HELLO

Débutant
HELLO
SVOOL

H→S, E→V, L→O, L→O, O→L. Chaque lettre indique sa position de miroir dans l'alphabet.

Mots communs - WORLD

Débutant
WORLD
DLIOW

W→D, O→L, R→I, L→O, D→W. La transformation est cohérente et réversible.

Le mot ATBASH

Débutant
ATBASH
ZGYZHS

A→Z, T→G, B→Y, A→Z, S→H, H→S. Le nom propre du chiffre démontre la règle du miroir.

Courte peine

Intermédiaire
MEET AT DAWN
NVVG ZG WZDA

Un exemple de phrase montrant que les espaces sont conservés pendant que les lettres sont en miroir.

Texte mixte

Intermédiaire
Attaque à minuit
Zggzxp zg Nrmmrtsg

Atbash conserve le cas tout en transformant les lettres.

Message complexe

Avancé
Le secret est caché dans le texte ancien !
Gsv hvxivg rh sroovn rm gsv zmxrvmg gvcg!

Une phrase complète avec ponctuation montrant l'encodage pratique du message.

Exemples de chiffrement de l'assiette hébraïque

Historical Hebreu Atbash exemples de textes bibliques.

Jérémie 25:26 - Sheshak

Jérémie 25:26
ששך
Translittération: Sheshach
(Babel/Babylon)
Anglais: Babel/Babylon

L'exemple biblique le plus connu où Sheshach code Babel, se référant à Babylone.

Jérémie 51:1 - Leb Kamai

Jérémie 51:1
לבקמי
Translittération: Leb-Kamai
(Kasdim/Chaldeans)
Anglais: Kasdim/Chaldeans

Leb Kamai décode à Kasdim, le nom hébreu des Chaldéens.

Principe alphabète hébreu

Alphabet hébreu
אלף תו בית שין
Translittération: Aleph Tav Beit Shin
A-T-B-SH démontre le principe du chiffrement
Anglais: Principe du chiffrement

Le nom Atbash vient de l'appariement des première et dernière lettres hébraïques, puis des deuxième et deuxième lettres.

Mise en œuvre de la programmation du chiffrement Atbash

Exemples prêts à la production en Python et JavaScript avec des notes détaillées.

Mise en œuvre de Python

python
def atbash_cipher(text):
    """
    Encode/decode text using Atbash cipher
    """
    result = ""
    
    for char in text:
        if char.isalpha():
            # Handle uppercase letters
            if char.isupper():
                # A=0, Z=25, so Z-A = 25-0 = 25
                position = ord(char) - ord('A')
                new_position = 25 - position
                result += chr(ord('A') + new_position)
            # Handle lowercase letters
            else:
                position = ord(char) - ord('a')
                new_position = 25 - position
                result += chr(ord('a') + new_position)
        else:
            # Keep non-alphabetic characters as-is
            result += char
    
    return result

# Example usage
original = "HELLO WORLD"
encoded = atbash_cipher(original)
decoded = atbash_cipher(encoded)  # Atbash is self-inverse

print(f"Original: {original}")
print(f"Encoded:  {encoded}")
print(f"Decoded:  {decoded}")

Une implémentation complète de Python qui prend en charge les lettres majuscules et minuscules et démontre le comportement auto-inverse d'Atbash.

Mise en œuvre JavaScript

javascript
function atbashCipher(text) {
    /**
     * Encode/decode text using Atbash cipher
     * @param {string} text - Input text to transform
     * @returns {string} - Transformed text
     */
    return text
        .split('')
        .map(char => {
            if (/[A-Z]/.test(char)) {
                // Handle uppercase letters (A=65, Z=90)
                const position = char.charCodeAt(0) - 65;
                const newPosition = 25 - position;
                return String.fromCharCode(65 + newPosition);
            } else if (/[a-z]/.test(char)) {
                // Handle lowercase letters (a=97, z=122)
                const position = char.charCodeAt(0) - 97;
                const newPosition = 25 - position;
                return String.fromCharCode(97 + newPosition);
            }
            // Keep non-alphabetic characters unchanged
            return char;
        })
        .join('');
}

// Example usage with arrow function syntax
const encode = text => atbashCipher(text);
const decode = text => atbashCipher(text); // Same function!

// Test the implementation
const message = "Attack at Dawn";
const encoded = encode(message);
const decoded = decode(encoded);

console.log(`Original: ${message}`);
console.log(`Encoded:  ${encoded}`);
console.log(`Decoded:  ${decoded}`);

Une implémentation JavaScript moderne utilisant les fonctionnalités ES6 et une approche fonctionnelle.

Python avancé avec Unicode

python
import string
from typing import Dict, Optional

class AtbashCipher:
    """
    Advanced Atbash cipher implementation with multiple character sets
    """
    
    def __init__(self, include_numbers: bool = False, include_special: bool = False):
        self.include_numbers = include_numbers
        self.include_special = include_special
        self._create_mappings()
    
    def _create_mappings(self) -> None:
        """Create character mapping dictionaries"""
        self.mappings: Dict[str, str] = {}
        
        # Letters
        upper = string.ascii_uppercase
        lower = string.ascii_lowercase
        self.mappings.update({
            char: upper[25 - i] for i, char in enumerate(upper)
        })
        self.mappings.update({
            char: lower[25 - i] for i, char in enumerate(lower)
        })
        
        # Numbers (optional)
        if self.include_numbers:
            digits = string.digits
            self.mappings.update({
                char: digits[9 - i] for i, char in enumerate(digits)
            })
        
        # Special characters (optional)
        if self.include_special:
            special = '!@#$%^&*()_+-=[]{}|;':",./<>?'
            reversed_special = special[::-1]
            self.mappings.update({
                char: reversed_special[i] for i, char in enumerate(special)
            })
    
    def transform(self, text: str) -> str:
        """Transform text using Atbash cipher"""
        return ''.join(
            self.mappings.get(char, char) for char in text
        )
    
    def encode(self, text: str) -> str:
        """Encode text (alias for transform)"""
        return self.transform(text)
    
    def decode(self, text: str) -> str:
        """Decode text (alias for transform - Atbash is self-inverse)"""
        return self.transform(text)

# Usage examples
cipher = AtbashCipher()
advanced_cipher = AtbashCipher(include_numbers=True, include_special=True)

text = "Hello, World! 123"
print(f"Original: {text}")
print(f"Basic:    {cipher.encode(text)}")
print(f"Advanced: {advanced_cipher.encode(text)}")

Une classe Python prête à la production avec support optionnel pour les nombres et les caractères spéciaux.

L'apprentissage par des exemples

Le chiffre Atbash est mieux compris par des exemples pratiques qui démontrent ses principes et ses applications. Ce tutoriel complet fournit des exemples allant de mots simples à des implémentations complexes.

Exemples fondamentaux

Transformations de mots simples

*HELLO → SVOOL *

  • H (8e lettre) → S (19e lettre)
  • E (5e lettre) → V (22e lettre)
  • L (12e lettre) → O (15e lettre)
  • L (12e lettre) → O (15e lettre)
  • O (15e lettre) → L (12e lettre)

*WORLD → DLIOW * La transformation démontre l'uniformité de la cartographie miroir où la position de chaque lettre est soustraite de 26 (dans un système à 1) ou 25 (dans un système à 0).

Niveaux de difficulté progressifs

Niveau débutant
  • Un seul mot: ATBASH → ZGYZHS
  • Expressions simples: MEET AT DAWN → NVVG ZG WZDA
  • Préservation mixte des cas: Attaque → Zggzxp
Niveau intermédiaire
  • Terminer les phrases avec ponctuation
  • Nombres et caractères spéciaux (si activé)
  • Exemples de messages du monde réel
Niveau avancé
  • Textes des paragraphes
  • Type de contenu mixte
  • Analyse historique des documents

Exemples hébreux et références bibliques

Le nom "Atbash"

Le chiffre reçoit son nom de l'alphabet hébreu appariement:

  • Aléph (-) + Tav (-) = AT
  • Beth (-) + Shin (-) = BASH
Jérémie 25
- Sheshak
Original Hebrew: ששך (Sheshach)
Atbash Decoded: בבל (Babel/Babylon)

C'est l'exemple biblique le plus célèbre où le prophète Jérémie utilise Atbash pour coder le nom de Babylone, peut-être pour éviter de nommer directement l'empire puissant.

Jérémie 51
- Leb Kamai
Original Hebrew: לב קמי (Leb Kamai)
Atbash Decoded: כשדים (Kasdim/Chaldeans)

Un autre exemple de Jérémie où "Leb Kamai" (littéralement "le cœur de ceux qui se lèvent contre moi") code "Kasdim" (Chaldéens).

Mise en œuvre de la programmation

Mise en œuvre de Python
def atbash_cipher(text):
    """
    Encode/decode text using Atbash cipher
    """
    result = ""
    
    for char in text:
        if char.isalpha():
            if char.isupper():
                # A=0, Z=25, so Z-A = 25-0 = 25
                position = ord(char) - ord('A')
                new_position = 25 - position
                result += chr(ord('A') + new_position)
            else:
                position = ord(char) - ord('a')
                new_position = 25 - position
                result += chr(ord('a') + new_position)
        else:
            result += char
    
    return result

# Example usage
message = "The secret is hidden"
encoded = atbash_cipher(message)
decoded = atbash_cipher(encoded)  # Atbash is self-inverse

print(f"Original: {message}")
print(f"Encoded:  {encoded}")
print(f"Decoded:  {decoded}")
Mise en œuvre JavaScript
function atbashCipher(text) {
    return text
        .split('')
        .map(char => {
            if (/[A-Z]/.test(char)) {
                const position = char.charCodeAt(0) - 65;
                const newPosition = 25 - position;
                return String.fromCharCode(65 + newPosition);
            } else if (/[a-z]/.test(char)) {
                const position = char.charCodeAt(0) - 97;
                const newPosition = 25 - position;
                return String.fromCharCode(97 + newPosition);
            }
            return char;
        })
        .join('');
}

// Example usage
const message = "Attack at Dawn";
const encoded = atbashCipher(message);
const decoded = atbashCipher(encoded);

console.log(`Original: ${message}`);
console.log(`Encoded:  ${encoded}`);
console.log(`Decoded:  ${decoded}`);
Classe avancée Python
import string
from typing import Dict

class AtbashCipher:
    def __init__(self, include_numbers=False, include_special=False):
        self.include_numbers = include_numbers
        self.include_special = include_special
        self._create_mappings()
    
    def _create_mappings(self):
        self.mappings = {}
        
        # Letters
        upper = string.ascii_uppercase
        lower = string.ascii_lowercase
        self.mappings.update({
            char: upper[25 - i] for i, char in enumerate(upper)
        })
        self.mappings.update({
            char: lower[25 - i] for i, char in enumerate(lower)
        })
        
        # Numbers (optional)
        if self.include_numbers:
            digits = string.digits
            self.mappings.update({
                char: digits[9 - i] for i, char in enumerate(digits)
            })
    
    def transform(self, text):
        return ''.join(
            self.mappings.get(char, char) for char in text
        )

Fondation mathématique

La transformation d'Atbash peut être exprimée mathématiquement:

Pour une lettre au poste i (0 base d'indexation):

encoded_position = (alphabet_length - 1) - i

Pour l'alphabet anglais (26 lettres):

encoded_position = 25 - i

Cette formule fonctionne pour toute longueur d'alphabet, la rendant adaptable à différentes langues.

Applications pédagogiques

Activités en classe
  1. ** Exercices de cartographie des lettres**: Les élèves créent leurs propres diagrammes de transformation alphabétique
  2. ** Analyse historique**: Examen des textes bibliques pour les modèles de chiffrement
  3. Défis en matière de programmation: Mise en œuvre du chiffrement dans différentes langues
  4. Cryptanalyse Practice: Apprentissage pour détecter et briser des chiffres simples
Projets de recherche
  • Analyse des modèles de fréquence dans les textes encodés par Atbash
  • Comparaison d'Atbash avec d'autres chiffrements de substitution
  • Importance historique de la cryptographie biblique
  • Développement d'algorithmes de détection de chiffrement

Exercices pratiques

Exercice 1: Encodage de base

Encoder ces mots en utilisant Encaisse:

  • SECRET
  • CIPHER
  • ANCIENT
Exercice 2: Exemples hébreux

Rechercher et analyser ces références bibliques:

  • Jérémie 25
    (Sheschach)
  • Jérémie 51
    (Leb Kamai)
  • Jérémie 51
    (variante Sheshach)
Exercice 3: Défi de mise en oeuvre

Écrire un programme qui:

  1. Accepte l'entrée de l'utilisateur
  2. Applique la transformation de l'Atbash
  3. Détecte si l'entrée est déjà Encodé à l'heure
  4. Fournit une cote de confiance

Importance historique

Le chiffre Atbash représente l'une des premières méthodes de chiffrement de l'humanité, démontrant que le besoin de communication sécurisée existe depuis des millénaires. Son apparition dans les textes bibliques montre que la cryptographie n'était pas seulement un outil militaire mais avait aussi des applications religieuses et littéraires.

Pertinence moderne

Bien que non sécurisé par des normes modernes, Atbash reste précieux pour:

  • Objectif éducatif dans les cours de cryptographie
  • Puzzle et développement de jeux
  • Analyse du texte historique
  • Comprendre l'évolution des méthodes de chiffrement

La simplicité d'Atbash en fait une excellente introduction aux concepts cryptographiques, servant de tremplin à des chiffrements plus complexes et à des algorithmes de chiffrement modernes.