< Summary

Information
Class: Interop
Assembly: System.Net.Security
File(s): File 1: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/Interop/Windows/SChannel/Interop.Sec_Application_Protocols.cs
File 2: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/Interop/Windows/SChannel/Interop.SecPkgContext_ApplicationProtocol.cs
File 3: https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/Interop/Windows/SspiCli/Interop.SSPI.cs
Line coverage
0%
Covered lines: 0
Uncovered lines: 64
Coverable lines: 64
Total lines: 685
Line coverage: 0%
Branch coverage
0%
Covered branches: 0
Total branches: 14
Branch coverage: 0%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Metrics

MethodBranch coverage Cyclomatic complexity NPath complexity Sequence coverage
File 1: GetProtocolLength(...)0%880%
File 1: ToByteArray(...)0%220%
File 1: SetProtocols(...)0%220%
File 3: SetToInvalid()100%110%
File 3: ToString()100%110%
File 3: .ctor(...)100%110%

File(s)

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/Interop/Windows/SChannel/Interop.Sec_Application_Protocols.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System;
 5using System.Collections.Generic;
 6using System.Diagnostics;
 7using System.Net.Security;
 8using System.Runtime.InteropServices;
 9
 10internal static partial class Interop
 11{
 12    [StructLayout(LayoutKind.Sequential, Pack = 1)]
 13    internal struct Sec_Application_Protocols
 14    {
 15        public uint ProtocolListsSize;
 16        public ApplicationProtocolNegotiationExt ProtocolExtensionType;
 17        public ushort ProtocolListSize;
 18
 19        public static int GetProtocolLength(List<SslApplicationProtocol> applicationProtocols)
 020        {
 021            int protocolListSize = 0;
 022            for (int i = 0; i < applicationProtocols.Count; i++)
 023            {
 024                int protocolLength = applicationProtocols[i].Protocol.Length;
 25
 026                if (protocolLength == 0 || protocolLength > byte.MaxValue)
 027                {
 028                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
 29                }
 30
 031                protocolListSize += protocolLength + 1;
 32
 033                if (protocolListSize > ushort.MaxValue)
 034                {
 035                    throw new ArgumentException(SR.net_ssl_app_protocols_invalid, nameof(applicationProtocols));
 36                }
 037            }
 38
 039            return protocolListSize;
 040        }
 41
 42        public static unsafe byte[] ToByteArray(List<SslApplicationProtocol> applicationProtocols)
 043        {
 044            int protocolListSize = GetProtocolLength(applicationProtocols);
 45
 046            Sec_Application_Protocols protocols = default;
 47
 048            int protocolListConstSize = sizeof(Sec_Application_Protocols) - sizeof(uint) /* offsetof(Sec_Application_Pro
 049            protocols.ProtocolListsSize = (uint)(protocolListConstSize + protocolListSize);
 50
 051            protocols.ProtocolExtensionType = ApplicationProtocolNegotiationExt.ALPN;
 052            protocols.ProtocolListSize = (ushort)protocolListSize;
 53
 054            byte[] buffer = new byte[sizeof(Sec_Application_Protocols) + protocolListSize];
 055            int index = 0;
 56
 057            MemoryMarshal.Write(buffer.AsSpan(index), in protocols);
 058            index += sizeof(Sec_Application_Protocols);
 59
 060            for (int i = 0; i < applicationProtocols.Count; i++)
 061            {
 062                ReadOnlySpan<byte> protocol = applicationProtocols[i].Protocol.Span;
 063                buffer[index++] = (byte)protocol.Length;
 064                protocol.CopyTo(buffer.AsSpan(index));
 065                index += protocol.Length;
 066            }
 67
 068            return buffer;
 069        }
 70
 71        public static unsafe void SetProtocols(Span<byte> buffer, List<SslApplicationProtocol> applicationProtocols, int
 072        {
 073            Span<Sec_Application_Protocols> alpn = MemoryMarshal.Cast<byte, Sec_Application_Protocols>(buffer);
 074            alpn[0].ProtocolListsSize = (uint)(sizeof(Sec_Application_Protocols) - sizeof(uint) + protocolLength);
 075            alpn[0].ProtocolExtensionType = ApplicationProtocolNegotiationExt.ALPN;
 076            alpn[0].ProtocolListSize = (ushort)protocolLength;
 77
 078            Span<byte> data = buffer.Slice(sizeof(Sec_Application_Protocols));
 079            for (int i = 0; i < applicationProtocols.Count; i++)
 080            {
 081                ReadOnlySpan<byte> protocol = applicationProtocols[i].Protocol.Span;
 82
 083                data[0] = (byte)protocol.Length;
 084                data = data.Slice(1);
 085                protocol.CopyTo(data);
 086                data = data.Slice(protocol.Length);
 087            }
 088        }
 89    }
 90}
 91

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/Interop/Windows/SChannel/Interop.SecPkgContext_ApplicationProtocol.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System;
 5using System.Diagnostics.CodeAnalysis;
 6using System.Runtime.CompilerServices;
 7using System.Runtime.InteropServices;
 8
 9internal static partial class Interop
 10{
 11    internal enum ApplicationProtocolNegotiationStatus
 12    {
 13        None = 0,
 14        Success,
 15        SelectedClientOnly
 16    }
 17
 18    internal enum ApplicationProtocolNegotiationExt
 19    {
 20        None = 0,
 21        NPN,
 22        ALPN
 23    }
 24
 25    [StructLayout(LayoutKind.Sequential)]
 26    internal struct SecPkgContext_ApplicationProtocol
 27    {
 28        private const int MaxProtocolIdSize = 0xFF;
 29
 30        public ApplicationProtocolNegotiationStatus ProtoNegoStatus;
 31        public ApplicationProtocolNegotiationExt ProtoNegoExt;
 32        public byte ProtocolIdSize;
 33        public ProtocolIdBuffer ProtocolId;
 34        [UnscopedRef]
 35        public ReadOnlySpan<byte> Protocol =>
 036            ((ReadOnlySpan<byte>)ProtocolId).Slice(0, ProtocolIdSize);
 37
 38        [InlineArray(MaxProtocolIdSize)]
 39        internal struct ProtocolIdBuffer
 40        {
 41            private byte _element0;
 42        }
 43    }
 44}
 45

https://raw.githubusercontent.com/dotnet/runtime/811a7eabb75c42db53440e8ba3f60c07511cfd1f/src/libraries/Common/src/Interop/Windows/SspiCli/Interop.SSPI.cs

#LineLine coverage
 1// Licensed to the .NET Foundation under one or more agreements.
 2// The .NET Foundation licenses this file to you under the MIT license.
 3
 4using System;
 5using System.Net.Security;
 6using System.Runtime.CompilerServices;
 7using System.Runtime.InteropServices;
 8
 9internal static partial class Interop
 10{
 11    internal static partial class SspiCli
 12    {
 13        internal const uint SECQOP_WRAP_NO_ENCRYPT = 0x80000001;
 14
 15        internal const int SEC_I_RENEGOTIATE = 0x90321;
 16
 17        internal const int SECPKG_NEGOTIATION_COMPLETE = 0;
 18        internal const int SECPKG_NEGOTIATION_OPTIMISTIC = 1;
 19
 20        [StructLayout(LayoutKind.Sequential, Pack = 1)]
 21        internal struct CredHandle
 22        {
 23            private IntPtr dwLower;
 24            private IntPtr dwUpper;
 25
 26            public bool IsZero
 27            {
 28                [MethodImpl(MethodImplOptions.AggressiveInlining)]
 29                get
 030                {
 031                    return dwLower == IntPtr.Zero && dwUpper == IntPtr.Zero;
 032                }
 33            }
 34
 35            internal void SetToInvalid()
 036            {
 037                dwLower = IntPtr.Zero;
 038                dwUpper = IntPtr.Zero;
 039            }
 40
 041            public override string ToString() => $"{dwLower:x}:{dwUpper:x}";
 42        }
 43
 44        internal enum ContextAttribute
 45        {
 46            // sspi.h
 47            SECPKG_ATTR_SIZES = 0,
 48            SECPKG_ATTR_NAMES = 1,
 49            SECPKG_ATTR_LIFESPAN = 2,
 50            SECPKG_ATTR_DCE_INFO = 3,
 51            SECPKG_ATTR_STREAM_SIZES = 4,
 52            SECPKG_ATTR_AUTHORITY = 6,
 53            SECPKG_ATTR_PACKAGE_INFO = 10,
 54            SECPKG_ATTR_NEGOTIATION_INFO = 12,
 55            SECPKG_ATTR_UNIQUE_BINDINGS = 25,
 56            SECPKG_ATTR_ENDPOINT_BINDINGS = 26,
 57            SECPKG_ATTR_CLIENT_SPECIFIED_TARGET = 27,
 58            SECPKG_ATTR_APPLICATION_PROTOCOL = 35,
 59
 60            // minschannel.h
 61            SECPKG_ATTR_REMOTE_CERT_CONTEXT = 0x53,    // returns PCCERT_CONTEXT
 62            SECPKG_ATTR_LOCAL_CERT_CONTEXT = 0x54,     // returns PCCERT_CONTEXT
 63            SECPKG_ATTR_ROOT_STORE = 0x55,             // returns HCERTCONTEXT to the root store
 64            SECPKG_ATTR_ISSUER_LIST_EX = 0x59,         // returns SecPkgContext_IssuerListInfoEx
 65            SECPKG_ATTR_CLIENT_CERT_POLICY = 0x60,     // sets    SecPkgCred_ClientCertCtlPolicy
 66            SECPKG_ATTR_CONNECTION_INFO = 0x5A,        // returns SecPkgContext_ConnectionInfo
 67            SECPKG_ATTR_SESSION_INFO = 0x5D,           // sets    SecPkgContext_SessionInfo
 68            SECPKG_ATTR_CIPHER_INFO = 0x64,            // returns SecPkgContext_CipherInfo
 69            SECPKG_ATTR_REMOTE_CERT_CHAIN = 0x67,      // returns PCCERT_CONTEXT
 70            SECPKG_ATTR_UI_INFO = 0x68,                // sets    SEcPkgContext_UiInfo
 71        }
 72
 73        // These values are defined within sspi.h as ISC_REQ_*, ISC_RET_*, ASC_REQ_* and ASC_RET_*.
 74        [Flags]
 75        internal enum ContextFlags
 76        {
 77            Zero = 0,
 78            // The server in the transport application can
 79            // build new security contexts impersonating the
 80            // client that will be accepted by other servers
 81            // as the client's contexts.
 82            Delegate = 0x00000001,
 83            // The communicating parties must authenticate
 84            // their identities to each other. Without MutualAuth,
 85            // the client authenticates its identity to the server.
 86            // With MutualAuth, the server also must authenticate
 87            // its identity to the client.
 88            MutualAuth = 0x00000002,
 89            // The security package detects replayed packets and
 90            // notifies the caller if a packet has been replayed.
 91            // The use of this flag implies all of the conditions
 92            // specified by the Integrity flag.
 93            ReplayDetect = 0x00000004,
 94            // The context must be allowed to detect out-of-order
 95            // delivery of packets later through the message support
 96            // functions. Use of this flag implies all of the
 97            // conditions specified by the Integrity flag.
 98            SequenceDetect = 0x00000008,
 99            // The context must protect data while in transit.
 100            // Confidentiality is supported for NTLM with Microsoft
 101            // Windows NT version 4.0, SP4 and later and with the
 102            // Kerberos protocol in Microsoft Windows 2000 and later.
 103            Confidentiality = 0x00000010,
 104            UseSessionKey = 0x00000020,
 105            AllocateMemory = 0x00000100,
 106
 107            // Connection semantics must be used.
 108            Connection = 0x00000800,
 109
 110            // Client applications requiring extended error messages specify the
 111            // ISC_REQ_EXTENDED_ERROR flag when calling the InitializeSecurityContext
 112            // Server applications requiring extended error messages set
 113            // the ASC_REQ_EXTENDED_ERROR flag when calling AcceptSecurityContext.
 114            InitExtendedError = 0x00004000,
 115            AcceptExtendedError = 0x00008000,
 116            // A transport application requests stream semantics
 117            // by setting the ISC_REQ_STREAM and ASC_REQ_STREAM
 118            // flags in the calls to the InitializeSecurityContext
 119            // and AcceptSecurityContext functions
 120            InitStream = 0x00008000,
 121            AcceptStream = 0x00010000,
 122            // Buffer integrity can be verified; however, replayed
 123            // and out-of-sequence messages will not be detected
 124            InitIntegrity = 0x00010000,       // ISC_REQ_INTEGRITY
 125            AcceptIntegrity = 0x00020000,       // ASC_REQ_INTEGRITY
 126
 127            InitManualCredValidation = 0x00080000,   // ISC_REQ_MANUAL_CRED_VALIDATION
 128            InitUseSuppliedCreds = 0x00000080,   // ISC_REQ_USE_SUPPLIED_CREDS
 129            InitIdentify = 0x00020000,   // ISC_REQ_IDENTIFY
 130            AcceptIdentify = 0x00080000,   // ASC_REQ_IDENTIFY
 131
 132            ProxyBindings = 0x04000000,   // ASC_REQ_PROXY_BINDINGS
 133            AllowMissingBindings = 0x10000000,   // ASC_REQ_ALLOW_MISSING_BINDINGS
 134
 135            UnverifiedTargetName = 0x20000000,   // ISC_REQ_UNVERIFIED_TARGET_NAME
 136        }
 137
 138        internal enum Endianness
 139        {
 140            SECURITY_NETWORK_DREP = 0x00,
 141            SECURITY_NATIVE_DREP = 0x10,
 142        }
 143
 144        internal enum CredentialUse
 145        {
 146            SECPKG_CRED_INBOUND = 0x1,
 147            SECPKG_CRED_OUTBOUND = 0x2,
 148            SECPKG_CRED_BOTH = 0x3,
 149        }
 150
 151        // wincrypt.h
 152        [StructLayout(LayoutKind.Sequential)]
 153        internal struct CERT_CHAIN_ELEMENT
 154        {
 155            public uint cbSize;
 156            public IntPtr pCertContext;
 157            // Since this structure is allocated by unmanaged code, we can
 158            // omit the fields below since we don't need to access them
 159            // CERT_TRUST_STATUS   TrustStatus;
 160            // IntPtr                pRevocationInfo;
 161            // IntPtr                pIssuanceUsage;
 162            // IntPtr                pApplicationUsage;
 163        }
 164
 165        // schannel.h
 166        [StructLayout(LayoutKind.Sequential)]
 167        internal struct SecPkgContext_IssuerListInfoEx
 168        {
 169            public IntPtr aIssuers;
 170            public uint cIssuers;
 171        }
 172
 173        [StructLayout(LayoutKind.Sequential)]
 174        internal unsafe struct SCHANNEL_CRED
 175        {
 176            public const int CurrentVersion = 0x4;
 177
 178            public int dwVersion;
 179            public int cCreds;
 180
 181            public Crypt32.CERT_CONTEXT** paCred;
 182
 183            public IntPtr hRootStore;               // == always null, OTHERWISE NOT RELIABLE
 184            public int cMappers;
 185            public IntPtr aphMappers;               // == always null, OTHERWISE NOT RELIABLE
 186            public int cSupportedAlgs;
 187            public IntPtr palgSupportedAlgs;       // == always null, OTHERWISE NOT RELIABLE
 188            public int grbitEnabledProtocols;
 189            public int dwMinimumCipherStrength;
 190            public int dwMaximumCipherStrength;
 191            public int dwSessionLifespan;
 192            public SCHANNEL_CRED.Flags dwFlags;
 193            public int reserved;
 194
 195            [Flags]
 196            public enum Flags
 197            {
 198                Zero = 0,
 199                SCH_CRED_NO_SYSTEM_MAPPER = 0x02,
 200                SCH_CRED_NO_SERVERNAME_CHECK = 0x04,
 201                SCH_CRED_MANUAL_CRED_VALIDATION = 0x08,
 202                SCH_CRED_NO_DEFAULT_CREDS = 0x10,
 203                SCH_CRED_AUTO_CRED_VALIDATION = 0x20,
 204                SCH_CRED_DISABLE_RECONNECTS = 0x80,
 205                SCH_CRED_REVOCATION_CHECK_END_CERT = 0x100,
 206                SCH_CRED_IGNORE_NO_REVOCATION_CHECK = 0x800,
 207                SCH_CRED_IGNORE_REVOCATION_OFFLINE = 0x1000,
 208                SCH_CRED_CACHE_ONLY_URL_RETRIEVAL = 0x8000,
 209                SCH_CRED_CACHE_ONLY_URL_RETRIEVAL_ON_CREATE = 0x20000,
 210                SCH_SEND_AUX_RECORD = 0x00200000,
 211                SCH_USE_STRONG_CRYPTO = 0x00400000,
 212            }
 213        }
 214
 215        [StructLayout(LayoutKind.Sequential)]
 216        internal unsafe struct SCH_CREDENTIALS
 217        {
 218            public const int CurrentVersion = 0x5;
 219
 220            public int dwVersion;
 221            public int dwCredformat;
 222            public int cCreds;
 223
 224            public Crypt32.CERT_CONTEXT** paCred;
 225
 226            public IntPtr hRootStore;               // == always null, OTHERWISE NOT RELIABLE
 227            public int cMappers;
 228            public IntPtr aphMappers;               // == always null, OTHERWISE NOT RELIABLE
 229
 230            public int dwSessionLifespan;
 231            public SCH_CREDENTIALS.Flags dwFlags;
 232            public int cTlsParameters;
 233            public TLS_PARAMETERS* pTlsParameters;
 234
 235            [Flags]
 236            public enum Flags
 237            {
 238                Zero = 0,
 239                SCH_CRED_NO_SYSTEM_MAPPER = 0x02,
 240                SCH_CRED_NO_SERVERNAME_CHECK = 0x04,
 241                SCH_CRED_MANUAL_CRED_VALIDATION = 0x08,
 242                SCH_CRED_NO_DEFAULT_CREDS = 0x10,
 243                SCH_CRED_AUTO_CRED_VALIDATION = 0x20,
 244                SCH_CRED_USE_DEFAULT_CREDS = 0x40,
 245                SCH_CRED_DISABLE_RECONNECTS = 0x80,
 246                SCH_CRED_REVOCATION_CHECK_END_CERT = 0x100,
 247                SCH_CRED_REVOCATION_CHECK_CHAIN = 0x200,
 248                SCH_CRED_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT = 0x400,
 249                SCH_CRED_IGNORE_NO_REVOCATION_CHECK = 0x800,
 250                SCH_CRED_IGNORE_REVOCATION_OFFLINE = 0x1000,
 251                SCH_CRED_CACHE_ONLY_URL_RETRIEVAL = 0x8000,
 252                SCH_CRED_CACHE_ONLY_URL_RETRIEVAL_ON_CREATE = 0x20000,
 253                SCH_SEND_ROOT_CERT = 0x40000,
 254                SCH_SEND_AUX_RECORD = 0x00200000,
 255                SCH_USE_STRONG_CRYPTO = 0x00400000,
 256                SCH_USE_PRESHAREDKEY_ONLY = 0x800000,
 257                SCH_ALLOW_NULL_ENCRYPTION = 0x02000000,
 258            }
 259        }
 260
 261        [StructLayout(LayoutKind.Sequential)]
 262        internal unsafe struct TLS_PARAMETERS
 263        {
 264            public int cAlpnIds;                        // Valid for server applications only. Must be zero otherwise. N
 265            public UNICODE_STRING* rgstrAlpnIds;                 // Valid for server applications only. Must be NULL oth
 266            public uint grbitDisabledProtocols;         // List protocols you DO NOT want negotiated.
 267            public int cDisabledCrypto;                 // Number of CRYPTO_SETTINGS structures; set to 0 if there are n
 268            public CRYPTO_SETTINGS* pDisabledCrypto;    // Array of CRYPTO_SETTINGS structures; set to NULL if there are
 269            public TLS_PARAMETERS.Flags dwFlags;        // Optional flags to pass; set to 0 if there are none.
 270
 271            [Flags]
 272            public enum Flags
 273            {
 274                Zero = 0,
 275                TLS_PARAMS_OPTIONAL = 0x01,     // Valid for server applications only. Must be zero otherwise.
 276                                                // TLS_PARAMETERS that will only be honored if they do not cause this se
 277            }
 278        }
 279
 280        [StructLayout(LayoutKind.Sequential)]
 281        internal unsafe struct CRYPTO_SETTINGS
 282        {
 283            public TlsAlgorithmUsage eAlgorithmUsage;   // How this algorithm is being used.
 284            public UNICODE_STRING strCngAlgId;          // CNG algorithm identifier.
 285            public int cChainingModes;                  // Set to 0 if CNG algorithm does not have a chaining mode.
 286            public UNICODE_STRING* rgstrChainingModes;  // Set to NULL if CNG algorithm does not have a chaining mode.
 287            public int dwMinBitLength;                  // Minimum bit length for the specified CNG algorithm. Set to 0 
 288            public int dwMaxBitLength;                  // Maximum bit length for the specified CNG algorithm. Set to 0 
 289
 290            public enum TlsAlgorithmUsage
 291            {
 292                TlsParametersCngAlgUsageKeyExchange,    // Key exchange algorithm. RSA, ECHDE, DHE, etc.
 293                TlsParametersCngAlgUsageSignature,      // Signature algorithm. RSA, DSA, ECDSA, etc.
 294                TlsParametersCngAlgUsageCipher,         // Encryption algorithm. AES, DES, RC4, etc.
 295                TlsParametersCngAlgUsageDigest,         // Digest of cipher suite. SHA1, SHA256, SHA384, etc.
 296                TlsParametersCngAlgUsageCertSig         // Signature and/or hash used to sign certificate. RSA, DSA, ECD
 297            }
 298        }
 299
 300        [StructLayout(LayoutKind.Sequential)]
 301        internal struct SecBuffer
 302        {
 303            public int cbBuffer;
 304            public SecurityBufferType BufferType;
 305            public IntPtr pvBuffer;
 306
 307            public static readonly unsafe int Size = sizeof(SecBuffer);
 308        }
 309
 310        [StructLayout(LayoutKind.Sequential)]
 311        internal unsafe struct SecBufferDesc
 312        {
 313            public readonly int ulVersion;
 314            public readonly int cBuffers;
 315            public void* pBuffers;
 316
 317            public SecBufferDesc(int count)
 0318            {
 0319                ulVersion = 0;
 0320                cBuffers = count;
 0321                pBuffers = null;
 0322            }
 323        }
 324
 325        [StructLayout(LayoutKind.Sequential)]
 326        internal unsafe struct SecPkgCred_ClientCertPolicy
 327        {
 328            public uint dwFlags;
 329            public Guid guidPolicyId;
 330            public uint dwCertFlags;
 331            public uint dwUrlRetrievalTimeout;
 332            public BOOL fCheckRevocationFreshnessTime;
 333            public uint dwRevocationFreshnessTime;
 334            public BOOL fOmitUsageCheck;
 335            public char* pwszSslCtlStoreName;
 336            public char* pwszSslCtlIdentifier;
 337        }
 338
 339        [StructLayout(LayoutKind.Sequential)]
 340        internal struct SecPkgContext_SessionInfo
 341        {
 342            public uint dwFlags;
 343            public uint cbSessionId;
 344            public SessionIdBuffer rgbSessionId;
 345
 346            [InlineArray(32)]
 347            internal struct SessionIdBuffer
 348            {
 349                private byte _element0;
 350            }
 351
 352            [Flags]
 353            public enum Flags
 354            {
 355                Zero = 0,
 356                SSL_SESSION_RECONNECT = 0x01,
 357            };
 358        }
 359
 360        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 361        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 362        internal static partial int EncryptMessage(
 363            ref CredHandle contextHandle,
 364            uint qualityOfProtection,
 365            ref SecBufferDesc inputOutput,
 366            uint sequenceNumber);
 367
 368        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 369        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 370        internal static unsafe partial int DecryptMessage(
 371            ref CredHandle contextHandle,
 372            ref SecBufferDesc inputOutput,
 373            uint sequenceNumber,
 374            uint* qualityOfProtection);
 375
 376        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 377        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 378        internal static partial int MakeSignature(
 379            ref CredHandle contextHandle,
 380            uint qualityOfProtection,
 381            ref SecBufferDesc inputOutput,
 382            uint sequenceNumber);
 383
 384        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 385        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 386        internal static unsafe partial int VerifySignature(
 387            ref CredHandle contextHandle,
 388            in SecBufferDesc input,
 389            uint sequenceNumber,
 390            uint* qualityOfProtection);
 391
 392        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 393        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 394        internal static partial int QuerySecurityContextToken(
 395            ref CredHandle phContext,
 396            out SecurityContextTokenHandle handle);
 397
 398        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 399        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 400        internal static partial int FreeContextBuffer(
 401            IntPtr contextBuffer);
 402
 403        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 404        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 405        internal static partial int FreeCredentialsHandle(
 406            ref CredHandle handlePtr);
 407
 408        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 409        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 410        internal static partial int DeleteSecurityContext(
 411            ref CredHandle handlePtr);
 412
 413        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 414        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 415        internal static unsafe partial int AcceptSecurityContext(
 416            ref CredHandle credentialHandle,
 417            void* inContextPtr,
 418            SecBufferDesc* inputBuffer,
 419            ContextFlags inFlags,
 420            Endianness endianness,
 421            ref CredHandle outContextPtr,
 422            ref SecBufferDesc outputBuffer,
 423            ref ContextFlags attributes,
 424            out long timeStamp);
 425
 426        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 427        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 428        internal static unsafe partial int QueryContextAttributesW(
 429            ref CredHandle contextHandle,
 430            ContextAttribute attribute,
 431            void* buffer);
 432
 433        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 434        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 435        internal static partial int SetContextAttributesW(
 436            ref CredHandle contextHandle,
 437            ContextAttribute attribute,
 438            byte[] buffer,
 439            int bufferSize);
 440
 441        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 442        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 443        internal static partial int EnumerateSecurityPackagesW(
 444            out int pkgnum,
 445            out SafeFreeContextBuffer_SECURITY handle);
 446
 447        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 448        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
 449        internal static unsafe partial int AcquireCredentialsHandleW(
 450            string? principal,
 451            string moduleName,
 452            int usage,
 453            void* logonID,
 454            IntPtr zero,
 455            void* keyCallback,
 456            void* keyArgument,
 457            ref CredHandle handlePtr,
 458            out long timeStamp);
 459
 460        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 461        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
 462        internal static unsafe partial int AcquireCredentialsHandleW(
 463            string? principal,
 464            string moduleName,
 465            int usage,
 466            void* logonID,
 467            SafeSspiAuthDataHandle authdata,
 468            void* keyCallback,
 469            void* keyArgument,
 470            ref CredHandle handlePtr,
 471            out long timeStamp);
 472
 473        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 474        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
 475        internal static unsafe partial int AcquireCredentialsHandleW(
 476            string? principal,
 477            string moduleName,
 478            int usage,
 479            void* logonID,
 480            SCHANNEL_CRED* authData,
 481            void* keyCallback,
 482            void* keyArgument,
 483            ref CredHandle handlePtr,
 484            out long timeStamp);
 485
 486        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 487        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
 488        internal static unsafe partial int AcquireCredentialsHandleW(
 489            string? principal,
 490            string moduleName,
 491            int usage,
 492            void* logonID,
 493            SCH_CREDENTIALS* authData,
 494            void* keyCallback,
 495            void* keyArgument,
 496            ref CredHandle handlePtr,
 497            out long timeStamp);
 498
 499        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 500        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 501        internal static unsafe partial int InitializeSecurityContextW(
 502            ref CredHandle credentialHandle,
 503            void* inContextPtr,
 504            byte* targetName,
 505            ContextFlags inFlags,
 506            int reservedI,
 507            Endianness endianness,
 508            SecBufferDesc* inputBuffer,
 509            int reservedII,
 510            ref CredHandle outContextPtr,
 511            ref SecBufferDesc outputBuffer,
 512            ref ContextFlags attributes,
 513            out long timeStamp);
 514
 515        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 516        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 517        internal static unsafe partial int CompleteAuthToken(
 518            void* inContextPtr,
 519            ref SecBufferDesc inputBuffers);
 520
 521        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 522        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 523        internal static unsafe partial int ApplyControlToken(
 524            void* inContextPtr,
 525            ref SecBufferDesc inputBuffers);
 526
 527        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 528        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 529        internal static partial SECURITY_STATUS SspiFreeAuthIdentity(
 530            IntPtr authData);
 531
 532        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 533        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true, StringMarshalling = StringMarshalling.Utf16)]
 534        internal static partial SECURITY_STATUS SspiEncodeStringsAsAuthIdentity(
 535            string userName,
 536            string domainName,
 537            string password,
 538            out SafeSspiAuthDataHandle authData);
 539
 540        [DefaultDllImportSearchPaths(DllImportSearchPath.System32)]
 541        [LibraryImport(Interop.Libraries.SspiCli, SetLastError = true)]
 542        internal static partial SECURITY_STATUS SetCredentialsAttributesW(
 543            in CredHandle handlePtr,
 544            uint ulAttribute,
 545            in SecPkgCred_ClientCertPolicy pBuffer,
 546            uint cbBuffer);
 547    }
 548}
 549
Generated by: ReportGenerator 5.5.11.0
10/9/2026 - 5:47:08 PM
GitHub | reportgenerator.io

Methods/Properties

GetProtocolLength(System.Collections.Generic.List`1<System.Net.Security.SslApplicationProtocol>)
ToByteArray(System.Collections.Generic.List`1<System.Net.Security.SslApplicationProtocol>)
SetProtocols(System.Span`1<System.Byte>,System.Collections.Generic.List`1<System.Net.Security.SslApplicationProtocol>,System.Int32)
Protocol()
IsZero()
SetToInvalid()
ToString()
.ctor(System.Int32)