Calculer et vérifier un checksum pour dialoguer avec l'extérieur

Je vous en parlais à l'occasion de la création de la fonction MD5() : pour les API que je mets en place j'utilise en général des contrôles d'intégrité des paramètres passés. Pour celà j'utilise un paramètre additionnel qui contient le checksum du tout.

Ca ne me sert pas dans les logiciels autonomes mais pour dialoguer avec des sites Internet. Il y a donc un bout de code côté Delphi pour calculer et vérifier le checksum et il y en a un côté serveur.

Du côté de Delphi je me suis créé une unité uChecksumVerif dans laquelle se trouve la classe ChecksumVerif permettant d'en appeler les méthodes de classe sans l'instancier.

Cette technique permet simplement de créer un espace de nom dans lequel caser des fonctions et procédures. Pratique désormais courante sous Delphi et C++ Builder.

Voici le source de l'unité en question:

unit uChecksumVerif;

interface

uses
  system.classes;

type
  ChecksumVerif = class
    // private
    class function get(param: string; key1: string; key2: string; key3: string;
      key4: string; key5: string; public: boolean): string; overload;
    // public
    class function get(param: TStrings; key1: string = ''; key2: string = '';
      key3: string = ''; key4: string = ''; key5: string = ''): string;
      overload;
    class function get(param: string; key1: string = ''; key2: string = '';
      key3: string = ''; key4: string = ''; key5: string = ''): string;
      overload;
    class function check(verif: string; param: TStrings; key1: string = '';
      key2: string = ''; key3: string = ''; key4: string = '';
      key5: string = ''): boolean; overload;
    class function check(verif: string; param: string; key1: string = '';
      key2: string = ''; key3: string = ''; key4: string = '';
      key5: string = ''): boolean; overload;
  end;

implementation

uses u_md5;

class function ChecksumVerif.get(param: string; key1: string; key2: string;
  key3: string; key4: string; key5: string; public: boolean): string;
var
  verif: string;
begin
  verif := MD5(param + key1 + key2 + key3 + key4 + key5);
  if public then
    result := copy(verif, 1 + random(Length(verif) - 10), 10)
  else
    result := verif;
end;

class function ChecksumVerif.get(param: TStrings; key1: string = '';
  key2: string = ''; key3: string = ''; key4: string = '';
  key5: string = ''): string;
var
  i: integer;
  ch: string;
begin
  ch := '';
  for i := 0 to param.Count - 1 do
  begin
    ch := ch + param[i];
  end;
  result := get(ch, key1, key2, key3, key4, key5, true);
end;

class function ChecksumVerif.get(param: string; key1: string = '';
  key2: string = ''; key3: string = ''; key4: string = '';
  key5: string = ''): string;
begin
  result := get(param, key1, key2, key3, key4, key5, true);
end;

class function ChecksumVerif.check(verif: string; param: TStrings;
  key1: string = ''; key2: string = ''; key3: string = ''; key4: string = '';
  key5: string = ''): boolean;
var
  i: integer;
  ch: string;
begin
  ch := '';
  for i := 0 to param.Count - 1 do
  begin
    ch := ch + param[i];
  end;
  result := check(verif, ch, key1, key2, key3, key4, key5);
end;

class function ChecksumVerif.check(verif: string; param: string;
  key1: string = ''; key2: string = ''; key3: string = ''; key4: string = '';
  key5: string = ''): boolean;
var
  verif_: string;
begin
  verif_ := get(param, key1, key2, key3, key4, key5, false);
  result := 0 < pos(verif, verif_);
end;

initialization

randomize;

end.

Le principe est assez simple. On appelle :

  • ChecksumVerif.get() pour générer un checksum à partir d'un ou plusieurs paramètres et de clés de cryptage
  • ChecksumVerif.check() pour s'assurer que le checksum reçu soit bien valide par rapport aux mêmes paramètres.

L'algorithme de génération du checksum est lui aussi très simple : on concatène dans l'ordre d'arrivée les différents paramètres, on en calcule le MD5 puis on ne ressort qu'une partie du résultat.

Pour la vérification, on calcule la clé et on vérifie que le checksum reçu est bien présent dans la chaine complète.

Je l'ai dit, MD5 n'est pas un algorithme sécurisé pour des mots de passe. Il a cependant l'avantage de toujours générer la même chose avec les mêmes infos d'entrée quel que soit le langage de développement utilisé. L'utilisation des mêmes paramètres donnera donc toujours la même chose à condition de les passer dans le même ordre pour le calcul et la vérification du checksum.

Pour compliquer les choses, plutôt que de sortir l'intégralité du code généré qui pourrait donner lieu à investigations de la part de hackers, on en ressort une partie qui en plus n'est pas toujours la même. Il devient ainsi totalement impossible de deviner la ou les clés de cryptage utilisées ni de les remplacer par un truc donnant le même résultat avec l'algorithme MD5.

Alors bien sûr, les mêmes paramètres donnant toujours le même résultat, cette technique ne peut servir que pour s'assurer de la cohérence d'informations, ni de leur provenance, ni de l'authenticité de leur émetteur. Pour ça il faut une donnée partagée entre les deux côtés qui ne soit visible nulle part et change à chaque fois, comme un identifiant de session ou une clé unique par exemple calculée avec Log'n Pass qui servirait de tiers de confiance.


A lire aussi

Evitez les plantages causés par une mauvaise utilisation de la librairie System.JSON (18/04/2018)
Plutôt INI ou JSON pour stocker vos paramètres ? (21/07/2017)
Calculer et vérifier un checksum pour dialoguer avec l'extérieur (19/07/2017)
Télécharger simplement un fichier via Internet en tâche de fond (10/07/2017)
Calculer un MD5 sous Delphi (04/07/2017)
Les threads et le blocage des écrans (14/06/2017)
Utilisation de processus sous Delphi : fonctionnement de base. (04/06/2017)
Passer un traitement lourd en tâche de fond sans bloquer l'écran (04/06/2017)
Ajouter des chaînes de caractères vides dans un objet JSON (19/05/2017)
Configurer le firewall de McAfee AntiVirus Plus pour utiliser l'App Tethering (28/06/2016)