Expose TLS Group through MsQuic API

docs/api/QUIC_HANDSHAKE_INFO.md

@@ -0,0 +1,76 @@
+QUIC_HANDSHAKE_INFO structure
+======
+
+Used to return the various algorithms negotiated during the TLS handshake.
+
+# Syntax
+
+```C
+typedef struct QUIC_HANDSHAKE_INFO {
+    QUIC_TLS_PROTOCOL_VERSION TlsProtocolVersion;
+    QUIC_CIPHER_ALGORITHM CipherAlgorithm;
+    int32_t CipherStrength;
+    QUIC_HASH_ALGORITHM Hash;
+    int32_t HashStrength;
+    QUIC_KEY_EXCHANGE_ALGORITHM KeyExchangeAlgorithm;
+    int32_t KeyExchangeStrength;
+    QUIC_CIPHER_SUITE CipherSuite;
+    QUIC_TLS_GROUP TlsGroup;            // Added in v2.5
+} QUIC_HANDSHAKE_INFO;
+```
+
+# Members
+
+#### `TlsProtocolVersion`
+
+Indicates which version of TLS was negotiated.
+
+`QUIC_TLS_PROTOCOL_UNKNOWN`
+
+An unknown or unexpected value was used.
+
+`QUIC_TLS_PROTOCOL_1_3`
+
+Version 1.3 was negotiated. This is currently the only expected value to be returned.
+
+#### `CipherAlgorithm`
+
+The `QUIC_CIPHER_ALGORITHM` negotiated.
+
+#### `CipherStrength`
+
+TODO
+
+#### `Hash`
+
+The `QUIC_HASH_ALGORITHM` negotiated.
+
+#### `HashStrength`
+
+TODO
+
+#### `KeyExchangeAlgorithm`
+
+The `QUIC_KEY_EXCHANGE_ALGORITHM` negotiated.
+
+#### `KeyExchangeStrength`
+
+TODO
+
+#### `CipherSuite`
+
+The `QUIC_CIPHER_SUITE` negotiated.
+
+#### `TlsGroup`
+
+The `QUIC_TLS_GROUP` negotiated.
+
+> **Note** - This field is not supported before MsQuic version v2.5. Calls to older versions of MsQuic will indicate a final output length not including this field. Additionally, older callers that use the old version of the struct will still work, and MsQuic will not try to write this field.
+
+# Remarks
+
+This may be queries for a connection after the handshake has completed via a call to [GetParam](GetParam.md) by using the `QUIC_PARAM_TLS_HANDSHAKE_INFO` parameter.
+
+# See Also
+
+[GetParam](GetParam.md)<br>

src/core/settings.c

@@ -1642,24 +1642,18 @@ QuicSettingsDumpNew(
     }
 }
 
-#define SETTINGS_SIZE_THRU_FIELD(SettingsType, Field) \
-    (FIELD_OFFSET(SettingsType, Field) + sizeof(((SettingsType*)0)->Field))
-
-#define SETTING_HAS_FIELD(SettingsType, Size, Field) \
-    (Size >= SETTINGS_SIZE_THRU_FIELD(SettingsType, Field))
-
 #define SETTING_COPY_TO_INTERNAL(Field, Settings, InternalSettings) \
     InternalSettings->IsSet.Field = Settings->IsSet.Field;          \
     InternalSettings->Field = Settings->Field;
 
 #define SETTING_COPY_TO_INTERNAL_SIZED(Field, SettingsType, Settings, SettingsSize, InternalSettings)   \
