using System;
using System.Collections.ObjectModel;
using System.Diagnostics;
using System.IO;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Permissions;
using FxResources.System.Security.Cryptography.Cng;
using Microsoft.CodeAnalysis;
using Microsoft.Win32.SafeHandles;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = "")]
[assembly: CLSCompliant(true)]
[assembly: SupportedOSPlatform("windows")]
[assembly: AssemblyDefaultAlias("System.Security.Cryptography.Cng")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: AssemblyMetadata("NotSupported", "True")]
[assembly: AssemblyMetadata(".NETFrameworkAssembly", "")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("System.Security.Cryptography.Cng")]
[assembly: AssemblyFileVersion("5.0.20.51904")]
[assembly: AssemblyInformationalVersion("5.0.0+cf258a14b70ad9069470a108f13765e0e5988f51")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("System.Security.Cryptography.Cng")]
[assembly: AssemblyMetadata("RepositoryUrl", "git://github.com/dotnet/runtime")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("5.0.0.0")]
[module: UnverifiableCode]
[module: System.Runtime.CompilerServices.NullablePublicOnly(false)]
namespace Microsoft.CodeAnalysis
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	internal sealed class EmbeddedAttribute : Attribute
	{
	}
}
namespace System.Runtime.CompilerServices
{
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Parameter | AttributeTargets.ReturnValue | AttributeTargets.GenericParameter, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableAttribute : Attribute
	{
		public readonly byte[] NullableFlags;

		public NullableAttribute(byte P_0)
		{
			NullableFlags = new byte[1] { P_0 };
		}

		public NullableAttribute(byte[] P_0)
		{
			NullableFlags = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Method | AttributeTargets.Interface | AttributeTargets.Delegate, AllowMultiple = false, Inherited = false)]
	internal sealed class NullableContextAttribute : Attribute
	{
		public readonly byte Flag;

