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 well-structured as an interface with clear constants and method signatures. It is flat with no nesting, concise, and each constant declaration occupies its own line. Javadocs explain intent for both methods. Minor deductions: the class-level comment has a grammatical issue ('Allow to customize') and constant alignment could improve readability, but overall clarity is high.
Run 3
The code is highly readable with clear structure, flat (no deep nesting), and explicit intent. Constants are grouped logically, and method contracts are well-documented with Javadoc. The interface is concise yet complete, avoiding unnecessary complexity. Each line serves a clear purpose, and the reading flow is natural, from constants to method definitions. The only minor drawback might be the long constant names, but they are standardized and self-explanatory.
Run 1
Code Structure: Logically organized into imports, interface documentation, algorithm constants, and two method declarations. Nesting: Flat, with no nested control flow. Clarity of intent: Descriptive names and Javadoc clearly explain signing and decryption, though 'given key' is implicit and 'atm' is informal. Code length: Concise for an interface; repeated constant aliases are appropriate but visually dense. Action granularity: Each constant and method declaration occupies its own line. Reading flow: Natural top-to-bottom progression, slightly weakened by missing spacing around imports and the ungrouped block of algorithm constants.
Run 2
Code Structure: The interface is logically organized into imports, algorithm constants, and two documented method declarations. Nesting: Completely flat apart from the interface boundary. Clarity of intent: Descriptive constant and method names plus parameter and return documentation make the API easy to understand; the introductory RSA wording is slightly ambiguous given the non-RSA signing constants. Code length: Concise overall, with necessary repetition in the constant aliases and useful documentation. Action granularity: Each line contains a single declaration, with no combined operations. Reading flow: Constants precede methods naturally, and consistent formatting supports scanning. Minor improvements include separating the package declaration from imports and visually grouping constants by algorithm family.
Run 3
Code Structure: Logically organized into imports, algorithm constants, and documented method declarations. Nesting: Flat interface with no nested control flow. Clarity of intent: Descriptive names and Javadoc clearly communicate signing and decryption responsibilities, although the introductory RSA qualifier is slightly ambiguous and 'atm' is informal. Code length: Concise for the API exposed; repetitive constant aliases are justified but visually dense. Action granularity: Each constant and method declaration occupies its own line, making individual elements easy to identify. Reading flow: Natural progression from supported algorithms to operations, with consistent formatting; blank lines between import groups and logical constant groups would improve scanning.