diff --git a/include/openssl/prefix_symbols.h b/include/openssl/prefix_symbols.h
index 317d396..9175ce2 100644
--- a/include/openssl/prefix_symbols.h
+++ b/include/openssl/prefix_symbols.h
@@ -1879,6 +1879,7 @@
 #pragma redefine_extname SSL_COMP_get_compression_methods BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_COMP_get_compression_methods)
 #pragma redefine_extname SSL_COMP_get_id BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_COMP_get_id)
 #pragma redefine_extname SSL_COMP_get_name BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_COMP_get_name)
+#pragma redefine_extname SSL_CREDENTIAL_add1_trust_anchor_group_inclusion BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_CREDENTIAL_add1_trust_anchor_group_inclusion)
 #pragma redefine_extname SSL_CREDENTIAL_dup_ref BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_CREDENTIAL_dup_ref)
 #pragma redefine_extname SSL_CREDENTIAL_free BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_CREDENTIAL_free)
 #pragma redefine_extname SSL_CREDENTIAL_get_ex_data BORINGSSL_ADD_USER_LABEL_AND_PREFIX(SSL_CREDENTIAL_get_ex_data)
@@ -4999,6 +5000,7 @@
 #define SSL_COMP_get_compression_methods BORINGSSL_ADD_PREFIX(SSL_COMP_get_compression_methods)
 #define SSL_COMP_get_id BORINGSSL_ADD_PREFIX(SSL_COMP_get_id)
 #define SSL_COMP_get_name BORINGSSL_ADD_PREFIX(SSL_COMP_get_name)
+#define SSL_CREDENTIAL_add1_trust_anchor_group_inclusion BORINGSSL_ADD_PREFIX(SSL_CREDENTIAL_add1_trust_anchor_group_inclusion)
 #define SSL_CREDENTIAL_dup_ref BORINGSSL_ADD_PREFIX(SSL_CREDENTIAL_dup_ref)
 #define SSL_CREDENTIAL_free BORINGSSL_ADD_PREFIX(SSL_CREDENTIAL_free)
 #define SSL_CREDENTIAL_get_ex_data BORINGSSL_ADD_PREFIX(SSL_CREDENTIAL_get_ex_data)
diff --git a/include/openssl/ssl.h b/include/openssl/ssl.h
index 5c6d17a..64806d2 100644
--- a/include/openssl/ssl.h
+++ b/include/openssl/ssl.h
@@ -856,8 +856,8 @@
                                                      CRYPTO_BUFFER *ocsp);
 
 // SSL_CREDENTIAL_set1_certificate_properties parses
-// `certificate_property_list` as a CertificatePropertyList (see Section 6 of
-// draft-ietf-tls-trust-anchor-ids-00) and applies recognized properties to
+// `certificate_property_list` as a CertificatePropertyList (see Section 7 of
+// draft-ietf-tls-trust-anchor-ids-04) and applies recognized properties to
 // `cred`. It returns one on success and zero on error. It is an error if
 // `certificate_property_list` does not parse correctly, or if any recognized
 // properties from `certificate_property_list` cannot be applied to `cred`.
@@ -868,7 +868,9 @@
 // logic, without requiring application changes for each property defined.
 //
 // BoringSSL currently supports the following properties:
-// * trust_anchor_identifier (see `SSL_CREDENTIAL_set1_trust_anchor_id`)
+// * trust_anchor_id (see `SSL_CREDENTIAL_set1_trust_anchor_id`)
+// * trust_anchor_group_inclusions (see
+//   `SSL_CREDENTIAL_add1_trust_anchor_group_inclusion`)
 //
 // Note this function does not automatically enable issuer matching. Callers
 // must separately call `SSL_CREDENTIAL_set_must_match_issuer` if desired.
@@ -3245,19 +3247,29 @@
 // SSL_CREDENTIAL_set1_trust_anchor_id sets `cred`'s trust anchor ID to `id`, or
 // clears it if `id_len` is zero. It returns one on success and zero on
 // error. If not clearing, `id` must be in binary format (Section 3 of