		public NullableContextAttribute(byte P_0)
		{
			Flag = P_0;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class NullablePublicOnlyAttribute : Attribute
	{
		public readonly bool IncludesInternals;

		public NullablePublicOnlyAttribute(bool P_0)
		{
			IncludesInternals = P_0;
		}
	}
}
namespace FxResources.System.Security.Cryptography.Cng
{
	internal static class SR
	{
	}
}
namespace Microsoft.Win32.SafeHandles
{
	public abstract class SafeNCryptHandle : SafeHandleZeroOrMinusOneIsInvalid
	{
		public override bool IsInvalid
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		protected SafeNCryptHandle()
			: base(ownsHandle: false)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected SafeNCryptHandle(IntPtr handle, SafeHandle parentHandle)
			: base(ownsHandle: false)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override bool ReleaseHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected abstract bool ReleaseNativeHandle();
	}
	public sealed class SafeNCryptKeyHandle : SafeNCryptHandle
	{
		public SafeNCryptKeyHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public SafeNCryptKeyHandle(IntPtr handle, SafeHandle parentHandle)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override bool ReleaseNativeHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class SafeNCryptProviderHandle : SafeNCryptHandle
	{
		public SafeNCryptProviderHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override bool ReleaseNativeHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class SafeNCryptSecretHandle : SafeNCryptHandle
	{
		public SafeNCryptSecretHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override bool ReleaseNativeHandle()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
}
namespace System
{
	internal static class SR
	{
		private static readonly bool s_usingResourceKeys = AppContext.TryGetSwitch("System.Resources.UseSystemResourceKeys", out var isEnabled) && isEnabled;

		private static ResourceManager s_resourceManager;

		internal static ResourceManager ResourceManager => s_resourceManager ?? (s_resourceManager = new ResourceManager(typeof(SR)));

		internal static string ArgumentOutOfRange_NeedNonNegNum => GetResourceString("ArgumentOutOfRange_NeedNonNegNum");

		internal static string Argument_EncodeDestinationTooSmall => GetResourceString("Argument_EncodeDestinationTooSmall");

		internal static string Argument_Invalid_SafeHandleInvalidOrClosed => GetResourceString("Argument_Invalid_SafeHandleInvalidOrClosed");

		internal static string Argument_InvalidOffLen => GetResourceString("Argument_InvalidOffLen");

		internal static string Argument_InvalidOidValue => GetResourceString("Argument_InvalidOidValue");

		internal static string Argument_InvalidValue => GetResourceString("Argument_InvalidValue");

		internal static string ArgumentNull_Buffer => GetResourceString("ArgumentNull_Buffer");

		internal static string ArgumentOutOfRange_NeedPosNum => GetResourceString("ArgumentOutOfRange_NeedPosNum");

		internal static string Cryptography_AlgKdfRequiresChars => GetResourceString("Cryptography_AlgKdfRequiresChars");

		internal static string Cryptography_ArgECDHKeySizeMismatch => GetResourceString("Cryptography_ArgECDHKeySizeMismatch");

		internal static string Cryptography_ArgECDHRequiresECDHKey => GetResourceString("Cryptography_ArgECDHRequiresECDHKey");

		internal static string Cryptography_ArgExpectedECDiffieHellmanCngPublicKey => GetResourceString("Cryptography_ArgExpectedECDiffieHellmanCngPublicKey");

		internal static string Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum => GetResourceString("Cryptography_Asn_EnumeratedValueRequiresNonFlagsEnum");

		internal static string Cryptography_Asn_NamedBitListRequiresFlagsEnum => GetResourceString("Cryptography_Asn_NamedBitListRequiresFlagsEnum");

		internal static string Cryptography_Asn_NamedBitListValueTooBig => GetResourceString("Cryptography_Asn_NamedBitListValueTooBig");

		internal static string Cryptography_Asn_UniversalValueIsFixed => GetResourceString("Cryptography_Asn_UniversalValueIsFixed");

		internal static string Cryptography_Asn_UnusedBitCountRange => GetResourceString("Cryptography_Asn_UnusedBitCountRange");

		internal static string Cryptography_AsnWriter_EncodeUnbalancedStack => GetResourceString("Cryptography_AsnWriter_EncodeUnbalancedStack");

		internal static string Cryptography_AsnWriter_PopWrongTag => GetResourceString("Cryptography_AsnWriter_PopWrongTag");

		internal static string Cryptography_TlsRequiresLabelAndSeed => GetResourceString("Cryptography_TlsRequiresLabelAndSeed");

		internal static string Cryptography_ArgDSARequiresDSAKey => GetResourceString("Cryptography_ArgDSARequiresDSAKey");

		internal static string Cryptography_ArgECDsaRequiresECDsaKey => GetResourceString("Cryptography_ArgECDsaRequiresECDsaKey");

		internal static string Cryptography_ArgRSARequiresRSAKey => GetResourceString("Cryptography_ArgRSARequiresRSAKey");

		internal static string Cryptography_CngKeyWrongAlgorithm => GetResourceString("Cryptography_CngKeyWrongAlgorithm");

		internal static string Cryptography_Der_Invalid_Encoding => GetResourceString("Cryptography_Der_Invalid_Encoding");

		internal static string Cryptography_Encryption_MessageTooLong => GetResourceString("Cryptography_Encryption_MessageTooLong");

		internal static string Cryptography_HashAlgorithmNameNullOrEmpty => GetResourceString("Cryptography_HashAlgorithmNameNullOrEmpty");

		internal static string Cryptography_InvalidAlgorithmGroup => GetResourceString("Cryptography_InvalidAlgorithmGroup");

		internal static string Cryptography_InvalidAlgorithmName => GetResourceString("Cryptography_InvalidAlgorithmName");

		internal static string Cryptography_InvalidCipherMode => GetResourceString("Cryptography_InvalidCipherMode");

		internal static string Cryptography_InvalidDsaParameters_MissingFields => GetResourceString("Cryptography_InvalidDsaParameters_MissingFields");

		internal static string Cryptography_InvalidDsaParameters_MismatchedPGY => GetResourceString("Cryptography_InvalidDsaParameters_MismatchedPGY");

		internal static string Cryptography_InvalidDsaParameters_MismatchedQX => GetResourceString("Cryptography_InvalidDsaParameters_MismatchedQX");

		internal static string Cryptography_InvalidDsaParameters_MismatchedPJ => GetResourceString("Cryptography_InvalidDsaParameters_MismatchedPJ");

		internal static string Cryptography_InvalidDsaParameters_SeedRestriction_ShortKey => GetResourceString("Cryptography_InvalidDsaParameters_SeedRestriction_ShortKey");

		internal static string Cryptography_InvalidDsaParameters_QRestriction_ShortKey => GetResourceString("Cryptography_InvalidDsaParameters_QRestriction_ShortKey");

		internal static string Cryptography_InvalidDsaParameters_QRestriction_LargeKey => GetResourceString("Cryptography_InvalidDsaParameters_QRestriction_LargeKey");

		internal static string Cryptography_CurveNotSupported => GetResourceString("Cryptography_CurveNotSupported");

		internal static string Cryptography_InvalidCurveOid => GetResourceString("Cryptography_InvalidCurveOid");

		internal static string Cryptography_InvalidIVSize => GetResourceString("Cryptography_InvalidIVSize");

		internal static string Cryptography_InvalidKeyBlobFormat => GetResourceString("Cryptography_InvalidKeyBlobFormat");

		internal static string Cryptography_InvalidKeySize => GetResourceString("Cryptography_InvalidKeySize");

		internal static string Cryptography_InvalidPadding => GetResourceString("Cryptography_InvalidPadding");

		internal static string Cryptography_InvalidProviderName => GetResourceString("Cryptography_InvalidProviderName");

		internal static string Cryptography_InvalidRsaParameters => GetResourceString("Cryptography_InvalidRsaParameters");

		internal static string Cryptography_KeyBlobParsingError => GetResourceString("Cryptography_KeyBlobParsingError");

		internal static string Cryptography_KeyTooSmall => GetResourceString("Cryptography_KeyTooSmall");

		internal static string Cryptography_OpenEphemeralKeyHandleWithoutEphemeralFlag => GetResourceString("Cryptography_OpenEphemeralKeyHandleWithoutEphemeralFlag");

		internal static string Cryptography_OpenInvalidHandle => GetResourceString("Cryptography_OpenInvalidHandle");

		internal static string Cryptography_MissingIV => GetResourceString("Cryptography_MissingIV");

		internal static string Cryptography_MustTransformWholeBlock => GetResourceString("Cryptography_MustTransformWholeBlock");

		internal static string Cryptography_NotValidPrivateKey => GetResourceString("Cryptography_NotValidPrivateKey");

		internal static string Cryptography_NotValidPublicOrPrivateKey => GetResourceString("Cryptography_NotValidPublicOrPrivateKey");

		internal static string Cryptography_OAEP_Decryption_Failed => GetResourceString("Cryptography_OAEP_Decryption_Failed");

		internal static string Cryptography_PartialBlock => GetResourceString("Cryptography_PartialBlock");

		internal static string Cryptography_RSA_DecryptWrongSize => GetResourceString("Cryptography_RSA_DecryptWrongSize");

		internal static string Cryptography_Pkcs8_EncryptedReadFailed => GetResourceString("Cryptography_Pkcs8_EncryptedReadFailed");

		internal static string Cryptography_SignHash_WrongSize => GetResourceString("Cryptography_SignHash_WrongSize");

		internal static string Cryptography_UnsupportedPaddingMode => GetResourceString("Cryptography_UnsupportedPaddingMode");

		internal static string Cryptography_TransformBeyondEndOfBuffer => GetResourceString("Cryptography_TransformBeyondEndOfBuffer");

		internal static string Cryptography_UnexpectedTransformTruncation => GetResourceString("Cryptography_UnexpectedTransformTruncation");

		internal static string Cryptography_UnknownAlgorithmIdentifier => GetResourceString("Cryptography_UnknownAlgorithmIdentifier");

		internal static string Cryptography_UnknownHashAlgorithm => GetResourceString("Cryptography_UnknownHashAlgorithm");

		internal static string Cryptography_UnknownPaddingMode => GetResourceString("Cryptography_UnknownPaddingMode");

		internal static string Cryptography_WeakKey => GetResourceString("Cryptography_WeakKey");

		internal static string Cryptography_WriteEncodedValue_OneValueAtATime => GetResourceString("Cryptography_WriteEncodedValue_OneValueAtATime");

		internal static string PlatformNotSupported_CryptographyCng => GetResourceString("PlatformNotSupported_CryptographyCng");

		internal static string Cryptography_ECC_NamedCurvesOnly => GetResourceString("Cryptography_ECC_NamedCurvesOnly");

		internal static string Cryptography_CSP_NoPrivateKey => GetResourceString("Cryptography_CSP_NoPrivateKey");

		internal static string Cryptography_InvalidECCharacteristic2Curve => GetResourceString("Cryptography_InvalidECCharacteristic2Curve");

		internal static string Argument_DestinationTooShort => GetResourceString("Argument_DestinationTooShort");

		private static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		internal static string GetResourceString(string resourceKey, string defaultString = null)
		{
			if (UsingResourceKeys())
			{
				return defaultString ?? resourceKey;
			}
			string text = null;
			try
			{
				text = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			if (defaultString != null && resourceKey.Equals(text))
			{
				return defaultString;
			}
			return text;
		}

		internal static string Format(string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(resourceFormat, p1);
		}

		internal static string Format(string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(resourceFormat, p1, p2);
		}

		internal static string Format(string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(resourceFormat, p1, p2, p3);
		}

		internal static string Format(string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(resourceFormat, args);
			}
			return resourceFormat;
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1);
			}
			return string.Format(provider, resourceFormat, p1);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1, object p2)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2);
			}
			return string.Format(provider, resourceFormat, p1, p2);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, object p1, object p2, object p3)
		{
			if (UsingResourceKeys())
			{
				return string.Join(", ", resourceFormat, p1, p2, p3);
			}
			return string.Format(provider, resourceFormat, p1, p2, p3);
		}

