Wspólne hasło ECDH pochodzące z OpenSSL i BouncyCastle nie zawsze są takie same, mimo że stałe i parametry domeny są takie same dla obu

Question

Próbuję zaimplementować kryptografię AES między aplikacją iOS a serwletem Java. Serwlet Java używa biblioteki BouncyCastle, a aplikacja iOS używa OpenSSL. Chociaż użyłem tej samej pary kluczy publicznych i prywatnych oraz parametrów domeny dla obu stron, wspólny sekret wygenerowany przez OpenSSL czasami różni się od tego, co generuje BouncyCastle po stronie serwera.

Procedura wygląda następująco;

1. a/para publiczny klucz prywatny wygenerowany na serwerze o określonej domeny parametrów (słownie server_public_key, server_private_key)
2. server_public_key jest osadzony w aplikacji na iOS w formie EC_POINT X i Y
3. w Uruchom- Aplikacja czasu iOS generuje swoją własną parę kluczy publiczny/prywatny (na przykład client_key_curve, która jest EC_KEY), a następnie
4. następnie ładuje server_public_key i oblicza wspólny sekret (key_agreement) w oparciu o server_public_key i client_key_curve i
5. następnie client_public_key (wyciąg z client_key_curve) oraz zaszyfrowany komunikat, który jest szyfrowany symetrycznie pomocą otrzymywane współdzielonego tajnego (key_agreement) są wysyłane do serwera
6. serwer - boczne, wspólny sekret ponownie oblicza się stosując client_public_key i serwer ECDH parametry, które są takie same jak po stronie klienta, a
7. następnie zaszyfrowany komunikat odszyfrowywany wykorzystując obliczone key_agreement

ALE odszyfrowane wiadomości nie zawsze są takie same, jak wiadomości wysłane przez klienta.

Ponieważ opracowałem też aplikację na Androida, która korzysta z tej samej procedury, ale stosuje kryptografię BouncyCastle, dlatego podejrzewam poprawność zaimplementowanego kodu za pomocą OpenSSL, więc kod ujawnia się tutaj, aby inni mogli pomóc w rozwiązaniu problemu. Co I zostały wdrożone do obliczenia wspólne hasło jest następujący

- (void)calculateSharedSecret 
{ 
    BN_CTX* bn_ctx; 

    EC_KEY*  client_key_curve = NULL; 
    EC_KEY*  server_key_curve = NULL; 
    EC_GROUP* client_key_group = NULL; 
    EC_GROUP* server_key_group = NULL; 
    EC_POINT* client_publicKey = NULL; 
    EC_POINT* server_publicKey = NULL; 
    BIGNUM*  client_privatKey = NULL; 

    BIGNUM* client_publicK_x = NULL; 
    BIGNUM* client_publicK_y = NULL; 
    BIGNUM* server_publicK_x = NULL; 
    BIGNUM* server_publicK_y = NULL; 

    NSException *p = [NSException exceptionWithName:@"" reason:@"" userInfo:nil]; 

    bn_ctx = BN_CTX_new(); 
    BN_CTX_start(bn_ctx); 

    client_publicK_x = BN_CTX_get(bn_ctx); 
    client_publicK_y = BN_CTX_get(bn_ctx); 
    client_privatKey = BN_CTX_get(bn_ctx); 
    server_publicK_x = BN_CTX_get(bn_ctx); 
    server_publicK_y = BN_CTX_get(bn_ctx); 

    // client 

    if ((client_key_curve = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)) == NULL) 
     @throw p; 

    if ((client_key_group = (EC_GROUP *)EC_KEY_get0_group(client_key_curve)) == NULL) 
     @throw p; 

    if (EC_KEY_generate_key(client_key_curve) != 1) 
     @throw p; 

    if ((client_publicKey = (EC_POINT *)EC_KEY_get0_public_key(client_key_curve)) == NULL) 
     @throw p; 

    if (EC_KEY_check_key(client_key_curve) != 1) 
     @throw p; 

    client_privatKey = (BIGNUM *)EC_KEY_get0_private_key(client_key_curve); 

    char *client_public_key = EC_POINT_point2hex(client_key_group, client_publicKey, POINT_CONVERSION_COMPRESSED, bn_ctx); 
    char *client_privat_key = BN_bn2hex(client_privatKey); 

    _clientPublicKey = [NSString stringWithCString:client_public_key encoding:NSUTF8StringEncoding]; 

    // server 

    NSArray* lines = [self loadServerPublicKeyXY]; 

    NSString *public_str_x = [lines objectAtIndex:0]; 
    NSString *public_str_y = [lines objectAtIndex:1]; 

    BN_dec2bn(&server_publicK_x, [public_str_x UTF8String]); 
    BN_dec2bn(&server_publicK_y, [public_str_y UTF8String]); 

    if ((server_key_curve = EC_KEY_new_by_curve_name(NID_X9_62_prime256v1)) == NULL) 
     @throw p; 

    if ((server_key_group = (EC_GROUP *)EC_KEY_get0_group(server_key_curve)) == NULL) 
     @throw p; 

    if (EC_KEY_generate_key(server_key_curve) != 1) 
     @throw p; 

    if ((server_publicKey = EC_POINT_new(server_key_group)) == NULL) 
     @throw p; 

    if (EC_POINT_set_affine_coordinates_GFp(server_key_group, server_publicKey, server_publicK_x, server_publicK_y, bn_ctx) != 1) 
     @throw p; 

    if (EC_KEY_check_key(server_key_curve) != 1) 
     @throw p; 

    unsigned char *key_agreement = NULL; 
    key_agreement = (unsigned char *)OPENSSL_malloc(SHA_DIGEST_LENGTH); 
    if (ECDH_compute_key(key_agreement, SHA_DIGEST_LENGTH, server_publicKey, client_key_curve, KDF1_SHA1) == 0) 
     @throw p; 
    _symmetricKey = [NSData dataWithBytes:key_agreement length:16]; 
} 

