Capitolo 14. Mcrypt

La libreria Mcrypt fornisce un'interfaccia comune per più algoritmi e metodi di cifratura. La programmazione è di tipo thread safe, ciò la rende adatta ad accessi simultanei di più processi (vedi appendice A).

14.1 Gli algoritmi

Gli algoritmi di cifratura realizzati in Mcrypt possono funzionare con i metodi ECB, CBC, nCFB e nOCB; sia gli algoritmi che i metodi sono caricati a runtime.

Tabella 14.1. Lista degli algoritmi simmetrici di Mcrypt.

Algoritmo	Lunghezza blocco (bit)	Lunghezza chiave (bit)
DES	64	56
Triple DES	64	56
CAST-128	64	128
CAST-256	128	256
xTEA	64	128
3-WAY	96	96
SKIPJACK	64	80
BLOWFISH	64	448
TWOFISH	128	128, 192, 256
LOKI97	128	128, 192, 256
RC2	64	8 ... 1 024
ARCFOUR	stream	1 ... 2 048
RC6	128	128, 192, 256
RIJNDAEL	128, 192, 256	128, 192, 256
MARS	128	128
PANAMA	stream	256
WAKE	stream	256
SERPENT	128	128
IDEA	64	128
GOST	64	256
SAFER SK	64, 128	64, 128
SAFER+	128	128, 192, 256

14.2 Struttura dei dati

Per sviluppare applicazioni con Mcrypt è necessario richiamare il file mcrypt.h. L'unico tipo utilizzato è MCRYPT che è un puntatore alla struttura CRYPT_STREAM e sever per inizializzare l'algoritmo di cifratura.

14.3 <mcrypt.h>

Il file definisce i tipi e i prototipi delle funzioni utilizzate dalla libreria.

Tipi definiti

#define MCRYPT_FAILED 0x0

struct CRYPT_STREAM;
typedef struct CRYPT_STREAM *MCRYPT;

Alcune funzioni

Prototipo	Descrizione
`MCRYPT mcrypt_module_open (char, char, char, char);`	La funziona associa all'algoritmo passato come primo parametro formale il metodo passato come terzo parametro formale. Il secondo e il quarto parametro formale sono le directory dove sono memorizzate le librerie relative all'algoritmo e ai metodi; generalmente indicare il puntatore NULLO. Restituisce un descrittore o `MCRYPT_FAILED` in caso di errore.
`int mcrypt_module_close (MCRYPT);`	Chiude il descrittore restituito da `mcrypt_module_open`.
`int mcrypt_generic_init (const MCRYPT, void, int, void);`	Inizializza tutti i buffer di memoria per i processi specificati. Il primo parametro formale rappressenta il descrittore restituito da `mcrypt_module_open`, il secondo parametro formale il puntatore alla chiave ed il terzo la lunghezza della stessa in byte. La lunghezza viene ottenuta con `mcrypt_get_key_size`. L'ultimo parametro formale è il puntatore al vettore di inizializzazione; la lunghezza di quest'ultimo può essere ottenuta con `mcrypt_get_iv_size`. Non tutti i metodi, in particolare lo ECB, hanno bisogno del vettore.
`int mcrypt_generic_deinit (const MCRYPT);`	Libera le risorse occupate dal descrittore al primo parametro formale.
`int mcrypt_generic_end (const MCRYPT);`	Libera le risorse occupate dal descrittore al primo parametro formale e chiude il modulo.
`int mcrypt_generic (MCRYPT, void*, int);`	Cifra il testo in chiaro passato nel secondo parametro formale. La lunghezza, in bytes, viene passata con il terzo parametro formale e deve essere `k` volte la lunghezza del blocco se si cifra con un metodo a blocchi. La lunghezza del blocco viene ottenuta con `mcrypt_get_block_size`. Ritorna zero se l'operazione avviene con successo e restituisce il testo cifrato al posto di quello in chiaro.
`int mdecrypt_generic (MCRYPT, void*, int);`	Come il precedente, tuttavia decifra il testo.
`int mcrypt_enc_set_state (MCRYPT, void*, int);`	Imposta lo stato dell'algoritmo. Il primo parametro formale è il descrittore
`int mcrypt_enc_get_state (MCRYPT, void, int);`
`int mcrypt_enc_mode_has_iv (MCRYPT);`
`int* mcrypt_enc_get_supported_key_sizes (MCRYPT, int*);`
`char** mcrypt_list_algorithms (char, int);`
`char** mcrypt_list_modes (char, int);`
`void mcrypt_free_p (char**, int);`
`void mcrypt_perror (int);`
`const char* mcrypt_strerror (int);`
`int mcrypt_module_self_test (char, char);`
`int mcrypt_module_is_block_algorithm (char, char);`
`int mcrypt_module_is_block_mode (char, char);`
`int mcrypt_module_get_algo_key_size (char, char);`
`int mcrypt_module_get_algo_block_size (char, char);`
`int* mcrypt_module_get_algo_supported_key_sizes (char, char, int*);`
`int mcrypt_module_algorithm_version (char, char);`
`int mcrypt_module_mode_version (char, char);`
`const char* mcrypt_check_version (const char*);`

14.4 Compilare il codice sorgente

Ogni progetto dovrà necessariamente caricare il file mcrypt.h mentre il linker dovrà richiamare la libreria libmcrypt.so.

Gli esempi della dispensa possono essere tutti compilati con il comando seguente:

$ gcc -o esempio esempio.c -lmcrypt [Invio]

14.5 La programmazione con Mcrypt

Nell'esempio in listato 14.2 viene aperto un algoritmo di cifratura e vengono visualizzate le informazioni sostanziali per una corretta inizializzazione.

Listato 14.2. Apertura di un algoritmo di cifratura.

#define ALG "arcfour"
#define MODE "stream"

#include <stdio.h>
#include <stdlib.h>
#include <mcrypt.h>

int main ()
{
        MCRYPT td;
        int block;
        int block_size;
        int key_size;
        int iv;

        // apre un algoritmo
        if (!(td = mcrypt_module_open (ALG, NULL, MODE, NULL)))
                exit (EXIT_FAILURE);

        if ((block = mcrypt_enc_is_block_algorithm (td)))
                printf ("Algoritmo a blocchi.\n");
        else
                printf ("Algoritmo a stream.\n");

        if ((iv = mcrypt_enc_mode_has_iv (td)))
                printf ("Utilizza un IV.\n");
        else
                printf ("Non utilizza un IV.\n");

        // calcola i bit del blocco e della chiave
        block_size = mcrypt_enc_get_block_size (td) * 8;
        key_size = mcrypt_enc_get_key_size (td) * 8;

        printf ("Lunghezza del blocco (bit): %d\n", block_size);
        printf ("Lunghezza della chiave (bit): %d\n", key_size);

        // rilascia le risorse occupate
        mcrypt_module_close (td);
}

Dovrebbe essere possibile fare riferimento a questa pagina anche con il nome mcrypt.html