CRYPTAGE (SIMPLE) AVEC CLE ALEATOIRE ET INTEGRE

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

    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.