Проверка результата (EC-) Диффи-Хеллмана

Итак, как я решил свою проблему:

Мои ключи в строках:

общедоступный A: co2D0pNxZJIeQ4RZlCRJYBDzNXSLluETdztid0M+HGzN1uGJ4JWZsenjWgRrmkLh3yqHQqzOBMl/wHVH97A6+g==

частный A: TXxii5Ka8LMvuc9arHu63qTmNKxGlgti+wpR3YhBGew=

общедоступный B: nUblC+OKdl94iBiWk0941wmYBiMt7C90CjOJPI2BPr8K7xGuC1XsR5DtwFCoM3Iew2BjBG+5SqrYwAPTJF7gdA==

частный B : sm6V7+hChvkFSeLNoR+5tItiX8gH5tT47xBkFaV6SDU=

Функции для получения закрытого ключа:

открытый статический PrivateKey getPrivateKey (byte [] encodedPrivateKey) {
   BigInteger s = новый BigInteger(1,encodedPrivateKey);
   ECNamedCurveParameterSpec ecCurve = ECNamedCurveTable.getParameterSpec("secp256r1");
   ECParameterSpec ecParameterSpec = new ECNamedCurveSpec("secp256r1", ecCurve.getCurve(), ecCurve.getG(), ecCurve.getN(), ecCurve.getH(), ecCurve.getSeed());
   ECPrivateKeySpec privateKeySpec = новый ECPrivateKeySpec(s, ecParameterSpec);
   пытаться {
       KeyFactory keyFactory = KeyFactory.getInstance("EC");
       вернуть keyFactory.generatePrivate(privateKeySpec);
    } поймать (NoSuchAlgorithmException | InvalidKeySpecException e) {
        e.printStackTrace();
        вернуть ноль;
   }
}

public static PublicKey rawToEncodedECPublicKey(String curveName, byte[] rawBytes) выдает NoSuchAlgorithmException, InvalidKeySpecException, InvalidParameterSpecException {
   KeyFactory kf = KeyFactory.getInstance("EC");
   byte[] x = Arrays.copyOfRange(rawBytes, 0, rawBytes.length/2);
   byte[] y = Arrays.copyOfRange(rawBytes, rawBytes.length/2, rawBytes.length);
   ECPoint w = новый ECPoint (новый BigInteger (1, x), новый BigInteger (1, y));
   return kf.generatePublic(новый ECPublicKeySpec(w, ecParameterSpecForCurve(curveName)));
}

public static java.security.spec.ECParameterSpec ecParameterSpecForCurve (String curveName) выдает NoSuchAlgorithmException, InvalidParameterSpecException {
   Параметры алгоритма params = Параметры алгоритма.getInstance("EC");
   params.init (новый ECGenParameterSpec (curveName));
   вернуть params.getParameterSpec (ECParameterSpec.class);
}

Нам нужно создать 2 пары ключей через ключи public/private в строке и проверить, равны ли они:

byte [] cle_publique_a_decode = Base64.getDecoder().decode(cle_publique_a);
byte [] cle_privee_a_decode = Base64.getDecoder().decode(cle_privee_a);
byte [] cle_publique_b_decode = Base64.getDecoder().decode(cle_publique_b);
byte [] cle_privee_b_decode = Base64.getDecoder().decode(cle_privee_b);

пытаться {
     PublicKey PublicKeyA = rawToEncodedECPublicKey("secp256r1",cle_publique_a_decode);
     PublicKey PublicKeyB = rawToEncodedECPublicKey("secp256r1",cle_publique_b_decode);

     PrivateKey PrivateKeyA = getPrivateKey(cle_privee_a_decode);
     PrivateKey PrivateKeyB = getPrivateKey(cle_privee_b_decode);

     // Секрет №1
     // PrivateKeyA + PublicKeyB = generateSecret
     KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH");
     keyAgreement.init(PrivateKeyA);
     keyAgreement.doPhase(PublicKeyB, true);
     byte[] generateSecret = keyAgreement.generateSecret();
     Строка base64_generateSecret = Base64.getEncoder().encodeToString(generateSecret);

     // Секрет №2
     // PrivateKeyB + PublicKeyA = generateSecret2
     KeyAgreement keyAgreement2 = KeyAgreement.getInstance("ECDH");
     keyAgreement.init(PrivateKeyB);
     keyAgreement.doPhase(PublicKeyA, true);
     byte[] generateSecret2 = keyAgreement.generateSecret();
     Строка base64_generateSecret2 = Base64.getEncoder().encodeToString(generateSecret);

     // сравним 2 секрета
     // (открытый ключ A + закрытый ключ B) == (открытый ключ B + закрытый ключ A)
     если (base64_generateSecret.equals (base64_generateSecret2)) {
          // Хорошо: секреты те же
          // Продолжить..
     }
     еще{
          // Плохо: секреты разные
     }
}
ловить{
     бросить новое исключение IllegalArgumentException (e.getMessage (), e);
}

Ключи равны, могу приступить к шифрованию.