Diffie-Hellman キー

2025-03-13

Diffie-Hellman キーの生成
Diffie-Hellman キーの交換の
Diffie-Hellman 秘密キーのエクスポート
コード例の

Diffie-Hellman キーの生成

Diffie-Hellman キーを生成するには、次の手順に従います。

CryptAcquireContext 関数を呼び出して、Microsoft Diffie-Hellman 暗号化プロバイダーへのハンドルを取得します。
新しいキーを生成します。これを実現するには、2 つの方法があります。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 パラメーターでステップ a で取得したキーハンドル、dwParam パラメーターの KP_G フラグ、および pbData パラメーターに G の値を含む構造体へのポインターを渡すことによって設定されます。
6. X の値は、CryptSetKeyParam 関数を呼び出し、手順 a で取得したキーハンドルを hKey パラメーターに渡し、dwParam パラメーターの KP_X フラグを渡し、pbData パラメーターで NULL をすることによって生成されます。
7. すべての関数呼び出しが成功した場合、Diffie-Hellman 公開キーを使用する準備が整います。
キーが不要になったら、キーハンドルを CryptDestroyKey 関数に渡して破棄します。

前の手順で CALG_DH_SF を指定した場合、キー値は、CryptSetKeyParamを呼び出すたびにストレージに保持されます。 G と P の値は、CryptGetKeyParam 関数を使用して取得できます。一部の CSP には、ハードコーディングされた G 値と P 値が含まれる場合があります。この場合、dwParam パラメーターで指定 CryptSetKeyParam が KP_G または KP_P で呼び出されると、NTE_FIXEDPARAMETER エラーが返されます。 CryptDestroyKey が呼び出されると、キーのハンドルは破棄されますが、キーの値は CSP に保持されます。ただし、CALG_DH_EPHEM が指定された場合、キーのハンドルは破棄され、すべての値が CSP からクリアされます。

Diffie-Hellman キーの交換

Diffie-Hellman アルゴリズムの目的は、セキュリティで保護されていないネットワーク経由で情報を共有することで、2 人以上の関係者が同一のシークレットセッションキーを作成して共有できるようにすることです。ネットワーク経由で共有される情報は、定数値と Diffie-Hellman 公開キーの形式です。 2 つのキー交換パーティによって使用されるプロセスは次のとおりです。

両当事者は、素数(P)と発電機番号(G)である Diffie-Hellman パラメータに同意する。
パーティー 1 は、その Diffie-Hellman 公開キーをパーティ 2 に送信します。
パーティー 2 は、秘密キーとパーティ 1 の公開キーに含まれる情報を使用して、シークレットセッションキーを計算します。
パーティー 2 は、その Diffie-Hellman 公開キーをパーティ 1 に送信します。
パーティー 1 は、秘密キーとパーティー 2 の公開キーに含まれる情報を使用して、シークレットセッションキーを計算します。
両当事者は同じセッションキーを持つようになり、データの暗号化と復号化に使用できます。これに必要な手順を次の手順に示します。

転送用の Diffie-Hellman 公開キーを準備するには

CryptAcquireContext 関数を呼び出して、Microsoft Diffie-Hellman 暗号化プロバイダーへのハンドルを取得します。
Diffie-Hellman キーを作成するには、CryptGenKey 関数を呼び出して新しいキーを作成するか、CryptGetUserKey 関数を呼び出して既存のキーを取得します。
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 暗号化プロバイダーへのハンドルを取得します。
Diffie-Hellman キーを作成するには、CryptGenKey 関数を呼び出して新しいキーを作成するか、CryptGetUserKey 関数を呼び出して既存のキーを取得します。
Diffie-Hellman 公開キーを CSP にインポートするには、CryptImportKey 関数を呼び出し、pbData パラメーターの公開キー BLOB へのポインター、dwDataLen パラメーター内の BLOB の長さ、および hPubKey パラメーターの Diffie-Hellman キーへのハンドルを渡します。これにより、計算 (Y^X) mod P が実行され、共有秘密キーが作成され、キー交換が完了します。この関数呼び出しは、hKey パラメーターの新しいシークレットセッションキーへのハンドルを返します。
この時点で、インポートされた Diffie-Hellman は CALG_AGREEDKEY_ANY型です。キーを使用するには、そのキーをセッションキーの種類に変換する必要があります。これは、dwParam を KP_ALGID に設定し、pbDataCALG_RC4などのセッションキーを表す ALG_ID 値へのポインターに設定された CryptSetKeyParam 関数を呼び出すことによって実現されます。 CryptEncrypt または CryptDecrypt関数で共有キーを使用する前に、キー変換する必要があります。キーの種類を変換する前に、これらの関数のいずれかに対して行われた呼び出しは失敗します。
これで、シークレットセッションキーを暗号化または暗号化解除に使用する準備ができました。
キーが不要になったら、CryptDestroyKey 関数を呼び出してキーハンドルを破棄します。

Diffie-Hellman 秘密キーのエクスポート

Diffie-Hellman 秘密キーをエクスポートするには、次の手順に従います。

CryptAcquireContext 関数を呼び出して、Microsoft Diffie-Hellman 暗号化プロバイダーへのハンドルを取得します。
Diffie-Hellman キーを作成するには、CryptGenKey 関数を呼び出して新しいキーを作成するか、CryptGetUserKey 関数を呼び出して既存のキーを取得します。
Diffie-Hellman 秘密キー BLOB を作成するには、CryptExportKey 関数を呼び出し、dwBlobType パラメーター PRIVATEKEYBLOB を渡し、hKey パラメーターの Diffie-Hellman キーへのハンドルを渡します。
キーハンドルが不要になったら、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 秘密キーのエクスポート

コード例

フィードバック

その他のリソース