-// draft-ietf-tls-trust-anchor-ids-00) of length `id_len`, and describe the
+// draft-ietf-tls-trust-anchor-ids-04) of length `id_len`, and describe the
 // issuer of the final certificate in `cred`'s certificate chain.
 //
 // Additionally, `cred` must enable issuer matching (see
 // `SSL_CREDENTIAL_set_must_match_issuer`) for this value to take effect.
 //
-// For better extensibility, callers are recommended to configure this
-// information with a CertificatePropertyList instead. See
-// `SSL_CREDENTIAL_set1_certificate_properties`.
+// For extensibility, callers are recommended to configure this information with
+// a CertificatePropertyList. See `SSL_CREDENTIAL_set1_certificate_properties`.
 OPENSSL_EXPORT int SSL_CREDENTIAL_set1_trust_anchor_id(SSL_CREDENTIAL *cred,
                                                        const uint8_t *id,
                                                        size_t id_len);
 
+// SSL_CREDENTIAL_add1_trust_anchor_group_inclusion specifies that `cred`
+// matches all trust anchor IDs equal to `base` followed some component between
+// `min` and `max`, inclusive. It returns one on success and zero on error. This
+// function may be called multiple times to register multiple group inclusions.
+//
+// For extensibility, callers are recommended to configure this information with
+// a CertificatePropertyList. See `SSL_CREDENTIAL_set1_certificate_properties`.
+OPENSSL_EXPORT int SSL_CREDENTIAL_add1_trust_anchor_group_inclusion(
+    SSL_CREDENTIAL *cred, const uint8_t *base, size_t base_len, uint64_t min,
+    uint64_t max);
+
 // SSL_CTX_set1_requested_trust_anchors configures `ctx` to request a
 // certificate issued by one of the trust anchors in `ids`. It returns one on
 // success and zero on error. `ids` must be a list of trust anchor IDs in
@@ -3265,10 +3277,10 @@
 //
 // The list may describe application's full list of supported trust anchors, or
 // a, possibly empty, subset. Applications can select this subset using
-// out-of-band information, such as the DNS hint in Section 5 of
-// draft-ietf-tls-trust-anchor-ids-00. Client applications sending a subset
+// out-of-band information, such as the DNS hint in Section 6 of
+// draft-ietf-tls-trust-anchor-ids-04. Client applications sending a subset
 // should use `SSL_get0_peer_available_trust_anchors` to implement the retry
-// flow from Section 4.3 of draft-ietf-tls-trust-anchor-ids-00.
+// flow from Section 4.3 of draft-ietf-tls-trust-anchor-ids-04.
 //
 // If empty (`ids_len` is zero), the trust_anchors extension will still be sent
 // in ClientHello. This may be used by a client application to signal support
@@ -3307,7 +3319,7 @@
 // This value is only available during the handshake and is expected to be
 // called in the event of certificate verification failure. Client applications
 // can use it to retry the connection, requesting different trust anchors. See
-// Section 4.3 of draft-ietf-tls-trust-anchor-ids-00 for details.
+// Section 4.3 of draft-ietf-tls-trust-anchor-ids-04 for details.
 // `CBS_get_u8_length_prefixed` may be used to iterate over the format.
 //
 // If needed in other contexts, callers may save the value during certificate
diff --git a/ssl/internal.h b/ssl/internal.h
index 30b2269..74c6c2e 100644
--- a/ssl/internal.h
+++ b/ssl/internal.h
@@ -24,6 +24,7 @@
 #include <algorithm>
 #include <atomic>
 #include <bitset>
+#include <cstdint>
 #include <initializer_list>
 #include <limits>
 #include <new>
@@ -1430,6 +1431,14 @@
   kRawPublicKey,
 };
 
