Diffie-Hellman密钥

项目
01/28/2024

生成Diffie-Hellman密钥
交换Diffie-Hellman密钥
导出Diffie-Hellman私钥
示例代码

生成Diffie-Hellman密钥

若要生成Diffie-Hellman密钥，请执行以下步骤：

调用 CryptAcquireContext 函数以获取 Microsoft Diffie-Hellman 加密提供程序的句柄。
生成新密钥。可通过两种方法来实现此目的：让 CryptoAPI 为 G、P 和 X 生成所有新值，或使用 G 和 P 的现有值，并为 X 生成新值。

通过生成所有新值来生成密钥
1. 调用 CryptGenKey 函数，在 Algid 参数中传递CALG_DH_SF (存储和转发) 或CALG_DH_EPHEM (临时) 。将使用 G 和 P 的新随机值、X 的新计算值生成密钥，并在 phKey 参数中返回其句柄。
2. 新密钥现已准备就绪，可供使用。 G 和 P 的值必须与密钥 (一起发送到收件人，或者在执行 密钥交换时由其他方法) 发送。
使用 G 和 P 的预定义值生成密钥
1. 调用 CryptGenKey，在 Algid 参数中传递CALG_DH_SF (存储和转发) 或CALG_DH_EPHEM (临时) ，并为 dwFlags 参数传递CRYPT_PREGEN。将在 phKey 参数中生成并返回密钥句柄。
2. 使用 pbData 成员设置为 P 值初始化CRYPT_DATA_BLOB结构。 BLOB 不包含标头信息，pbData 成员采用小端格式。
3. P 的值是通过调用 CryptSetKeyParam 函数、传递 hKey 参数中的步骤中检索的键句柄、dwParam 参数中的KP_P标志以及指向包含 pbData 参数中 P 值的结构的指针来设置的。
4. 使用 pbData 成员设置为 G 值初始化CRYPT_DATA_BLOB结构。 BLOB 不包含标头信息， pbData 成员采用小端格式。
5. G 的值是通过调用 CryptSetKeyParam 函数、传递在 hKey 参数中的步骤中检索的密钥句柄、dwParam 参数中的KP_G标志，以及指向包含 pbData 参数中 G 值的结构的指针来设置的。
6. X 的值通过调用 CryptSetKeyParam 函数、传递 hKey 参数中的步骤中检索的密钥句柄、dwParam 参数中的KP_X标志和 pbData 参数中的 NULL 来生成。
7. 如果所有函数调用都成功，Diffie-Hellman公钥可供使用。
当不再需要密钥时，通过将密钥句柄传递给 CryptDestroyKey 函数来销毁它。

如果在前面的过程中指定 了CALG_DH_SF ，则密钥值将保留在存储中，每次调用 CryptSetKeyParam。然后，可以使用 CryptGetKeyParam 函数检索 G 和 P 值。某些 CSP 可能具有硬编码的 G 和 P 值。在这种情况下，如果使用 dwParam 参数中指定的KP_G或KP_P调用 CryptSetKeyParam，将返回NTE_FIXEDPARAMETER错误。如果调用 CryptDestroyKey，则销毁密钥的句柄，但键值保留在云解决方案提供商中。但是，如果指定了CALG_DH_EPHEM，则销毁密钥的句柄，并且从云解决方案提供商中清除所有值。

交换Diffie-Hellman密钥

Diffie-Hellman算法的目的是通过不安全的网络共享信息，使两个或更多方能够创建和共享相同的机密会话密钥。通过网络共享的信息采用几个常量值和Diffie-Hellman公钥的形式。两个密钥交换方使用的过程如下所示：

双方都同意Diffie-Hellman参数，这些参数是 (P) 和生成器编号 (G) 。
Party 1 将其Diffie-Hellman公钥发送到第 2 方。
Party 2 使用其私钥和第 1 方公钥中包含的信息来计算机密会话密钥。
第 2 方将其Diffie-Hellman公钥发送到第 1 方。
Party 1 使用其私钥和第 2 方公钥中包含的信息来计算机密会话密钥。
双方现在具有相同的会话密钥，可用于加密和解密数据。此过程中显示了此操作所需的步骤。

准备用于传输的Diffie-Hellman公钥

调用 CryptAcquireContext 函数以获取 Microsoft Diffie-Hellman 加密提供程序的句柄。
通过调用 CryptGenKey 函数创建新密钥，或通过调用 CryptGetUserKey 函数检索现有密钥来创建Diffie-Hellman密钥。
通过调用 CryptExportKey（为 pbData 参数传递 NULL）获取保存Diffie-Hellman密钥 BLOB 所需的大小。所需的大小将在 pdwDataLen 中返回。
为密钥 BLOB 分配内存。
通过调用CryptExportKey 函数、在 dwBlobType 参数中传递 PUBLICKEYBLOB 以及 hKey 参数中Diffie-Hellman键的句柄来创建Diffie-Hellman公钥 BLOB。此函数调用会导致计算公钥值， (G^X) mod P。
如果上述所有函数调用都成功，Diffie-Hellman公钥 BLOB 现已准备好进行编码和传输。

导入Diffie-Hellman公钥并计算机密会话密钥

调用 CryptAcquireContext 函数以获取 Microsoft Diffie-Hellman 加密提供程序的句柄。
通过调用 CryptGenKey 函数创建新密钥，或通过调用 CryptGetUserKey 函数检索现有密钥来创建Diffie-Hellman密钥。
若要将Diffie-Hellman公钥导入云解决方案提供商，请调用 CryptImportKey 函数，将指针传递到 pbData 参数中的公钥 BLOB、dwDataLen 参数中的 BLOB 长度以及 hPubKey 参数中Diffie-Hellman密钥的句柄。这会导致计算（ (Y^X) mod P）执行，从而创建共享密钥、机密密钥并完成 密钥交换。此函数调用返回 hKey 参数中新的机密会话密钥的句柄。
此时，导入的Diffie-Hellman的类型为 CALG_AGREEDKEY_ANY。在使用密钥之前，必须将其转换为会话密钥类型。为此，调用将 dwParam 设置为 KP_ALGID的 CryptSetKeyParam 函数，并将 pbData 设置为指向表示会话键的ALG_ID值的指针，例如CALG_RC4。在 CryptEncrypt 或 CryptDecrypt 函数中使用共享密钥之前，必须转换密钥。在转换密钥类型之前对其中任一函数的调用将失败。
机密会话密钥现已准备好用于加密或解密。
不再需要密钥时，通过调用 CryptDestroyKey 函数来销毁密钥句柄。

导出Diffie-Hellman私钥

若要导出Diffie-Hellman私钥，请执行以下步骤：

调用 CryptAcquireContext 函数以获取 Microsoft Diffie-Hellman 加密提供程序的句柄。
通过调用 CryptGenKey 函数创建新密钥，或通过调用 CryptGetUserKey 函数检索现有密钥来创建Diffie-Hellman密钥。
通过调用 CryptExportKey 函数、在 dwBlobType 参数中传递 PRIVATEKEYBLOB 以及 hKey 参数中Diffie-Hellman密钥的句柄来创建Diffie-Hellman私钥 BLOB。
不再需要密钥句柄时，调用 CryptDestroyKey 函数以销毁密钥句柄。

示例代码

以下示例演示如何创建、导出、导入和使用Diffie-Hellman密钥来执行密钥交换。

#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;
}

通过

Diffie-Hellman密钥

生成Diffie-Hellman密钥

交换Diffie-Hellman密钥

导出Diffie-Hellman私钥

示例代码

反馈

其他资源