DÉCRYPTER LES FICHIERS IMAGE JPG (VOUS AVEZ ÉGARÉ LA CLÉ)

Commentaire de japee le 24/10/2003 00:36:50 administrateur CS

Oui, Delphiprog, je suis sur que ça va en intéresser plus d'un(e) ;)

Le positionnement de mes blocs try..except et try..finally me semblait logique... il faut que j'étudie ça à tête reposée.

Le thread, c'est prévu, et pourquoi pas plusieurs threads qui se partageraient le travail (ouh la la, la complication... :( )

J'avais déjà fait un programme tout à fait fonctionnel, mais le code me fait un peu honte, maintenant. Je crois que je vais m'y remettre, c'est un bon exercice de programmation.

Merci pour tes conseils et encouragements Delphiprog :)

Commentaire de japee le 25/10/2003 00:14:20 administrateur CS

Que tu es impatient, kimmelf2 !

Mets donc un OpenDialog avec la propriété multiselect, en attendant...
Ou une recherche récursive de tous les fichiers comportant l'extension .jpg se trouvant dans un répertoire sélectionné.

Sinon, patiente, comme dit plus haut, j'y reviendrai, mais j'ai pas trop le temps...

Ah, quand les hormones nous travaillent... mdr :)

Commentaire de japee le 27/10/2003 03:36:29 administrateur CS

Je constate que tu es un couche-tard, kimmelf2 !

Attention, comme disait ma grand-mère, jeunesse qui veille et vieillesse qui dort sont tous deux près de la mort ;)
C'est comme ça que j'ai décidé de ne plus dormir ! ptdrrrrr :))))))))

Ce bout de code, j'essayais de te l'expliquer, est destiné à être mis dans une boucle qui va s'occuper des fichiers à décrypter, de manière automatique.

Merci pour ton "bravo", j'en conclus que ça fonctionne, hein ? (manquerait plus que ça marche pas...)

Ultra-mini-débutant deviendra grand, t'en fais pas !

Bonne prog', faut pas mollir !!!!

Commentaire de japee le 27/10/2003 16:45:16 administrateur CS

Bravo, lenine! Exactement ce qu'il fallait faire en attendant que j'aie pondu un exécutable mettant ce code en oeuvre... pffff, j'arrive pas à me motiver, mais ça va me prendre d'un coup, c'est sûr.

Quand je vous dit que ça marche, hein ?

Surtout en utilisant la procedure avec TFileStream, qui élimine les problèmes de fichier en lecture seule copiés sur le disque dur (j'ai jamais trop bien compris pourquoi ça posait problème...)

Commentaire de japee le 28/10/2003 17:42:41 administrateur CS

Merci pour tes explications, kimmelf, les problèmes d'accès aux fichiers sous Windows sont effectivement communs à tous les langages, et je n'ai en principe pas de difficulté à en comprendre la logique ;)
Ce qui est difficilement compréhensible, c'est qu'un fichier en lecture seule est (apparemment ?) impossible à lire (j'ai bien dit à lire), du moins byte par byte, s'il est situé sur le disque dur ???
C'est du moins le cas ici en lisant le fichier (byte par byte), en modifiant ce byte, et en copiant le byte obtenu dans un fichier cible.
Alors que cela ne pose pas de problème (et là on retrouve la logique) s'il est lu à partir d'un support CD-Rom...
Mais bon, le problème ne se pose plus si l'on utilise TFileStream (conseillé !), alors... (d'autant plus que c'est 2 fois plus rapide).
Bon courage avec ta réinstallation, paraît que XP plante moins, mais on aime ou pas... et puis c'est dur de suivre l'évolution, on n'a pas forcément les moyens financiers de changer de système d'exploitation tous les 2 ans !
Il faudrait avoir le courage de migrer vers Linux ! ;)
Enfin, en réinstallant Win98 SE tous les ans, j'arrive à ne pas trop galérer :(
Bon courage, à + (et reviens vite à Delphi !) ;)

Commentaire de jbanety le 30/10/2003 08:23:29

ça me rappelle quand j'avais trouvé une source pour décoder la clé de cryptage des cd DCOD, les petit cd's de cul pour les cochons :)

Enfin bon j'ai essayé et excellent boulot !

Commentaire de japee le 03/11/2003 15:16:01 administrateur CS

Oui, darkstorm, on se sert du premier byte pour déterminer la clé, car on sait que le premier byte d'un fichier jpg "normal" (non crypté) est "FF" (facile à voir avec un éditeur hexadécimal), et 5A pour un fichier crypté.
On peut supposer que l'opérateur logique xor est utilisé, coup de bol, c'est le cas !
En partant du principe que ByteCodé xor ByteDécodé = Clé, et que ByteCodé xor Clé = ByteDécodé, reste plus qu'à appliquer...
Comme ils se sont pas foulés, en calculant la clé sur le premier octet et en l'appliquant à tous les bytes du fichier (y compris le premier bien sûr), on obtient le fichier décrypté.
On pourrait se dispenser de chercher la clé à chaque fois, car il semblerait que ce soit toujours la même, donc ça ferait gagner un peu de temps...
Bon, mais s'il leur venait à l'idée de changer la clé, hein ?
Ou alors ne calculer qu'une seule fois, sur un fichier, en partant du principe que la même clé sera utilisée pour toute la série d'image cryptées...
Tout est envisageable, il ne s'agit ici que du principe, à chacun de voir pour améliorer la rapidité, il semble qu'il y ait des possibilités ! ;)

