[PILLOLA] Criptare i dati

[JHammer]

Criptare dati in modo reversibile

Non sto proponendo qualcosa di veramente originale perchè si tratta del classico algoritmo di criptazione in chiave privata.
L'algoritmo produce un nuovo dato che è praticamente inattaccabile...lo svantaggio è intrinseco nel fatto che l'algoritmo è...a chiave privata (quindi la chiave ve tenuta nascosta nel cassetto!)

Idea alla base: la chiave viene usata per effettuare un xor byte a byte con il dato. Il risultato viene quindi impaccato su una stringa in cui ogni byte è rappresentato dalla sua rappresentazione esadecimale.
Lo svantaggio è che in questo modo la stringa si raddoppia (un byte = 2 cifre exa) però possiamo trattare il dato criptato come stringa {0,1,...,9,A,...F}(senza preoccuparci di caratteri 'pericolosi').
Poichè la criptazione è tanto più robusta tanto più la chiave è lunga, nel caso di chiavi corte (meno di 32 caratteri) sostituisco la chiave con la versione md5 della chiave stessa

L'operazione xor ha i vantaggi

1) genera un dato di uscita simile a un rumore binario (altissima scorrelazione intersimbolica)
2) è semplice ed efficiente
3) soprattutto reversibile

Ok...queste le funzioni

str_crypt($data, $key);
   - $data è la stringa da criptare
   - $key la chiave
   > Ritorna la stringa criptata

str_decrypt($cdata, $key);
   - $cdata la stringa criptata
   - $key la chiave (la stessa usata in str_crypt per produrre $cdata)
   > Ritorna la stringa decriptata

Questo il codice...copiatelo e incollatevo nel file degli attrezzi!

ATTENZIONE : per la vostra salute non cercate di capire il codice

CRIPTAZIONE

function str_crypt($data, $key)
{
  if(strlen($key)<32) $key = md5($key);
  $ld  = strlen($data);
  $lk  = strlen($key);
  for($i=0, $crdata=""; $i<$ld; $i++){
    $crdata .= sprintf("%02X",(ord($data[$i]))^(ord($key[$i%$lk])));
  }
  return $crdata;
}

DECRIPTAZIONE

function str_decrypt($cdata, $key)
{
  if(strlen($key)<32) $key = md5($key);
  $ld  = strlen($cdata);
  $lk  = strlen($key);
  for($i=0, $data=""; $i<$ld; $i+=2){
    $data .= chr((hexdec(substr($cdata, $i, 2)))^(ord($key[($i>>1)%$lk])));
  }
  return $data;
}

Ora un programmino di test (suppongo abbiate incluso il file con le funzioni o il codice fornito!)

<?php
  $data = "Testo da criptare";
  $key  = "lamiapassword";

  $cdata = str_crypt($data, $key);
  $ddata = str_decrypt($cdata, $key);

  // verifica!
  echo "Testo da criptare : ".$data."
";
  echo "Password          : ".$key."
";
  echo "Testo criptato    : ".$cdata."
";
  echo "Testo decriptato  : ".$ddata."
"
?>

Dovreste vedere il seguente output
Notate che la stringa criptata è come dicevo il doppio di quella originale (però sono caratteri 'umani')

Testo da criptare : Testo da criptare
Password : lamiapassword
Testo criptato : 350112400B465D531857110A4412544355
Testo decriptato : Testo da criptare

Per i perfezionisti: si potrebbe modificare l'algoritmo per scrivere i dati senza la notazione esadecimale in modo da rendere efficiente la criptazione e quindi applicarla anche a file di grosse dimensioni.

Conclusione
Se dovete criptare password, email (soprattutto le email che troppo spesso sono in chiaro!) avete una soluzione semplice e pronta da usare!

Da jhammer solo pillole di qualità (e originali!)

[Manuelandro]

grazie. Mi hai chiarito un pò meglio le idee riguardo questo argomento. Forse un giorno riuscirò a cripatre dei dati.

Ora ti chiedo umilmente di farmi un esempio, se io volessi fare na cosa tipo:

1)Un utente inserisce la sua password ad esempio pippo.
2)Nella tabella la password è criptata(in modo da fregare chi riuscisse con una injection a leggere tutte le pass).
3)Quando la password però viene utilizzata, quindi c'è una verifica con una query, il valore è quello non criptato.

In aprole povere vorrei che gli utenti utilizzassero normalmente la propria pass, solo che quando la vai a vedere nel db, non la vedi sotto forma normale ma criptata!

[andr3a]

mi dai il permesso di farci una classe basata su questi 2 metodi ?
ovviamente con i riferimenti al tuo operato

[JHammer]

[supersaibal]Originariamente inviato da Manuelandro

Ora ti chiedo umilmente di farmi un esempio, se io volessi fare na cosa tipo:

1)Un utente inserisce la sua password ad esempio pippo.
2)Nella tabella la password è criptata(in modo da fregare chi riuscisse con una injection a leggere tutte le pass).
3)Quando la password però viene utilizzata, quindi c'è una verifica con una query, il valore è quello non criptato.

