Der Schlüsselplan von TLS fällt über server_handshake_traffic_secret fehl ⇐ Java

[Anonymous]

Ich erstelle einen minimalen TLS 1.3/HTTPS -Server in Java nur mit Sockets. Beim Testen mit OpenSSL wird der Serverhello akzeptiert, aber wenn es Zeit für verschlüsseltes Erweiterung fehlschlägt. Nach dem Debuggen mit der Flag -TEYLOGFILE kam ich zu dem Schluss, dass der "server_handshake_traffic_secret" auf dem Server (ME) und dem Client (OpenSSL) nicht gleich ist. Kontext, Länge, Salz gegen IKM und AAD (für AES/GCM). Ich habe dreimal alles überprüft.

Code: Select all

public static byte[] expandLabel(byte[] secret, String label, byte[] context, int length)
throws NoSuchAlgorithmException, InvalidKeyException {

// Prefix the label with "tls13 " as per TLS 1.3 spec
String fullLabel = "tls13 " + label;
byte[] labelBytes = fullLabel.getBytes(StandardCharsets.UTF_8);
byte[] contextBytes = (context != null) ? context : new byte[0];

// Total length of the label structure
int hkdfLabelLength = 2 + 1 + labelBytes.length + 1 + contextBytes.length;

if (labelBytes.length < 7 || labelBytes.length > 255) {
throw new IllegalArgumentException("Label length must be between 7 and 255 bytes");
}
if (contextBytes.length > 255) {
throw new IllegalArgumentException("Context length must be between 0 and 255 bytes");
}

ByteBuffer buffer = ByteBuffer.allocate(hkdfLabelLength);

// Set byte order to BIG_ENDIAN for TLS 1.3 spec compliance
// buffer.order(ByteOrder.BIG_ENDIAN);

// Write the output length (uint16)
buffer.putShort((short) length);

// Write the label length (uint8) and the label bytes
buffer.put((byte) labelBytes.length);
buffer.put(labelBytes);

// Write the context length (uint8) and the context bytes
buffer.put((byte) contextBytes.length);
buffer.put(contextBytes);

byte[] hkdfLabel = buffer.array();
return expand(secret, hkdfLabel, length);
}

ecdh/sharedSecret.

Code: Select all

NamedParameterSpec paramSpec = new NamedParameterSpec("X25519");
ECGenParameterSpec ecSpec = new ECGenParameterSpec("X25519");

KeyFactory kf = KeyFactory.getInstance("X25519");
XECPublicKeySpec clientPublicKeySpec = new XECPublicKeySpec(paramSpec,
new BigInteger(1, clientPubKey));
XECPublicKey clientPublicKey = (XECPublicKey) kf.generatePublic(clientPublicKeySpec);

XECPrivateKey secretKey = (XECPrivateKey) key.getPrivate();

KeyAgreement ka = KeyAgreement.getInstance("X25519");
ka.init(secretKey);
ka.doPhase(clientPublicKey, true);
byte[] sharedSecret = ka.generateSecret();
< /code>
Schlüsselplan.KeySchedule ks = new KeySchedule();

ks.early_secret = HKDF.extract(HKDF.zeros, HKDF.zeros);
System.out.println("early_serect: " + Hex.toHexString(ks.early_secret) + " zeros length "+ HKDF.zeros.length);
ks.derived_secret = HKDF.expandLabel(ks.early_secret, "derived", null, 32);

ks.handshake_secret = HKDF.extract(ks.derived_secret, sharedSecret);
// ks.handshake_secret = HKDF.extract(sharedSecret, ks.derived_secret);

ks.server_handshake_traffic_secret = HKDF.expandLabel(ks.handshake_secret, "s hs traffic",trascriptHash, 32);// 
Ich habe eine einfache Implementierung von HKDF (extrahieren und erweitert) unter Verwendung von Bouncy Castle HMAC und mit dem ersten Testfall aus dem RFC5869 getestet.  Testfall nicht hier, sondern arbeiten.public static byte[] extract(byte[] salt, byte[] ikm)
throws NoSuchAlgorithmException, InvalidKeyException {
if (salt == null || salt.length == 0) {
// If salt is not provided, use a string of HashLen zeros
salt = new byte[32]; // 32 for SHA-256
}

Mac mac = Mac.getInstance(HMAC_ALGORITHM);
mac.init(new SecretKeySpec(salt, HMAC_ALGORITHM));
return mac.doFinal(ikm); // PRK
}

// HKDF-Expand(PRK, info, length)
public static byte[] expand(byte[] prk, byte[] info, int outputLength)
throws NoSuchAlgorithmException, InvalidKeyException {
int hashLen = 32; // for SHA-256
int n = (int) Math.ceil((double) outputLength / hashLen);
if (n > 255) {
throw new IllegalArgumentException("Cannot expand to more than 255 blocks");
}

byte[] okm = new byte[outputLength];
byte[] previousT = new byte[0];
Mac mac = Mac.getInstance(HMAC_ALGORITHM);
mac.init(new SecretKeySpec(prk, HMAC_ALGORITHM));

int offset = 0;
for (int i = 1; i