Source code
package io.netty.handler.codec.quic;
import io.netty.util.concurrent.FastThreadLocal;
import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.ByteBuffer;
import java.security.InvalidKeyException;
import java.security.NoSuchAlgorithmException;
import java.security.SecureRandom;
import java.util.Arrays;
final class Hmac {
private static final String ALGORITHM = "HmacSHA256";
// Two independent keys so that CID signing and reset-token signing are
// cryptographically decoupled: an observer cannot derive one output from
// the other even when both use the same input value (RFC 9000 §21.11).
private static final byte[] CID_KEY = new byte[32];
private static final byte[] TOKEN_KEY = new byte[32];
static {
SecureRandom rng = new SecureRandom();
rng.nextBytes(CID_KEY);
rng.nextBytes(TOKEN_KEY);
}
private static final FastThreadLocal<Mac> CID_MACS = new FastThreadLocal<Mac>() {
@Override
protected Mac initialValue() {
return newMac(CID_KEY);
}
};
private static final FastThreadLocal<Mac> TOKEN_MACS = new FastThreadLocal<Mac>() {
@Override
protected Mac initialValue() {
return newMac(TOKEN_KEY);
}
};
private static Mac newMac(byte[] key) {
try {
Mac mac = Mac.getInstance(ALGORITHM);
mac.init((new SecretKeySpec(key, ALGORITHM)));
return mac;
} catch (NoSuchAlgorithmException | InvalidKeyException exception) {
throw new IllegalStateException(exception);
}
}
private static ByteBuffer sign(Mac mac, ByteBuffer input, int outLength) {
mac.reset();
mac.update(input);
byte[] signBytes = mac.doFinal();
if (signBytes.length != outLength) {
signBytes = Arrays.copyOf(signBytes, outLength);
}
return ByteBuffer.wrap(signBytes);
}
static ByteBuffer signCid(ByteBuffer input, int outLength) {
return sign(CID_MACS.get(), input, outLength);
}
static ByteBuffer signToken(ByteBuffer input, int outLength) {
return sign(TOKEN_MACS.get(), input, outLength);
}
private Hmac() { }
}
Run 1
The code is well-structured and highly readable. It has a clear purpose, sensible organization with static initialization, and good use of named constants. The nested anonymous classes for FastThreadLocal are only one level deep, keeping nesting shallow. Each action is generally one per line, and the reading flow is logical. Comments explain the rationale for two separate keys, enhancing clarity. The only minor deductions are for the unnecessary parentheses around the SecretKeySpec argument and a slightly redundant length check in sign (since HMAC-SHA256 always produces 32 bytes, but the flexibility is justified if callers request shorter outputs). Overall, concise and maintainable.
Run 2
The code is well-structured with clear separation between key initialization, MAC creation, and signing logic. Nesting is minimal, with only one try-catch block and straightforward conditionals. Intent is explicitly documented through comments explaining the cryptographic decoupling of two keys. The class is concise, avoiding unnecessary length while maintaining clarity. Action granularity is generally one action per line, though some lines could be split for even better readability. Reading flow is natural: static fields, initialization, utilities, then public methods. Minor improvements could include extracting the catch block error handling or adding a comment for the outLength truncation logic, but overall the code demonstrates high readability with proper encapsulation and clear naming conventions.
Run 3
The code is well-structured with clear separation of concern (key management, Mac creation, signing logic). It maintains flat nesting and clean helpers. Naming conventions are descriptive (CID_KEY, TOKEN_KEY, signCid, signToken). The static initialization and FastThreadLocal usage are straightforward. Comments explain the cryptographic rationale for two separate keys. One minor issue is the blank line after try, which slightly disrupts the visual flow. Also, the unused import 'java.util.Arrays' is present, but it's actually used in sign() for copying. The sign() method is concise with clear action granularity. Overall, highly readable with good intent clarity.
Run 1
Code Structure: Well-organized constants, key initialization, thread-local instances, shared helpers, and purpose-specific entry points. Nesting: Shallow, with only simple anonymous classes, a try/catch, and one conditional. Clarity of intent: Descriptive names and a useful security comment clearly distinguish CID signing from token signing; however, consuming the input buffer and padding outputs beyond the digest length are not documented. Code length: Concise overall, with minor duplication in thread-local initialization and redundant parentheses. Action granularity: Each statement performs a single clear operation. Reading flow: Natural progression from configuration to implementation to entry points, slightly interrupted by an unnecessary blank line and minor formatting inconsistencies.
Run 2
Code Structure: Constants, key initialization, thread-local instances, helpers, and public-facing operations are logically grouped. Nesting: Shallow try/catch and a single conditional keep complexity low. Clarity of intent: Descriptive names and the key-separation comment clearly explain the purpose; however, sign consumes the input buffer and may truncate or pad output without documenting these behaviors. Code length: Concise overall, with minor duplication in the thread-local declarations. Action granularity: Each line generally performs one clear operation. Reading flow: Initialization leads naturally into shared helpers and signing entry points. Minor formatting issues, including an empty line inside try, redundant parentheses, and tight package/import spacing, slightly reduce polish.
Run 3
Code Structure: Constants, key initialization, thread-local MAC instances, shared helpers, and signing entry points are logically organized. Nesting: Shallow nesting is limited to initialization overrides, a try/catch, and one conditional. Clarity of intent: Descriptive names and the key-separation comment clearly explain the purpose; input buffer consumption and output truncation or padding are not explicitly documented. Code length: Compact, with shared helpers avoiding substantial duplication. Action granularity: Each statement performs a single clear operation. Reading flow: Natural progression from setup to implementation to public-facing package-level methods. Minor formatting distractions include an extra blank line, redundant parentheses around SecretKeySpec construction, and inconsistent spacing.