ABP
| Type |
Méthode de cryptage |
|---|---|
| Date de création |
31 mars 2025 |
| Nom de code du projet |
ABP |
| Auteur(s) | |
| License | |
| Temps de développement |
Débuté. |
ABP (Additional Binary Patterns) est un algorithme de cryptage de chaînes de caractères, conçu le 31 mars 2025. Il repose sur l'utilisation d'une table de patterns (motifs) pour transformer un texte de manière réversible.
Fonctionnement
Une table de patterns est un ensemble de sous-ensembles non vides d'octets. Chaque sous-ensemble (ou pattern) a une taille qui peut varier indépendamment des autres.
Chiffrement
Pour encoder une chaîne de caractères avec ABP, on suit ces étapes :
- Convertir le texte en une suite d’octets (UTF-8).
- Appliquer chaque pattern de la table successivement sur ces octets :
- Additionner l’octet du texte avec l’octet du pattern correspondant.
- Si la somme dépasse 255, revenir à 0 (modulo 256).
- Répéter l’opération pour tous les caractères du texte, en parcourant les patterns de manière cyclique.
Application en Python
def encode(text: str, patterns: list[list[int]]) -> bytes:
data = list(text.encode())
for pattern in patterns:
for i in range(len(data)):
data[i] = (data[i] + pattern[i % len(pattern)]) % 256
return bytes(data)
Déchiffrement
Le déchiffrement suit le même processus en sens inverse :
- Lire le texte chiffré sous forme d’octets.
- Appliquer les patterns dans l’ordre inverse :
- Soustraire l’octet du pattern de l’octet du texte.
- Si le résultat est négatif, revenir à 255 (modulo 256).
- Répéter jusqu’à restaurer le texte original.
Application en Python
def decode(ciphertext: bytes, patterns: list[list[int]]) -> str:
data = list(ciphertext)
for pattern in reversed(patterns):
for i in range(len(data)):
data[i] = (data[i] - pattern[i % len(pattern)]) % 256
return bytes(data).decode()
Génération de patterns
Les patterns peuvent être définis manuellement ou générés dynamiquement à partir d’une clé. Une méthode nommée K2P (Key to Patterns) permet de dériver une table de patterns à partir du hash d’une clé secrète, assurant ainsi une protection supplémentaire.
Application en Python
import hashlib
def hash_key(key: str) -> bytes:
sha1 = hashlib.sha1(key.encode()).digest()
sha256 = hashlib.sha256(key.encode()).digest()
sha512 = hashlib.sha512(key.encode()).digest()
combined = sha1 + sha256 + sha512
return combined
def generate_patterns(key: str, num_patterns: int = 100) -> list:
hash_data = hash_key(key)
patterns = []
offset = 0
for i in range(num_patterns):
length = (hash_data[offset] % 62) + 3
pattern = hash_data[offset:offset + length]
if len(pattern) < length:
pattern += hash_data[:length - len(pattern)]
patterns.append(list(pattern))
offset = (offset + length) % len(hash_data)
return patterns
