Chiffrement des données avec CNG
L’utilisation principale de n’importe quelle API de chiffrement consiste à chiffrer et déchiffrer des données. CNG vous permet de chiffrer des données à l’aide d’un nombre minimal d’appels de fonction et vous permet d’effectuer toute la gestion de la mémoire. Bien que de nombreux détails de l’implémentation du protocole soient laissés à l’utilisateur, CNG fournit les primitives qui effectuent le chiffrement et le déchiffrement des données réelles.
Chiffrement de données
Pour chiffrer les données, procédez comme suit :
Ouvrez un fournisseur d’algorithmes qui prend en charge le chiffrement, par exemple BCRYPT_DES_ALGORITHM.
Créez une clé pour chiffrer les données avec. Une clé peut être créée à l’aide de l’une des fonctions suivantes :
- BCryptGenerateKeyPair ou BCryptImportKeyPair pour les fournisseurs asymétriques.
- BCryptGenerateSymmetricKey ou BCryptImportKey pour les fournisseurs symétriques.
Notes
Le chiffrement et le déchiffrement des données avec une clé asymétrique sont gourmands en calcul par rapport au chiffrement de clé symétrique. Si vous devez chiffrer des données avec une clé asymétrique, vous devez chiffrer les données avec une clé symétrique, chiffrer la clé symétrique avec une clé asymétrique et inclure la clé symétrique chiffrée avec le message. Le destinataire peut ensuite déchiffrer la clé symétrique et utiliser la clé symétrique pour déchiffrer les données.
Obtenez la taille des données chiffrées. Cela est basé sur l’algorithme de chiffrement, le schéma de remplissage (le cas échéant) et la taille des données à chiffrer. Vous pouvez obtenir la taille des données chiffrées à l’aide de la fonction BCryptEncrypt , en passant NULL pour le paramètre pbOutput . Tous les autres paramètres doivent être identiques au moment où les données sont réellement chiffrées, à l’exception du paramètre pbInput , qui n’est pas utilisé dans ce cas.
Vous pouvez chiffrer les données en place avec la même mémoire tampon ou chiffrer les données dans une mémoire tampon distincte.
Si vous souhaitez chiffrer les données en place, passez le pointeur de mémoire tampon en texte clair pour les paramètres pbInput et pbOutput dans la fonction BCryptEncrypt . Il est possible que la taille des données chiffrées soit supérieure à la taille des données non chiffrées, de sorte que la mémoire tampon en texte brut doit être suffisamment grande pour contenir les données chiffrées, pas seulement le texte brut. Vous pouvez utiliser la taille obtenue à l’étape 3 pour allouer la mémoire tampon en texte brut.
Si vous souhaitez chiffrer les données dans une mémoire tampon distincte, allouez une mémoire tampon pour les données chiffrées à l’aide de la taille obtenue à l’étape 3.
Appelez la fonction BCryptEncrypt pour chiffrer les données. Cette fonction écrit les données chiffrées à l’emplacement fourni dans le paramètre pbOutput .
Conservez les données chiffrées selon les besoins.
Répétez les étapes 5 et 6 jusqu’à ce que toutes les données soient chiffrées.
Exemple de chiffrement des données
L’exemple suivant montre comment chiffrer des données avec CNG à l’aide de l’algorithme de chiffrement symétrique standard de chiffrement standard.
// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
// PARTICULAR PURPOSE.
//
// Copyright (C) Microsoft. All rights reserved.
/*++
Abstract:
Sample program for AES-CBC encryption using CNG
--*/
#include <windows.h>
#include <stdio.h>
#include <bcrypt.h>
#define NT_SUCCESS(Status) (((NTSTATUS)(Status)) >= 0)
#define STATUS_UNSUCCESSFUL ((NTSTATUS)0xC0000001L)
#define DATA_TO_ENCRYPT "Test Data"
const BYTE rgbPlaintext[] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
};
static const BYTE rgbIV[] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
};
static const BYTE rgbAES128Key[] =
{
0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07,
0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F
};
void PrintBytes(
IN BYTE *pbPrintData,
IN DWORD cbDataLen)
{
DWORD dwCount = 0;
for(dwCount=0; dwCount < cbDataLen;dwCount++)
{
printf("0x%02x, ",pbPrintData[dwCount]);
if(0 == (dwCount + 1 )%10) putchar('\n');
}
}
void __cdecl wmain(
int argc,
__in_ecount(argc) LPWSTR *wargv)
{
BCRYPT_ALG_HANDLE hAesAlg = NULL;
BCRYPT_KEY_HANDLE hKey = NULL;
NTSTATUS status = STATUS_UNSUCCESSFUL;
DWORD cbCipherText = 0,
cbPlainText = 0,
cbData = 0,
cbKeyObject = 0,
cbBlockLen = 0,
cbBlob = 0;
PBYTE pbCipherText = NULL,
pbPlainText = NULL,
pbKeyObject = NULL,
pbIV = NULL,
pbBlob = NULL;
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(wargv);
// Open an algorithm handle.
if(!NT_SUCCESS(status = BCryptOpenAlgorithmProvider(
&hAesAlg,
BCRYPT_AES_ALGORITHM,
NULL,
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptOpenAlgorithmProvider\n", status);
goto Cleanup;
}
// Calculate the size of the buffer to hold the KeyObject.
if(!NT_SUCCESS(status = BCryptGetProperty(
hAesAlg,
BCRYPT_OBJECT_LENGTH,
(PBYTE)&cbKeyObject,
sizeof(DWORD),
&cbData,
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptGetProperty\n", status);
goto Cleanup;
}
// Allocate the key object on the heap.
pbKeyObject = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbKeyObject);
if(NULL == pbKeyObject)
{
wprintf(L"**** memory allocation failed\n");
goto Cleanup;
}
// Calculate the block length for the IV.
if(!NT_SUCCESS(status = BCryptGetProperty(
hAesAlg,
BCRYPT_BLOCK_LENGTH,
(PBYTE)&cbBlockLen,
sizeof(DWORD),
&cbData,
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptGetProperty\n", status);
goto Cleanup;
}
// Determine whether the cbBlockLen is not longer than the IV length.
if (cbBlockLen > sizeof (rgbIV))
{
wprintf (L"**** block length is longer than the provided IV length\n");
goto Cleanup;
}
// Allocate a buffer for the IV. The buffer is consumed during the
// encrypt/decrypt process.
pbIV= (PBYTE) HeapAlloc (GetProcessHeap (), 0, cbBlockLen);
if(NULL == pbIV)
{
wprintf(L"**** memory allocation failed\n");
goto Cleanup;
}
memcpy(pbIV, rgbIV, cbBlockLen);
if(!NT_SUCCESS(status = BCryptSetProperty(
hAesAlg,
BCRYPT_CHAINING_MODE,
(PBYTE)BCRYPT_CHAIN_MODE_CBC,
sizeof(BCRYPT_CHAIN_MODE_CBC),
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptSetProperty\n", status);
goto Cleanup;
}
// Generate the key from supplied input key bytes.
if(!NT_SUCCESS(status = BCryptGenerateSymmetricKey(
hAesAlg,
&hKey,
pbKeyObject,
cbKeyObject,
(PBYTE)rgbAES128Key,
sizeof(rgbAES128Key),
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptGenerateSymmetricKey\n", status);
goto Cleanup;
}
// Save another copy of the key for later.
if(!NT_SUCCESS(status = BCryptExportKey(
hKey,
NULL,
BCRYPT_OPAQUE_KEY_BLOB,
NULL,
0,
&cbBlob,
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptExportKey\n", status);
goto Cleanup;
}
// Allocate the buffer to hold the BLOB.
pbBlob = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbBlob);
if(NULL == pbBlob)
{
wprintf(L"**** memory allocation failed\n");
goto Cleanup;
}
if(!NT_SUCCESS(status = BCryptExportKey(
hKey,
NULL,
BCRYPT_OPAQUE_KEY_BLOB,
pbBlob,
cbBlob,
&cbBlob,
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptExportKey\n", status);
goto Cleanup;
}
cbPlainText = sizeof(rgbPlaintext);
pbPlainText = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbPlainText);
if(NULL == pbPlainText)
{
wprintf(L"**** memory allocation failed\n");
goto Cleanup;
}
memcpy(pbPlainText, rgbPlaintext, sizeof(rgbPlaintext));
//
// Get the output buffer size.
//
if(!NT_SUCCESS(status = BCryptEncrypt(
hKey,
pbPlainText,
cbPlainText,
NULL,
pbIV,
cbBlockLen,
NULL,
0,
&cbCipherText,
BCRYPT_BLOCK_PADDING)))
{
wprintf(L"**** Error 0x%x returned by BCryptEncrypt\n", status);
goto Cleanup;
}
pbCipherText = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbCipherText);
if(NULL == pbCipherText)
{
wprintf(L"**** memory allocation failed\n");
goto Cleanup;
}
// Use the key to encrypt the plaintext buffer.
// For block sized messages, block padding will add an extra block.
if(!NT_SUCCESS(status = BCryptEncrypt(
hKey,
pbPlainText,
cbPlainText,
NULL,
pbIV,
cbBlockLen,
pbCipherText,
cbCipherText,
&cbData,
BCRYPT_BLOCK_PADDING)))
{
wprintf(L"**** Error 0x%x returned by BCryptEncrypt\n", status);
goto Cleanup;
}
// Destroy the key and reimport from saved BLOB.
if(!NT_SUCCESS(status = BCryptDestroyKey(hKey)))
{
wprintf(L"**** Error 0x%x returned by BCryptDestroyKey\n", status);
goto Cleanup;
}
hKey = 0;
if(pbPlainText)
{
HeapFree(GetProcessHeap(), 0, pbPlainText);
}
pbPlainText = NULL;
// We can reuse the key object.
memset(pbKeyObject, 0 , cbKeyObject);
// Reinitialize the IV because encryption would have modified it.
memcpy(pbIV, rgbIV, cbBlockLen);
if(!NT_SUCCESS(status = BCryptImportKey(
hAesAlg,
NULL,
BCRYPT_OPAQUE_KEY_BLOB,
&hKey,
pbKeyObject,
cbKeyObject,
pbBlob,
cbBlob,
0)))
{
wprintf(L"**** Error 0x%x returned by BCryptGenerateSymmetricKey\n", status);
goto Cleanup;
}
//
// Get the output buffer size.
//
if(!NT_SUCCESS(status = BCryptDecrypt(
hKey,
pbCipherText,
cbCipherText,
NULL,
pbIV,
cbBlockLen,
NULL,
0,
&cbPlainText,
BCRYPT_BLOCK_PADDING)))
{
wprintf(L"**** Error 0x%x returned by BCryptDecrypt\n", status);
goto Cleanup;
}
pbPlainText = (PBYTE)HeapAlloc (GetProcessHeap (), 0, cbPlainText);
if(NULL == pbPlainText)
{
wprintf(L"**** memory allocation failed\n");
goto Cleanup;
}
if(!NT_SUCCESS(status = BCryptDecrypt(
hKey,
pbCipherText,
cbCipherText,
NULL,
pbIV,
cbBlockLen,
pbPlainText,
cbPlainText,
&cbPlainText,
BCRYPT_BLOCK_PADDING)))
{
wprintf(L"**** Error 0x%x returned by BCryptDecrypt\n", status);
goto Cleanup;
}
if (0 != memcmp(pbPlainText, (PBYTE)rgbPlaintext, sizeof(rgbPlaintext)))
{
wprintf(L"Expected decrypted text comparison failed.\n");
goto Cleanup;
}
wprintf(L"Success!\n");
Cleanup:
if(hAesAlg)
{
BCryptCloseAlgorithmProvider(hAesAlg,0);
}
if (hKey)
{
BCryptDestroyKey(hKey);
}
if(pbCipherText)
{
HeapFree(GetProcessHeap(), 0, pbCipherText);
}
if(pbPlainText)
{
HeapFree(GetProcessHeap(), 0, pbPlainText);
}
if(pbKeyObject)
{
HeapFree(GetProcessHeap(), 0, pbKeyObject);
}
if(pbIV)
{
HeapFree(GetProcessHeap(), 0, pbIV);
}
}
Déchiffrement de données
Pour déchiffrer les données, procédez comme suit :
Ouvrez un fournisseur d’algorithmes qui prend en charge le chiffrement, par exemple BCRYPT_DES_ALGORITHM.
Obtenez la clé avec laquelle les données ont été chiffrées et utilisez cette clé pour obtenir un handle pour la clé.
Obtenez la taille des données déchiffrées. Cela est basé sur l’algorithme de chiffrement, le schéma de remplissage (le cas échéant) et la taille des données à déchiffrer. Vous pouvez obtenir la taille des données chiffrées à l’aide de la fonction BCryptDecrypt , en passant NULL pour le paramètre pbOutput . Les paramètres qui spécifient le schéma de remplissage et le vecteur d’initialisation (IV) doivent être identiques au moment où les données ont été chiffrées à l’exception du paramètre pbInput , qui n’est pas utilisé dans ce cas.
Allouez une mémoire tampon pour les données déchiffrées.
Vous pouvez déchiffrer les données en place à l’aide de la même mémoire tampon ou déchiffrer les données dans une mémoire tampon distincte.
Si vous souhaitez déchiffrer les données en place, passez le pointeur de mémoire tampon de chiffrement pour les paramètres pbInput et pbOutput dans la fonction BCryptDecrypt .
Si vous souhaitez déchiffrer les données dans une mémoire tampon distincte, allouez une mémoire tampon pour les données déchiffrées à l’aide de la taille obtenue à l’étape 3.
Appelez la fonction BCryptDecrypt pour déchiffrer les données. Les paramètres qui spécifient le schéma de remplissage et IV doivent être identiques au moment où les données ont été chiffrées. Cette fonction écrit les données déchiffrées à l’emplacement fourni dans le paramètre pbOutput .
Conservez les données déchiffrées selon les besoins.
Répétez les étapes 5 et 6 jusqu’à ce que toutes les données ont été déchiffrées.