+struct SSLTrustAnchorRange {
+  Array<uint8_t> base;
+  uint64_t min = 0;
+  uint64_t max = 0;
+
+  bool Contains(Span<const uint8_t> id) const;
+};
+
 class SSLCredential : public ssl_credential_st,
                       public RefCounted<SSLCredential> {
  public:
@@ -1552,6 +1561,10 @@
   // chain in `chain`.
   Array<uint8_t> trust_anchor_id;
 
+  // trust_anchor_group_inclusions describes trust anchor groups that also match
+  // this credential.
+  Vector<SSLTrustAnchorRange> trust_anchor_group_inclusions;
+
   CRYPTO_EX_DATA ex_data;
 
   // must_match_issuer is a flag indicating that this credential should be
diff --git a/ssl/ssl_credential.cc b/ssl/ssl_credential.cc
index 87bf24c..06bc2cd 100644
--- a/ssl/ssl_credential.cc
+++ b/ssl/ssl_credential.cc
@@ -12,11 +12,14 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#include <openssl/base.h>
 #include <openssl/ssl.h>
 
 #include <assert.h>
 
+#include <algorithm>
+#include <optional>
+
+#include <openssl/bytestring.h>
 #include <openssl/hkdf.h>
 #include <openssl/span.h>
 
@@ -83,9 +86,10 @@
       }
     }
   }
+
   // If the credential has a trust anchor ID and it matches one sent by the
   // peer, it is good.
