다음을 통해 공유

Diffie-Hellman 키

  • 아티클

Diffie-Hellman 키 생성

Diffie-Hellman 키를 생성하려면 다음 단계를 수행합니다.

  1. CryptAcquireContext 함수를 호출하여 Microsoft Diffie-Hellman 암호화 공급자에 대한 핸들을 가져옵니다.

  2. 새 키를 생성합니다. CryptoAPI가 G, P 및 X에 대한 모든 새 값을 생성하도록 하거나 G 및 P에 대한 기존 값을 사용하고 X에 대한 새 값을 생성하여 이 작업을 수행하는 두 가지 방법이 있습니다.

    모든 새 값을 생성하여 키를 생성하려면

    1. Algid 매개 변수에 CALG_DH_SF(저장 및 전달) 또는 CALG_DH_EPHEM(임시)를 전달하여 CryptGenKey 함수를 호출합니다. 키는 X에 대해 새로 계산된 값인 G 및 P에 대해 임의의 새 값을 사용하여 생성되며 해당 핸들은 phKey 매개 변수에 반환됩니다.
    2. 이제 새 키를 사용할 준비가 되었습니다. 키 교환수행할 때 G 및 P의 값을 키와 함께 받는 사람에게 보내야 합니다(또는 다른 방법으로 전송).

    G 및 P 미리 정의된 값을 사용하여 키를 생성하려면

    1. Algid 매개 변수에서 CALG_DH_SF(저장 및 전달) 또는 CALG_DH_EPHEM(임시)를 전달하고 dwFlags 매개 변수에 대한 CRYPT_PREGEN 전달하는 CryptGenKey 호출합니다. 키 핸들이 생성되고 phKey 매개 변수에 반환됩니다.
    2. pbData 멤버를 P 값으로 설정하여 CRYPT_DATA_BLOB 구조체를 초기화합니다. BLOB 헤더 정보를 포함하지 않으며 pbData 멤버는 little-endian 형식입니다.
    3. P 값은 CryptSetKeyParam 함수를 호출하고, hKey 매개 변수의 1단계에서 검색된 키 핸들, dwParam 매개 변수의 KP_P 플래그 및 pbData 매개 변수에 P 값을 포함하는 구조체에 대한 포인터를 전달하여 설정합니다.
    4. pbData 멤버를 G 값으로 설정하여 CRYPT_DATA_BLOB 구조를 초기화합니다. BLOB에는 헤더 정보가 없으며 pbData 멤버는 little-endian 형식입니다.
    5. G 값은 CryptSetKeyParam 함수를 호출하고, hKey 매개 변수의 1단계에서 검색된 키 핸들, dwParam 매개 변수의 KP_G 플래그 및 pbData 매개 변수에 G 값을 포함하는 구조체에 대한 포인터를 전달하여 설정합니다.
    6. X 값은 CryptSetKeyParam 함수를 호출하고, hKey 매개 변수의 1단계에서 검색된 키 핸들을 전달하고, dwParam 매개 변수의 KP_X 플래그를 전달하고, pbData 매개 변수에 NULL 생성됩니다.
    7. 모든 함수 호출이 성공하면 Diffie-Hellman 공개 키를 사용할 준비가 됩니다.

  3. 키가 더 이상 필요하지 않으면 키 핸들을 CryptDestroyKey 함수에 전달하여 제거합니다.

이전 절차에서 CALG_DH_SF 지정한 경우 CryptSetKeyParam호출할 때마다 키 값이 스토리지에 유지됩니다. 그런 다음 CryptGetKeyParam 함수를 사용하여 G 및 P 값을 검색할 수 있습니다. 일부 CSP에는 하드 코딩된 G 및 P 값이 있을 수 있습니다. 이 경우 dwParam 매개 변수에 지정된 KP_G 또는 KP_PCryptSetKeyParam 호출되면 NTE_FIXEDPARAMETER 오류가 반환됩니다. CryptDestroyKey 호출되면 키에 대한 핸들이 제거되지만 키 값은 CSP에 유지됩니다. 그러나 CALG_DH_EPHEM 지정한 경우 키에 대한 핸들이 제거되고 CSP에서 모든 값이 지워집니다.

Diffie-Hellman 키 교환

