alphabet bilitère

[SAKAROV]

L'alphabet bilitère est un vieux procédé stéganographique (son inventeur le dénommait ainsi) datant du tout début du 17e siècle.

Le procédé est assez simplet.

Dans un premier temps, nous avons un tableau de substitution de l'alphabet (du temps de l'auteur), soit :

          AAA   AAB   ABA   ABB   BAA   BAB   BBA   BBB

AA       a         b         c           d            e             f          g          h    
AB      i-j         k         l           m            n            o          p          q  
BA       r          s        t          u-v          w            x          y          z

Soit :

a = AAAAA
b = AAAAB
c = AAABA
d = AAABB
e = AABAA
f = AABAB
g = AABBA
h = AABBB
i-j = ABAAA
k = ABAAB
l = ABABA
m = ABABB
n = ABBAA
o = ABBAB
p = ABBBA
q = ABBBB
r = BAAAA
s = BAAAB
t = BAABA
u-v = BAABB
w = BABAA
x = BABAB
y = BABBA
z = BABBB

Nous n'utilisons pas les espaces. En effet, nous savons que chaque caractère équivaut à une suite de A et de B égale à 5.

chiffrement :


- simple substitution des lettres par les lettres adéquates (h=AABBB, e=AABAA, etc.) ;


Soit, le résultat (sous la forme "helloparis" (sans espaces)) :

AABBBAABAAABABAABABAABBABABBBAAAAAABAAAAABAAABAAAB

déchiffrement :

- tronquage par groupes de 5 ;
- substitution des groupes de 5 lettres (bilitère) en une seule (decyphered) ;

Exemples

hello my name is roger

=

AABBBAABAAABABAABABAABBABABABBBABBAABBAAAAAAAABABBAABAAABAAABAAABBAAAAABBABAABBAAABAABAAAA

bonjour

=

AAAABABBABABBAAABAAAABBABBAABBBAAAA

Bon, le seul inconvénient est que le i et le j, ainsi que le u et le v sont similaires. L'algo est ainsi fait ; l'auteur écrivait en latin, c'est comme ça faut le savoir

Ainsi, pour 'bonjour a vous' on obtiendra :

AAAABABBABABBAAABAAAABBABBAABBBAAAAAAAAABAABBABBABBAABBBAAAB

Lorsqu'on le déchiffre on aura :

bon[j-i]o[u-v]ra[v-u]o[v-u]s

[Sadik]

Exemple de code python

Salut,
pour les besoins d'une conférence j'ai fait un petit programme en Python appliquant ce chiffrement et permettant de le déchiffrer.
Il n'est surement pas optimisé mais bon On partage ?
Utilisé sous python3

#! /usr/bin/python

# -*- coding: utf8 -*-

from tkinter import *
import re
import string

"""Programme de cryptage/décryptage selon l'alphabet Bilitère"""


def crypt():
#Cryptage
    message_clair= txt1.get(1.0,END)
    #On récupère le contenu du champ de texte en haut
    message_chiffre=''
    #déclaration de la variable
    for lettre in message_clair:
        if lettre=='a':
            lettre='AAAAA'
        elif lettre=='b':
            lettre='AAAAB'
        elif lettre=='c':
            lettre='AAABA'
        elif lettre=='d':
            lettre='AAABB'
        elif lettre=='e':
            lettre='AABAA'
        elif lettre=='f':
            lettre='AABAB'
        elif lettre=='g':
            lettre='AABBA'
        elif lettre=='h':
            lettre='AABBB'
        elif lettre=='i':
            lettre='ABAAA'
        elif lettre=='j':
            lettre='ABAAA'
        elif lettre=='k':
            lettre='ABAAB'
        elif lettre=='l':
            lettre='ABABA'
        elif lettre=='m':
            lettre='ABABB'
        elif lettre=='n':
            lettre='ABBAA'
        elif lettre=='o':
            lettre='ABBAB'
        elif lettre=='p':
            lettre='ABBBA'
        elif lettre=='q':
            lettre='ABBBB'
        elif lettre=='r':
            lettre='BAAAA'
        elif lettre=='s':
            lettre='BAAAB'
        elif lettre=='t':
            lettre='BAABA'
        elif lettre=='u':
            lettre='BAABB'
        elif lettre=='v':
            lettre='BAABB'
        elif lettre=='w':
            lettre='BABAA'
        elif lettre=='x':
            lettre='BABAB'
        elif lettre=='y':
            lettre='BABBA'
        elif lettre=='z':
            lettre='BABBB'
        else:
            lettre=''
        message_chiffre+=lettre
        #Boucle de conversion selon l'alphabet bilitère

    txt1.delete(1.0,END)
    txt3.insert (INSERT,message_chiffre)
    #Insertion du message chiffré dans le champ de texte du bas