-  if (!cred->trust_anchor_id.empty() && hs->peer_requested_trust_anchors) {
+  if (hs->peer_requested_trust_anchors) {
     CBS cbs = CBS(*hs->peer_requested_trust_anchors), candidate;
     while (CBS_len(&cbs) > 0) {
       if (!CBS_get_u8_length_prefixed(&cbs, &candidate) ||
@@ -93,7 +97,12 @@
         OPENSSL_PUT_ERROR(SSL, ERR_R_INTERNAL_ERROR);
         return false;
       }
-      if (candidate == Span(cred->trust_anchor_id)) {
+      if (candidate == Span(cred->trust_anchor_id) ||
+          std::any_of(cred->trust_anchor_group_inclusions.begin(),
+                      cred->trust_anchor_group_inclusions.end(),
+                      [&](const SSLTrustAnchorRange &r) {
+                        return r.Contains(candidate);
+                      })) {
         hs->matched_peer_trust_anchor = true;
         return true;
       }
@@ -117,6 +126,22 @@
   }
 }
 
+bool SSLTrustAnchorRange::Contains(Span<const uint8_t> id) const {
+  // See draft-ietf-tls-trust-anchor-ids-04, Section 3.1.
+  if (!base.empty() && (base.back() & 0x80)) {
+    return false;  // `base` is a truncated OID component.
+  }
+  if (id.size() <= base.size() || id.first(base.size()) != base) {
+    return false;  // `base` is not a strict prefix of `id`.
+  }
+  CBS rest = id.subspan(base.size());
+  uint64_t v;
+  if (!CBS_get_asn1_oid_component(&rest, &v) || CBS_len(&rest) != 0) {
+    return false;  // `id` was not exactly one OID component more than `base`.
+  }
+  return min <= v && v <= max;
+}
+
 static ExDataClass g_ex_data_class;
 
 SSLCredential::SSLCredential(SSLCredentialType type_arg)
@@ -725,6 +750,27 @@
   return 1;
 }
 
+int SSL_CREDENTIAL_add1_trust_anchor_group_inclusion(SSL_CREDENTIAL *cred,
+                                                     const uint8_t *base,
+                                                     size_t base_len,
+                                                     uint64_t min,
+                                                     uint64_t max) {
+  auto *cred_impl = FromOpaque(cred);
+  // For now, this is only valid for X.509.
+  if (!cred_impl->UsesX509()) {
+    OPENSSL_PUT_ERROR(SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
+    return 0;
+  }
+
+  SSLTrustAnchorRange range;
+  if (!range.base.CopyFrom(Span(base, base_len))) {
+    return 0;
+  }
+  range.min = min;
+  range.max = max;
+  return cred_impl->trust_anchor_group_inclusions.Push(std::move(range));
+}
+
 int SSL_CREDENTIAL_set1_certificate_properties(
     SSL_CREDENTIAL *cred, CRYPTO_BUFFER *cert_property_list) {
   auto *cred_impl = FromOpaque(cred);
@@ -733,53 +779,71 @@
     OPENSSL_PUT_ERROR(SSL, ERR_R_SHOULD_NOT_HAVE_BEEN_CALLED);
     return 0;
   }
-  std::optional<CBS> trust_anchor;
-  CBS cbs, cpl;
-  CRYPTO_BUFFER_init_CBS(cert_property_list, &cbs);
 
-  if (!CBS_get_u16_length_prefixed(&cbs, &cpl)) {
+  CBS cbs, list;
+  CRYPTO_BUFFER_init_CBS(cert_property_list, &cbs);
+  if (!CBS_get_u16_length_prefixed(&cbs, &list) || CBS_len(&cbs) != 0) {
     OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST);
     return 0;
   }
-  while (CBS_len(&cpl) != 0) {
-    uint16_t cp_type;
-    CBS cp_data;
-    if (!CBS_get_u16(&cpl, &cp_type) ||
-        !CBS_get_u16_length_prefixed(&cpl, &cp_data)) {
+  std::optional<uint16_t> last_type;
+  while (CBS_len(&list) != 0) {
+    uint16_t type;
+    CBS data;
+    if (!CBS_get_u16(&list, &type) ||
+        !CBS_get_u16_length_prefixed(&list, &data) ||
+        // Properties must be numerically sorted by type and must not contain
+        // duplicates.
+        (last_type.has_value() && type <= last_type.value())) {
       OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST);
       return 0;
     }
-    switch (cp_type) {
-      case 0:  // trust anchor identifier.
-        if (trust_anchor.has_value()) {
+    last_type = type;
+
+    switch (type) {
+      case 0:  // trust_anchor_id
+        // See draft-ietf-tls-trust-anchor-ids-04, Section 7.1.
+        if (!CBS_len(&data)) {
+          OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_TRUST_ANCHOR_LIST);
+          return 0;
+        }
+        if (!SSL_CREDENTIAL_set1_trust_anchor_id(cred_impl, CBS_data(&data),
+                                                 CBS_len(&data))) {
+          return 0;
+        }
+        break;
+      case 1: {  // trust_anchor_group_inclusions
+        // See draft-ietf-tls-trust-anchor-ids-04, Section 7.2.
+        CBS range_list;
+        if (!CBS_get_u16_length_prefixed(&data, &range_list) ||
+            CBS_len(&data) != 0 || CBS_len(&range_list) == 0) {
           OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST);
           return 0;
         }
-        trust_anchor = cp_data;
+        while (CBS_len(&range_list) != 0) {
+          CBS base;
+          uint64_t min, max;
+          if (!CBS_get_u8_length_prefixed(&range_list, &base) ||
+              CBS_len(&base) == 0 ||  //
+              !CBS_get_u64(&range_list, &min) ||
+              !CBS_get_u64(&range_list, &max)) {
+            OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST);
+            return 0;
+          }
+          if (!SSL_CREDENTIAL_add1_trust_anchor_group_inclusion(
+                  cred_impl, CBS_data(&base), CBS_len(&base), min, max)) {
+            return 0;
+          }
+        }
         break;
+      }
       default:
         break;
     }
   }
-  if (CBS_len(&cbs) != 0) {
-    OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST);
-    return 0;
-  }
-  // Certificate property list has parsed correctly.
 
   // We do not currently retain `cert_property_list`, but if we define another
   // property with larger fields (e.g. stapled SCTs), it may make sense for
   // those fields to retain `cert_property_list` and alias into it.
-  if (trust_anchor.has_value()) {
-    if (!CBS_len(&trust_anchor.value())) {
-      OPENSSL_PUT_ERROR(SSL, SSL_R_INVALID_TRUST_ANCHOR_LIST);
-      return 0;
-    }
-    if (!SSL_CREDENTIAL_set1_trust_anchor_id(cred_impl,
-                                             CBS_data(&trust_anchor.value()),
-                                             CBS_len(&trust_anchor.value()))) {
-      return 0;
-    }
-  }
   return 1;
 }