In parole povere vorrei che gli utenti utilizzassero normalmente la propria pass, solo che quando la vai a vedere nel db, non la vedi sotto forma normale ma criptata! [/supersaibal]

L'idea è quella di memorizzare i dati nel db sotto forma criptata a parte magari il nome utente che potrebbe fungere da id.

Esempio:

utente               pippo 
password             ppass
email                pippo@disney.com

nel db non andrai a memorizzare "ppass" e "pippo@disney.com" ma le loro versioni criptate rispetto a...quale chiave?...rispetto a un'unica chiave che sai solo te e che compare solo in script php (quindi tecnicamente un pò più sicura).
Quindi nel db andranno

nome_utente          crypt_pwd                     crypt_mail
"pippo"     crypt("ppass","tuapassword")   crypt("pippo@disney.com","tuapassword")

pippo torna al tuo sito e vuole loggarsi...scrive ppass
tu vai a cercare nel db l'utente di nome pippo e verifichi se

[password criptata nel db]==crypt(password_inserita, "tuapassword")

Criptare le password è forse meno importante perchè il metodo md5() funziona ma essendo irreversibile non permette di risalire ai dati originali ma solo se i due dati, quello appena inserito e quello memorizzato, sono uguali!
Nel caso di email la codifica reversibile potrebbe essere più interessante!
Criptare gli indirizzi potrebbe anche essere una buona difesa contro lo spamming.
Anche interessante il fatto di risalire alla password utente se questo se la fosse dimenticata.

Per il resto, come dicevo, il limite è dato dal fatto che è un metodo a chiave privata...quindi...okkio a non perdere la chiave o a darla a qualcuno!

[andr3a]

[supersaibal]Originariamente inviato da andr3a
mi dai il permesso di farci una classe basata su questi 2 metodi ?
ovviamente con i riferimenti al tuo operato [/supersaibal]

si: la pubblico su devpro
no: tanto l' ho gia' fatta ( in php5 e php4 ma quella per php4 va stestata che io ho solo php5 ), quindi la uso senza pubblicarla

[JHammer]

[supersaibal]Originariamente inviato da andr3a
mi dai il permesso di farci una classe basata su questi 2 metodi ?
ovviamente con i riferimenti al tuo operato [/supersaibal]

Vai tranquillo...comunque è davvero semplice.

Sembra complicato perchè ho dovuto imparare le varie funzioni di conversione del php (in c sembra meno oscuro)

In pratica esegue una roba simile

dato  xor    key          out

d     ^      p      
a     ^      a
t     ^      s
o     ^      s
      ^      p     {quello che viene!}
d     ^      a
a     ^      s
      ^      s
c     ^      p
r     ^      a  
...  ...   ...
Poi sfrutto la proprietà che

se      out  = data ^ key
allora  data = out  ^ key

Infine per rendere 'stringabile' l'output converto il
risultato [0,255] nella sua notazione esadecimale.

[Gianni_T]

[supersaibal]Originariamente inviato da JHammer
L'operazione xor ha i vantaggi

1) genera un dato di uscita simile a un rumore binario (altissima scorrelazione intersimbolica)
2) è semplice ed efficiente
3) soprattutto reversibile

e queste cose dove le hai lette? Sul manuale delle giovani marmotte?

1) ciò che produce lo XOR è fortemente correlato. Effettuandone l'autocorrelazione (spero che tu sappia di cosa si tratta altrimenti non avresti dovuto scrivere quelle cose) si trovano dei picchi distanti un numero di cifre (+ o -) pari alla lunghezza della chiave. Questo è il modo per risalire alla lunghezza della chiave.
Simile a rumore bianco??? Lo spettro di un segnale correlato come questo è (+ o -) a righe. Appena uno vuole capire come è stato criptato un dato fa il modulo quadro della trasformata e si trova con delle simpatiche righe e subito capisce che è stato utilizzato lo XOR

2) Si, è semplice, ma cosa indendi per efficiente? Che in 10 secondi viene crackata?

3) se vuoi qualcosa di reversibile usa il blowfish, phpMyAdmin docet!

Bye.

[andr3a]

ma e' un metodo affidabile e sicuro oppure e' un metodo ce con un po' di matematica sulle spalle si scavalca in un attimo ?

tipo che se facessi un controllo sulle ripetizioni di 32 in 32 per togliere la pass ( tanto saranno tutte da 32 perche' uno che se ne inventa una piu' grande ... ne dubito ) potrei scavalcarla ? :master:

[JHammer]

[supersaibal]Originariamente inviato da andr3a
ma e' un metodo affidabile e sicuro oppure e' un metodo ce con un po' di matematica sulle spalle si scavalca in un attimo ?

tipo che se facessi un controllo sulle ripetizioni di 32 in 32 per togliere la pass ( tanto saranno tutte da 32 perche' uno che se ne inventa una piu' grande ... ne dubito ) potrei scavalcarla ? :master: [/supersaibal]