Commentaire de deep69 le 16/05/2004 13:48:47

Salut,

yep excelent avec filestream,hélas j'ai le PCMag n°147 et

l'image ne ce decrypte pas :-(

voici les 4 premiers octets que j'obtient ÿåóö au lieu de ÿØÿà

Commentaire de Fulminex le 11/08/2005 02:43:54

J'ai écrit ce code en Turbo Pacal à l'époque... Si ton code est lent, c'est parce-qu'il lit octet par octet... Une lecture par bloc et un traitement séparé du bloc en mémoire, ça accélère "achment"! ^^

Commentaire de japee le 23/08/2006 16:39:46 administrateur CS

Salut Cirec,

J'ai repris ce code car il était vraiment mal foutu et me faisait honte. Son seul intérêt est de montrer le mécanisme du cryptage par xor.

Quant au problème de la rapidité, il est résolu dans un code posté ultérieurement, grâce à Shining et à TMemoryStream.

Mais ta manière de procéder m'intéresse, elle est en quelque sorte à mi chemin entre BlockRead et FileStream, et je vais l'étudier de plus près.

Sinon, j'en ai deux autres en réserve, il va falloir que je compare les performances...

Une version assez rapide :

procedure DecodeFileBlocks(const FromFileName, ToFileName: string);
var
  OldF, NewF: file;
  Buffer: array[0..1023] of Byte;
  FilePointer: LongInt; // pointeur de position dans le fichier
  BytesRead: Integer;
  i: Integer;
  Key: Byte;
begin
  AssignFile(OldF, FromFileName);
  try
    Reset(OldF, 1);
    BlockRead(OldF, Buffer, SizeOf(Buffer), BytesRead);
    Key := Buffer[0] xor 255;
    Seek(OldF, 0);
    AssignFile(NewF, ToFileName);
    try
      Rewrite(NewF, 1);
      while not Eof(OldF) do
      begin
        FilePointer := FilePos(OldF);
        BlockRead(OldF, Buffer, SizeOf(Buffer), BytesRead);
        for i := 0 to BytesRead - 1 do
          Buffer[i] := Buffer[i] xor Key;
        Seek(NewF, FilePointer);
        BlockWrite(NewF, Buffer, BytesRead);
      end;
    finally
      CloseFile(NewF);
    end;
  finally
    CloseFile(OldF);
  end;
end;

Une version ultra rapide :

procedure DecodeMemoryStream(const FromFileName, ToFileName: string);
var
  Tmp,
  Key,
  PosPointer: LongWord;
  MStream: TMemoryStream;
begin
  MStream := TMemoryStream.Create;
  try
    MStream.LoadFromFile(FromFileName);
    MStream.Seek(0, soFromBeginning);
    MStream.Read(Tmp, 4);
    Key := Tmp xor $E0FFD8FF;
    MStream.Seek(0, soFromBeginning);
    while MStream.Position < MStream.Size do
    begin
      PosPointer := MStream.Position;
      MStream.Read(Tmp, 4);
      Tmp := Tmp xor Key;
      MStream.Position := PosPointer;
      MStream.Write(Tmp, 4);
      MStream.Position := PosPointer + 4;
    end;
    MStream.SaveToFile(ToFileName);
  finally
    MStream.Free;
  end;
end;

Quoi qu'il en soit, voilà un beau catalogue des manières de lire et écrire dans les fichier, c'est presque un tutoriel, lol...

A +
japee

Commentaire de cirec le 23/08/2006 23:57:02 administrateur CS

Voilà
cette procedure est vraiment la plus rapide de toutes :

procedure DecodeMemoryStreamBlock(const FromFileName, ToFileName: string);
var
  Key,
  PosPointer: LongWord;
  Buffer    : Array[1..1024] of Byte;
  MStream: TMemoryStream;
  NbALire, NbLu, TotalLu : LongInt;
  i: Integer;
begin
  MStream := TMemoryStream.Create;
  try
    MStream.LoadFromFile(FromFileName);
    MStream.Seek(0, soFromBeginning);
    MStream.Read(Key, 4);
    Key := Key xor $E0FFD8FF;
    MStream.Seek(0, soFromBeginning);
    TotalLu := 0;
    NbALire := SizeOf(Buffer);
    Repeat
      If (TotalLu + NbALire) > MStream.Size Then NbALire := MStream.Size - TotalLu;
      PosPointer := MStream.Position;
      NbLu := MStream.Read(Buffer, NbALire);
     For I:= 1 to NbLu do
        Buffer[I] := Buffer[I] Xor Key;
      MStream.Position := PosPointer;
      MStream.WriteBuffer(Buffer, NbLu);
      TotalLu := TotalLu + NbLu;    
    Until TotalLu >= MStream.Size;
    MStream.SaveToFile(ToFileName);
  finally
    MStream.Free;
  end;
end;


Bonne nuit ;-)
@+
Cirec