-    if (SETTING_HAS_FIELD(SettingsType, SettingsSize, Field)) {                                         \
+    if (CXPLAT_STRUCT_HAS_FIELD(SettingsType, SettingsSize, Field)) {                                         \
         InternalSettings->IsSet.Field = Settings->IsSet.Field;                                          \
         InternalSettings->Field = Settings->Field;                                                      \
     }
 
 #define SETTING_COPY_FLAG_TO_INTERNAL_SIZED(FlagField, Flag, SettingsType, Settings, SettingsSize, InternalSettings)    \
-    if (SETTING_HAS_FIELD(SettingsType, SettingsSize, FlagField)) {                                                     \
+    if (CXPLAT_STRUCT_HAS_FIELD(SettingsType, SettingsSize, FlagField)) {                                                     \
         InternalSettings->IsSet.Flag = !!Settings->IsSet.Flag;                                                          \
         InternalSettings->Flag = !!Settings->Flag;                                                                      \
     }
@@ -1673,7 +1667,7 @@ QuicSettingsGlobalSettingsToInternal(
     _Out_ QUIC_SETTINGS_INTERNAL* InternalSettings
     )
 {
-    if (!SETTING_HAS_FIELD(QUIC_GLOBAL_SETTINGS, SettingsSize, LoadBalancingMode)) {
+    if (!CXPLAT_STRUCT_HAS_FIELD(QUIC_GLOBAL_SETTINGS, SettingsSize, LoadBalancingMode)) {
         return QUIC_STATUS_INVALID_PARAMETER;
     }
 
@@ -1775,7 +1769,7 @@ QuicSettingsSettingsToInternal(
     _Out_ QUIC_SETTINGS_INTERNAL* InternalSettings
     )
 {
-    if (!SETTING_HAS_FIELD(QUIC_SETTINGS, SettingsSize, MtuDiscoveryMissingProbeCount)) {
+    if (!CXPLAT_STRUCT_HAS_FIELD(QUIC_SETTINGS, SettingsSize, MtuDiscoveryMissingProbeCount)) {
         return QUIC_STATUS_INVALID_PARAMETER;
     }
 
@@ -1920,13 +1914,13 @@ QuicSettingsSettingsToInternal(
     Settings->Field = InternalSettings->Field;
 
 #define SETTING_COPY_FROM_INTERNAL_SIZED(Field, SettingsType, Settings, SettingsSize, InternalSettings) \
-    if (SETTING_HAS_FIELD(SettingsType, SettingsSize, Field)) {                                         \
+    if (CXPLAT_STRUCT_HAS_FIELD(SettingsType, SettingsSize, Field)) {                                         \
         Settings->IsSet.Field = InternalSettings->IsSet.Field;                                          \
         Settings->Field = InternalSettings->Field;                                                      \
     }
 
 #define SETTING_COPY_FLAG_FROM_INTERNAL_SIZED(FlagField, Flag, SettingsType, Settings, SettingsSize, InternalSettings)  \
-    if (SETTING_HAS_FIELD(SettingsType, SettingsSize, FlagField)) {                                                     \
+    if (CXPLAT_STRUCT_HAS_FIELD(SettingsType, SettingsSize, FlagField)) {                                                     \
         Settings->IsSet.Flag = InternalSettings->IsSet.Flag;                                                            \
         Settings->Flag = InternalSettings->Flag;                                                                        \
     }
@@ -1940,7 +1934,7 @@ QuicSettingsGetSettings(
         QUIC_SETTINGS* Settings
     )
 {
-    uint32_t MinimumSettingsSize = (uint32_t)SETTINGS_SIZE_THRU_FIELD(QUIC_SETTINGS, MtuDiscoveryMissingProbeCount);
+    uint32_t MinimumSettingsSize = (uint32_t)CXPLAT_STRUCT_SIZE_THRU_FIELD(QUIC_SETTINGS, MtuDiscoveryMissingProbeCount);
 
     if (*SettingsLength == 0) {
         *SettingsLength = sizeof(QUIC_SETTINGS);
@@ -2103,7 +2097,7 @@ QuicSettingsGetGlobalSettings(
         QUIC_GLOBAL_SETTINGS* Settings
     )
 {
-    const uint32_t MinimumSettingsSize = (uint32_t)SETTINGS_SIZE_THRU_FIELD(QUIC_GLOBAL_SETTINGS, LoadBalancingMode);
+    const uint32_t MinimumSettingsSize = (uint32_t)CXPLAT_STRUCT_SIZE_THRU_FIELD(QUIC_GLOBAL_SETTINGS, LoadBalancingMode);
 
     if (*SettingsLength == 0) {
         *SettingsLength = sizeof(QUIC_GLOBAL_SETTINGS);

src/cs/lib/msquic_generated.cs

@@ -472,6 +472,20 @@ internal enum QUIC_KEY_EXCHANGE_ALGORITHM
         NONE = 0,
     }
 
+    internal enum QUIC_TLS_GROUP
+    {
+        QUIC_TLS_GROUP_UNKNOWN = 0,
+        QUIC_TLS_GROUP_SECP256R1 = 23,
+        QUIC_TLS_GROUP_SECP384R1 = 24,
+        QUIC_TLS_GROUP_X25519 = 29,
+        QUIC_TLS_GROUP_MLKEM512 = 512,
+        QUIC_TLS_GROUP_MLKEM768 = 513,
+        QUIC_TLS_GROUP_MLKEM1024 = 514,
+        QUIC_TLS_GROUP_SECP256R1MLKEM768 = 4587,
+        QUIC_TLS_GROUP_X25519MLKEM768 = 4588,
+        QUIC_TLS_GROUP_SECP384R1MLKEM1024 = 4589,
+    }
+
     internal enum QUIC_CIPHER_SUITE
     {
         TLS_AES_128_GCM_SHA256 = 0x1301,
@@ -506,6 +520,8 @@ internal partial struct QUIC_HANDSHAKE_INFO
         internal int KeyExchangeStrength;
 
         internal QUIC_CIPHER_SUITE CipherSuite;
+
+        internal QUIC_TLS_GROUP TlsGroup;
     }
 
     internal partial struct QUIC_STATISTICS

src/inc/msquic.h

@@ -430,6 +430,23 @@ typedef enum QUIC_KEY_EXCHANGE_ALGORITHM {
     QUIC_KEY_EXCHANGE_ALGORITHM_NONE  = 0,
 } QUIC_KEY_EXCHANGE_ALGORITHM;
 
+//
+// See the following IANA registry for the TLS groups:
+//   https://www.iana.org/assignments/tls-parameters/tls-parameters.xhtml#tls-parameters-8
+//
+typedef enum QUIC_TLS_GROUP {
+    QUIC_TLS_GROUP_UNKNOWN              = 0,
+    QUIC_TLS_GROUP_SECP256R1            = 23,
+    QUIC_TLS_GROUP_SECP384R1            = 24,
+    QUIC_TLS_GROUP_X25519               = 29,
+    QUIC_TLS_GROUP_MLKEM512             = 512,
+    QUIC_TLS_GROUP_MLKEM768             = 513,
+    QUIC_TLS_GROUP_MLKEM1024            = 514,
+    QUIC_TLS_GROUP_SECP256R1MLKEM768    = 4587,
+    QUIC_TLS_GROUP_X25519MLKEM768       = 4588,
+    QUIC_TLS_GROUP_SECP384R1MLKEM1024   = 4589,
+} QUIC_TLS_GROUP;
+
 typedef enum QUIC_CIPHER_SUITE {
     QUIC_CIPHER_SUITE_TLS_AES_128_GCM_SHA256        = 0x1301,
     QUIC_CIPHER_SUITE_TLS_AES_256_GCM_SHA384        = 0x1302,
@@ -456,6 +473,7 @@ typedef struct QUIC_HANDSHAKE_INFO {
     QUIC_KEY_EXCHANGE_ALGORITHM KeyExchangeAlgorithm;
     int32_t KeyExchangeStrength;
     QUIC_CIPHER_SUITE CipherSuite;
+    QUIC_TLS_GROUP TlsGroup;            // Added in v2.5
 } QUIC_HANDSHAKE_INFO;
 
 //

src/inc/quic_platform.h

@@ -49,6 +49,12 @@ extern "C" {
 #define CXPLAT_CONTAINING_RECORD(address, type, field) \
     ((type *)((uint8_t*)(address) - offsetof(type, field)))
 
+#define CXPLAT_STRUCT_SIZE_THRU_FIELD(Type, Field) \
+    (offsetof(Type, Field) + sizeof(((Type*)0)->Field))
+
+#define CXPLAT_STRUCT_HAS_FIELD(Type, Size, Field) \
+    (Size >= CXPLAT_STRUCT_SIZE_THRU_FIELD(Type, Field))
+
 typedef struct CXPLAT_LIST_ENTRY {
     struct CXPLAT_LIST_ENTRY* Flink;
     struct CXPLAT_LIST_ENTRY* Blink;

src/perf/lib/SecNetPerf.h

@@ -193,6 +193,29 @@ QuicPrintConnectionStatistics(
         (unsigned long long)Stats.RecvDroppedPackets,
         (unsigned long long)Stats.RecvDuplicatePackets,
         (unsigned long long)Stats.RecvDecryptionFailures);
+    QUIC_HANDSHAKE_INFO HandshakeInfo = {};
+    uint32_t HandshakeInfoSize = sizeof(HandshakeInfo);
+    ApiTable->GetParam(Connection, QUIC_PARAM_TLS_HANDSHAKE_INFO, &HandshakeInfoSize, &HandshakeInfo);
+    WriteOutput(
+        "Connection TLS Info:\n"
+        "  TlsProtocolVersion        0x%x\n"
+        "  CipherAlgorithm           0x%x\n"
+        "  CipherStrength            %u\n"
+        "  Hash                      0x%x\n"
+        "  HashStrength              %u\n"
+        "  KeyExchangeAlgorithm      %u\n"
+        "  KeyExchangeStrength       %u\n"
+        "  CipherSuite               0x%x\n"
+        "  TlsGroup                  %u\n",
+        HandshakeInfo.TlsProtocolVersion,
+        HandshakeInfo.CipherAlgorithm,
+        HandshakeInfo.CipherStrength,
+        HandshakeInfo.Hash,
+        HandshakeInfo.HashStrength,
+        HandshakeInfo.KeyExchangeAlgorithm,
+        HandshakeInfo.KeyExchangeStrength,
+        HandshakeInfo.CipherSuite,
+        HandshakeInfo.TlsGroup);
 }
 
 inline

src/platform/tls_quictls.c

@@ -34,6 +34,10 @@
 #include "tls_quictls.c.clog.h"
 #endif
 
+#ifdef IS_OPENSSL_3
+__owur uint16_t tls1_nid2group_id(int nid); // Not currently public API
+#endif
+
 extern EVP_CIPHER *CXPLAT_AES_256_CBC_ALG_HANDLE;
 
 uint16_t CxPlatTlsTPHeaderSize = 0;
@@ -1193,6 +1197,21 @@ CxPlatTlsSecConfigCreate(
         goto Exit;
     }
 
+    /* TODO - This is a WIP to configure OpenSSL to the same defaults as Schannel
+    Ret =
+        SSL_CTX_set1_groups_list(
+            SecurityConfig->SSLCtx,
+            "X25519:P-256:P-384");
+    if (Ret != 1) {
+        QuicTraceEvent(
+            LibraryErrorStatus,
+            "[ lib] ERROR, %u, %s.",
+            ERR_get_error(),
+            "SSL_CTX_set1_groups_list failed");
+        Status = QUIC_STATUS_TLS_ERROR;
+        goto Exit;
+    }*/
+
     if (SecurityConfig->Flags & QUIC_CREDENTIAL_FLAG_USE_TLS_BUILTIN_CERTIFICATE_VALIDATION) {
         Ret = SSL_CTX_set_default_verify_paths(SecurityConfig->SSLCtx);
         if (Ret != 1) {
@@ -2269,7 +2288,7 @@ CxPlatTlsParamGet(
     switch (Param) {
 
         case QUIC_PARAM_TLS_HANDSHAKE_INFO: {
-            if (*BufferLength < sizeof(QUIC_HANDSHAKE_INFO)) {
+            if (*BufferLength < CXPLAT_STRUCT_SIZE_THRU_FIELD(QUIC_HANDSHAKE_INFO, CipherSuite)) {
                 *BufferLength = sizeof(QUIC_HANDSHAKE_INFO);
                 Status = QUIC_STATUS_BUFFER_TOO_SMALL;
                 break;
@@ -2281,6 +2300,7 @@ CxPlatTlsParamGet(
             }
 
             QUIC_HANDSHAKE_INFO* HandshakeInfo = (QUIC_HANDSHAKE_INFO*)Buffer;
+            CxPlatZeroMemory(HandshakeInfo, *BufferLength);
             HandshakeInfo->TlsProtocolVersion =
                 CxPlatMapVersion(
                     SSL_get_version(TlsContext->Ssl));
@@ -2297,6 +2317,13 @@ CxPlatTlsParamGet(
             }
             HandshakeInfo->CipherSuite = SSL_CIPHER_get_protocol_id(Cipher);
             Status = CxPlatMapCipherSuite(HandshakeInfo);
+#ifdef IS_OPENSSL_3
+            if (CXPLAT_STRUCT_HAS_FIELD(QUIC_HANDSHAKE_INFO, *BufferLength, TlsGroup)) {
+                HandshakeInfo->TlsGroup =
+                    tls1_nid2group_id(
+                        SSL_get_negotiated_group(TlsContext->Ssl));
+            }
+#endif
             break;
         }
 

src/platform/tls_schannel.c

@@ -3058,7 +3058,7 @@ CxPlatTlsParamGet(
             break;
 
         case QUIC_PARAM_TLS_HANDSHAKE_INFO: {
-            if (*BufferLength < sizeof(QUIC_HANDSHAKE_INFO)) {
+            if (*BufferLength < CXPLAT_STRUCT_SIZE_THRU_FIELD(QUIC_HANDSHAKE_INFO, CipherSuite)) {
                 *BufferLength = sizeof(QUIC_HANDSHAKE_INFO);
                 Status = QUIC_STATUS_BUFFER_TOO_SMALL;
                 break;
@@ -3121,6 +3121,9 @@ CxPlatTlsParamGet(
             HandshakeInfo->KeyExchangeAlgorithm = ConnInfo.aiExch;
             HandshakeInfo->KeyExchangeStrength = ConnInfo.dwExchStrength;
             HandshakeInfo->CipherSuite = CipherInfo.dwCipherSuite;
+            if (CXPLAT_STRUCT_HAS_FIELD(QUIC_HANDSHAKE_INFO, *BufferLength, TlsGroup)) {
+                HandshakeInfo->TlsGroup = CipherInfo.dwKeyType;
+            }
             break;
         }
 

src/rs/ffi/linux_bindings.rs

@@ -718,6 +718,17 @@ pub type QUIC_HASH_ALGORITHM = ::std::os::raw::c_uint;
 pub const QUIC_KEY_EXCHANGE_ALGORITHM_QUIC_KEY_EXCHANGE_ALGORITHM_NONE:
     QUIC_KEY_EXCHANGE_ALGORITHM = 0;
 pub type QUIC_KEY_EXCHANGE_ALGORITHM = ::std::os::raw::c_uint;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_UNKNOWN: QUIC_TLS_GROUP = 0;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_SECP256R1: QUIC_TLS_GROUP = 23;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_SECP384R1: QUIC_TLS_GROUP = 24;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_X25519: QUIC_TLS_GROUP = 29;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_MLKEM512: QUIC_TLS_GROUP = 512;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_MLKEM768: QUIC_TLS_GROUP = 513;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_MLKEM1024: QUIC_TLS_GROUP = 514;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_SECP256R1MLKEM768: QUIC_TLS_GROUP = 4587;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_X25519MLKEM768: QUIC_TLS_GROUP = 4588;
+pub const QUIC_TLS_GROUP_QUIC_TLS_GROUP_SECP384R1MLKEM1024: QUIC_TLS_GROUP = 4589;
+pub type QUIC_TLS_GROUP = ::std::os::raw::c_uint;
 pub const QUIC_CIPHER_SUITE_QUIC_CIPHER_SUITE_TLS_AES_128_GCM_SHA256: QUIC_CIPHER_SUITE = 4865;
 pub const QUIC_CIPHER_SUITE_QUIC_CIPHER_SUITE_TLS_AES_256_GCM_SHA384: QUIC_CIPHER_SUITE = 4866;
 pub const QUIC_CIPHER_SUITE_QUIC_CIPHER_SUITE_TLS_CHACHA20_POLY1305_SHA256: QUIC_CIPHER_SUITE =
@@ -741,10 +752,11 @@ pub struct QUIC_HANDSHAKE_INFO {
     pub KeyExchangeAlgorithm: QUIC_KEY_EXCHANGE_ALGORITHM,
     pub KeyExchangeStrength: i32,
     pub CipherSuite: QUIC_CIPHER_SUITE,
+    pub TlsGroup: QUIC_TLS_GROUP,
 }
 #[allow(clippy::unnecessary_operation, clippy::identity_op)]
 const _: () = {
-    ["Size of QUIC_HANDSHAKE_INFO"][::std::mem::size_of::<QUIC_HANDSHAKE_INFO>() - 32usize];
+    ["Size of QUIC_HANDSHAKE_INFO"][::std::mem::size_of::<QUIC_HANDSHAKE_INFO>() - 36usize];
     ["Alignment of QUIC_HANDSHAKE_INFO"][::std::mem::align_of::<QUIC_HANDSHAKE_INFO>() - 4usize];
     ["Offset of field: QUIC_HANDSHAKE_INFO::TlsProtocolVersion"]
         [::std::mem::offset_of!(QUIC_HANDSHAKE_INFO, TlsProtocolVersion) - 0usize];
@@ -762,6 +774,8 @@ const _: () = {
         [::std::mem::offset_of!(QUIC_HANDSHAKE_INFO, KeyExchangeStrength) - 24usize];
     ["Offset of field: QUIC_HANDSHAKE_INFO::CipherSuite"]
         [::std::mem::offset_of!(QUIC_HANDSHAKE_INFO, CipherSuite) - 28usize];
+    ["Offset of field: QUIC_HANDSHAKE_INFO::TlsGroup"]
+        [::std::mem::offset_of!(QUIC_HANDSHAKE_INFO, TlsGroup) - 32usize];
 };
 #[repr(C)]
 #[derive(Debug, Copy, Clone)]