Chaves de Diffie-Hellman
- Gerando chaves de Diffie-Hellman
- Trocando chaves de Diffie-Hellman
- Exportando uma chave privada Diffie-Hellman
- Código de exemplo
Gerando chaves de Diffie-Hellman
Para gerar uma chave Diffie-Hellman, execute as seguintes etapas:
Chame a função CryptAcquireContext para obter um identificador para o Provedor criptográfico do Microsoft Diffie-Hellman.
Gere a nova chave. Há duas maneiras de fazer isso: fazendo com que o CryptoAPI gere todos os novos valores para G, P e X ou usando valores existentes para G e P e gerando um novo valor para X.
Para gerar a chave gerando todos os novos valores
- Chame a função CryptGenKey, passando CALG_DH_SF (repositório e para frente) ou CALG_DH_EPHEM (efêmero) no parâmetro Argel. A chave será gerada usando valores novos e aleatórios para G e P, um valor recém-calculado para X e seu identificador será retornado no parâmetro phKey .
- A nova chave agora está pronta para uso. Os valores de G e P devem ser enviados ao destinatário junto com a chave (ou enviados por algum outro método) ao fazer uma troca de chaves.
Para gerar a chave usando valores predefinidos para G e P
- Chame CryptGenKey passando CALG_DH_SF (store e forward) ou CALG_DH_EPHEM (efêmero) no parâmetro Algid e CRYPT_PREGEN para o parâmetro dwFlags . Um identificador de chave será gerado e retornado no parâmetro phKey .
- Inicialize uma estrutura de CRYPT_DATA_BLOB com o membro pbData definido como o valor P. O BLOB não contém informações de cabeçalho e o membro pbData está no formato little-endian .
- O valor de P é definido chamando a função CryptSetKeyParam , passando o identificador de chave recuperado na etapa a no parâmetro hKey , o sinalizador KP_P no parâmetro dwParam e um ponteiro para a estrutura que contém o valor de P no parâmetro pbData .
- Inicialize uma estrutura de CRYPT_DATA_BLOB com o membro pbData definido como o valor G. O BLOB não contém informações de cabeçalho e o membro pbData está no formato little-endian.
- O valor de G é definido chamando a função CryptSetKeyParam , passando o identificador de chave recuperado na etapa a no parâmetro hKey , o sinalizador KP_G no parâmetro dwParam e um ponteiro para a estrutura que contém o valor de G no parâmetro pbData .
- O valor de X é gerado chamando a função CryptSetKeyParam , passando o identificador de chave recuperado na etapa a no parâmetro hKey , o sinalizador KP_X no parâmetro dwParam e NULL no parâmetro pbData .
- Se todas as chamadas de função tiverem sido bem-sucedidas, o Diffie-Hellman chave pública estará pronto para uso.
Quando a chave não for mais necessária, destrua-a passando o identificador de chave para a função CryptDestroyKey .
Se CALG_DH_SF foi especificado nos procedimentos anteriores, os valores de chave serão persistidos no armazenamento com cada chamada para CryptSetKeyParam. Os valores G e P podem ser recuperados usando a função CryptGetKeyParam . Alguns CSPs podem ter valores de G e P codificados. Nesse caso, um erro de NTE_FIXEDPARAMETER será retornado se CryptSetKeyParam for chamado com KP_G ou KP_P especificado no parâmetro dwParam . Se CryptDestroyKey for chamado, o identificador para a chave será destruído, mas os valores de chave serão mantidos no CSP. No entanto, se CALG_DH_EPHEM foi especificado, o identificador para a chave será destruído e todos os valores serão limpos do CSP.
Trocando chaves de Diffie-Hellman
A finalidade do algoritmo Diffie-Hellman é possibilitar que duas ou mais partes criem e compartilhem uma chave de sessão secreta idêntica compartilhando informações em uma rede que não é segura. As informações que são compartilhadas pela rede estão na forma de alguns valores constantes e um Diffie-Hellman chave pública. O processo usado por duas partes de troca de chaves é o seguinte:
- Ambas as partes concordam com os parâmetros Diffie-Hellman que são um número primo (P) e um número de gerador (G).
- O Partido 1 envia seu Diffie-Hellman chave pública para o partido 2.
- A Parte 2 calcula a chave de sessão secreta usando as informações contidas em sua chave privada e na chave pública do partido 1.
- O Partido 2 envia seu Diffie-Hellman chave pública para o partido 1.
- A parte 1 calcula a chave de sessão secreta usando as informações contidas na chave privada e na chave pública do partido 2.
- Ambas as partes agora têm a mesma chave de sessão, que pode ser usada para criptografar e descriptografar dados. As etapas necessárias para isso são mostradas no procedimento a seguir.
Para preparar uma chave pública Diffie-Hellman para transmissão
- Chame a função CryptAcquireContext para obter um identificador para o Provedor criptográfico do Microsoft Diffie-Hellman.
- Crie uma chave Diffie-Hellman chamando a função CryptGenKey para criar uma nova chave ou chamando a função CryptGetUserKey para recuperar uma chave existente.
- Obtenha o tamanho necessário para manter o BLOB de chave Diffie-Hellman chamando o CryptExportKey, passando NULL para o parâmetro pbData . O tamanho necessário será retornado em pdwDataLen.
- Alocar memória para o BLOB de chave.
- Crie um BLOB de chave pública Diffie-Hellman chamando a função CryptExportKey , passando PUBLICKEYBLOB no parâmetro dwBlobType e o identificador para a chave Diffie-Hellman no parâmetro hKey . Essa chamada de função causa o cálculo do valor da chave pública, (G^X) mod P.
- Se todas as chamadas de função anteriores tiverem sido bem-sucedidas, o BLOB de chave pública Diffie-Hellman agora estará pronto para ser codificado e transmitido.
Para importar uma chave pública Diffie-Hellman e calcular a chave de sessão secreta
- Chame a função CryptAcquireContext para obter um identificador para o Provedor criptográfico do Microsoft Diffie-Hellman.
- Crie uma chave Diffie-Hellman chamando a função CryptGenKey para criar uma nova chave ou chamando a função CryptGetUserKey para recuperar uma chave existente.
- Para importar a chave pública Diffie-Hellman para o CSP, chame a função CryptImportKey , passando um ponteiro para o BLOB de chave pública no parâmetro pbData , o comprimento do BLOB no parâmetro dwDataLen e o identificador para a chave Diffie-Hellman no parâmetro hPubKey . Isso faz com que o cálculo , (Y^X) mod P, seja executado, criando assim a chave compartilhada e secreta e concluindo a troca de chaves. Essa chamada de função retorna um identificador para a nova chave de sessão secreta no parâmetro hKey .
- Neste ponto, a Diffie-Hellman importada é do tipo CALG_AGREEDKEY_ANY. Antes que a chave possa ser usada, ela deve ser convertida em um tipo de chave de sessão. Isso é feito chamando a função CryptSetKeyParam com dwParam definido como KP_ALGID e com pbData definido como um ponteiro para um valor ALG_ID que representa uma chave de sessão, como CALG_RC4. A chave deve ser convertida antes de usar a chave compartilhada na função CryptEncrypt ou CryptDecrypt . As chamadas feitas para qualquer uma dessas funções antes de converter o tipo de chave falharão.
- A chave de sessão secreta agora está pronta para ser usada para criptografia ou descriptografia.
- Quando a chave não for mais necessária, destrua o identificador de chave chamando a função CryptDestroyKey .
Exportando uma chave privada Diffie-Hellman
Para exportar uma chave privada Diffie-Hellman, execute as seguintes etapas:
- Chame a função CryptAcquireContext para obter um identificador para o Provedor criptográfico do Microsoft Diffie-Hellman.
- Crie uma chave Diffie-Hellman chamando a função CryptGenKey para criar uma nova chave ou chamando a função CryptGetUserKey para recuperar uma chave existente.
- Crie um BLOB de chave privada Diffie-Hellman chamando a função CryptExportKey , passando PRIVATEKEYBLOB no parâmetro dwBlobType e o identificador para a chave Diffie-Hellman no parâmetro hKey .
- Quando o identificador de chave não for mais necessário, chame a função CryptDestroyKey para destruir o identificador de chave.
Código de exemplo
O exemplo a seguir mostra como criar, exportar, importar e usar uma chave Diffie-Hellman para executar uma troca de chaves.
#include <tchar.h>
#include <windows.h>
#include <wincrypt.h>
#pragma comment(lib, "crypt32.lib")
// The key size, in bits.
#define DHKEYSIZE 512
// Prime in little-endian format.
static const BYTE g_rgbPrime[] =
{
0x91, 0x02, 0xc8, 0x31, 0xee, 0x36, 0x07, 0xec,
0xc2, 0x24, 0x37, 0xf8, 0xfb, 0x3d, 0x69, 0x49,
0xac, 0x7a, 0xab, 0x32, 0xac, 0xad, 0xe9, 0xc2,
0xaf, 0x0e, 0x21, 0xb7, 0xc5, 0x2f, 0x76, 0xd0,
0xe5, 0x82, 0x78, 0x0d, 0x4f, 0x32, 0xb8, 0xcb,
0xf7, 0x0c, 0x8d, 0xfb, 0x3a, 0xd8, 0xc0, 0xea,
0xcb, 0x69, 0x68, 0xb0, 0x9b, 0x75, 0x25, 0x3d,
0xaa, 0x76, 0x22, 0x49, 0x94, 0xa4, 0xf2, 0x8d
};
// Generator in little-endian format.
static BYTE g_rgbGenerator[] =
{
0x02, 0x88, 0xd7, 0xe6, 0x53, 0xaf, 0x72, 0xc5,
0x8c, 0x08, 0x4b, 0x46, 0x6f, 0x9f, 0x2e, 0xc4,
0x9c, 0x5c, 0x92, 0x21, 0x95, 0xb7, 0xe5, 0x58,
0xbf, 0xba, 0x24, 0xfa, 0xe5, 0x9d, 0xcb, 0x71,
0x2e, 0x2c, 0xce, 0x99, 0xf3, 0x10, 0xff, 0x3b,
0xcb, 0xef, 0x6c, 0x95, 0x22, 0x55, 0x9d, 0x29,
0x00, 0xb5, 0x4c, 0x5b, 0xa5, 0x63, 0x31, 0x41,
0x13, 0x0a, 0xea, 0x39, 0x78, 0x02, 0x6d, 0x62
};
BYTE g_rgbData[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};
int _tmain(int argc, _TCHAR* argv[])
{
UNREFERENCED_PARAMETER(argc);
UNREFERENCED_PARAMETER(argv);
BOOL fReturn;
HCRYPTPROV hProvParty1 = NULL;
HCRYPTPROV hProvParty2 = NULL;
DATA_BLOB P;
DATA_BLOB G;
HCRYPTKEY hPrivateKey1 = NULL;
HCRYPTKEY hPrivateKey2 = NULL;
PBYTE pbKeyBlob1 = NULL;
PBYTE pbKeyBlob2 = NULL;
HCRYPTKEY hSessionKey1 = NULL;
HCRYPTKEY hSessionKey2 = NULL;
PBYTE pbData = NULL;
/************************
Construct data BLOBs for the prime and generator. The P and G
values, represented by the g_rgbPrime and g_rgbGenerator arrays
respectively, are shared values that have been agreed to by both
parties.
************************/
P.cbData = DHKEYSIZE/8;
P.pbData = (BYTE*)(g_rgbPrime);
G.cbData = DHKEYSIZE/8;
G.pbData = (BYTE*)(g_rgbGenerator);
/************************
Create the private Diffie-Hellman key for party 1.
************************/
// Acquire a provider handle for party 1.
fReturn = CryptAcquireContext(
&hProvParty1,
NULL,
MS_ENH_DSS_DH_PROV,
PROV_DSS_DH,
CRYPT_VERIFYCONTEXT);
if(!fReturn)
{
goto ErrorExit;
}
// Create an ephemeral private key for party 1.
fReturn = CryptGenKey(
hProvParty1,
CALG_DH_EPHEM,
DHKEYSIZE << 16 | CRYPT_EXPORTABLE | CRYPT_PREGEN,
&hPrivateKey1);
if(!fReturn)
{
goto ErrorExit;
}
// Set the prime for party 1's private key.
fReturn = CryptSetKeyParam(
hPrivateKey1,
KP_P,
(PBYTE)&P,
0);
if(!fReturn)
{
goto ErrorExit;
}
// Set the generator for party 1's private key.
fReturn = CryptSetKeyParam(
hPrivateKey1,
KP_G,
(PBYTE)&G,
0);
if(!fReturn)
{
goto ErrorExit;
}
// Generate the secret values for party 1's private key.
fReturn = CryptSetKeyParam(
hPrivateKey1,
KP_X,
NULL,
0);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Create the private Diffie-Hellman key for party 2.
************************/
// Acquire a provider handle for party 2.
fReturn = CryptAcquireContext(
&hProvParty2,
NULL,
MS_ENH_DSS_DH_PROV,
PROV_DSS_DH,
CRYPT_VERIFYCONTEXT);
if(!fReturn)
{
goto ErrorExit;
}
// Create an ephemeral private key for party 2.
fReturn = CryptGenKey(
hProvParty2,
CALG_DH_EPHEM,
DHKEYSIZE << 16 | CRYPT_EXPORTABLE | CRYPT_PREGEN,
&hPrivateKey2);
if(!fReturn)
{
goto ErrorExit;
}
// Set the prime for party 2's private key.
fReturn = CryptSetKeyParam(
hPrivateKey2,
KP_P,
(PBYTE)&P,
0);
if(!fReturn)
{
goto ErrorExit;
}
// Set the generator for party 2's private key.
fReturn = CryptSetKeyParam(
hPrivateKey2,
KP_G,
(PBYTE)&G,
0);
if(!fReturn)
{
goto ErrorExit;
}
// Generate the secret values for party 2's private key.
fReturn = CryptSetKeyParam(
hPrivateKey2,
KP_X,
NULL,
0);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Export Party 1's public key.
************************/
// Public key value, (G^X) mod P is calculated.
DWORD dwDataLen1;
// Get the size for the key BLOB.
fReturn = CryptExportKey(
hPrivateKey1,
NULL,
PUBLICKEYBLOB,
0,
NULL,
&dwDataLen1);
if(!fReturn)
{
goto ErrorExit;
}
// Allocate the memory for the key BLOB.
if(!(pbKeyBlob1 = (PBYTE)malloc(dwDataLen1)))
{
goto ErrorExit;
}
// Get the key BLOB.
fReturn = CryptExportKey(
hPrivateKey1,
0,
PUBLICKEYBLOB,
0,
pbKeyBlob1,
&dwDataLen1);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Export Party 2's public key.
************************/
// Public key value, (G^X) mod P is calculated.
DWORD dwDataLen2;
// Get the size for the key BLOB.
fReturn = CryptExportKey(
hPrivateKey2,
NULL,
PUBLICKEYBLOB,
0,
NULL,
&dwDataLen2);
if(!fReturn)
{
goto ErrorExit;
}
// Allocate the memory for the key BLOB.
if(!(pbKeyBlob2 = (PBYTE)malloc(dwDataLen2)))
{
goto ErrorExit;
}
// Get the key BLOB.
fReturn = CryptExportKey(
hPrivateKey2,
0,
PUBLICKEYBLOB,
0,
pbKeyBlob2,
&dwDataLen2);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Party 1 imports party 2's public key.
The imported key will contain the new shared secret
key (Y^X) mod P.
************************/
fReturn = CryptImportKey(
hProvParty1,
pbKeyBlob2,
dwDataLen2,
hPrivateKey1,
0,
&hSessionKey2);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Party 2 imports party 1's public key.
The imported key will contain the new shared secret
key (Y^X) mod P.
************************/
fReturn = CryptImportKey(
hProvParty2,
pbKeyBlob1,
dwDataLen1,
hPrivateKey2,
0,
&hSessionKey1);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Convert the agreed keys to symmetric keys. They are currently of
the form CALG_AGREEDKEY_ANY. Convert them to CALG_RC4.
************************/
ALG_ID Algid = CALG_RC4;
// Enable the party 1 public session key for use by setting the
// ALGID.
fReturn = CryptSetKeyParam(
hSessionKey1,
KP_ALGID,
(PBYTE)&Algid,
0);
if(!fReturn)
{
goto ErrorExit;
}
// Enable the party 2 public session key for use by setting the
// ALGID.
fReturn = CryptSetKeyParam(
hSessionKey2,
KP_ALGID,
(PBYTE)&Algid,
0);
if(!fReturn)
{
goto ErrorExit;
}
/************************
Encrypt some data with party 1's session key.
************************/
// Get the size.
DWORD dwLength = sizeof(g_rgbData);
fReturn = CryptEncrypt(
hSessionKey1,
0,
TRUE,
0,
NULL,
&dwLength,
sizeof(g_rgbData));
if(!fReturn)
{
goto ErrorExit;
}
// Allocate a buffer to hold the encrypted data.
pbData = (PBYTE)malloc(dwLength);
if(!pbData)
{
goto ErrorExit;
}
// Copy the unencrypted data to the buffer. The data will be
// encrypted in place.
memcpy(pbData, g_rgbData, sizeof(g_rgbData));
// Encrypt the data.
dwLength = sizeof(g_rgbData);
fReturn = CryptEncrypt(
hSessionKey1,
0,
TRUE,
0,
pbData,
&dwLength,
sizeof(g_rgbData));
if(!fReturn)
{
goto ErrorExit;
}
/************************
Decrypt the data with party 2's session key.
************************/
dwLength = sizeof(g_rgbData);
fReturn = CryptDecrypt(
hSessionKey2,
0,
TRUE,
0,
pbData,
&dwLength);
if(!fReturn)
{
goto ErrorExit;
}
ErrorExit:
if(pbData)
{
free(pbData);
pbData = NULL;
}
if(hSessionKey2)
{
CryptDestroyKey(hSessionKey2);
hSessionKey2 = NULL;
}
if(hSessionKey1)
{
CryptDestroyKey(hSessionKey1);
hSessionKey1 = NULL;
}
if(pbKeyBlob2)
{
free(pbKeyBlob2);
pbKeyBlob2 = NULL;
}
if(pbKeyBlob1)
{
free(pbKeyBlob1);
pbKeyBlob1 = NULL;
}
if(hPrivateKey2)
{
CryptDestroyKey(hPrivateKey2);
hPrivateKey2 = NULL;
}
if(hPrivateKey1)
{
CryptDestroyKey(hPrivateKey1);
hPrivateKey1 = NULL;
}
if(hProvParty2)
{
CryptReleaseContext(hProvParty2, 0);
hProvParty2 = NULL;
}
if(hProvParty1)
{
CryptReleaseContext(hProvParty1, 0);
hProvParty1 = NULL;
}
return 0;
}
Comentários
Em breve: Ao longo de 2024, eliminaremos os problemas do GitHub como o mecanismo de comentários para conteúdo e o substituiremos por um novo sistema de comentários. Para obter mais informações, consulte https://aka.ms/ContentUserFeedback.
Enviar e exibir comentários de