Source code
package io.netty.handler.ssl;
import io.netty.internal.tcnative.SSLPrivateKeyMethod;
import io.netty.util.internal.UnstableApi;
import javax.net.ssl.SSLEngine;
/**
* Allow to customize private key signing / decrypting (when using RSA). Only supported when using BoringSSL atm.
*/
@UnstableApi
public interface OpenSslPrivateKeyMethod {
int SSL_SIGN_RSA_PKCS1_SHA1 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA1;
int SSL_SIGN_RSA_PKCS1_SHA256 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA256;
int SSL_SIGN_RSA_PKCS1_SHA384 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA384;
int SSL_SIGN_RSA_PKCS1_SHA512 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_SHA512;
int SSL_SIGN_ECDSA_SHA1 = SSLPrivateKeyMethod.SSL_SIGN_ECDSA_SHA1;
int SSL_SIGN_ECDSA_SECP256R1_SHA256 = SSLPrivateKeyMethod.SSL_SIGN_ECDSA_SECP256R1_SHA256;
int SSL_SIGN_ECDSA_SECP384R1_SHA384 = SSLPrivateKeyMethod.SSL_SIGN_ECDSA_SECP384R1_SHA384;
int SSL_SIGN_ECDSA_SECP521R1_SHA512 = SSLPrivateKeyMethod.SSL_SIGN_ECDSA_SECP521R1_SHA512;
int SSL_SIGN_RSA_PSS_RSAE_SHA256 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA256;
int SSL_SIGN_RSA_PSS_RSAE_SHA384 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA384;
int SSL_SIGN_RSA_PSS_RSAE_SHA512 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PSS_RSAE_SHA512;
int SSL_SIGN_ED25519 = SSLPrivateKeyMethod.SSL_SIGN_ED25519;
int SSL_SIGN_RSA_PKCS1_MD5_SHA1 = SSLPrivateKeyMethod.SSL_SIGN_RSA_PKCS1_MD5_SHA1;
/**
* Signs the input with the given key and returns the signed bytes.
*
* @param engine the {@link SSLEngine}
* @param signatureAlgorithm the algorithm to use for signing
* @param input the digest itself
* @return the signed data (must not be {@code null})
* @throws Exception thrown if an error is encountered during the signing
*/
byte[] sign(SSLEngine engine, int signatureAlgorithm, byte[] input) throws Exception;
/**
* Decrypts the input with the given key and returns the decrypted bytes.
*
* @param engine the {@link SSLEngine}
* @param input the input which should be decrypted
* @return the decrypted data (must not be {@code null})
* @throws Exception thrown if an error is encountered during the decrypting
*/
byte[] decrypt(SSLEngine engine, byte[] input) throws Exception;
}
Run 1
The code is well-structured as a concise interface definition. Constants are logically grouped and consistently formatted, though the list is long. The interface avoids unnecessary nesting and has a clear purpose: defining a custom private key method for SSL operations. Method signatures are concise with clear parameter names and return types. Javadoc comments effectively document intent and behavior. Reading flow is natural, with constants first, then methods, and clear documentation separating them. Minor deductions result from repetitive constant declarations and slight verbosity in Javadoc, but overall readability is high.
Run 2
The code is highly readable. It has a clear, logical structure: package declaration, imports, Javadoc, interface declaration, constants, and two method signatures with descriptive Javadocs. There is no nesting, and each constant is on its own line, maintaining good action granularity. The intent is explicit — an interface for customizing private key operations with SSL. The code is concise but appropriately verbose where needed, especially in Javadocs. Reading flow is natural, with constants grouped by type and methods clearly separated. Minor deductions for the long constant lines and redundant repetition of the 'SSLPrivateKeyMethod' prefix, but overall this is exceptionally clean and well-documented.
Run 3
The code is highly readable. The structure is logical: imports, interface declaration, constants, and method signatures follow a clear pattern. Nesting is nearly non-existent (just one level). Intent is clear—the Javadoc explains the interface's purpose, and method comments clarify parameters and return values. The constants are repetitive but that's necessary for interoperability; the flat list is concise, though grouping by algorithm family could slightly improve scannability. Each line contains one action. The overall flow—constants, then sign, then decrypt—is natural. The only minor issue is the long list of constants without grouping comments.
Run 1
Code Structure: Logically organized into imports, algorithm constants, and two documented methods. Nesting: Flat interface declarations with no nested control flow. Clarity of intent: Descriptive constant and method names plus parameter documentation make the purpose clear, although references to a 'given key' leave key selection implicit. Code length: Concise for the exposed API; the repetitive constants are appropriate but visually dense. Action granularity: Each constant or method declaration occupies its own line. Reading flow: Natural progression from supported algorithms to signing and decryption operations. Minor improvements include spacing between package and imports, grouping constants by algorithm family, and replacing informal or awkward documentation wording such as 'atm' and 'during the decrypting'.
Run 2
Code Structure: Clearly organized interface with imports, algorithm constants, and two documented method declarations. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive names and Javadoc make signing and decryption responsibilities clear, though the introductory RSA qualifier is ambiguous and 'atm' is informal. Code length: Concise for its purpose; repeated constant mappings are justified but visually dense. Action granularity: Each constant and method declaration occupies its own line. Reading flow: Natural progression from supported algorithms to operations, with helpful spacing between methods. Blank lines after the package declaration and between constant families would improve scanning.
Run 3
Code Structure: Clearly organized interface with imports, algorithm constants, and two documented method declarations. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive constant and method names plus parameter documentation make signing and decryption responsibilities clear; the introductory wording is slightly awkward, and key selection is implicit. Code length: Concise for the exposed API, although the repetitive constant list occupies much of the code. Action granularity: Each constant and method declaration appears on its own line. Reading flow: Natural progression from supported algorithms to operations, with consistent formatting; blank lines between import groups and logical constant groups would improve scanning.