Diffie-Hellman (to RC4) с Wincrypt From Python

В настоящее время я работаю над проектом, написанным на C++, который использует CryptoAPI для выполнения обмена ключами Диффи-Хеллмана. У меня немного проблемы с тем, чтобы это работало, поскольку возможный ключ сеанса RC4, который я получаю, не может использоваться для шифрования одного и того же текста в Python (с использованием pycrypto).Diffie-Hellman (to RC4) с Wincrypt From Python

C++ код для выполнения обмена ключами Диффи-Хеллмана был взят из msdn, но здесь включен для потомков:

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

Я считаю, что я могу завершить обмен ключами Диффи-Хеллмана в Python, как и Я могу сгенерировать те же общедоступные и закрытые ключи без ошибок. Я основал обмен ключей Diffie-Hellman на this repository.

Я не смог проверить это, однако, как я могу, похоже, не получить общий секрет, экспортированный из кода C++ (аналогично this thread, на который никогда не отвечали удовлетворительно). Я могу однако получить ключ RC4 сеанса с помощью следующего кода:

// Get the key length 
DWORD keylen; 
CryptExportKey( 
    hSessionKey1, 
    NULL,  
    PLAINTEXTKEYBLOB, 
    0, 
    NULL, 
    &keylen); 

// Get the session key 
CryptExportKey( 
    hSessionKey1, 
    NULL,  
    PLAINTEXTKEYBLOB, 
    0, 
    encKey,  
    &keylen);

Выход из этой функции получает меня:

08 02 00 00 01 68 00 00 10 00 00 00 75 2c 59 8c 6e e0 8c 9f ed 30 17 7e 9d a5 85 2b

Я знаю, что есть 12 байт заголовок + длина на этом, так что оставляет меня со следующим 16 байт ключа RC4 сессии:

75 2c 59 8c 6e e0 8c 9f ed 30 17 7e 9d a5 85 2b

Так что я в настоящее время пытается проверить, что я могу зашифровать один и тот же открытый текст с помощью RC4, который я приобрел от CryptExportKey. Я в настоящее время пытается зашифровать g_rgbData из кода C++ выше, который установлен на:

BYTE g_rgbData[] = {0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08};

С кодом C++ я получаю следующий зашифрованный результат:

cc 94 aa ec 86 6e a8 26

Использование PyCrypto У меня есть следующий код :

from Crypto.Cipher import ARC4 
key = '75 2c 59 8c 6e e0 8c 9f ed 30 17 7e 9d a5 85 2b' 
key = key.replace(' ', '').decode('hex') 

plaintext = '0102030405060708' 
plaintext = plaintext.replace(' ', '').decode('hex') 

rc4 = ARC4.new(key) 
encrypted = rc4.encrypt(plaintext) 

print encrypted.encode('hex')

Это приводит следующий вывод:

00 5b 64 25 4e a5 62 e3

Что не соответствует выходу C++. Я играл с энтузиазмом, но я подозреваю, что что-то еще может случиться.

К сожалению, если это долго наматывается, но это приводит меня к двум вопросам:

Всякий раз, когда вы переход от общего ключа к RC4 (с использованием CryptSetKeyParam с CALG_RC4), что на самом деле происходит под капот здесь? Кажется, я не могу найти никакой информации об этом процессе, чтобы я мог реализовать его в Python.
Любая идея, почему мой RC4 не будет работать с одним и тем же ключом и тем же открытым текстом в Python?

Любая помощь была бы принята с благодарностью!

источник

2015-12-19 Jeremy

Вы, вероятно, не должны использовать RC4 - это считается полностью сломанным (https://tools.ietf.org/html/rfc7465, http://www.theregister.co.uk/2015/07/16/rc4_get_rid_of_it_already_say_boffins /) –

@AlanStokes Да, я довольно подробно читал о RC4, чтобы разобраться в этой проблеме. Этот код не будет использоваться в какой-либо производственной системе. Это началось как интерес к немногому изучению криптографии, причем RC4 выглядит довольно прямолинейно. Теперь я пытаюсь разобраться, почему CryptoAPI не ведет себя так, как я ожидаю; больше любопытства, чем что-либо еще. – Jeremy

Вот почему у нас нет хорошей безопасности. Можно также использовать шифр Цезаря. – zaph

Наконец-то прошло некоторое время, чтобы просмотреть ваш код. Когда я запускаю свой код локально, я могу экспортировать ключ сеанса и успешно использовать его в pycrypto. Я предполагаю, что вы либо не экспортируете ключ сеанса правильно (например, это то, что вы опубликовали, что вы используете?), Либо данные, которые вы шифруете на C++, это не те же данные, которые вы шифруете в Python, - проверьте, что данные вы шифруете также правильно. Я подозреваю, что это, вероятно, последний, так как на самом деле вы не можете портить CryptExportKey, который вы опубликовали.

источник

2015-12-22 01:30:50 Julio

Ugh. Да, я случайно удалил memcpy (pbData, g_rgbData, sizeof (g_rgbData)); 'который заставлял меня шифровать данные, которых я не ожидал. Супер раздражает, но теперь он работает. Благодаря! – Jeremy

Согласно PyCrypto docs ключ должен быть не менее 40 байт:

ключ (байт строка) - Секретный ключ для использования в симметричного шифра. Он может иметь любую длину, с минимумом 40 байт. Его криптографическая сила всегда ограничена 2048 бит (256 байтов).

, но тогда возникает противоречие чуть выше:

key_size = xrange (1, 257)

Размер ключа (в байтах)

позволяет кнопочная длины от 1 до 256, поэтому я не уверен, что это даже помогает.

источник

2015-12-22 00:39:43

ответ

Смежные вопросы