Cryptage (simple) avec cle aleatoire et integre

Télécharger le projet
Commenter

Description

Programme de cryptage de fichier simple puisque je n'utilise que la combinaison d'un Xor et d'un Rot (cryptage de cesars).
L'avantage c'est que je crypt des blocs de 4 octets avec chaque fois une clé différente et j'inclu la clé dans le fichier.

PS : C'est pas pour çà que c'est pas securisé, loin de là !

Source / Exemple : 


{
 ------------------------------------------------------

    Unité de démonstration pour Delphi.fr

    Unité de cryptage de fichier avec clé aléatoire
    Ecrit Par LEVEUGLE Damien (c) 2005

 ------------------------------------------------------
}

unit cryptage;

interface

uses SysUtils;

procedure Crypter  ( FichierSource: string; FichierDestination : String );
procedure Decrypter( FichierSource: string; FichierDestination : String );

implementation

{ Crypter un fichier }
procedure Crypter( FichierSource: string; FichierDestination : String );
var
    BufSource : Array[1..4] of Char;         // Notre morceau de fichier en mémoire
    BufCrypte : Array[0..4] of Char;         // Buffer crypter avec la clé ( BufCrypt[0] = clé )

    SourceF, DestF : File;

    CryptageKey : Byte; // Notre clé généré aleatoirement

    Lu    : Integer;    // Nombre d'octet de fichier lu
    Ecrit : Integer;    // Nombre d'octet de fichier ecrit (pour verif. uniquement)

    i : Integer;        // Pour notre boucle

begin

    Randomize;

    Assign (SourceF, FichierSource);          // On ouvre le fichier source
    Reset  (SourceF, 1);

    Assign (DestF, FichierDestination);       // On crée le fichier destination
    Rewrite(DestF, 1);

    repeat

        FillChar( BufSource, SizeOf(BufSource), #0 ); // Initialise les buffers
        FillChar( BufCrypte, SizeOf(BufCrypte), #0 );

        CryptageKey := Random(255);             // On crée notre clé

        BlockRead( SourceF, BufSource, SizeOf( BufSource ), Lu );     // On lit un bloc de 2Ko de notre fichier source

        BufCrypte[0] := Chr( CryptageKey );  // On insère la clé a l'index 0

        for i := 1 to Lu do        // on crypte ce bloc en insérant la clé devant le bloc
            BufCrypte[i] := Chr( ( Ord( BufSource[i] ) xor CryptageKey ) + CryptageKey );   // Le reste on crypt simplement ( XOR + ROT )

        if Lu > 0 then BlockWrite( DestF, BufCrypte, Lu + 1, Ecrit );        // On ecrit notre Bloc crypté

    until ( ( Lu = 0 ) or ( ( Lu + 1 )<> Ecrit ) );        // On reprend un bloc de 2Ko

    Close( SourceF );     // On ferme
    Close( DestF   );     // les fichiers ouverts

end;

{ Decrypter un fichier }
procedure Decrypter( FichierSource: string; FichierDestination : String );
var
    BufCrypter : Array[0..4] of Char;    // Notre bloc crypter
    BufDecrypt : Array[1..4] of Char;    // Bloc decrypter

    SourceF, DestF : File;

    CryptageKey : Byte;                     // La clé

    Lu    : Integer;
    Ecrit : Integer;

    i : Integer;

begin

    Assign (SourceF, FichierSource);        // On ouvre nos fichiers
    Reset  (SourceF, 1);

    Assign (DestF, FichierDestination);     // Bla Bla ...
    Rewrite(DestF, 1);

    repeat

        FillChar( BufCrypter, SizeOf(BufCrypter), #0 );     // Initialise les buffers
        FillChar( BufDecrypt, SizeOf(BufDecrypt), #0 );

        BlockRead( SourceF, BufCrypter, SizeOf( BufCrypter ), Lu );   // On lit le fichier crypté

        CryptageKey := Ord( BufCrypter[0] );    // On recupère le premier caractère du bloc (c'est notre clé)

        for i := 1 to (Lu - 1) do
            BufDecrypt[i] := Chr( ( Ord( BufCrypter[i] ) - CryptageKey ) xor CryptageKey );    // Le reste on le decrypte grâce à la clé recupérée

        if Lu > 0 then BlockWrite( DestF, BufDecrypt, (Lu - 1), Ecrit );     // Et comme pour le cryptage ba on ecrit notre bloc dans le fichier destination
                                                            // ( "Lu - 1" car notre bufferDecrypt commence à 1 alors que notre BufCrypter commence à 0 )
    until ( ( Lu <= 0 ) or ( (Lu - 1) <> Ecrit ) );

    Close( SourceF );       // On ferme tout .. bla bla
    Close( DestF   );

end;

end.

Conclusion :


1) Vous pouvez changer la taille du bloc d'octet à codifier simplement (suffit de changer la valeur max dans les "Arrays" sans touché au code).

2) Vous pouvez modifier la methode de cryptage en combinant des Xor et des Rot comme il vous convient, et vous pouvez meme faire une opération de cryptage sur la clé si çà vous chante :-)

3) Marche parfaitement avec tout type de fichier ( j'ai même testé avec des Zip et des EXE).

Bon Code

Damien.
Télécharger le projet

Codes Sources

A voir également

S'inscrire maintenant

Vous n'êtes pas encore membre ?

inscrivez-vous, c'est gratuit et ça prend moins d'une minute !

Les membres obtiennent plus de réponses que les utilisateurs anonymes.

Le fait d'être membre vous permet d'avoir un suivi détaillé de vos demandes et codes sources.

Le fait d'être membre vous permet d'avoir des options supplémentaires.

Du même auteur (elguevel)