Deci, așa mi-am rezolvat problema:
Cheile mele în șiruri:
public A : co2D0pNxZJIeQ4RZlCRJYBDzNXSLluETdztid0M+HGzN1uGJ4JWZsenjWgRrmkLh3yqHQqzOBMl/wHVH97A6+g==
privat A : TXxii5Ka8LMvuc9arHu63qTmNKxGlgti+wpR3YhBGew=
public B : nUblC+OKdl94iBiWk0941wmYBiMt7C90CjOJPI2BPr8K7xGuC1XsR5DtwFCoM3Iew2BjBG+5SqrYwAPTJF7gdA==
privat B : sm6V7+hChvkFSeLNoR+5tItiX8gH5tT47xBkFaV6SDU=
Funcții pentru a obține cheia privată:
public static PrivateKey getPrivateKey(byte[] encodedPrivateKey) {
BigInteger s = nou BigInteger(1,codedPrivateKey);
ECNamedCurveParameterSpec ecCurve = ECNamedCurveTable.getParameterSpec("secp256r1");
ECParameterSpec ecParameterSpec = ECNamedCurveSpec nou("secp256r1", ecCurve.getCurve(), ecCurve.getG(), ecCurve.getN(), ecCurve.getH(), ecCurve.getSeed());
ECPrivateKeySpec privateKeySpec = ECPrivateKeySpec nou(e, ecParameterSpec);
încerca {
KeyFactory keyFactory = KeyFactory.getInstance("EC");
return keyFactory.generatePrivate(privateKeySpec);
} catch (NoSuchAlgorithmException | InvalidKeySpecException e) {
e.printStackTrace();
returnează nul;
}
}
public static PublicKey rawToEncodedECPublicKey(String curveName, byte[] rawBytes) aruncă 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 = nou ECPoint(new BigInteger(1,x), new BigInteger(1,y));
returnează kf.generatePublic(new ECPublicKeySpec(w, ecParameterSpecForCurve(curveName)));
}
public static java.security.spec.ECParameterSpec ecParameterSpecForCurve(String curveName) aruncă NoSuchAlgorithmException, InvalidParameterSpecException {
AlgorithmParameters params = AlgorithmParameters.getInstance("EC");
params.init(new ECGenParameterSpec(curveName));
return params.getParameterSpec(ECParameterSpec.class);
}
Trebuie să creăm 2 perechi de chei prin chei publice/private în șir și să verificăm dacă ambele sunt egale:
byte [] cle_publique_a_decode = Base64.getDecoder().decode(cle_publique_a);
octet [] cle_privee_a_decode = Base64.getDecoder().decode(cle_privee_a);
byte [] cle_publique_b_decode = Base64.getDecoder().decode(cle_publique_b);
octet [] cle_privee_b_decode = Base64.getDecoder().decode(cle_privee_b);
încerca {
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);
// Secretul #1
// PrivateKeyA + PublicKeyB = generateSecret
KeyAgreement keyAgreement = KeyAgreement.getInstance("ECDH");
keyAgreement.init(PrivateKeyA);
keyAgreement.doPhase(PublicKeyB, true);
byte[] generateSecret = keyAgreement.generateSecret();
String base64_generateSecret = Base64.getEncoder().encodeToString(generateSecret);
// Secretul #2
// PrivateKeyB + PublicKeyA = generateSecret2
KeyAgreement keyAgreement2 = KeyAgreement.getInstance("ECDH");
keyAgreement.init(PrivateKeyB);
keyAgreement.doPhase(PublicKeyA, true);
byte[] generateSecret2 = keyAgreement.generateSecret();
String base64_generateSecret2 = Base64.getEncoder().encodeToString(generateSecret);
// compara 2 secrete
// (cheie publică A + cheie privată B) == (cheie publică B + cheie privată A)
if(base64_generateSecret.equals(base64_generateSecret2)){
// Bine: Secretele sunt aceleași
// continua..
}
altfel{
// Nu este bine: Secretele sunt diferite
}
}
captură{
aruncă o nouă excepție IllegalArgumentException(e.getMessage(), e);
}
Cheile sunt egale, pot începe să criptez.