		internal static string Format(IFormatProvider provider, string resourceFormat, params object[] args)
		{
			if (args != null)
			{
				if (UsingResourceKeys())
				{
					return resourceFormat + ", " + string.Join(", ", args);
				}
				return string.Format(provider, resourceFormat, args);
			}
			return resourceFormat;
		}
	}
}
namespace System.Security.Cryptography
{
	public sealed class AesCng : Aes
	{
		public override byte[] Key
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override int KeySize
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public AesCng()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public AesCng(string keyName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public AesCng(string keyName, CngProvider provider)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public AesCng(string keyName, CngProvider provider, CngKeyOpenOptions openOptions)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateDecryptor()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[]? rgbIV)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateEncryptor()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[]? rgbIV)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public override void GenerateIV()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override void GenerateKey()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class CngAlgorithm : IEquatable<CngAlgorithm>
	{
		public string Algorithm
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDiffieHellman
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDiffieHellmanP256
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDiffieHellmanP384
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDiffieHellmanP521
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDsa
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDsaP256
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDsaP384
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm ECDsaP521
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm MD5
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm Rsa
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm Sha1
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm Sha256
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm Sha384
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithm Sha512
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngAlgorithm(string algorithm)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool Equals(object? obj)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool Equals(CngAlgorithm? other)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override int GetHashCode()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator ==(CngAlgorithm? left, CngAlgorithm? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator !=(CngAlgorithm? left, CngAlgorithm? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override string ToString()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class CngAlgorithmGroup : IEquatable<CngAlgorithmGroup>
	{
		public string AlgorithmGroup
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithmGroup DiffieHellman
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithmGroup Dsa
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithmGroup ECDiffieHellman
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithmGroup ECDsa
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngAlgorithmGroup Rsa
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngAlgorithmGroup(string algorithmGroup)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool Equals(object? obj)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool Equals(CngAlgorithmGroup? other)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override int GetHashCode()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator ==(CngAlgorithmGroup? left, CngAlgorithmGroup? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator !=(CngAlgorithmGroup? left, CngAlgorithmGroup? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override string ToString()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	[Flags]
	public enum CngExportPolicies
	{
		None = 0,
		AllowExport = 1,
		AllowPlaintextExport = 2,
		AllowArchiving = 4,
		AllowPlaintextArchiving = 8
	}
	public sealed class CngKey : IDisposable
	{
		public CngAlgorithm Algorithm
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngAlgorithmGroup? AlgorithmGroup
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngExportPolicies ExportPolicy
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public SafeNCryptKeyHandle Handle
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public bool IsEphemeral
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public bool IsMachineKey
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string? KeyName
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public int KeySize
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKeyUsages KeyUsage
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public IntPtr ParentWindowHandle
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngProvider? Provider
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public SafeNCryptProviderHandle ProviderHandle
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngUIPolicy UIPolicy
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string? UniqueName
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		internal CngKey()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Create(CngAlgorithm algorithm)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Create(CngAlgorithm algorithm, string? keyName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Create(CngAlgorithm algorithm, string? keyName, CngKeyCreationParameters? creationParameters)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public void Delete()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public void Dispose()
		{
		}

		public static bool Exists(string keyName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool Exists(string keyName, CngProvider provider)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool Exists(string keyName, CngProvider provider, CngKeyOpenOptions options)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public byte[] Export(CngKeyBlobFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public CngProperty GetProperty(string name, CngPropertyOptions options)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool HasProperty(string name, CngPropertyOptions options)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Import(byte[] keyBlob, CngKeyBlobFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Import(byte[] keyBlob, CngKeyBlobFormat format, CngProvider provider)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Open(SafeNCryptKeyHandle keyHandle, CngKeyHandleOpenOptions keyHandleOpenOptions)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Open(string keyName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Open(string keyName, CngProvider provider)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static CngKey Open(string keyName, CngProvider provider, CngKeyOpenOptions openOptions)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public void SetProperty(CngProperty property)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class CngKeyBlobFormat : IEquatable<CngKeyBlobFormat>
	{
		public static CngKeyBlobFormat EccFullPrivateBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat EccFullPublicBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat EccPrivateBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat EccPublicBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string Format
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat GenericPrivateBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat GenericPublicBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat OpaqueTransportBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngKeyBlobFormat Pkcs8PrivateBlob
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKeyBlobFormat(string format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool Equals(object? obj)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool Equals(CngKeyBlobFormat? other)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override int GetHashCode()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator ==(CngKeyBlobFormat? left, CngKeyBlobFormat? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator !=(CngKeyBlobFormat? left, CngKeyBlobFormat? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override string ToString()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	[Flags]
	public enum CngKeyCreationOptions
	{
		None = 0,
		MachineKey = 0x20,
		OverwriteExistingKey = 0x80
	}
	public sealed class CngKeyCreationParameters
	{
		public CngExportPolicies? ExportPolicy
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKeyCreationOptions KeyCreationOptions
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKeyUsages? KeyUsage
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngPropertyCollection Parameters
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public IntPtr ParentWindowHandle
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngProvider Provider
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngUIPolicy? UIPolicy
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKeyCreationParameters()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	[Flags]
	public enum CngKeyHandleOpenOptions
	{
		None = 0,
		EphemeralKey = 1
	}
	[Flags]
	public enum CngKeyOpenOptions
	{
		None = 0,
		UserKey = 0,
		MachineKey = 0x20,
		Silent = 0x40
	}
	[Flags]
	public enum CngKeyUsages
	{
		None = 0,
		Decryption = 1,
		Signing = 2,
		KeyAgreement = 4,
		AllUsages = 0xFFFFFF
	}
	public struct CngProperty : IEquatable<CngProperty>
	{
		private object _dummy;

		private int _dummyPrimitive;

		public readonly string Name
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public readonly CngPropertyOptions Options
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngProperty(string name, byte[]? value, CngPropertyOptions options)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool Equals(object? obj)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool Equals(CngProperty other)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override int GetHashCode()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public byte[]? GetValue()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator ==(CngProperty left, CngProperty right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator !=(CngProperty left, CngProperty right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class CngPropertyCollection : Collection<CngProperty>
	{
		public CngPropertyCollection()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	[Flags]
	public enum CngPropertyOptions
	{
		Persist = int.MinValue,
		None = 0,
		CustomProperty = 0x40000000
	}
	public sealed class CngProvider : IEquatable<CngProvider>
	{
		public static CngProvider MicrosoftSmartCardKeyStorageProvider
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public static CngProvider MicrosoftSoftwareKeyStorageProvider
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string Provider
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngProvider(string provider)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool Equals(object? obj)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool Equals(CngProvider? other)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override int GetHashCode()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator ==(CngProvider? left, CngProvider? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static bool operator !=(CngProvider? left, CngProvider? right)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override string ToString()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class CngUIPolicy
	{
		public string? CreationTitle
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string? Description
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string? FriendlyName
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngUIProtectionLevels ProtectionLevel
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public string? UseContext
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngUIPolicy(CngUIProtectionLevels protectionLevel)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public CngUIPolicy(CngUIProtectionLevels protectionLevel, string? friendlyName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public CngUIPolicy(CngUIProtectionLevels protectionLevel, string? friendlyName, string? description)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public CngUIPolicy(CngUIProtectionLevels protectionLevel, string? friendlyName, string? description, string? useContext)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public CngUIPolicy(CngUIProtectionLevels protectionLevel, string? friendlyName, string? description, string? useContext, string? creationTitle)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	[Flags]
	public enum CngUIProtectionLevels
	{
		None = 0,
		ProtectKey = 1,
		ForceHighProtection = 2
	}
	public sealed class DSACng : DSA
	{
		public CngKey Key
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override string? KeyExchangeAlgorithm
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override KeySizes[] LegalKeySizes
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override string SignatureAlgorithm
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public DSACng()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public DSACng(int keySize)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public DSACng(CngKey key)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override byte[] CreateSignature(byte[] rgbHash)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public override DSAParameters ExportParameters(bool includePrivateParameters)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override void ImportParameters(DSAParameters parameters)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool VerifySignature(byte[] rgbHash, byte[] rgbSignature)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class ECDiffieHellmanCng : ECDiffieHellman
	{
		public CngAlgorithm HashAlgorithm
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public byte[]? HmacKey
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKey Key
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public ECDiffieHellmanKeyDerivationFunction KeyDerivationFunction
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override int KeySize
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public byte[]? Label
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override ECDiffieHellmanPublicKey PublicKey
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public byte[]? SecretAppend
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public byte[]? SecretPrepend
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public byte[]? Seed
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public bool UseSecretAgreementAsHmacKey
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public ECDiffieHellmanCng()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public ECDiffieHellmanCng(int keySize)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public ECDiffieHellmanCng(CngKey key)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public byte[] DeriveKeyMaterial(CngKey otherPartyPublicKey)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override byte[] DeriveKeyMaterial(ECDiffieHellmanPublicKey otherPartyPublicKey)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public SafeNCryptSecretHandle DeriveSecretAgreementHandle(CngKey otherPartyPublicKey)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public SafeNCryptSecretHandle DeriveSecretAgreementHandle(ECDiffieHellmanPublicKey otherPartyPublicKey)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public void FromXmlString(string xml, ECKeyXmlFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public string ToXmlString(ECKeyXmlFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class ECDiffieHellmanCngPublicKey : ECDiffieHellmanPublicKey
	{
		public CngKeyBlobFormat BlobFormat
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		private ECDiffieHellmanCngPublicKey()
			: base(null)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public static ECDiffieHellmanPublicKey FromByteArray(byte[] publicKeyBlob, CngKeyBlobFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public static ECDiffieHellmanCngPublicKey FromXmlString(string xml)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public CngKey Import()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override string ToXmlString()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public enum ECDiffieHellmanKeyDerivationFunction
	{
		Hash,
		Hmac,
		Tls
	}
	public sealed class ECDsaCng : ECDsa
	{
		public CngAlgorithm HashAlgorithm
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public CngKey Key
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override int KeySize
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override KeySizes[] LegalKeySizes
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public ECDsaCng()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public ECDsaCng(int keySize)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public ECDsaCng(CngKey key)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public void FromXmlString(string xml, ECKeyXmlFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public byte[] SignData(byte[] data)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public byte[] SignData(byte[] data, int offset, int count)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public byte[] SignData(Stream data)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override byte[] SignHash(byte[] hash)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public string ToXmlString(ECKeyXmlFormat format)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool VerifyData(byte[] data, byte[] signature)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool VerifyData(byte[] data, int offset, int count, byte[] signature)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public bool VerifyData(Stream data, byte[] signature)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool VerifyHash(byte[] hash, byte[] signature)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public enum ECKeyXmlFormat
	{
		Rfc4050
	}
	public sealed class RSACng : RSA
	{
		public CngKey Key
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override KeySizes[] LegalKeySizes
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public RSACng()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public RSACng(int keySize)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public RSACng(CngKey key)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override byte[] Decrypt(byte[] data, RSAEncryptionPadding padding)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public override byte[] Encrypt(byte[] data, RSAEncryptionPadding padding)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override RSAParameters ExportParameters(bool includePrivateParameters)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override byte[] HashData(byte[] data, int offset, int count, HashAlgorithmName hashAlgorithm)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override byte[] HashData(Stream data, HashAlgorithmName hashAlgorithm)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override void ImportParameters(RSAParameters parameters)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override byte[] SignHash(byte[] hash, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override bool VerifyHash(byte[] hash, byte[] signature, HashAlgorithmName hashAlgorithm, RSASignaturePadding padding)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
	public sealed class TripleDESCng : TripleDES
	{
		public override byte[] Key
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public override int KeySize
		{
			get
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
			set
			{
				throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
			}
		}

		public TripleDESCng()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public TripleDESCng(string keyName)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public TripleDESCng(string keyName, CngProvider provider)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public TripleDESCng(string keyName, CngProvider provider, CngKeyOpenOptions openOptions)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateDecryptor()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateDecryptor(byte[] rgbKey, byte[]? rgbIV)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateEncryptor()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override ICryptoTransform CreateEncryptor(byte[] rgbKey, byte[]? rgbIV)
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		protected override void Dispose(bool disposing)
		{
		}

		public override void GenerateIV()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}

		public override void GenerateKey()
		{
			throw new PlatformNotSupportedException(System.SR.PlatformNotSupported_CryptographyCng);
		}
	}
}
namespace System.Runtime.Versioning
{
	internal abstract class OSPlatformAttribute : Attribute
	{
		public string PlatformName { get; }

		private protected OSPlatformAttribute(string platformName)
		{
			PlatformName = platformName;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly, AllowMultiple = false, Inherited = false)]
	internal sealed class TargetPlatformAttribute : OSPlatformAttribute
	{
		public TargetPlatformAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event, AllowMultiple = true, Inherited = false)]
	internal sealed class SupportedOSPlatformAttribute : OSPlatformAttribute
	{
		public SupportedOSPlatformAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event, AllowMultiple = true, Inherited = false)]
	internal sealed class UnsupportedOSPlatformAttribute : OSPlatformAttribute
	{
		public UnsupportedOSPlatformAttribute(string platformName)
			: base(platformName)
		{
		}
	}
}