i

void *KDF1_SHA1(const void *input, size_t inlen, void *output, size_t *outlen) 
{ 
    if (*outlen < SHA_DIGEST_LENGTH) 
     return NULL; 
    else 
     *outlen = SHA_DIGEST_LENGTH; 
    return SHA1(input, inlen, output); 
} 

_clientPublicKey i _symmetricKey deklarowane są na poziomie klasy

samej krzywej (o nazwie prime256v1 lub secp256r1) jest używane po obu stronach, ale wyniki nie zawsze są takie same.

Edycja 1: W odpowiedzi na @PeterDettman, już opublikowana serwer - kod boczną więcej wyjaśnienia

public byte[] generateAESSymmetricKey(byte[] client_public_key_hex) throws InvalidRequest{ 
    try { 
     // ECDH Private Key as well as other prime256v1 params was generated by Java "keytool" and stored in a JKS file 
     KeyStore keyStore = ...; 
     PrivateKey privateKey = (PrivateKey) keyStore.getKey("keyAlias", "keyStorePassword".toCharArray()); 
     ECPrivateKeyParameters ecdhPrivateKeyParameters = (ECPrivateKeyParameters) (PrivateKeyFactory.createKey(privateKey.getEncoded())); 

     ECCurve ecCurve = ecdhPrivateKeyParameters.getParameters().getCurve(); 
     ECDomainParameters ecDomainParameters = ecdhPrivateKeyParameters.getParameters(); 
     ECPublicKeyParameters client_public_key = new ECPublicKeyParameters(ecCurve.decodePoint(client_public_key_hex), ecDomainParameters); 

     BasicAgreement agree = new ECDHBasicAgreement(); 
     agree.init(ecdhPrivateKeyParameters); 
     byte[] keyAgreement = agree.calculateAgreement(client_public_key).toByteArray(); 

     SHA1Digest sha1Digest = new SHA1Digest(); 
     sha1Digest.update(keyAgreement, 0, keyAgreement.length); 
     byte hashKeyAgreement[] = new byte[sha1Digest.getDigestSize()]; 
     sha1Digest.doFinal(hashKeyAgreement, 0); 

     byte[] server_calculatd_symmetric_key = new byte[16]; 
     System.arraycopy(hashKeyAgreement, 0, server_calculatd_symmetric_key, 0, server_calculatd_symmetric_key.length); 
     return server_calculatd_symmetric_key; 
    } catch (Throwable ignored) { 
     return null; 
    } 
} 

gdzie client_public_key_hex jest client_public_key, który jest przekształcany do tablicy bajtu. Oczekiwany wynik to, że server_calculatd_symmetric_key jest przez cały czas równy symmetricKey. ALE nie zawsze są takie same.

EDIT 2: W informacji zwrotnej, aby odpowiedzieć @PeterDettman, zrobiłem kilka zmian, aby odzwierciedlić jego sugestię i chociaż tempo zmniejsza nierówności, wygenerowany klucz umów (wspólny sekret) po obu stronach wciąż nie są równe we wszystkich przypadkach .

Jest to możliwe do odtworzenia jednego przypadku nierówności z następującymi danymi

• klucz publiczny: 02E05C058C3DF6E8D63791660D9C5EA98B5A0822AB93339B0B8815322131119C4C
• Privat klucz: 062E8AC930BD6009CF929E51B37432498075D21C335BD00086BF68CE09933ACA
• Generated Shared Tajne przez OpenSSL: 51d027264f8540e5d0fde70000000000
• Generated Shared tajne przez BouncyCastle: 51d027264f8540e5d0fde700e5db0fab

Więc jest jakiś błąd w kodzie lub procedury wdrożone?

Dzięki

Answer 1

Jest problem w kodzie serwera w taki sposób, że wartość umowy ECDH jest przekształcany w bajtach:

byte[] keyAgreement = agree.calculateAgreement(client_public_key).toByteArray(); 

Spróbuj to zamiast:

BigInteger agreementValue = agree.calculateAgreement(client_public_key); 
byte[] keyAgreement = BigIntegers.asUnsignedByteArray(agree.getFieldSize(), agreementValue); 

Ta wola upewnij się, że macierz o stałej wielkości jako dane wyjściowe, która jest wymagana do konwertowania elementów pola EC na ciągi oktetów (wyszukaj "Element pola do Oktetu konwersji pierwotnej", aby uzyskać więcej d etails).

Zalecam ignorowanie części wyprowadzania klucza SHA1, dopóki nie uzyskasz tablicy bajtów keyAgreement języka Java, aby dokładnie dopasować dane wejściowe do funkcji KDF1_SHA1.