QCA (Qt Cryptographic Architecture) est une bibliothèque annexe à Qt. Elle fournit des services cryptographiques pour Qt, qui ne gère nativement que les hash MD4, MD5 et SHA1.

Toutes les fonctionnalités cryptographiques sont fournies par des extensions (dans le dossier plugins/crypto), chargées dynamiquement, à l'exécution, en fonction des besoins.

Cette bibliothèque est orientée vers la sécurité : outre les fonctions de hachage cryptographique (MD4, MD5, SHA-1, SHA-512, Blowfish…), elle propose une implémentation des algorithmes les plus répandus et éprouvés (TLS, OpenGPG, RSA…), des emplacements mémoires sécurisés (qui ne seront jamais écrits sur le disque dur), des nombres pseudo-aléatoires…

QCA se base sur un système d'extensions : lui-même ne fournit strictement rien, tout est implémenté dans les extensions. Ces extensions se servent d'autres bibliothèques renommées et optimisées : OpenSSL, Cyrus SASL, GNU PG…

Il y a deux possibilités : soit les binaires pour votre compilateur sont déjà disponibles, soit ils ne le sont pas. S'ils le sont, téléchargez cette archive et installez-la. Sous Windows, n'oubliez pas d'exécuter le script installwin.bat : il installera les fichiers nécessaires dans votre installation de Qt. S'ils ne le sont pas, suivez les instructions ci-dessous après avoir téléchargé les plug-ins.

Vous devez commencer par récupérer les sources sur le site officiel. Elles sont compressées avec BZip2 et rassemblées avec TAR : vous pouvez utiliser ces binaires en ligne de commande, ou utiliser un outil d'archivage comme 7Zip ou WinRar.

Dans une invite de commande, entrez les commandes suivantes si vous travaillez sous Windows avec Visual Studio :

configure
nmake
installwin

Sous Windows avec MinGW/GCC, les commandes sont les suivantes :

configure
make
installwin

Pour tous les autres systèmes d'exploitation, les commandes à exécuter sont les suivantes :

./configure
make
make install
/sbin/ldconfig

Ensuite, configurez votre IDE avec les répertoires de QCA (répertoires include/, lib/ et bin/).

Ici, vous n'aurez que QCA, sans le moindre plug-in, ce qui se révèle insuffisant dans la pratique.

Vous devrez télécharger les sources de chaque plug-in ainsi que les dépendances. Les fichiers de projet sont livrés. Utilisez simplement ces commandes (pour Visual Studio).

qmake
nmake

Ou bien celles-ci (pour les autres compilateurs).

qmake
make

Il vous suffit de vous assurer que votre application liera bien avec libqca.

Vous devez toujours passer par qmake, comme d'habitude avec Qt. Cependant, vous devrez introduire la ligne suivante dans votre fichier de projet :

CONFIG *= crypto

Si vous voulez générer un nouveau projet qui inclut directement la bibliothèque QCA, vous pouvez aussi utiliser cette commande.

qmake -project "CONFIG *= crypto

Ici, l'opérande *= permet de n'inclure la bibliothèque que si elle ne l'est pas encore, contrairement à +=, qui ajoute inconditionnellement.

QCA fournit la classe QCA::Random pour la génération de nombres pseudo-aléatoires. Seules ses fonctions statiques sont prévues pour être utilisées. Les voici :

• randomChar() (renvoie un unsigned char) ;
• randomInt() (renvoie un int) ;
• randomArray() (renvoie un QCA::SecureArray).

Les nombres sont générés à partir d'un plug-in. Ceci signifie que le plug-in définit les bornes des nombres générés, vous ne pouvez pas le spécifier, contrairement à Boost.Random (dans Boost, vous choisissez la fonction ; dans QCA, un plug-in est choisi).

// On initialise QCA, ce qui permettra de nettoyer la mémoire
// en fin de programme
QCA::Initializer init;

// Un entier pseudo-aléatoire
int randInt = QCA::Random::randomInt();

// Un caractère (octet) pseudo-aléatoire
unsigned char randInt = QCA::Random::randomChar();

// 10 octets aléatoires
// Un octet est un nombre compris entre (2^0)-1 et (2^8)-1
// c'est-à-dire entre 0 et 255
QCA::SecureArray array = QCA::Random::randomArray(10);

Un ordinateur est incapable de générer arbitrairement un nombre, il doit se baser sur un élément, de préférence variable dans le temps. En général, il s'agit du timestamp. Les algorithmes de génération de nombres pseudo-aléatoires sont chaotiques, c'est-à-dire que, pour une très petite variation de l'entrée, le résultat est fort différent.

