Make recording the selected credential opt-in per context and store the id in existing padding

Author: Alex Choulos

boringssl-static/src/test/java/io/netty/internal/tcnative/SSLCredentialIdTest.java

@@ -61,6 +61,7 @@ public void newCredentialsHavePositiveDistinctIds() throws Exception {
     public void freshSslHasNoSelectedCredentialId() throws Exception {
         long ctx = SSLContext.make(SSL.SSL_PROTOCOL_TLSV1_2, SSL.SSL_MODE_SERVER);
         try {
+            SSLContext.setRecordSelectedCredential(ctx, true);
             long ssl = SSL.newSSL(ctx, true);
             try {
                 assertEquals(0, SSL.getSelectedCredentialId(ssl));

openssl-classes/src/main/java/io/netty/internal/tcnative/SSL.java

@@ -1011,9 +1011,10 @@ public static AsyncTask getAsyncTask(long ssl) {
      * <p>Returns:
      * <ul>
      *   <li>during a handshake that has already selected a credential, the id of that credential;</li>
-     *   <li>otherwise, the id recorded by the most recent completed handshake;</li>
-     *   <li>{@code 0} when no credential was selected, when the credential came from a legacy API, or when no
-     *   handshake has completed yet.</li>
+     *   <li>otherwise, the id recorded by the most recent completed handshake, if
+     *   {@link SSLContext#setRecordSelectedCredential(long, boolean)} is enabled;</li>
+     *   <li>{@code 0} when no credential was selected, when the credential came from a legacy API, when recording is
+     *   disabled, or when no handshake has completed yet.</li>
      * </ul>
      *
      * <p>This is a BoringSSL-specific feature.</p>

openssl-classes/src/main/java/io/netty/internal/tcnative/SSLContext.java

@@ -683,6 +683,17 @@ public static void setAlpnProtos(long ctx, String[] alpnProtos, int selectorFail
      */
     public static native void setUseTasks(long ctx, boolean useTasks);
 
+    /**
+     * Enable or disable recording the credential selected by each completed handshake, so that it can be obtained
+     * via {@link SSL#getSelectedCredentialId(long)} after the handshake. Disabled by default.
+     *
+     * <p>This only has an effect when using BoringSSL.</p>
+     *
+     * @param ctx context to use
+     * @param record {@code true} to enable, {@code false} to disable.
+     */
+    public static native void setRecordSelectedCredential(long ctx, boolean record);
+
     /**
      * Adds a certificate compression algorithm to the given {@link SSLContext} or throws an
      * exception if certificate compression is not supported or the algorithm not recognized.

openssl-dynamic/src/main/c/ssl_private.h

@@ -389,6 +389,7 @@ struct tcn_ssl_ctxt_t {
     unsigned char            context_id[SHA_DIGEST_LENGTH];
 
     int                      use_tasks;
+    int                      record_selected_credential;
 };
 
 // Store the callback to run and also if it was consumed via SSL.getTask(...).
@@ -404,16 +405,15 @@ void tcn_ssl_task_free(JNIEnv*, tcn_ssl_task_t*);
 typedef struct tcn_ssl_state_t tcn_ssl_state_t;
 struct tcn_ssl_state_t {
     int handshakeCount;
+    // Fills the padding before ctx so recording the selected credential adds no per-connection memory.
+    apr_uint32_t selected_credential_id;
     tcn_ssl_ctxt_t *ctx;
     tcn_ssl_task_t* ssl_task;
     tcn_ssl_verify_config_t verify_config;
     // Saved at async task creation time so the retry path can reproduce the
     // len < sk_CRYPTO_BUFFER_num(chain) check (both locals are 0/NULL there).
     int task_array_len;
     int task_chain_num;
-#ifdef OPENSSL_IS_BORINGSSL
-    jlong selected_credential_id;
-#endif
 };
 
 #define TCN_GET_SSL_CTX(ssl, C)                             \

openssl-dynamic/src/main/c/sslcontext.c

@@ -194,8 +194,9 @@ static void ssl_info_callback(const SSL *ssl, int where, int ret) {
     if (0 != (where & SSL_CB_HANDSHAKE_DONE)) {
         // BoringSSL frees the handshake state (and its selected credential) before SSL_do_handshake returns,
         // so record the selection here. Assign unconditionally so a later handshake without one clears it.
-        if ((state = tcn_SSL_get_app_state(ssl)) != NULL) {
-            state->selected_credential_id = tcn_SSL_CREDENTIAL_get_id(SSL_get0_selected_credential(ssl));
+        if ((state = tcn_SSL_get_app_state(ssl)) != NULL && state->ctx->record_selected_credential != 0) {
+            state->selected_credential_id =
+                    (apr_uint32_t) tcn_SSL_CREDENTIAL_get_id(SSL_get0_selected_credential(ssl));
         }
     }
 #endif
@@ -2917,6 +2918,14 @@ TCN_IMPLEMENT_CALL(void, SSLContext, setUseTasks)(TCN_STDARGS, jlong ctx, jboole
     c->use_tasks = useTasks == JNI_TRUE ? 1 : 0;
 }
 
+TCN_IMPLEMENT_CALL(void, SSLContext, setRecordSelectedCredential)(TCN_STDARGS, jlong ctx, jboolean record) {
+    tcn_ssl_ctxt_t *c = J2P(ctx, tcn_ssl_ctxt_t *);
+
+    TCN_CHECK_NULL(c, ctx, /* void */);
+
+    c->record_selected_credential = record == JNI_TRUE ? 1 : 0;
+}
+
 
 TCN_IMPLEMENT_CALL(jboolean, SSLContext, setCurvesList0)(TCN_STDARGS, jlong ctx, jstring curves) {
     tcn_ssl_ctxt_t *c = J2P(ctx, tcn_ssl_ctxt_t *);
@@ -3113,6 +3122,7 @@ static const JNINativeMethod fixed_method_table[] = {
   { TCN_METHOD_TABLE_ENTRY(disableOcsp, (J)V, SSLContext) },
   { TCN_METHOD_TABLE_ENTRY(getSslCtx, (J)J, SSLContext) },
   { TCN_METHOD_TABLE_ENTRY(setUseTasks, (JZ)V, SSLContext) },
+  { TCN_METHOD_TABLE_ENTRY(setRecordSelectedCredential, (JZ)V, SSLContext) },
   { TCN_METHOD_TABLE_ENTRY(setNumTickets, (JI)Z, SSLContext) },
   { TCN_METHOD_TABLE_ENTRY(setCurvesList0, (JLjava/lang/String;)Z, SSLContext) },
   { TCN_METHOD_TABLE_ENTRY(setMaxCertList, (JI)V, SSLContext) },