Clanker review.

Author: ZeroIntensity

Lib/test/test_ssl.py

@@ -2114,6 +2114,15 @@ def test_set_ech_config(self):
                 self.assertRaises(ssl.SSLError, ctx.set_ech_config, config)
         self.assertIsNone(ctx.set_ech_config(self.ECH_CONFIG))
 
+    @unittest.skipUnless(ssl.HAS_ECH, 'requires ECH')
+    def test_mixed_ech_config_versions(self):
+        ctx = make_test_context()
+        supported = self.ECH_CONFIG[2:]
+        unsupported = b'\xff\xff\x00\x01\x00'
+        for entries in (unsupported + supported, supported + unsupported):
+            config = len(entries).to_bytes(2, 'big') + entries
+            self.assertIsNone(ctx.set_ech_config(config))
+
     @unittest.skipUnless(ssl.HAS_ECH, 'requires ECH')
     def test_status_before_handshake(self):
         ctx = make_test_context()
@@ -2168,6 +2177,19 @@ def test_outer_alpn_does_not_replace_inner(self):
         self.assertEqual(client.selected_alpn_protocol(), 'h2')
         self.assertEqual(server.selected_alpn_protocol(), 'h2')
 
+    @unittest.skipUnless(ssl.HAS_ECH, 'requires ECH')
+    def test_outer_alpn_without_ech_config(self):
+        for options in (0, ssl.OP_ECH_GREASE):
+            client_ctx, server_ctx, hostname = testing_context()
+            client_ctx.options |= options
+            client_ctx.set_alpn_protocols(['h2'])
+            client_ctx.set_outer_alpn_protocols(['http/1.1'])
+            server_ctx.set_alpn_protocols(['h2', 'http/1.1'])
+            client, server, *_ = connected_bio_pair(
+                client_ctx, server_ctx, hostname)
+            self.assertEqual(client.selected_alpn_protocol(), 'h2')
+            self.assertEqual(server.selected_alpn_protocol(), 'h2')
+
     @unittest.skipUnless(ssl.HAS_ECH, 'requires ECH')
     def test_grease(self):
         client_ctx, server_ctx, hostname = testing_context()

Modules/_ssl.c

@@ -942,6 +942,23 @@ newPySSLSocket(PySSLContext *sslctx, PySocketSockObject *sock,
         return NULL;
     }
 
+#ifdef HAVE_OPENSSL_ECH
+    if (socket_type == PY_SSL_CLIENT) {
+        char *inner_sni = NULL, *outer_sni = NULL;
+        int status = SSL_ech_get1_status(self->ssl, &inner_sni, &outer_sni);
+        OPENSSL_free(inner_sni);
+        OPENSSL_free(outer_sni);
+        /* OpenSSL also applies outer ALPN to ordinary and GREASE handshakes. */
+        if ((status == SSL_ECH_STATUS_NOT_CONFIGURED ||
+             status == SSL_ECH_STATUS_GREASE) &&
+            SSL_ech_set1_outer_alpn_protos(self->ssl, NULL, 0) != 1) {
+            _setSSLError(get_state_ctx(sslctx), NULL, 0, __FILE__, __LINE__);
+            Py_DECREF(self);
+            return NULL;
+        }
+    }
+#endif
+
     if (socket_type == PY_SSL_SERVER) {
 #define SID_CTX "Python"
         /* Set the session id context (server-side only) */
@@ -5220,10 +5237,35 @@ _ssl__SSLContext_set_ech_config_impl(PySSLContext *self,
         return NULL;
     }
     OSSL_ECHSTORE *store = NULL;
-    BIO *config_bio = BIO_new_mem_buf(ech_config->buf, ech_config->len);
+    BIO *config_bio = BIO_new(BIO_s_mem());
     if (config_bio == NULL) {
         goto fail;
     }
+    const unsigned char *config = ech_config->buf;
+    int config_len = (int)ech_config->len;
+    if (config_len >= 2 && ((config[0] << 8) | config[1]) == config_len - 2) {
+        config += 2;
+        config_len -= 2;
+        /* OpenSSL only recognizes binary input with a supported first entry. */
+        while (config_len >= 4 &&
+               ((config[0] << 8) | config[1]) != OSSL_ECH_RFC9849_VERSION) {
+            int entry_len = 4 + ((config[2] << 8) | config[3]);
+            if (entry_len > config_len) {
+                break;
+            }
+            config += entry_len;
+            config_len -= entry_len;
+        }
+        unsigned char length[2] = {
+            (unsigned char)(config_len >> 8), (unsigned char)config_len
+        };
+        if (BIO_write(config_bio, length, sizeof(length)) != sizeof(length)) {
+            goto fail;
+        }
+    }
+    if (BIO_write(config_bio, config, config_len) != config_len) {
+        goto fail;
+    }
     store = OSSL_ECHSTORE_new(NULL, NULL);
     if (store == NULL) {
         goto fail;