Soit deux collections compactes d’octets quelconques bien rangées à deux endroits distincts de la mémoire vive d’un ordinateur fonctionnant sous système Windows. On se donne comme tâche de « transformer » chacun des octets de la première en fonction de la teneur de ceux de la seconde de telle sorte qu’ils ne soient plus reconnaissables, mais qu’ils puissent redevenir ce qu’ils étaient avec la même « transformation ».

Cela s’appelle du cryptage/décryptage par clé !

Côté algorithme de « transformation », celui-ci n’a que faire des significations respectives des messages contenus par les deux collections ; ils peuvent être n’importe quoi. Ce qui compte pour lui est que la nature de la « transformation » ne donnera pratiquement aucune prise à la cryptanalyse. Alors on peut imaginer un cryptage par procédé dit de Vernam alimenté par un double générateur congruentiel de nombres pseudo-aléatoires dont la génération non spontanée est rendue dépendante du résultat d’une fonction de hachage des octets de la clé. Simple…

Rien n’interdit que cet algorithme de cryptage/décryptage soit englobé dans une toute petite DLL qui pourrait être utilisable par Delphi bien sûr mais aussi par d’autres langages sous Windows… Alors voici cette DLL compilable par Delphi :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
library CryptoV64;
 
uses
   Windows;
// Routine exportable *******************************************************
 
procedure CrypteV64(PBuff,PKey: pointer; SizeBuf,SizeKey: longWord); stdCall;
var Al1,Al2 : longInt;
asm
    push     ebx
    push     esi
    mov      esi,[ebp+$08]
    push     edi
    mov      edi,[ebp+$0C]
    mov      ebx,Dword ptr[edi]
    mov      eax,Dword ptr[edi+4]
    xor      ecx,ecx
    mov      ecx,[ebp+$14]
    sub      ecx,$8
    jbe      @Xorise
    add      edi,$09
    @Sert:
          xor      edx,edx
          mov      dl,byte ptr[edi]
          test      dl,dl
          jnz       @NZ
          or        dl,$FF
          @NZ:
          mul      edx
          add      ebx,edx
          inc      edi
          loop     @Sert
    @Xorise:
    mov      Al1,ebx
    mov      Al2,eax
    mov      ecx,[ebp+$10]
    shr      ecx,$3
    jz       @Reste
    @XorQWords:
          xor     DWord ptr[esi],ebx
          add     esi,$4
          xor     DWord ptr[esi],eax
          add     esi,$4
          xor     eax,eax
          dec     eax
          imul    edx,Al1,$08088405
          inc     edx
          mov     Al1,edx
          mul     edx
          mov     ebx,edx
          xor     eax,eax
          dec     eax
          imul    edx,Al2,$08088405
          inc     edx
          mov     Al2,edx
          mul     edx
          mov     eax,edx
          loop    @XorQWords
    @Reste:
    mov      ecx,[ebp+$10]
    and      ecx,$7
    jz       @Fin
    @XorBytes:
          xor    Byte ptr[esi],al
          inc    esi
          mov    al,bl
          shr    ebx,$8
          ror    eax,$8
          loop   @XorBytes
    @Fin:
    pop      edi
    pop      esi
    pop      ebx
end;
 
exports
    CrypteV64;
 
begin
end.
Pour ceux qui ne sont pas familiarisés avec les librairies en Delphi, il suffit d’ouvrir un nouveau projet, d’y supprimer l’unit1 fournie puis de remplacer le code source du projet fourni par le code ci-dessus ; ensuite la compilation de ce projet va produire en répertoire de travail un fichier dénommé CryptoV64.dll.

L’unique procédure de cette dll n’attend pour faire sont job que 4 paramètres : un pointeur sur le premier octet du buffer à crypter, un pointeur sur le premier octet du buffer de clé, la quantité d’octets du buffer à crypter et enfin la quantité d’octets du buffer de clé et l’opération de « transformation » ne nécessitera qu’une fraction de seconde pour s’accomplir car elle travaille en 2x32 bits.

Comment s’en servir dans un projet-programme en Delphi pour crypter un fichier ?

1/ Placer CryptoV64.dll dans le même répertoire que lui.

2/ Pour assurer la liaison avec la fonction de cryptage/décryptage contenue en dll, placer dans la partie Implementation du programme la déclaration suivante :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
procedure CrypteV64(PBuf,PKey: pointer; SizeBuf,SizeKey: longWord); stdCall; external'CryptoV64';
3/ Déclarer la clef de cryptage dans une String :

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
MaClef : String ;
MaClef :='Les sanglots longs des violons de l''automne' ;
4/ Appeler le fichier à crypter/décrypter dans un buffer de type TMemoryStream

Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
MonStream : TMemoryStream ;
MonStream :=TMemoryStream.Create ;
MonStream.LoadFromFile('MonFichier.dat');
5/ Crypter ou décrypter avec

Code : Sélectionner tout - Visualiser dans une fenêtre à part
CrypteV64(MonStream.Memory, @MaClef[1], MonStream.Size, length(Maclef));
6/ sauver le fichier crypté/décrypté et libérer la RAM
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
MonStream.SaveToFile('MonFichierCrypté.dat') ;
MonStream.free ;
Commentaires :

Les "conteneurs" de fichiers et clés peuvent être divers (array, buffers réservés en RAM, String longues etc...)
La clé doit avoir plus de 8 octets, en deçà, le cryptage aura lieu, mais le décryptage sera impossible.
La clé utilisée lors du décryptage doit être exactement identique au bit près à celle ayant servi au cryptage.

N.B. Pour ceux qui répugnent à l'emploi des dll, il est possible ici de copier-coller la procédure de cryptage en programme Delphi.