Cryptographie : Signer des données avec l'API Windows

18/11/2002

Par LFE (autres articles)
 

Ce document a pour but de présenter la signature de données et le contrôle de cette signature à l'aide d'une paire de clés asymétiques en utilisant l'API Windows

• La clé privée est celle que vous gardez précieusement.
• La clé publique est celle que vous pouvez distribuer.
• L'Autorité de Certification est un organisme, une société, une personne, etc ... à qui l'on accorde sa confiance pour certifier que la personne, la société est bien qui elle prétend être.
• un Certificat est une clé publique, certifiée par une Autorité de Certification.

#define CRYPT_SIGN_MESSAGE_PARA_HAS_CMS_FIELDS

#define CRYPT_TYPE (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)
#define CERT_STORE_NAME L"MY"

HCERTSTORE hCertStore;
					
hCertStore = CertOpenStore(CERT_STORE_PROV_SYSTEM, 0, NULL, CERT_SYSTEM_STORE_CURRENT_USER, CERT_STORE_NAME);

• le type de magasin,
• le type d'encodage des certificats : 0 car inutilisé dans ce cas particulier
• un 'cryptography provider' : NULL demande d'en créer un par défaut, qui est l'option recommandée
• des flags de configuration : nous précisons ici que nous allons travailler dans le magasin de l' utilisateur courant
• le dernier paramètre est le nom du magasin de certificats utilisé( MY ).

CertCloseStore(hCertStore, CERT_CLOSE_STORE_CHECK_FLAG);

PCCERT_CONTEXT CertSignerContext ;
AnsiString aKey;

aKey = "LFE@home.be";

CertSignerContext = CertFindCertificateInStore(hCertStore,
                                               CRYPT_TYPE,
                                               0,
                                               CERT_FIND_SUBJECT_STR,
                                               WideString(aKey.c_str()),
                                               NULL);

• le handle du magasin de certificats dans lequel la recherche va se faire
• le type d'encodage des certificats
• 0 dans la plupart des cas, ce paramètre permet de configurer des options en fonction du type de recherche
• le type de recherche que l'on va effectuer ( nous allons chercher le certificat sur la base du Nom repris dans le sujet du certificat
• le critère de recherche (ici, le nom repris dans le champ certificat)
• le dernier paramètre permet d'effectuer la recherche à partir d'un certificat donné.
  NULL indique que c'est le début de la recherche. Ce paramètre est utile quand on recherche un certificat sur base d'un critère qui n'est pas un identifiant unique.

CertFreeCertificateContext(CertSignerContext);

• initialiser une structure contenant les paramètres de la signature
• appeler une première fois la fonction de signature pour déterminer la longueur du buffer qui contiendra les données après signature
• Appeler une seconde fois la fonction de signature pour effectuer la signature proprement dite

CRYPT_SIGN_MESSAGE_PARA SignMsgParam;
BYTE* pbToBeSigned[1];
DWORD cbToBeSigned[1];
bool lOk;

memset(&SignMsgParam, 0x00, sizeof(CRYPT_SIGN_MESSAGE_PARA));
SignMsgParam.cbSize = sizeof(CRYPT_SIGN_MESSAGE_PARA);
SignMsgParam.dwMsgEncodingType = CRYPT_TYPE;
SignMsgParam.HashAlgorithm.pszObjId = szOID_RSA_SHA1RSA;
SignMsgParam.pSigningCert = CertSignerContext;
SignMsgParam.cMsgCert = 1;
SignMsgParam.rgpMsgCert = &CertSignerContext;
pbToBeSigned[0] = (char *) malloc(Edit1->Text.Length() + 1);
strcpy(pbToBeSigned[0], Edit1->Text.c_str());
cbToBeSigned[0] = Edit1->Text.Length();

// Get The output buffer size
lOk = CryptSignMessage(&SignMsgParam,
                       false,
                       1,
                       (const BYTE **)rgpbToBeSigned,
                       rgcbToBeSigned,
                       NULL,
                       &cbSignedMsgBlob);

cSignedMsg = (char*)malloc(cbSignedMsgBlob);
memset(cSignedMsg,0x00,cbSignedMsgBlob);

// Sign the Message
lOk = CryptSignMessage(&SignMsgParam,
                       false,
                       1,
                       (const BYTE **)rgpbToBeSigned,
                       rgcbToBeSigned,
                       cSignedMsg,
                       &cbSignedMsgBlob);

• cbSize est la taille de la structure.
• dwMsgEncondingType est le type d'encodage des certificats.
• HashAlgortihm est le type de hashage utilisé pour créer la signature.
• pSigningCert est le handle du certificat utilisé pour signer les données.
• cMsgCert est le nombre d'eléments repris dans le paramètre rgpMsgCert.
• rgpMsgCert est un tableau de pointeurs sur des structures de type PCCERT_CONTEXT. Il s'agit du (des) certificat(s) à joindre aux données.

• pbToBeSigned, contient les pointeurs sur les buffers de données à signer.
• cbToBeSigned, contient les longueurs de ces buffers.