def uncrypt():
#Décryptage
    message_clair=''
    message_chiffre=txt3.get(1.0,END)
    txt1.delete(1.0,END)
    longueur=len(message_chiffre)
    #On récupère la longueur du message chiffre
    nbr_divisions=longueur//5
    #On la divise par 5
    message_chiffre=[message_chiffre[5*i:5*(i+1)] for i in range(nbr_divisions)]
    #On divise le message par groupe de 5, afin de permettre la conversion
    for elt in message_chiffre:
        if elt=='AAAAA':
            elt='a'
        elif elt=='AAAAB':
            elt='b'
        elif elt=='AAABA':
            elt='c'
        elif elt=='AAABB':
            elt='d'
        elif elt=='AABAA':
            elt='e'
        elif elt=='AABAB':
            elt='f'
        elif elt=='AABBA':
            elt='g'
        elif elt=='AABBB':
            elt='h'
        elif elt=='ABAAA':
            elt='i'
        elif elt=='ABAAA':
            elt='j'
        elif elt=='ABAAB':
            elt='k'
        elif elt=='ABABA':
            elt='l'
        elif elt=='ABABB':
            elt='m'
        elif elt=='ABBAA':
            elt='n'
        elif elt=='ABBAB':
            elt='o'
        elif elt=='ABBBA':
            elt='p'
        elif elt=='ABBBB':
            elt='q'
        elif elt=='BAAAA':
            elt='r'
        elif elt=='BAAAB':
            elt='s'
        elif elt=='BAABA':
            elt='t'
        elif elt=='BAABB':
            elt='u'
        elif elt=='BAABB':
            elt='v'
        elif elt=='BABAA':
            elt='w'
        elif elt=='BABAB':
            elt='x'
        elif elt=='BABBA':
            elt='y'
        elif elt=='BABBB':
            elt='z'
        message_clair+=elt
        #Boucle de conversion
    txt3.delete(1.0,END)
    txt1.insert(INSERT,message_clair)

fen=Tk()
fen.title('Cryptage/Decryptage VIGENERE By V.Wallyn')
Label(fen,text='Texte à CRYPTER ou Texte DECRYPTE',fg='red').grid(row=0)
txt1=Text(fen,height=10,width=70)
txt1.grid(row=1)
bouUncrypt=Button(fen,text='Decrypter',command=uncrypt)
bouUncrypt.grid(row=2,sticky=E)
bouCrypt=Button(fen,text='Crypter',command=crypt)
bouCrypt.grid(row=4,sticky=W)
Label(fen,text='Texte CRYPTE ou a Texte à décrypter',fg='red').grid(row=4)
txt3=Text(fen,height=10,width=70)
txt3.grid(row=5)
fen.mainloop()

#Interface graphique

[fred]

@Sadik,

Ça fonctionne peut-être, mais pour les puristes en programmation, ça fait mal aux yeux

Je te propose une solution avec les dictionnaires en python permettant de simplifier grandement le code, je te laisse méditer là dessus...

>>> myDict = {
...            'a': 'AAAAA',
...            'b': 'AAAAB',
...            'c': 'AAABA'
...          }
>>> chaine = 'abc'
>>> res = ''
>>> for letter in chaine:
...     res += myDict[letter]
... 
>>> res
'AAAAAAAAABAAABA'

On peut faire cela avec les listes

>>> myList = ['AAAAA', 'AAAAB', 'AAABA']
>>> chr(97)
'a'
>>> ord('a')
97
>>> chaine = 'abc'
>>> for ind, letter in enumerate(chaine):
...     res += myList[ord(letter)-97]
... 
>>> res
'AAAAAAAAABAAABA'

Bonne continuation...

[Sadik]

Re: alphabet bilitère

Merci
*honteux*

[fred]

Il n'y a pas de quoi être honteux, à partir du moment où on est humble et qu'on accepte d'apprendre, c'est toujours un plaisir d'aider

[fred]

Voilà une proposition en C, assez complexe, c'est pourquoi je pense que ce type de solution ne sera pas proposée...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct{
    char letter[10];
    char code[10];
} Element;