Diciamo che i metodi a chiave privata sono i più BLINDATI di tutti.
Perchè vengono usati raramente? Ovvio: perchè occorre maneggiare una chiave che può essere carpita nella transazione.

Discorso importante merita la chiave: occorre che questa sia sufficientemente 'lunga e varia'.
Per questo motivo uso la md5 della chiave se questa fosse (come è in pratica) troppo corta.
La funzione di hash md5 ha la propietà da un lato banale di allungare la chiave (128 bit) e dall'altra di renderla 'pseudocasuale' (immagino che serva a 'distanziare parole simili per minimizzare le collisioni nello spazio delle parole')( VVoVe: )

Se banalmente usassi una chiave di un solo carattere riproponi in uscita la stessa varianza di ingresso!
Una chiave lunga produce invece valori pseudocasuali che sono per definizione scorrelati quindi inattaccabili.
Volendo fare una cosa 'estrema' si potrebbe usare la chiave come seme per una sequenza di byte pseudocasuali con cui mascherare (via xor) i caratteri del dato.
Questo darebbe alla sequenza in uscita un aspetto ancora più 'amorfo' (ma reputo i 128 bit della md5 più che sufficienti)

[andr3a]

x php5: http://www.devpro.it/php5_id_75.html


se poteste testarmi anche quella pr PHP4 uppo pure questa e vi ringrazio

<?php // 4
/**
 * This class encrypts or decrypts a string with a key
 * Thanks to JHammer from HTML.IT comunity for
 * simples but really efficients crypt <=> decrypt methods
 * .
 * EXAMPLE:
 *			$data = &file_get_contents( "myfile.txt" ); // or string
 *			$key  = "myPassword";
 *                      
 *                      // ENCRYPTED DATA
 *			$cdata = &KeyCrypt::encrypt($data, $key );
 *                      // DECRYPTED
 *			$ddata = &KeyCrypt::decrypt($cdata, $key );
 *
 *                      // DO YOU WANT A TEST ?
 *                      if( $data === $ddata ) {
 *				echo 'really cool !';
 *                      }
 * @Compatibility	>= PHP 5.0
 * @Author		Andrea Giammarchi
 * @Site		http://www.devpro.it/
 * @Mail		andrea [ at ] 3site [ dot ] it
 * @Date		09/02/2005
 * @LastModified	09/02/2005 14:00
 * @Version		1.0
 */
class KeyCrypt {
	
	/**
	 * public method
         * encrypts a string with a key
         *	KeyCrypt::encrypt( &$data:String, $key:String, $compression:Boolean( true ) ):String
         * @param	String		string to encrypt
         * @param	String		key for this encryption
         * @param	Boolean		use gzcompression* [ DEFAULT: true ]
         * 				*you need ZLIB enabled
         * @return	String		encrypted string
         */
	function encrypt( &$data, $key, $compression = true ) {
		list( $lk, $key ) = KeyCrypt::__getKey( $key );
		for( $a=0, $ld = &strlen( $data ), $crdata = ''; $a < $ld; $a++ ){
			$crdata .= sprintf("%02X",(ord($data[$a]))^(ord($key[$a%$lk])));
		}
		return $compression === true ? gzcompress( $crdata, 9 ) : $crdata;
	}
        
        /**
	 * public method
         * decrypts an encrypted string with a key
         *	KeyCrypt::decrypt( &$data:String, $key:String, $compression:Boolean( true ) ):String
         * @param	String		string to decrypt
         * @param	String		key for this decryption
         * @param	Boolean		use gzcompression* [ DEFAULT: true ]
         * 				*you need ZLIB enabled and an encrypted data string
         * @return	String		decrypted string
         */
	function decrypt( &$cdata, $key, $compression = true ) {
		if( $compression === true ) {
			$cdata = &gzuncompress( $cdata );
		}
		list( $lk, $key ) = KeyCrypt::__getKey( $key );
		for( $a=0, $ld = &strlen( $cdata ), $data = ''; $a < $ld; $a += 2 ){
			$data .= chr((hexdec(substr($cdata, $a, 2)))^(ord($key[($a>>1)%$lk])));
		}
		return $data;
	}
        
        /**
	 * private method
         * checks if key length is more than 32 and if not converts key to its md5 hash
         *	KeyCrypt::__getKey( &$key:String ):Array
         * @param	String		key used for encryption or decryption
         * @return	Array		key length, new key ( if hashed, old key if not hashed )
         */
	function __getKey( &$key ) {
		if( ( $lk = &strlen( $key ) ) < 32 ) {
			$key = &md5( $key );
			$lk = 32;
		}
		return Array( $lk, $key );
	}
}
?>

[ editato ]
a grandi linee fa la stesa cosa solo che di default comprime i dati con gzcompress, su un file non molto grande ( 8860 caratteri ) restituisce una stringa di lunghezza 6180 , contro i 16600 e passa della funzione senza copressione