Diffie-Hellman 알고리즘의 목적은 둘 이상의 당사자가 안전하지 않은 네트워크를 통해 정보를 공유하여 동일한 비밀 세션 키를 만들고 공유할 수 있도록 하는 것입니다. 네트워크를 통해 공유되는 정보는 몇 가지 상수 값과 Diffie-Hellman 공개 키 형식입니다. 두 키 교환 당사자가 사용하는 프로세스는 다음과 같습니다.

  • 양 당사자는 소수(P) 및 생성기 번호(G)인 Diffie-Hellman 매개 변수에 동의합니다.
  • 파티 1은 Diffie-Hellman 공개 키를 파티 2에 보냅니다.
  • 파티 2는 프라이빗 키 및 파티 1의 공개 키에 포함된 정보를 사용하여 비밀 세션 키를 계산합니다.
  • 파티 2는 파티 1에 Diffie-Hellman 공개 키를 보냅니다.
  • 파티 1은 프라이빗 키 및 파티 2의 공개 키에 포함된 정보를 사용하여 비밀 세션 키를 계산합니다.
  • 이제 두 당사자 모두 데이터 암호화 및 암호 해독에 사용할 수 있는 동일한 세션 키가 있습니다. 이에 필요한 단계는 다음 절차에 나와 있습니다.

전송 Diffie-Hellman 공개 키를 준비하려면

  1. CryptAcquireContext 함수를 호출하여 Microsoft Diffie-Hellman 암호화 공급자에 대한 핸들을 가져옵니다.
  2. CryptGenKey 함수를 호출하여 새 키를 만들거나 CryptGetUserKey 함수를 호출하여 기존 키를 검색하여 Diffie-Hellman 키를 만듭니다.
  3. CryptExportKey호출하고 pbData 매개 변수에 NULL 전달하여 Diffie-Hellman 키 BLOB을 유지하는 데 필요한 크기를 가져옵니다. 필요한 크기는 pdwDataLen 반환됩니다.
  4. 키 BLOB에 대한 메모리를 할당합니다.
  5. CryptExportKey 함수를 호출하고 dwBlobType 매개 변수의 publicKEYBLOB 전달하고 hKey 매개 변수의 Diffie-Hellman 키에 핸들을 전달하여 Diffie-Hellman 공개 키 BLOB 만듭니다. 이 함수 호출은 공개 키 값(G^X) 모드 P를 계산합니다.
  6. 이전의 모든 함수 호출이 성공하면 Diffie-Hellman 공개 키 BLOB을 인코딩하고 전송할 준비가 되었습니다.

Diffie-Hellman 공개 키를 가져오고 비밀 세션 키 계산하려면

  1. CryptAcquireContext 함수를 호출하여 Microsoft Diffie-Hellman 암호화 공급자에 대한 핸들을 가져옵니다.
  2. CryptGenKey 함수를 호출하여 새 키를 만들거나 CryptGetUserKey 함수를 호출하여 기존 키를 검색하여 Diffie-Hellman 키를 만듭니다.
  3. Diffie-Hellman 공개 키를 CSP로 가져오려면 CryptImportKey 함수를 호출하여 pbData 매개 변수의 공개 키 BLOB에 대한 포인터, dwDataLen 매개 변수의 BLOB 길이 및 hPubKey 매개 변수의 Diffie-Hellman 키에 대한 핸들을 전달합니다. 이렇게 하면 계산(Y^X) 모드 P가 수행되므로 공유 비밀 키를 만들고 키 교환완료합니다. 이 함수 호출은 hKey 매개 변수의 새 비밀 세션 키에 대한 핸들을 반환합니다.
  4. 이 시점에서 가져온 Diffie-Hellman CALG_AGREEDKEY_ANY형식입니다. 키를 사용하려면 먼저 세션 키 형식으로 변환해야 합니다. 이 작업은 dwParamKP_ALGID 설정된 CryptSetKeyParam 함수를 호출하고 CALG_RC4같은 세션 키를 나타내는 ALG_ID 값에 대한 포인터로 설정된 pbData 사용하여 수행됩니다. CryptEncrypt 또는 CryptDecrypt 함수에서 공유 키를 사용하기 전에 키를 변환해야 합니다. 키 형식을 변환하기 전에 이러한 함수 중 하나에 대한 호출이 실패합니다.
  5. 이제 비밀 세션 키를 암호화 또는 암호 해독에 사용할 준비가 되었습니다.
  6. 키가 더 이상 필요하지 않으면 CryptDestroyKey 함수를 호출하여 키 핸들을 삭제합니다.

Diffie-Hellman 프라이빗 키 내보내기

Diffie-Hellman 프라이빗 키를 내보내려면 다음 단계를 수행합니다.

  1. CryptAcquireContext 함수를 호출하여 Microsoft Diffie-Hellman 암호화 공급자에 대한 핸들을 가져옵니다.
  2. CryptGenKey 함수를 호출하여 새 키를 만들거나 CryptGetUserKey 함수를 호출하여 기존 키를 검색하여 Diffie-Hellman 키를 만듭니다.
  3. CryptExportKey 함수를 호출하고 dwBlobType 매개 변수의 privateKEYBLOB 전달하고 hKey 매개 변수의 Diffie-Hellman 키에 핸들을 전달하여 Diffie-Hellman 프라이빗 키 BLOB 만듭니다.
  4. 키 핸들이 더 이상 필요하지 않은 경우 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;
}