• un pointeur sur la structure de type CRYPT_SIGN_MESSAGE.
• un booléen qui vaut true si la signature est détachée, false sinon.
• le nombre d'eléments des 2 tableaux contenant respectivement les pointeurs sur les buffers à signer, et les longueurs de ces buffers.
• le tableau pbToBeSigned
• le tableau cbToBeSigned
• le pointeur sur le buffer recevant la signature
• la longueur des données signées.

• le premier appel de la fonction avec NULL comme pointeur de retour fait effectuer le calcul de la longueur.
• le second appel, avec un pointeur non NULL, signe les données.

SignMsgParam.cMsgCert = 0;
SignMsgParam.rgpMsgCert = NULL;

lOk = CryptSignMessage(&SignMsgParam,
                       true,
                       1,
                       (const  BYTE **)rgpbToBeSigned,
                       rgcbToBeSigned,
                       NULL,
                       &cbSignedMsgBlob);

lOk = CryptSignMessage(&SignMsgParam,
                       true,
                       1,
                       (const  BYTE **)rgpbToBeSigned,
                       rgcbToBeSigned,
                       cSignedMsg,
                       &cbSignedMsgBlob);

• le certificat est joint à la signature, il suffit alors de contrôler que le message est bien conforme
• le certificat n'est pas joint. Dans ce cas, il faut spécifier la façon de le retrouver. Pour des raisons de simplicité, nous supposerons que le certificat est déjà dans le magasin de certificat de l'utilisateur.

CRYPT_VERIFY_MESSAGE_PARA VerifParams;
DWORD cbSignedData, cbData;
char *pbSignedData, *pbData;

// récupérer les données signées et la longueur de ces données 

memset(&VerifParams, 0x00, sizeof(CRYPT_VERIFY_MESSAGE_PARA));
VerifParams.cbSize = sizeof(CRYPT_VERIFY_MESSAGE_PARA);
VerifParams.dwMsgAndCertEncodingType = CRYPT_TYPE;

// Get The output buffer size
lOk = CryptVerifyMessageSignature(&VerifParams,
                                  0,
                                  pbSignedData,
                                  cbSignedData,
                                  NULL,
                                  &cbData,
                                  NULL);

pbData = (char*)malloc(cbData);
memset(pbData, 0x00, cbData);

// Verify the Message Signature
lOk = CryptVerifyMessageSignature(&VerifParams,
                                  0,
                                  pbSignedData,
                                  cbSgnedData,
                                  pbData,
                                  &cbData,
                                  NULL);

VerifParams.pfnGetSignerCertificate = CryptGetSignerCertificateCallback;
VerifParams.pvGetArg = hCertStore;

PCCERT_CONTEXT __stdcall CryptGetSignerCertificateCallback( 
               void* pvGetArg, 
               DWORD dwCertEncodingType,
               PCERT_INFO pSignerId, 
               HCERTSTORE hMsgCertStore);

PCCERT_CONTEXT __stdcall CryptGetSignerCertificateCallback( 
               void* pvGetArg,
               DWORD dwCertEncodingType,
               PCERT_INFO pSignerId, 
               HCERTSTORE hMsgCertStore)
{
PCCERT_CONTEXT CertSignerContext = NULL;

CertSignerContext = CertFindCertificateInStore(pvGetArg,
                                               CRYPT_TYPE,
                                               0,
                                               CERT_FIND_SUBJECT_CERT,
                                               pSignerId,
                                               NULL);
    return CertSignerContext;
}

CRYPT_VERIFY_MESSAGE_PARA VerifParams;
BYTE* pbToBeSigned[1];
DWORD cbToBeSigned[1];
bool lOk;

memset(&VerifParams, 0x00, sizeof(CRYPT_VERIFY_MESSAGE_PARA));
VerifParams.cbSize = sizeof(CRYPT_VERIFY_MESSAGE_PARA);
VerifParams.dwMsgAndCertEncodingType = CRYPT_TYPE;
lOk = CryptVerifyDetachedMessageSignature(&VerifParams,
                                          0,
                                          pbSignature,
                                          cbSignature,
                                          1,
                                          pbToBeSigned,
                                          cbToBeSigned,
                                          NULL);

• une structure de type CRYPT_VERIFY_MESSAGE_PARA.
• le n° d'ordre de la signature à vérifier.
• la signature
• la longueur de la signature
• le nombre d'éléments des 2 paramètres suivants
• un premier tableau pbToBeSigned contient les pointeurs sur les buffers de données à signer
• un second tableau cbToBeSigned contient les longueurs des buffers de données à signer
.
• un pointeur sur un pointeur de type PCCERT_CONTEXT, si l'on désire utiliser le certificat ayant servi à la signature pour d'autres opérations, NULL sinon.
  (Attention, dans ce cas, il ne faudra pas oublier de le libérer par un appel à CertFreeCertificatContext).

Voir également mes autres articles :

Piloter Word sous C++ Builder et Delphi

Piloter Excel sous C++ Builder et Delphi

Utiliser l'API mySQL sous C++ Builder et Delphi

Utiliser un WebService sous C++ Builder et Delphi

Utiliser FMOD sous C++ Builder

Créer et utiliser une DLL sous C++ Builder

Signer des données avec C++ Builder

Comment déployer une application SWT via WebStart

Créer et déployer un premier servlet avec TomCat

Sans oublier :

la FAQ C++ Builder par Geronimo

la FAQ C

la FAQ C++