Par définition, et d'un point de vue statistique, les nombres aléatoires sont répartis uniformément entre les bornes autorisées. Aussi, si une grande quantité de nombres aléatoires est générée et que la plage des valeurs autorisées est divisée en domaines de tailles identiques, les nombres générés seront répartis plus ou moins équitablement entre les différents domaines.

QCA, en tant que bibliothèque de cryptographie, propose des primitives cryptographiques, comme des algorithmes de hachage.

Une somme de contrôle cryptographique (couramment désignée par le terme anglais hash) est une empreinte qui permet d'identifier, avec un certain degré d'erreur, des données. Plusieurs données peuvent avoir la même empreinte : cela s'appelle une collision. Ce sont ces collisions qui mettent à mal certains anciens algorithmes (MD4, MD5, SHA-0, SHA-1) : en effet, cela permet d'envoyer un fichier corrompu et vérolé sans que le destinataire ne puisse le remarquer.

QCA supporte un certain nombre d'algorithmes :

• SHA-0 ;
• SHA-1 ;
• MD2 ;
• MD4 ;
• MD5 ;
• RIPEMD160 ;
• SHA-224 ;
• SHA-256 ;
• SHA-384 ;
• SHA-512 ;
• Whirlpool.

Pour calculer une empreinte de données, il faut commencer par initialiser un QCA::Hash avec un des algorithmes ci-dessus (écrivez le nom de l'algorithme en minuscules, en gardant tiret et chiffres). Ensuite, utilisez la fonction update() pour y insérer des données. final() permet de récupérer le hash résultant.

Cependant, avant d'utiliser un tel algorithme, vous devez être sûr qu'il soit disponible. En effet, tous les algorithmes sont implémentés dans des extensions. Pour ce faire, utilisez la fonction QCA::isSupported().

Voici un exemple d'utilisation, avec stockage de l'empreinte en mémoire sécurisée.

#include <QtCrypto>
int main(){


// Création du tableau qui recevra le hash
QCA::SecureArray hash;
// Instanciation du hasher
QCA::Hash hasher ("sha1");

// Le plug-in de SHA-1 a-t-il été chargé ?
if( QCA::isSupported("sha1") )
{
  // On ajoute la chaîne "password" aux données à hacher
  hasher.update ( "password" );
  // On ajoute le QByteArray "salt" aux données à hacher
  hasher.update ( QByteArray ("salt") );
  // On ajoute le contenu du fichier "salts.sha1" aux données à hacher
  hasher.update ( QFile ("salts.sha1") );
  // On écrit dans le tableau le hash
  hash = hasher.final();
}

// Le plug-in de Whirlpool a-t-il été chargé ?
if( QCA::isSupported("whirlpool") )
{
  // On ajoute la chaîne "password" aux données à hacher
  hasher.update ( "password" );
  // On ajoute le QByteArray "salt" aux données à hacher
  hasher.update ( QByteArray ("salt") );
  // On ajoute le contenu du fichier "salts.whirl" aux données à hacher
  hasher.update ( QFile ("salts.whirl") );
  // On écrit l'empreinte dans le tableau 
  hash = hasher.final();
}


}

QCA fournit la classe SecureArray pour gérer la mémoire sécurisée. Elle se différencie de QString ou de QByteArray par le fait que l'on peut être sûr que les données seront écrites uniquement en mémoire vive, jamais sur le disque dur, où elles pourraient être récupérées plus facilement en cas d'attaque par un pirate.

Elle est semblable à QByteArray pour les fonctionnalités proposées : append(), at(), clear(), constData(), data(), resize() et size() sont autant de fonctions qui existent des deux côtés. Un SecureArray peut être facilement transformé en QByteArray grâce à la fonction toByteArray().

Cette classe est implicitement partagée (elle dérive de QSharedDataPointer).

Voici un exemple d'utilisation : un calcul de hash puis stockage en mémoire sécurisée.

#include <QtCrypto>

// Création du tableau qui recevra l'empreinte
QCA::SecureArray hash;

// L'extension SHA-1 a-t-il été chargée ?
if(QCA::isSupported("sha1"))
{
  // Instanciation du hasher
  QCA::Hash hasher ("sha1");
  // On ajoute la chaîne "password" aux données à traiter
  hasher.update ( "password" );
  // On écrit dans le tableau l'empreinte
  hash = hasher.final();
}