FAQ Qt FAQ Qt Creator FAQ PyQt & PySide

FAQ QtConsultez toutes les FAQ

Nombre d'auteurs : 25, nombre de questions : 299, dernière mise à jour : 15 octobre 2016 

 
OuvrirSommaireBibliothèques complémentairesQCA

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. Les dernières versions sont compatibles avec Qt3 et Qt4.

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

Cette bibliothèque est orientée vers la sécurité : outre les hash (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 de plug-ins : lui-même ne fournit strictement rien, tout est implémenté dans les plug-ins. Ces plug-ins se servent d'autres bibliothèques renommées et optimisées : OpenSSL, Cyrus SASL, GNU PG...

Créé le 30 octobre 2009  par Thibaut Cuvelier

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 un invite de commandes, entrez les commandes suivantes si vous travaillez sous Windows avec Visual Studio :

 
Sélectionnez
configure
nmake
installwin

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

 
Sélectionnez
configure
make
installwin

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

 
Sélectionnez
./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).

 
Sélectionnez
qmake
nmake

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

 
Sélectionnez
qmake
make
Mis à jour le 7 mai 2012  par Thibaut Cuvelier

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 :

 
Sélectionnez
CONFIG *= crypto

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

 
Sélectionnez
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.

Mis à jour le 7 mai 2012  par Thibaut Cuvelier

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.

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).

 
Sélectionnez
// 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);
Créé le 30 octobre 2009  par Thibaut Cuvelier

Lien : Pourquoi parler de nombres pseudo-aléatoires ?

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 nombre 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.

Mis à jour le 7 mai 2012  par Thibaut Cuvelier

Lien : Comment générer un nombre pseudo-aléatoire ?

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 équivalent: hash), est une empreinte qui permet d'identifier, avec un certain degré d'erreur, des données. Plusieurs données peuvent avoir le même hash : cela s'appelle une collision. Ce sont ces collisions qui mettent à mal certains anciens algorithmes (MD4, MD5, SHA-0, bientôt 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 de hachage.

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

Pour pouvoir hacher des 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, vous utilisez la fonction update() pour y insérer des données. final() permet de récupérer le hash résultant.

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

Voici un exemple d'utilisation, avec stockage du hash en mémoire sécurisée.

 
CacherSélectionnez
Mis à jour le 7 mai 2012  par Thibaut Cuvelier

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 facilement.

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.

 
CacherSélectionnez
Créé le 30 octobre 2009  par Thibaut Cuvelier

Lien : Comment générer un hash cryptographique de données ?

  

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2006 - 2016 Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.