Element *createDictionary();
char *getCode(const char *string, Element *elements);
char *strip(const char *string);

int main(void){

    Element *elem = createDictionary();
    const char *test = "bonjour ,a +vous";
    char *res, *t;

    t = strip(test);

    printf("%s\n", t);

    res = getCode(t, elem);

    printf("%s\n", res); /* AAAABABBABABBAAABAAAABBABBAABBBAAAAAAAAABAABBABBABBAABBBAAAB */

    free(elem);
    free(res);
    free(t);

    return 0;
}

Element *createDictionary(){

    int i;
    Element e;
    const char *part1[8] = {"AAAAA", "AAAAB", "AAABA", "AAABB", "AABAA", "AABAB", "AABBA", "AABBB"};
    const char *part2[10] = {"ABAAB", "ABABA", "ABABB", "ABBAA", "ABBAB", "ABBBA", "ABBBB", "BAAAA", "BAAAB", "BAABA"};
    const char *part3[4] = {"BABAA", "BABAB", "BABBA", "BABBB"};

    Element *myElements = malloc(sizeof(Element) * 24);
    if (myElements == NULL) exit(-1);

    for (i=0; i<8; i++){
        sprintf(e.letter, "%c", 97+i);
        strcpy(e.code, part1[i]);
        myElements[i] = e;
    }

    strcpy(e.letter, "[i-j]");
    strcpy(e.code, "ABAAA");
    myElements[8] = e;

    for (i=0; i<10; i++){
        sprintf(e.letter, "%c", 107+i);
        strcpy(e.code, part2[i]);
        myElements[9+i] = e;
    }

    strcpy(e.letter, "[u-v]");
    strcpy(e.code, "BAABB");
    myElements[19] = e;

    for (i=0; i<4; i++){
        sprintf(e.letter, "%c", 119+i);
        strcpy(e.code, part3[i]);
        myElements[20+i] = e;
    }

    return myElements;

}

char *getCode(const char *string, Element *elements){

    char letter[5];
    int i, j;

    size_t length = strlen(string);

    char *result = malloc(sizeof(char) * 5 * length + 1);
    if (result == NULL){
        free(elements);
        exit(-1);
    }

    for (i=0; i<(int)length; i++){
        sprintf(letter, "%c", string[i]);
        for (j=0; j<24; j++){
            if (strcmp(elements[j].letter, letter) == 0)
                strcat(result, elements[j].code);
        }

        if (strcmp(letter, "i") == 0 || strcmp(letter, "j") == 0)
            strcat(result, elements[8].code);
        if (strcmp(letter, "u") == 0 || strcmp(letter, "v") == 0)
            strcat(result, elements[19].code);
    }

    return result;
}

char *strip(const char *string){

    int i, j;
    size_t length = strlen(string);
    char *res = malloc(sizeof(char) * length + 1);

    if (res == NULL) exit(-1);

    j = 0;

    for (i=0; string[i]!='\0'; i++){
        if (97 <= string[i] && string[i] < 123){
            res[j] = string[i];
            j++;
        }
    }

    res[j] = '\0';

    return res;
}

Je pars sur le principe des dictionnaires en python, je crée des éléments, qui comprennent chacun

• La lettre
• Le code correspondant à la lettre

Il n'est bien sûr pas terminé, c'était juste pour apporter une idée d'algorithme, ça doit tout de même être assez rapide, car que de l'indexation de tableau.

Bonne continuation...

P.S Je m'amuserais sans doute à le faire en java

[xhacker]

j'ai de même un algorithme qui n'est pas sophistiqué en c++



Include <iostream>
include <string>
using namespace std