diff --git a/ssl/ssl_test.cc b/ssl/ssl_test.cc
index af516e7..cf0a639 100644
--- a/ssl/ssl_test.cc
+++ b/ssl/ssl_test.cc
@@ -5915,97 +5915,70 @@
 }
 
 TEST(SSLTest, CredentialCertProperties) {
-  // A CertificatePropertyList containing a trust_anchors property, and an
-  // unknown property 0xbb with 0 bytes of data.
   bssl::UniquePtr<SSL_CREDENTIAL> cred(SSL_CREDENTIAL_new_x509());
   ASSERT_TRUE(cred);
-  ASSERT_FALSE(SSL_CREDENTIAL_is_complete(cred.get()));
-  static const uint8_t kTestProperties1[] = {0x00, 0x0b, 0x00, 0x00, 0x00,
-                                             0x03, 0xba, 0xdb, 0x0b, 0x00,
-                                             0xbb, 0x00, 0x00};
-  bssl::UniquePtr<CRYPTO_BUFFER> pl(
-      CRYPTO_BUFFER_new(kTestProperties1, sizeof(kTestProperties1), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_TRUE(SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
 
-  // A CertificatePropertyList containing a trust_anchors property, and an
-  // unknown property 0xbb with 1 byte of data.
-  static const uint8_t kTestProperties2[] = {0x00, 0x0c, 0x00, 0x00, 0x00,
-                                             0x03, 0xba, 0xdb, 0x0b, 0x00,
-                                             0xbb, 0x00, 0x01, 0xba};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties2, sizeof(kTestProperties2), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_TRUE(SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
-
-  // A CertificatePropertyList containing a trust_anchors property, and an
-  // unknown but malformed property 0xbb with missing data.
-  static const uint8_t kTestProperties3[] = {0x00, 0x09, 0x00, 0x00, 0x00, 0x03,
-                                             0xba, 0xdb, 0x0b, 0x00, 0xbb};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties3, sizeof(kTestProperties3), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_FALSE(
-      SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
-  EXPECT_TRUE(ErrorEquals(ERR_get_error(), ERR_LIB_SSL,
-                          SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST));
-
-  // A CertificatePropertyList containing a trust_anchors property, and an
-  // unknown but malformed property 0xbb with incorrect length data.
-  static const uint8_t kTestProperties4[] = {0x00, 0x0c, 0x00, 0x00, 0x00,
-                                             0x03, 0xba, 0xdb, 0x0b, 0x00,
-                                             0xbb, 0x00, 0x03, 0xba};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties4, sizeof(kTestProperties4), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_FALSE(
-      SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
-  EXPECT_TRUE(ErrorEquals(ERR_get_error(), ERR_LIB_SSL,
-                          SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST));
-
-  // A CertificatePropertyList containing a trust_anchors property with 0 bytes
-  // of data.
-  static const uint8_t kTestProperties5[] = {0x00, 0x04, 0x00,
-                                             0x00, 0x00, 0x00};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties5, sizeof(kTestProperties5), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_FALSE(
-      SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
-  EXPECT_TRUE(ErrorEquals(ERR_get_error(), ERR_LIB_SSL,
-                          SSL_R_INVALID_TRUST_ANCHOR_LIST));
-
-  // A CertificatePropertyList containing a trust_anchors property with extra
-  // data.
-  static const uint8_t kTestProperties6[] = {0x00, 0x08, 0x00, 0x00, 0x00,
-                                             0x03, 0xba, 0xdb, 0x0b, 0xbb};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties6, sizeof(kTestProperties6), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_FALSE(
-      SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
-  EXPECT_TRUE(ErrorEquals(ERR_get_error(), ERR_LIB_SSL,
-                          SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST));
-
-  // A CertificatePropertyList containing a trust_anchors property with missing
-  // data.
-  static const uint8_t kTestProperties7[] = {0x00, 0x06, 0x00, 0x00,
-                                             0x00, 0x03, 0xba, 0xdb};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties7, sizeof(kTestProperties7), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_FALSE(
-      SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
-  EXPECT_TRUE(ErrorEquals(ERR_get_error(), ERR_LIB_SSL,
-                          SSL_R_INVALID_CERTIFICATE_PROPERTY_LIST));
-
-  // A CertificatePropertyList containing only a trust_anchors property.
-  static const uint8_t kTestProperties8[] = {0x00, 0x07, 0x00, 0x00, 0x00,
-                                             0x03, 0xba, 0xdb, 0x0b};
-  pl.reset(
-      CRYPTO_BUFFER_new(kTestProperties8, sizeof(kTestProperties8), nullptr));
-  ASSERT_TRUE(pl);
-  EXPECT_TRUE(SSL_CREDENTIAL_set1_certificate_properties(cred.get(), pl.get()));
+  static const struct {
+    std::vector<uint8_t> props;
+    bool ok;
+  } kTests[] = {
+      // trust_anchors and an unknown property 0xbb with 0 bytes of data.
+      {{0x00, 0x0b, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb, 0x0b, 0x00, 0xbb, 0x00,
+        0x00},
+       true},
+      // trust_anchors and an unknown property 0xbb with 1 byte of data.
+      {{0x00, 0x0c, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb, 0x0b, 0x00, 0xbb, 0x00,
+        0x01, 0xba},
+       true},
+      // trust_anchors and an unknown but malformed property 0xbb with missing
+      // data.
+      {{0x00, 0x09, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb, 0x0b, 0x00, 0xbb},
+       false},
+      // trust_anchors and an unknown but malformed property 0xbb with incorrect
+      // length data.
+      {{0x00, 0x0c, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb, 0x0b, 0x00, 0xbb, 0x00,
+        0x03, 0xba},
+       false},
+      // trust_anchors with 0 bytes of data.
+      {{0x00, 0x04, 0x00, 0x00, 0x00, 0x00}, false},
+      // trust_anchors with extra data.
+      {{0x00, 0x08, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb, 0x0b, 0xbb}, false},
+      // trust_anchors with missing data.
+      {{0x00, 0x06, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb}, false},
+      // Only trust_anchors.
+      {{0x00, 0x07, 0x00, 0x00, 0x00, 0x03, 0xba, 0xdb, 0x0b}, true},
+      // Duplicate trust_anchors.
+      {{0x00, 0x0e, 0x00, 0x00, 0x00, 0x03, 0x11, 0x11, 0x11, 0x00, 0x00, 0x00,
+        0x03, 0x22, 0x22, 0x22},
+       false},
+      // Only unknown properties.
+      {{0x00, 0x08, 0xaa, 0xaa, 0x00, 0x00, 0xbb, 0xbb, 0x00, 0x00}, true},
+      // Duplicate unknown properties.
+      {{0x00, 0x08, 0xaa, 0xaa, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00}, false},
+      // Out of order unknown properties.
+      {{0x00, 0x08, 0xbb, 0xbb, 0x00, 0x00, 0xaa, 0xaa, 0x00, 0x00}, false},
+      // Empty trust_anchor_group_inclusions (should have been omitted).
+      {{0x00, 0x06, 0x00, 0x01, 0x00, 0x02, 0x00, 0x00}, false},
+      // Trailing data after trust_anchor_group_inclusions.
+      {{0x00, 0x1b, 0x00, 0x01, 0x00, 0x17, 0x00, 0x14, 0x03, 0x11,
+        0x11, 0x11, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+        0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00},
+       false},
+  };
+  for (const auto &t : kTests) {
+    SCOPED_TRACE(Bytes(t.props));
+    bssl::UniquePtr<CRYPTO_BUFFER> props(
+        CRYPTO_BUFFER_new(t.props.data(), t.props.size(), nullptr));
+    ASSERT_TRUE(props);
+    if (t.ok) {
+      EXPECT_TRUE(
+          SSL_CREDENTIAL_set1_certificate_properties(cred.get(), props.get()));
+    } else {
+      EXPECT_FALSE(
+          SSL_CREDENTIAL_set1_certificate_properties(cred.get(), props.get()));
+      ERR_clear_error();
+    }
+  }
 }
 
 TEST(SSLTest, SetChainAndKeyCtx) {
diff --git a/ssl/test/runner/common.go b/ssl/test/runner/common.go
index a46c32f..20c4f13 100644
--- a/ssl/test/runner/common.go
+++ b/ssl/test/runner/common.go
@@ -2434,16 +2434,23 @@
 	return supportedSignatureAlgorithms
 }
 
+type TrustAnchorRange struct {
+	Base     []byte
+	Min, Max uint64
+}
+
 const (
-	certPropTrustAnchorID uint16 = 0
+	certPropTrustAnchorID              uint16 = 0
+	certPropTrustAnchorGroupInclusions uint16 = 1
 )
 
 type CertificatePropertyList struct {
-	TrustAnchorID []byte
+	TrustAnchorID              []byte
+	TrustAnchorGroupInclusions []TrustAnchorRange
 }
 
 func (c *CertificatePropertyList) Empty() bool {
-	return len(c.TrustAnchorID) == 0
+	return len(c.TrustAnchorID) == 0 && len(c.TrustAnchorGroupInclusions) == 0
 }
 
 func (c *CertificatePropertyList) Marshal() []byte {
@@ -2455,6 +2462,18 @@
 			// no additional length prefix.
 			addUint16LengthPrefixedBytes(props, c.TrustAnchorID)
 		}
+		if len(c.TrustAnchorGroupInclusions) != 0 {
+			props.AddUint16(certPropTrustAnchorGroupInclusions)
+			props.AddUint16LengthPrefixed(func(prop *cryptobyte.Builder) {
+				prop.AddUint16LengthPrefixed(func(ranges *cryptobyte.Builder) {
+					for _, r := range c.TrustAnchorGroupInclusions {
+						addUint8LengthPrefixedBytes(ranges, r.Base)
+						ranges.AddUint64(r.Min)
+						ranges.AddUint64(r.Max)
+					}
+				})
+			})
+		}
 	})
 	return bb.BytesOrPanic()
 }
@@ -2591,6 +2610,12 @@
 	return &ret
 }
 
+func (c *Credential) WithProperties(props CertificatePropertyList) *Credential {
+	ret := *c
+	ret.Properties = props
+	return &ret
+}
+
 type handshakeMessage interface {
 	marshal() []byte
 	unmarshal([]byte) bool
diff --git a/ssl/test/runner/trust_anchor_tests.go b/ssl/test/runner/trust_anchor_tests.go
index 847250e..cf0043a 100644
--- a/ssl/test/runner/trust_anchor_tests.go
+++ b/ssl/test/runner/trust_anchor_tests.go
@@ -352,4 +352,83 @@
 		expectedError:      ":UNEXPECTED_EXTENSION:",
 		expectedLocalError: "remote error: unsupported extension",
 	})
+
+	group := []byte{1, 2, 3, 4, 5}
+	// These ranges match the test group.
+	match := TrustAnchorRange{Base: []byte{1, 2, 3, 4}, Min: 1, Max: 10}
+	matchExact := TrustAnchorRange{Base: []byte{1, 2, 3, 4}, Min: 5, Max: 5}
+	// These ranges do not.
+	wrongBase := TrustAnchorRange{Base: []byte{1, 2, 3, 5}, Min: 5, Max: 10}
+	componentTooLow := TrustAnchorRange{Base: []byte{1, 2, 3, 4}, Min: 1, Max: 4}
+	componentTooHigh := TrustAnchorRange{Base: []byte{1, 2, 3, 4}, Min: 6, Max: 10}
+	matchParent := TrustAnchorRange{Base: []byte{1, 2, 3}, Min: 1, Max: 10}
+	matchChild := TrustAnchorRange{Base: []byte{1, 2, 3, 4, 5}, Min: 1, Max: 10}
+	matchChild2 := TrustAnchorRange{Base: []byte{1, 2, 3, 4, 5}, Min: 0, Max: 0}
+	matchGrandChild := TrustAnchorRange{Base: []byte{1, 2, 3, 4, 5, 6}, Min: 1, Max: 10}
+
+	testCases = append(testCases, testCase{
+		testType: serverTest,
+		name:     "TrustAnchorGroups-Match-Server",
+		config: Config{
+			MinVersion:          VersionTLS13,
+			RequestTrustAnchors: [][]byte{group},
+			Bugs: ProtocolBugs{
+				ExpectPeerAvailableTrustAnchors: [][]byte{id1, id2},
+				ExpectPeerMatchTrustAnchor:      ptrTo(true),
+			},
+		},
+		shimCredentials: []*Credential{
+			// Neither the ID nor the group inclusions match.
+			rsaCertificate.WithMustMatchIssuer(true).WithProperties(CertificatePropertyList{
+				TrustAnchorID: id1,
+				TrustAnchorGroupInclusions: []TrustAnchorRange{
+					wrongBase, componentTooLow, componentTooHigh, matchParent, matchChild, matchChild2, matchGrandChild,
+				},
+			}),
+			// The group inclusions match, after skipping some irrelevant inclusions.
+			ecdsaP256Certificate.WithMustMatchIssuer(true).WithProperties(CertificatePropertyList{
+				TrustAnchorID: id2,
+				TrustAnchorGroupInclusions: []TrustAnchorRange{
+					wrongBase, match,
+				},
+			}),
+		},
+		expectations: connectionExpectations{
+			peerCertificate: &ecdsaP256Certificate,
+		},
+		flags: []string{"-expect-selected-credential", "1"},
+	})
+
+	testCases = append(testCases, testCase{
+		testType: serverTest,
+		name:     "TrustAnchorGroups-MatchExact-Server",
+		config: Config{
+			MinVersion:          VersionTLS13,
+			RequestTrustAnchors: [][]byte{group},
+			Bugs: ProtocolBugs{
+				ExpectPeerAvailableTrustAnchors: [][]byte{id1, id2},
+				ExpectPeerMatchTrustAnchor:      ptrTo(true),
+			},
+		},
+		shimCredentials: []*Credential{
+			// Neither the ID nor the group inclusions match.
+			rsaCertificate.WithMustMatchIssuer(true).WithProperties(CertificatePropertyList{
+				TrustAnchorID: id1,
+				TrustAnchorGroupInclusions: []TrustAnchorRange{
+					wrongBase, componentTooLow, componentTooHigh, matchParent, matchChild, matchGrandChild,
+				},
+			}),
+			// The group inclusions match, after skipping some irrelevant inclusions.
+			ecdsaP256Certificate.WithMustMatchIssuer(true).WithProperties(CertificatePropertyList{
+				TrustAnchorID: id2,
+				TrustAnchorGroupInclusions: []TrustAnchorRange{
+					wrongBase, matchExact,
+				},
+			}),
+		},
+		expectations: connectionExpectations{
+			peerCertificate: &ecdsaP256Certificate,
+		},
+		flags: []string{"-expect-selected-credential", "1"},
+	})
 }