Comment décrypter le texte chiffré de Blowfish avec un en-tête salé?

Question

J'ai un chiffrement qui a été crypté en utilisant le module Crypt::CBC de Perl que je souhaite décrypter ailleurs.

Le cryptogramme a été généré en utilisant la version « simple » du constructeur Crypt::CBC, qui est:

use Crypt::CBC; 
$cipher = Crypt::CBC->new(-key => 'my secret key', 
          -cipher => 'Blowfish' 
         ); 

À la lecture de la page MAN, cette méthode de construction prendra la chaîne simple sel clé et aléatoire pour générer une clé littérale à utiliser pour le cryptage, ainsi que l'incorporation d'un en-tête avec le sel.

« sel » - combiner le mot de passe avec une valeur aléatoire de 8 octets à générer à la fois la clé de chiffrement par bloc et l'IV de la phrase de passe fournie . Le sel sera ajouté au début du flux de données permettant le décryptage à régénérer à la fois la clé et IV étant donné la phrase de passe correcte. Cette méthode est compatible avec les versions actuelles d'OpenSSL.

J'ai besoin maintenant de déchiffrer le texte chiffré sur une autre plate-forme qui prend en charge que le déchiffrement CBC donne le texte chiffré, une clé littérale & IV. Pour tenter de générer la clé littérale, IV sel &, j'ai utilisé Crypt :: CBC pour générer les valeurs comme ceci:

my $crypt = new Crypt::CBC(-key => 'my secret key', -cipher => 'Blowfish'); 
my $out = $crypt->decrypt($ciphertext); 
my $literal_key = $crypt->key(); 
my $iv = $crypt->iv(); 
my $salt = $crypt->salt(); 

Le décryptage ici est correct, mais j'ai été incapable d'utiliser la clé littérale généré & IV pour déchiffrer le chiffre; ce produit des déchets:

my $crypt2 = new Crypt::CBC(
    -literal_key => 1, 
    -key => $literal_key, 
    -cipher => 'Blowfish', 
    -iv => $iv, 
    -header => 'none'); 
my $rubbish - $crypt2->decrypt($ciphertext); 

Je ne peux pas fournir une clé littérale et utiliser un en-tête salée donc je suis perdu pour le prochain mouvement.

Comment puis-je déchiffrer ce texte?

EDIT: Le système cible ne fonctionne pas Perl, mais je l'ai été en mesure de générer la valeur identique dans les ordures $ ci-dessus, donc je suis sûr qu'il utilise le même algorithme (CBC, Blowfish) à déchiffrer.

Answer 1

Pour décrypter le flux, vous devez d'abord supprimer l'en-tête ajouté par « sel de Crypt :: CBC "mode" L'en-tête comprend les 8 caractères Salted__ suivis de 8 octets de données salées.

En perl, quelque chose comme ça devrait le faire:

my $crypt2 = new Crypt::CBC(
    -literal_key => 1, 
    -key => $literal_key, 
    -cipher => 'Blowfish', 
    -iv => $iv, 
    -header => 'none'); 
my $cleartext = $crypt2->decrypt(substr($ciphertext, 16)); 

Answer 2

Cela peut fonctionner. Votre clé devra être exactement 56 octets de longueur et iv devra être exactement huit octets:

#!/usr/bin/perl 

use strict; 
use warnings; 

use Crypt::CBC; 

my $key = "x" x 56; 
my $iv = "x" x 8; 

my $plaintext = "this is just some normal text\n"; 
my $ciphertext = Crypt::CBC->new(
    -cipher  => 'Blowfish', 
    -header  => 'none', 
    -literal_key => 1, 
    -key   => $key, 
    -iv   => $iv, 
)->encrypt($plaintext); 

print Crypt::CBC->new(
    -cipher  => 'Blowfish', 
    -header  => 'none', 
    -literal_key => 1, 
    -key   => $key, 
    -iv   => $iv, 
)->decrypt($ciphertext); 

Answer 3

Si quelqu'un a besoin de la fonction _salted_key_and_iv en PHP - ici il est:

function _salted_key_and_iv ($pass, $salt) { 
     if(strlen($salt) != 8) { 
      die("Salt must be 8 bytes long"); 
     } 

     $key_len = 56; 
     $iv_len = 8; 

     $desired_len = $key_len+$iv_len; 

     $data = ''; 
     $d = ''; 

     while (strlen($data) < $desired_len) { 
      $d = pack("H*", md5($d . $pass . $salt)); 
      $data .= "$d"; 
     } 

     return $data; 
}