string alphabetCrypt(string lettre)
{
if lettre=='a'
{
lettre='AAAAA' ;
}
else if lettre=='b'
{
lettre='AAAAB'
}
else if lettre=='c'
{
lettre='AAABA' ;
}
else if lettre=='d'
{
lettre='AAABB' ;
}
else if lettre=='e'
{
lettre='AABAA' ;
}
else if lettre=='f'
{
lettre='AABAB' ;
}
else if lettre=='g'
{
lettre='AABBA' ;
}
else if lettre=='h'
{
lettre='AABBB' ;
}
else if lettre=='i'
{
lettre='ABAAA' ;
}
else if lettre=='j'
{
lettre='ABAAA' ;
}
else if lettre=='k'
{
lettre='ABAAB' ;
}
else if lettre=='l'
{
lettre='ABABA' ;
}
else if lettre=='m'
{
lettre='ABABB' ;
}
else if lettre=='n'
{
lettre='ABBAA' ;
}
else if lettre=='o'
{
lettre='ABBAB' ;
}
else if lettre=='p'
{
lettre='ABBBA' ;
}
else if lettre=='q'
{
lettre='ABBBB' ;
}

else if lettre=='r'
{
lettre='BAAAA' ;
}
else if lettre=='s':
{
lettre='BAAAB' ;
}
else if lettre=='t':
{
lettre='BAABA' ;
}
else if lettre=='u':
{
lettre='BAABB' ;
}
else if lettre=='v':
{
lettre='BAABB' ;
}
else if lettre=='w':
{
lettre='BABAA' ;
}

else if lettre=='x':
{
lettre='BABAB' ;
}
else if lettre=='y':
{
lettre='BABBA' ;
}
else if lettre=='z'
{ 
lettre='BABBB' ;
}
return lettre ;
}





void main()
{
string lettre1,lettre2,lettre3,lettre4,lettre 5 ;

lettre1=alphabetCrypt(lettre1) ;
lettre2=alphabetCrypt(lettre2) ;
lettre3=alphabetCrypt(lettre3) ;
lettre4=alphabetCrypt(lettre4) ;
lettre5=alphabetCrypt(lettre5) ;

cout << "le mot est"<<lettre1<<<<lettre2<<<<lettre3<<<<lettre4<<<<lettre5<<<<endl ;

return 0 ;
}

[xhacker]

je me suis trompé quel part donc le bon algorithme est

#Include <iostream>
#include <string>
using namespace std;

string alphabetCrypt(string lettre)
{
if lettre=='a'
{
            lettre='AAAAA' ;
}
else if lettre=='b'
{            
lettre='AAAAB'
}
else if  lettre=='c'
{
            lettre='AAABA' ;
}
else if lettre=='d'
{
            lettre='AAABB' ;
}
else if lettre=='e'
{            
            lettre='AABAA' ;
}
else if lettre=='f'
{
            lettre='AABAB' ;
}
else if lettre=='g'
{
            lettre='AABBA' ;
}
else if lettre=='h'
{
            lettre='AABBB' ;
}
else if lettre=='i'
{
            lettre='ABAAA' ;
}
else if lettre=='j'
{
            lettre='ABAAA' ;
}
else if lettre=='k'
{
            lettre='ABAAB' ;
}
else if lettre=='l'
{
            lettre='ABABA' ;
}
else if lettre=='m'
{
            lettre='ABABB' ;
}
else if lettre=='n'
{
            lettre='ABBAA' ;
}
 else if lettre=='o'
{
            lettre='ABBAB' ;
}
else if lettre=='p'
{
            lettre='ABBBA' ;
}
else if lettre=='q'
{
            lettre='ABBBB' ;
}

else if lettre=='r'
{
            lettre='BAAAA' ;
}
else if lettre=='s':
{
            lettre='BAAAB' ;
}
else  if  lettre=='t':
{
            lettre='BAABA' ;
}
else if lettre=='u':
{
            lettre='BAABB' ;
}
else if lettre=='v':
{
            lettre='BAABB' ;
}
else if lettre=='w':
{
            lettre='BABAA' ;
}

else if lettre=='x':
{
            lettre='BABAB' ;
}
else if lettre=='y':
{
            lettre='BABBA' ;
}
else if lettre=='z'
{ 
            lettre='BABBB' ;
}
return lettre ;
}





void main()
{
string  lettre1,lettre2,lettre3,lettre4,lettre 5 ;

lettre1=alphabetCrypt(lettre1) ;
lettre2=alphabetCrypt(lettre2) ;
lettre3=alphabetCrypt(lettre3) ;
lettre4=alphabetCrypt(lettre4) ;
lettre5=alphabetCrypt(lettre5) ;

cout << "le mot est"<<lettre1<<<<lettre2<<<<lettre3<<<<lettre4<<<<lettre5<<<<endl ;

return 0 ;
}

Balises code ajoutée, attention de ne pas les oublier à l'aide du bouton # dans éditeur avancé

[fred]

Si tu fais du C++, je trouve cela dommage de ne pas utiliser sa force... Il existe le pattern map, qui te permettra de travailler sous forme de dictionnaire assez simplement.

Bonne continuation.