using System;
using System.Buffers;
using System.Collections;
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using System.Diagnostics;
using System.Diagnostics.CodeAnalysis;
using System.Formats.Asn1;
using System.IO;
using System.Linq;
using System.Numerics;
using System.Reflection;
using System.Resources;
using System.Runtime.CompilerServices;
using System.Runtime.InteropServices;
using System.Runtime.Versioning;
using System.Security;
using System.Security.Cryptography;
using System.Security.Cryptography.Asn1;
using System.Security.Cryptography.Asn1.Pkcs12;
using System.Security.Cryptography.Asn1.Pkcs7;
using System.Security.Cryptography.Pkcs;
using System.Security.Cryptography.Pkcs.Asn1;
using System.Security.Cryptography.X509Certificates;
using System.Security.Cryptography.Xml;
using System.Security.Permissions;
using System.Text;
using System.Threading;
using FxResources.System.Security.Cryptography.Pkcs;
using Internal.Cryptography;
using Internal.Cryptography.Pal.AnyOS;
using Microsoft.CodeAnalysis;

[assembly: CompilationRelaxations(8)]
[assembly: RuntimeCompatibility(WrapNonExceptionThrows = true)]
[assembly: Debuggable(DebuggableAttribute.DebuggingModes.IgnoreSymbolStoreSequencePoints)]
[assembly: TargetFramework(".NETStandard,Version=v2.1", FrameworkDisplayName = ".NET Standard 2.1")]
[assembly: AssemblyMetadata("Serviceable", "True")]
[assembly: AssemblyMetadata("PreferInbox", "True")]
[assembly: AssemblyDefaultAlias("System.Security.Cryptography.Pkcs")]
[assembly: NeutralResourcesLanguage("en-US")]
[assembly: CLSCompliant(true)]
[assembly: AssemblyMetadata("IsTrimmable", "True")]
[assembly: UnsupportedOSPlatform("browser")]
[assembly: DefaultDllImportSearchPaths(DllImportSearchPath.System32 | DllImportSearchPath.AssemblyDirectory)]
[assembly: AssemblyCompany("Microsoft Corporation")]
[assembly: AssemblyCopyright("© Microsoft Corporation. All rights reserved.")]
[assembly: AssemblyDescription("Provides support for PKCS and CMS algorithms.\r\n\r\nCommonly Used Types:\r\nSystem.Security.Cryptography.Pkcs.EnvelopedCms")]
[assembly: AssemblyFileVersion("8.0.23.53103")]
[assembly: AssemblyInformationalVersion("8.0.0+5535e31a712343a63f5d7d796cd874e563e5ac14")]
[assembly: AssemblyProduct("Microsoft® .NET")]
[assembly: AssemblyTitle("System.Security.Cryptography.Pkcs")]
[assembly: AssemblyMetadata("RepositoryUrl", "https://github.com/dotnet/runtime")]
[assembly: SecurityPermission(SecurityAction.RequestMinimum, SkipVerification = true)]
[assembly: AssemblyVersion("8.0.0.0")]
[module: UnverifiableCode]
[module: RefSafetyRules(11)]
[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;
		}
	}
	[CompilerGenerated]
	[Microsoft.CodeAnalysis.Embedded]
	[AttributeUsage(AttributeTargets.Module, AllowMultiple = false, Inherited = false)]
	internal sealed class RefSafetyRulesAttribute : Attribute
	{
		public readonly int Version;

		public RefSafetyRulesAttribute(int P_0)
		{
			Version = P_0;
		}
	}
}
namespace FxResources.System.Security.Cryptography.Pkcs
{
	internal static class SR
	{
	}
}
namespace Internal.Cryptography
{
	internal abstract class DecryptorPal : IDisposable
	{
		public RecipientInfoCollection RecipientInfos { get; }

		internal DecryptorPal(RecipientInfoCollection recipientInfos)
		{
			RecipientInfos = recipientInfos;
		}

		public abstract ContentInfo TryDecrypt(RecipientInfo recipientInfo, X509Certificate2 cert, AsymmetricAlgorithm privateKey, X509Certificate2Collection originatorCerts, X509Certificate2Collection extraStore, out Exception exception);

		public abstract void Dispose();
	}
	internal abstract class KeyAgreeRecipientInfoPal : RecipientInfoPal
	{
		public abstract DateTime Date { get; }

		public abstract SubjectIdentifierOrKey OriginatorIdentifierOrKey { get; }

		public abstract CryptographicAttributeObject OtherKeyAttribute { get; }

		internal KeyAgreeRecipientInfoPal()
		{
		}
	}
	internal static class KeyLengths
	{
		public const int Rc2_40Bit = 40;

		public const int Rc2_56Bit = 56;

		public const int Rc2_64Bit = 64;

		public const int Rc2_128Bit = 128;

		public const int Rc4Max_128Bit = 128;

		public const int Des_64Bit = 64;

		public const int TripleDes_192Bit = 192;

		public const int DefaultKeyLengthForRc2AndRc4 = 128;
	}
	internal abstract class KeyTransRecipientInfoPal : RecipientInfoPal
	{
		internal KeyTransRecipientInfoPal()
		{
		}
	}
	internal static class PkcsHelpers
	{
		private static readonly bool s_oidIsInitOnceOnly = DetectInitOnlyOid();

		private static bool DetectInitOnlyOid()
		{
			Oid oid = new Oid("2.16.840.1.101.3.4.2.1", null);
			try
			{
				oid.Value = "2.16.840.1.101.3.4.2.2";
				return false;
			}
			catch (PlatformNotSupportedException)
			{
				return true;
			}
		}

		internal static HashAlgorithmName GetDigestAlgorithm(Oid oid)
		{
			return GetDigestAlgorithm(oid.Value);
		}

		internal static HashAlgorithmName GetDigestAlgorithm(string oidValue, bool forVerification = false)
		{
			switch (oidValue)
			{
			case "1.2.840.113549.1.1.4":
				if (!forVerification)
				{
					break;
				}
				goto case "1.2.840.113549.2.5";
			case "1.2.840.113549.2.5":
				return HashAlgorithmName.MD5;
			case "1.2.840.113549.1.1.5":
				if (!forVerification)
				{
					break;
				}
				goto case "1.3.14.3.2.26";
			case "1.3.14.3.2.26":
				return HashAlgorithmName.SHA1;
			case "1.2.840.113549.1.1.11":
				if (!forVerification)
				{
					break;
				}
				goto case "2.16.840.1.101.3.4.2.1";
			case "2.16.840.1.101.3.4.2.1":
				return HashAlgorithmName.SHA256;
			case "1.2.840.113549.1.1.12":
				if (!forVerification)
				{
					break;
				}
				goto case "2.16.840.1.101.3.4.2.2";
			case "2.16.840.1.101.3.4.2.2":
				return HashAlgorithmName.SHA384;
			case "1.2.840.113549.1.1.13":
				if (!forVerification)
				{
					break;
				}
				goto case "2.16.840.1.101.3.4.2.3";
			case "2.16.840.1.101.3.4.2.3":
				return HashAlgorithmName.SHA512;
			}
			throw new CryptographicException(System.SR.Cryptography_UnknownHashAlgorithm, oidValue);
		}

		internal static string GetOidFromHashAlgorithm(HashAlgorithmName algName)
		{
			if (algName == HashAlgorithmName.MD5)
			{
				return "1.2.840.113549.2.5";
			}
			if (algName == HashAlgorithmName.SHA1)
			{
				return "1.3.14.3.2.26";
			}
			if (algName == HashAlgorithmName.SHA256)
			{
				return "2.16.840.1.101.3.4.2.1";
			}
			if (algName == HashAlgorithmName.SHA384)
			{
				return "2.16.840.1.101.3.4.2.2";
			}
			if (algName == HashAlgorithmName.SHA512)
			{
				return "2.16.840.1.101.3.4.2.3";
			}
			throw new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm, algName.Name);
		}

		public static byte[] Resize(this byte[] a, int size)
		{
			Array.Resize(ref a, size);
			return a;
		}

		public static void RemoveAt<T>(ref T[] arr, int idx)
		{
			if (arr.Length == 1)
			{
				arr = Array.Empty<T>();
				return;
			}
			T[] array = new T[arr.Length - 1];
			if (idx != 0)
			{
				Array.Copy(arr, array, idx);
			}
			if (idx < array.Length)
			{
				Array.Copy(arr, idx + 1, array, idx, array.Length - idx);
			}
			arr = array;
		}

		public static System.Security.Cryptography.Asn1.AttributeAsn[] NormalizeAttributeSet(System.Security.Cryptography.Asn1.AttributeAsn[] setItems, Action<byte[]> encodedValueProcessor = null)
		{
			AsnWriter asnWriter = new AsnWriter(AsnEncodingRules.DER);
			asnWriter.PushSetOf();
			foreach (System.Security.Cryptography.Asn1.AttributeAsn attributeAsn in setItems)
			{
				attributeAsn.Encode(asnWriter);
			}
			asnWriter.PopSetOf();
			byte[] array = asnWriter.Encode();
			encodedValueProcessor?.Invoke(array);
			try
			{
				System.Formats.Asn1.AsnValueReader reader = new System.Formats.Asn1.AsnValueReader(array, AsnEncodingRules.DER).ReadSetOf();
				System.Security.Cryptography.Asn1.AttributeAsn[] array2 = new System.Security.Cryptography.Asn1.AttributeAsn[setItems.Length];
				int num = 0;
				while (reader.HasData)
				{
					System.Security.Cryptography.Asn1.AttributeAsn.Decode(ref reader, array, out var decoded);
					array2[num] = decoded;
					num++;
				}
				return array2;
			}
			catch (AsnContentException inner)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
			}
		}

		internal static byte[] EncodeContentInfo(ReadOnlyMemory<byte> content, string contentType, AsnEncodingRules ruleSet = AsnEncodingRules.DER)
		{
			System.Security.Cryptography.Asn1.Pkcs7.ContentInfoAsn contentInfoAsn = default(System.Security.Cryptography.Asn1.Pkcs7.ContentInfoAsn);
			contentInfoAsn.ContentType = contentType;
			contentInfoAsn.Content = content;
			System.Security.Cryptography.Asn1.Pkcs7.ContentInfoAsn contentInfoAsn2 = contentInfoAsn;
			AsnWriter asnWriter = new AsnWriter(ruleSet);
			contentInfoAsn2.Encode(asnWriter);
			return asnWriter.Encode();
		}

		public static CmsRecipientCollection DeepCopy(this CmsRecipientCollection recipients)
		{
			CmsRecipientCollection cmsRecipientCollection = new CmsRecipientCollection();
			CmsRecipientEnumerator enumerator = recipients.GetEnumerator();
			while (enumerator.MoveNext())
			{
				CmsRecipient current = enumerator.Current;
				X509Certificate2 certificate = current.Certificate;
				X509Certificate2 certificate2 = new X509Certificate2(certificate.Handle);
				CmsRecipient recipient = (((object)current.RSAEncryptionPadding != null) ? new CmsRecipient(current.RecipientIdentifierType, certificate2, current.RSAEncryptionPadding) : new CmsRecipient(current.RecipientIdentifierType, certificate2));
				cmsRecipientCollection.Add(recipient);
				GC.KeepAlive(certificate);
			}
			return cmsRecipientCollection;
		}

		public static byte[] UnicodeToOctetString(this string s)
		{
			byte[] array = new byte[2 * (s.Length + 1)];
			Encoding.Unicode.GetBytes(s, 0, s.Length, array, 0);
			return array;
		}

		public static string OctetStringToUnicode(this byte[] octets)
		{
			if (octets.Length < 2)
			{
				return string.Empty;
			}
			int num = octets.Length;
			int num2 = num - 1;
			for (int i = 0; i < num2; i += 2)
			{
				if (octets[i] == 0 && octets[i + 1] == 0)
				{
					num = i;
					break;
				}
			}
			return Encoding.Unicode.GetString(octets, 0, num);
		}

		public static X509Certificate2Collection GetStoreCertificates(StoreName storeName, StoreLocation storeLocation, bool openExistingOnly)
		{
			using X509Store x509Store = new X509Store(storeName, storeLocation);
			OpenFlags openFlags = OpenFlags.IncludeArchived;
			if (openExistingOnly)
			{
				openFlags |= OpenFlags.OpenExistingOnly;
			}
			x509Store.Open(openFlags);
			return x509Store.Certificates;
		}

		public static X509Certificate2 TryFindMatchingCertificate(this X509Certificate2Collection certs, SubjectIdentifier recipientIdentifier)
		{
			switch (recipientIdentifier.Type)
			{
			case SubjectIdentifierType.IssuerAndSerialNumber:
			{
				X509IssuerSerial x509IssuerSerial = (X509IssuerSerial)recipientIdentifier.Value;
				byte[] ba2 = x509IssuerSerial.SerialNumber.ToSerialBytes();
				string issuerName = x509IssuerSerial.IssuerName;
				X509Certificate2Enumerator enumerator2 = certs.GetEnumerator();
				while (enumerator2.MoveNext())
				{
					X509Certificate2 current2 = enumerator2.Current;
					byte[] serialNumber = current2.GetSerialNumber();
					if (AreByteArraysEqual(serialNumber, ba2) && current2.Issuer == issuerName)
					{
						return current2;
					}
				}
				break;
			}
			case SubjectIdentifierType.SubjectKeyIdentifier:
			{
				string skiString = (string)recipientIdentifier.Value;
				byte[] ba = skiString.ToSkiBytes();
				X509Certificate2Enumerator enumerator = certs.GetEnumerator();
				while (enumerator.MoveNext())
				{
					X509Certificate2 current = enumerator.Current;
					byte[] subjectKeyIdentifier = PkcsPal.Instance.GetSubjectKeyIdentifier(current);
					if (AreByteArraysEqual(ba, subjectKeyIdentifier))
					{
						return current;
					}
				}
				break;
			}
			default:
				throw new CryptographicException();
			}
			return null;
		}

		internal static bool AreByteArraysEqual(byte[] ba1, byte[] ba2)
		{
			return ba1.AsSpan().SequenceEqual(ba2.AsSpan());
		}

		internal static byte[] ToSkiBytes(this string skiString)
		{
			return skiString.UpperHexStringToByteArray();
		}

		public static string ToSkiString(this byte[] skiBytes)
		{
			return ToUpperHexString(skiBytes);
		}

		public static string ToBigEndianHex(this ReadOnlySpan<byte> bytes)
		{
			return ToUpperHexString(bytes);
		}

		internal static byte[] ToSerialBytes(this string serialString)
		{
			byte[] array = serialString.UpperHexStringToByteArray();
			Array.Reverse(array);
			return array;
		}

		public static string ToSerialString(this byte[] serialBytes)
		{
			serialBytes = serialBytes.CloneByteArray();
			Array.Reverse(serialBytes);
			return ToUpperHexString(serialBytes);
		}

		private static string ToUpperHexString(ReadOnlySpan<byte> ba)
		{
			return System.HexConverter.ToString(ba);
		}

		private static byte[] UpperHexStringToByteArray(this string normalizedString)
		{
			byte[] array = new byte[normalizedString.Length / 2];
			for (int i = 0; i < array.Length; i++)
			{
				char c = normalizedString[i * 2];
				byte b = (byte)(UpperHexCharToNybble(c) << 4);
				c = normalizedString[i * 2 + 1];
				b |= UpperHexCharToNybble(c);
				array[i] = b;
			}
			return array;
		}

		private static byte UpperHexCharToNybble(char c)
		{
			if (c >= '0' && c <= '9')
			{
				return (byte)(c - 48);
			}
			if (c >= 'A' && c <= 'F')
			{
				return (byte)(c - 65 + 10);
			}
			throw new CryptographicException();
		}

		public static Pkcs9AttributeObject CreateBestPkcs9AttributeObjectAvailable(Oid oid, ReadOnlySpan<byte> encodedAttribute)
		{
			return oid.Value switch
			{
				"1.3.6.1.4.1.311.88.2.1" => new Pkcs9DocumentName(encodedAttribute), 
				"1.3.6.1.4.1.311.88.2.2" => new Pkcs9DocumentDescription(encodedAttribute), 
				"1.2.840.113549.1.9.5" => new Pkcs9SigningTime(encodedAttribute), 
				"1.2.840.113549.1.9.3" => new Pkcs9ContentType(encodedAttribute), 
				"1.2.840.113549.1.9.4" => new Pkcs9MessageDigest(encodedAttribute), 
				"1.2.840.113549.1.9.21" => new Pkcs9LocalKeyId
				{
					RawData = encodedAttribute.ToArray()
				}, 
				_ => new Pkcs9AttributeObject(oid, encodedAttribute), 
			};
		}

		internal static byte[] OneShot(this ICryptoTransform transform, byte[] data)
		{
			return transform.OneShot(data, 0, data.Length);
		}

		internal static byte[] OneShot(this ICryptoTransform transform, byte[] data, int offset, int length)
		{
			if (transform.CanTransformMultipleBlocks)
			{
				return transform.TransformFinalBlock(data, offset, length);
			}
			using MemoryStream memoryStream = new MemoryStream(length);
			using (CryptoStream cryptoStream = new CryptoStream(memoryStream, transform, CryptoStreamMode.Write))
			{
				cryptoStream.Write(data, offset, length);
			}
			return memoryStream.ToArray();
		}

		public static void EnsureSingleBerValue(ReadOnlySpan<byte> source)
		{
			if (!AsnDecoder.TryReadEncodedValue(source, AsnEncodingRules.BER, out var _, out var _, out var _, out var bytesConsumed) || bytesConsumed != source.Length)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
			}
		}

		public static int FirstBerValueLength(ReadOnlySpan<byte> source)
		{
			if (!AsnDecoder.TryReadEncodedValue(source, AsnEncodingRules.BER, out var _, out var _, out var _, out var bytesConsumed))
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
			}
			return bytesConsumed;
		}

		public static ReadOnlyMemory<byte> DecodeOctetStringAsMemory(ReadOnlyMemory<byte> encodedOctetString)
		{
			try
			{
				ReadOnlySpan<byte> span = encodedOctetString.Span;
				if (AsnDecoder.TryReadPrimitiveOctetString(span, AsnEncodingRules.BER, out var value, out var bytesConsumed))
				{
					if (bytesConsumed != span.Length)
					{
						throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
					}
					if (span.Overlaps(value, out var elementOffset))
					{
						return encodedOctetString.Slice(elementOffset, value.Length);
					}
				}
				byte[] array = AsnDecoder.ReadOctetString(span, AsnEncodingRules.BER, out bytesConsumed);
				if (bytesConsumed != span.Length)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				}
				return array;
			}
			catch (AsnContentException inner)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
			}
		}

		public static byte[] DecodeOctetString(ReadOnlyMemory<byte> encodedOctets)
		{
			try
			{
				int bytesConsumed;
				byte[] result = AsnDecoder.ReadOctetString(encodedOctets.Span, AsnEncodingRules.BER, out bytesConsumed);
				if (bytesConsumed != encodedOctets.Length)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				}
				return result;
			}
			catch (AsnContentException inner)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
			}
		}

		public static byte[] EncodeOctetString(byte[] octets)
		{
			AsnWriter asnWriter = new AsnWriter(AsnEncodingRules.DER);
			asnWriter.WriteOctetString(octets);
			return asnWriter.Encode();
		}

		public static byte[] EncodeUtcTime(DateTime utcTime)
		{
			AsnWriter asnWriter = new AsnWriter(AsnEncodingRules.DER);
			try
			{
				if (utcTime.Kind == DateTimeKind.Unspecified)
				{
					asnWriter.WriteUtcTime(utcTime.ToLocalTime(), 2049);
				}
				else
				{
					asnWriter.WriteUtcTime(utcTime, 2049);
				}
				return asnWriter.Encode();
			}
			catch (ArgumentException ex)
			{
				throw new CryptographicException(ex.Message, ex);
			}
		}

		public static DateTime DecodeUtcTime(byte[] encodedUtcTime)
		{
			try
			{
				int bytesConsumed;
				DateTimeOffset dateTimeOffset = AsnDecoder.ReadUtcTime(encodedUtcTime, AsnEncodingRules.BER, out bytesConsumed);
				if (bytesConsumed != encodedUtcTime.Length)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				}
				return dateTimeOffset.UtcDateTime;
			}
			catch (AsnContentException inner)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
			}
		}

		public static string DecodeOid(ReadOnlySpan<byte> encodedOid)
		{
			if (encodedOid.Length == 2 && encodedOid[0] == 6 && encodedOid[1] == 0)
			{
				return string.Empty;
			}
			try
			{
				int bytesConsumed;
				string result = AsnDecoder.ReadObjectIdentifier(encodedOid, AsnEncodingRules.BER, out bytesConsumed);
				if (bytesConsumed != encodedOid.Length)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				}
				return result;
			}
			catch (AsnContentException inner)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
			}
		}

		public static bool TryGetRsaOaepEncryptionPadding(ReadOnlyMemory<byte>? parameters, [NotNullWhen(true)] out RSAEncryptionPadding rsaEncryptionPadding, [NotNullWhen(false)] out Exception exception)
		{
			exception = null;
			rsaEncryptionPadding = null;
			if (!parameters.HasValue || parameters.Value.IsEmpty)
			{
				exception = new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				return false;
			}
			try
			{
				OaepParamsAsn oaepParamsAsn = OaepParamsAsn.Decode(parameters.Value, AsnEncodingRules.DER);
				if (oaepParamsAsn.MaskGenFunc.Algorithm != "1.2.840.113549.1.1.8" || !oaepParamsAsn.MaskGenFunc.Parameters.HasValue || oaepParamsAsn.PSourceFunc.Algorithm != "1.2.840.113549.1.1.9")
				{
					exception = new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
					return false;
				}
				if (System.Security.Cryptography.Asn1.AlgorithmIdentifierAsn.Decode(oaepParamsAsn.MaskGenFunc.Parameters.Value, AsnEncodingRules.DER).Algorithm != oaepParamsAsn.HashFunc.Algorithm)
				{
					exception = new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
					return false;
				}
				ReadOnlySpan<byte> other = new byte[2] { 4, 0 };
				if (oaepParamsAsn.PSourceFunc.Parameters.HasValue && !oaepParamsAsn.PSourceFunc.Parameters.Value.Span.SequenceEqual(other))
				{
					exception = new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
					return false;
				}
				switch (oaepParamsAsn.HashFunc.Algorithm)
				{
				case "1.3.14.3.2.26":
					rsaEncryptionPadding = RSAEncryptionPadding.OaepSHA1;
					return true;
				case "2.16.840.1.101.3.4.2.1":
					rsaEncryptionPadding = RSAEncryptionPadding.OaepSHA256;
					return true;
				case "2.16.840.1.101.3.4.2.2":
					rsaEncryptionPadding = RSAEncryptionPadding.OaepSHA384;
					return true;
				case "2.16.840.1.101.3.4.2.3":
					rsaEncryptionPadding = RSAEncryptionPadding.OaepSHA512;
					return true;
				default:
					exception = new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm, oaepParamsAsn.HashFunc.Algorithm);
					return false;
				}
			}
			catch (CryptographicException ex)
			{
				exception = ex;
				return false;
			}
		}

		[return: NotNullIfNotNull("oid")]
		public static Oid CopyOid(this Oid oid)
		{
			if (s_oidIsInitOnceOnly)
			{
				return oid;
			}
			if (oid != null)
			{
				return new Oid(oid);
			}
			return null;
		}
	}
	internal abstract class PkcsPal
	{
		private protected static readonly byte[] s_rsaOaepSha1Parameters = new byte[2] { 48, 0 };

		private protected static readonly byte[] s_rsaOaepSha256Parameters = new byte[49]
		{
			48, 47, 160, 15, 48, 13, 6, 9, 96, 134,
			72, 1, 101, 3, 4, 2, 1, 5, 0, 161,
			28, 48, 26, 6, 9, 42, 134, 72, 134, 247,
			13, 1, 1, 8, 48, 13, 6, 9, 96, 134,
			72, 1, 101, 3, 4, 2, 1, 5, 0
		};

		private protected static readonly byte[] s_rsaOaepSha384Parameters = new byte[49]
		{
			48, 47, 160, 15, 48, 13, 6, 9, 96, 134,
			72, 1, 101, 3, 4, 2, 2, 5, 0, 161,
			28, 48, 26, 6, 9, 42, 134, 72, 134, 247,
			13, 1, 1, 8, 48, 13, 6, 9, 96, 134,
			72, 1, 101, 3, 4, 2, 2, 5, 0
		};

		private protected static readonly byte[] s_rsaOaepSha512Parameters = new byte[49]
		{
			48, 47, 160, 15, 48, 13, 6, 9, 96, 134,
			72, 1, 101, 3, 4, 2, 3, 5, 0, 161,
			28, 48, 26, 6, 9, 42, 134, 72, 134, 247,
			13, 1, 1, 8, 48, 13, 6, 9, 96, 134,
			72, 1, 101, 3, 4, 2, 3, 5, 0
		};

		private protected static readonly byte[] s_rsaPkcsParameters = new byte[2] { 5, 0 };

		private static readonly PkcsPal s_instance = new ManagedPkcsPal();

		public static PkcsPal Instance => s_instance;

		public abstract byte[] Encrypt(CmsRecipientCollection recipients, ContentInfo contentInfo, AlgorithmIdentifier contentEncryptionAlgorithm, X509Certificate2Collection originatorCerts, CryptographicAttributeObjectCollection unprotectedAttributes);

		public abstract DecryptorPal Decode(ReadOnlySpan<byte> encodedMessage, out int version, out ContentInfo contentInfo, out AlgorithmIdentifier contentEncryptionAlgorithm, out X509Certificate2Collection originatorCerts, out CryptographicAttributeObjectCollection unprotectedAttributes);

		public abstract Oid GetEncodedMessageType(ReadOnlySpan<byte> encodedMessage);

		public abstract void AddCertsFromStoreForDecryption(X509Certificate2Collection certs);

		public abstract Exception CreateRecipientsNotFoundException();

		public abstract Exception CreateRecipientInfosAfterEncryptException();

		public abstract Exception CreateDecryptAfterEncryptException();

		public abstract Exception CreateDecryptTwiceException();

		public abstract byte[] GetSubjectKeyIdentifier(X509Certificate2 certificate);

		public abstract T GetPrivateKeyForSigning<T>(X509Certificate2 certificate, bool silent) where T : AsymmetricAlgorithm;

		public abstract T GetPrivateKeyForDecryption<T>(X509Certificate2 certificate, bool silent) where T : AsymmetricAlgorithm;
	}
	internal abstract class RecipientInfoPal
	{
		public abstract byte[] EncryptedKey { get; }

		public abstract AlgorithmIdentifier KeyEncryptionAlgorithm { get; }

		public abstract SubjectIdentifier RecipientIdentifier { get; }

		public abstract int Version { get; }

		internal RecipientInfoPal()
		{
		}
	}
	internal static class Helpers
	{
		[UnsupportedOSPlatformGuard("browser")]
		internal static bool HasSymmetricEncryption { get; } = true;


		public static bool IsDSASupported => true;

		public static bool IsRC2Supported => true;

		[UnsupportedOSPlatformGuard("browser")]
		internal static bool HasMD5 { get; } = true;


		[return: NotNullIfNotNull("src")]
		public static byte[] CloneByteArray(this byte[] src)
		{
			if (src == null)
			{
				return null;
			}
			return (byte[])src.Clone();
		}

		internal static bool TryCopyToDestination(this ReadOnlySpan<byte> source, Span<byte> destination, out int bytesWritten)
		{
			if (source.TryCopyTo(destination))
			{
				bytesWritten = source.Length;
				return true;
			}
			bytesWritten = 0;
			return false;
		}

		internal static int HashOidToByteLength(string hashOid)
		{
			return hashOid switch
			{
				"2.16.840.1.101.3.4.2.1" => 32, 
				"2.16.840.1.101.3.4.2.2" => 48, 
				"2.16.840.1.101.3.4.2.3" => 64, 
				"1.3.14.3.2.26" => 20, 
				"1.2.840.113549.2.5" => 16, 
				_ => throw new CryptographicException(System.SR.Format(System.SR.Cryptography_UnknownHashAlgorithm, hashOid)), 
			};
		}
	}
}
namespace Internal.Cryptography.Pal.AnyOS
{
	internal static class AsnHelpers
	{
		internal static SubjectIdentifierOrKey ToSubjectIdentifierOrKey(this OriginatorIdentifierOrKeyAsn originator)
		{
			if (originator.IssuerAndSerialNumber.HasValue)
			{
				X500DistinguishedName x500DistinguishedName = new X500DistinguishedName(originator.IssuerAndSerialNumber.Value.Issuer.ToArray());
				return new SubjectIdentifierOrKey(SubjectIdentifierOrKeyType.IssuerAndSerialNumber, new X509IssuerSerial(x500DistinguishedName.Name, originator.IssuerAndSerialNumber.Value.SerialNumber.Span.ToBigEndianHex()));
			}
			if (originator.SubjectKeyIdentifier.HasValue)
			{
				return new SubjectIdentifierOrKey(SubjectIdentifierOrKeyType.SubjectKeyIdentifier, originator.SubjectKeyIdentifier.Value.Span.ToBigEndianHex());
			}
			if (originator.OriginatorKey.HasValue)
			{
				OriginatorPublicKeyAsn value = originator.OriginatorKey.Value;
				return new SubjectIdentifierOrKey(SubjectIdentifierOrKeyType.PublicKeyInfo, new PublicKeyInfo(value.Algorithm.ToPresentationObject(), value.PublicKey.ToArray()));
			}
			return new SubjectIdentifierOrKey(SubjectIdentifierOrKeyType.Unknown, string.Empty);
		}

		internal static AlgorithmIdentifier ToPresentationObject(this System.Security.Cryptography.Asn1.AlgorithmIdentifierAsn asn)
		{
			byte[] parameters = Array.Empty<byte>();
			int keyLength;
			switch (asn.Algorithm)
			{
			case "1.2.840.113549.3.2":
			{
				if (!asn.Parameters.HasValue)
				{
					keyLength = 0;
					break;
				}
				int effectiveKeyBits = System.Security.Cryptography.Asn1.Rc2CbcParameters.Decode(asn.Parameters.Value, AsnEncodingRules.BER).GetEffectiveKeyBits();
				switch (effectiveKeyBits)
				{
				case 40:
				case 56:
				case 64:
				case 128:
					keyLength = effectiveKeyBits;
					break;
				default:
					keyLength = 0;
					break;
				}
				break;
			}
			case "1.2.840.113549.3.4":
			{
				if (!asn.Parameters.HasValue)
				{
					keyLength = 0;
					break;
				}
				int bytesWritten = 0;
				try
				{
					AsnReader asnReader = new AsnReader(asn.Parameters.Value, AsnEncodingRules.BER);
					if (asnReader.PeekTag() != Asn1Tag.Null)
					{
						if (asnReader.TryReadPrimitiveOctetString(out var contents))
						{
							bytesWritten = contents.Length;
						}
						else
						{
							Span<byte> destination = stackalloc byte[16];
							if (!asnReader.TryReadOctetString(destination, out bytesWritten))
							{
								throw new CryptographicException();
							}
						}
					}
				}
				catch (AsnContentException inner)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
				}
				keyLength = 128 - 8 * bytesWritten;
				break;
			}
			case "1.3.14.3.2.7":
				keyLength = 64;
				break;
			case "1.2.840.113549.3.7":
				keyLength = 192;
				break;
			case "1.2.840.113549.1.1.7":
				if (!asn.HasNullEquivalentParameters())
				{
					keyLength = 0;
					parameters = asn.Parameters.Value.ToArray();
					break;
				}
				goto default;
			default:
				keyLength = 0;
				break;
			}
			return new AlgorithmIdentifier(new Oid(asn.Algorithm), keyLength)
			{
				Parameters = parameters
			};
		}
	}
	internal sealed class ManagedPkcsPal : PkcsPal
	{
		internal sealed class ManagedDecryptorPal : DecryptorPal
		{
			private readonly byte[] _dataCopy;

			private EnvelopedDataAsn _envelopedData;

			public ManagedDecryptorPal(byte[] dataCopy, EnvelopedDataAsn envelopedDataAsn, RecipientInfoCollection recipientInfos)
				: base(recipientInfos)
			{
				_dataCopy = dataCopy;
				_envelopedData = envelopedDataAsn;
			}

			public unsafe override ContentInfo TryDecrypt(RecipientInfo recipientInfo, X509Certificate2 cert, AsymmetricAlgorithm privateKey, X509Certificate2Collection originatorCerts, X509Certificate2Collection extraStore, out Exception exception)
			{
				if (recipientInfo.Pal is ManagedKeyTransPal managedKeyTransPal)
				{
					RSA rSA = privateKey as RSA;
					if (privateKey != null && rSA == null)
					{
						exception = new CryptographicException(System.SR.Cryptography_Cms_Ktri_RSARequired);
						return null;
					}
					byte[] array = managedKeyTransPal.DecryptCek(cert, rSA, out exception);
					fixed (byte* ptr = array)
					{
						try
						{
							if (exception != null)
							{
								return null;
							}
							return TryDecryptCore(array, _envelopedData.EncryptedContentInfo.ContentType, _envelopedData.EncryptedContentInfo.EncryptedContent, _envelopedData.EncryptedContentInfo.ContentEncryptionAlgorithm, out exception);
						}
						finally
						{
							if (array != null)
							{
								Array.Clear(array, 0, array.Length);
							}
						}
					}
				}
				exception = new CryptographicException(System.SR.Cryptography_Cms_RecipientType_NotSupported, recipientInfo.Type.ToString());
				return null;
			}

			public static ContentInfo TryDecryptCore(byte[] cek, string contentType, ReadOnlyMemory<byte>? content, System.Security.Cryptography.Asn1.AlgorithmIdentifierAsn contentEncryptionAlgorithm, out Exception exception)
			{
				if (!content.HasValue)
				{
					exception = null;
					return new ContentInfo(new Oid(contentType), Array.Empty<byte>());
				}
				byte[] array = DecryptContent(content.Value, cek, contentEncryptionAlgorithm, out exception);
				if (exception != null)
				{
					return null;
				}
				if (contentType != "1.2.840.113549.1.7.1")
				{
					array = GetAsnSequenceWithContentNoValidation(array);
				}
				exception = null;
				return new ContentInfo(new Oid(contentType), array);
			}

			private static byte[] GetAsnSequenceWithContentNoValidation(ReadOnlySpan<byte> content)
			{
				AsnWriter asnWriter = new AsnWriter(AsnEncodingRules.BER);
				asnWriter.WriteOctetString(content);
				byte[] array = asnWriter.Encode();
				array[0] = 48;
				return array;
			}

			private static byte[] DecryptContent(ReadOnlyMemory<byte> encryptedContent, byte[] cek, System.Security.Cryptography.Asn1.AlgorithmIdentifierAsn contentEncryptionAlgorithm, out Exception exception)
			{
				exception = null;
				if (encryptedContent.IsEmpty)
				{
					return Array.Empty<byte>();
				}
				int length = encryptedContent.Length;
				byte[] array = System.Security.Cryptography.CryptoPool.Rent(length);
				try
				{
					encryptedContent.CopyTo(array);
					using SymmetricAlgorithm symmetricAlgorithm = OpenAlgorithm(contentEncryptionAlgorithm);
					ICryptoTransform cryptoTransform;
					try
					{
						cryptoTransform = symmetricAlgorithm.CreateDecryptor(cek, symmetricAlgorithm.IV);
					}
					catch (ArgumentException inner)
					{
						throw new CryptographicException(System.SR.Cryptography_Cms_InvalidSymmetricKey, inner);
					}
					using (cryptoTransform)
					{
						return cryptoTransform.OneShot(array, 0, length);
					}
				}
				catch (CryptographicException ex)
				{
					exception = ex;
					return null;
				}
				finally
				{
					System.Security.Cryptography.CryptoPool.Return(array, length);
				}
			}

			public override void Dispose()
			{
			}
		}

		private sealed class ManagedKeyAgreePal : KeyAgreeRecipientInfoPal
		{
			private readonly KeyAgreeRecipientInfoAsn _asn;

			private readonly int _index;

			public override byte[] EncryptedKey => _asn.RecipientEncryptedKeys[_index].EncryptedKey.ToArray();

			public override AlgorithmIdentifier KeyEncryptionAlgorithm => _asn.KeyEncryptionAlgorithm.ToPresentationObject();

			public override SubjectIdentifier RecipientIdentifier => new SubjectIdentifier(_asn.RecipientEncryptedKeys[_index].Rid.IssuerAndSerialNumber, _asn.RecipientEncryptedKeys[_index].Rid.RKeyId?.SubjectKeyIdentifier);

			public override int Version => _asn.Version;

			public override DateTime Date
			{
				get
				{
					KeyAgreeRecipientIdentifierAsn rid = _asn.RecipientEncryptedKeys[_index].Rid;
					if (!rid.RKeyId.HasValue)
					{
						throw new InvalidOperationException(System.SR.Cryptography_Cms_Key_Agree_Date_Not_Available);
					}
					if (!rid.RKeyId.Value.Date.HasValue)
					{
						return DateTime.FromFileTimeUtc(0L);
					}
					return rid.RKeyId.Value.Date.Value.LocalDateTime;
				}
			}

			public override SubjectIdentifierOrKey OriginatorIdentifierOrKey => _asn.Originator.ToSubjectIdentifierOrKey();

			public override CryptographicAttributeObject OtherKeyAttribute
			{
				get
				{
					KeyAgreeRecipientIdentifierAsn rid = _asn.RecipientEncryptedKeys[_index].Rid;
					if (!rid.RKeyId.HasValue)
					{
						throw new InvalidOperationException(System.SR.Cryptography_Cms_Key_Agree_Date_Not_Available);
					}
					if (!rid.RKeyId.Value.Other.HasValue)
					{
						return null;
					}
					Oid oid = new Oid(rid.RKeyId.Value.Other.Value.KeyAttrId);
					ReadOnlySpan<byte> encodedData = ReadOnlySpan<byte>.Empty;
					if (rid.RKeyId.Value.Other.Value.KeyAttr.HasValue)
					{
						encodedData = rid.RKeyId.Value.Other.Value.KeyAttr.Value.Span;
					}
					Pkcs9AttributeObject asnEncodedData = new Pkcs9AttributeObject(oid, encodedData);
					AsnEncodedDataCollection values = new AsnEncodedDataCollection(asnEncodedData);
					return new CryptographicAttributeObject(oid, values);
				}
			}

			internal ManagedKeyAgreePal(KeyAgreeRecipientInfoAsn asn, int index)
			{
				_asn = asn;
				_index = index;
			}
		}

		internal sealed class ManagedKeyTransPal : KeyTransRecipientInfoPal
		{
			private readonly KeyTransRecipientInfoAsn _asn;

			public override byte[] EncryptedKey => _asn.EncryptedKey.ToArray();

			public override AlgorithmIdentifier KeyEncryptionAlgorithm => _asn.KeyEncryptionAlgorithm.ToPresentationObject();

			public override SubjectIdentifier RecipientIdentifier => new SubjectIdentifier(_asn.Rid.IssuerAndSerialNumber, _asn.Rid.SubjectKeyIdentifier);

			public override int Version => _asn.Version;

			internal ManagedKeyTransPal(KeyTransRecipientInfoAsn asn)
			{
				_asn = asn;
			}

			internal byte[] DecryptCek(X509Certificate2 cert, RSA privateKey, out Exception exception)
			{
				ReadOnlyMemory<byte>? parameters = _asn.KeyEncryptionAlgorithm.Parameters;
				string algorithm = _asn.KeyEncryptionAlgorithm.Algorithm;
				if (!(algorithm == "1.2.840.113549.1.1.1"))
				{
					if (!(algorithm == "1.2.840.113549.1.1.7"))
					{
						exception = new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm, _asn.KeyEncryptionAlgorithm.Algorithm);
						return null;
					}
				}
				else if (parameters.HasValue && !parameters.Value.Span.SequenceEqual(PkcsPal.s_rsaPkcsParameters))
				{
					exception = new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
					return null;
				}
				return DecryptCekCore(cert, privateKey, _asn.EncryptedKey.Span, algorithm, parameters, out exception);
			}

			internal static byte[] DecryptCekCore(X509Certificate2 cert, RSA privateKey, ReadOnlySpan<byte> encryptedKey, string keyEncryptionAlgorithm, ReadOnlyMemory<byte>? algorithmParameters, out Exception exception)
			{
				RSAEncryptionPadding rsaEncryptionPadding;
				if (!(keyEncryptionAlgorithm == "1.2.840.113549.1.1.1"))
				{
					if (!(keyEncryptionAlgorithm == "1.2.840.113549.1.1.7"))
					{
						exception = new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm, keyEncryptionAlgorithm);
						return null;
					}
					if (!PkcsHelpers.TryGetRsaOaepEncryptionPadding(algorithmParameters, out rsaEncryptionPadding, out exception))
					{
						return null;
					}
				}
				else
				{
					rsaEncryptionPadding = RSAEncryptionPadding.Pkcs1;
				}
				if (privateKey != null)
				{
					return DecryptKey(privateKey, rsaEncryptionPadding, encryptedKey, out exception);
				}
				using RSA privateKey2 = cert.GetRSAPrivateKey();
				return DecryptKey(privateKey2, rsaEncryptionPadding, encryptedKey, out exception);
			}
		}

		public override void AddCertsFromStoreForDecryption(X509Certificate2Collection certs)
		{
			certs.AddRange(PkcsHelpers.GetStoreCertificates(StoreName.My, StoreLocation.CurrentUser, openExistingOnly: false));
			try
			{
				certs.AddRange(PkcsHelpers.GetStoreCertificates(StoreName.My, StoreLocation.LocalMachine, openExistingOnly: false));
			}
			catch (CryptographicException)
			{
			}
		}

		public override byte[] GetSubjectKeyIdentifier(X509Certificate2 certificate)
		{
			X509Extension x509Extension = certificate.Extensions["2.5.29.14"] ?? new X509SubjectKeyIdentifierExtension(certificate.PublicKey, X509SubjectKeyIdentifierHashAlgorithm.CapiSha1, critical: false);
			try
			{
				System.Formats.Asn1.AsnValueReader asnValueReader = new System.Formats.Asn1.AsnValueReader(x509Extension.RawData, AsnEncodingRules.DER);
				if (asnValueReader.TryReadPrimitiveOctetString(out var value))
				{
					asnValueReader.ThrowIfNotEmpty();
					return value.ToArray();
				}
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
			}
			catch (AsnContentException inner)
			{
				throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
			}
		}

		public override T GetPrivateKeyForSigning<T>(X509Certificate2 certificate, bool silent)
		{
			return GetPrivateKey<T>(certificate);
		}

		public override T GetPrivateKeyForDecryption<T>(X509Certificate2 certificate, bool silent)
		{
			return GetPrivateKey<T>(certificate);
		}

		private static T GetPrivateKey<T>(X509Certificate2 certificate) where T : AsymmetricAlgorithm
		{
			if (typeof(T) == typeof(RSA))
			{
				return (T)(AsymmetricAlgorithm)certificate.GetRSAPrivateKey();
			}
			if (typeof(T) == typeof(ECDsa))
			{
				return (T)(AsymmetricAlgorithm)certificate.GetECDsaPrivateKey();
			}
			if (typeof(T) == typeof(DSA) && Internal.Cryptography.Helpers.IsDSASupported)
			{
				return (T)(AsymmetricAlgorithm)certificate.GetDSAPrivateKey();
			}
			return null;
		}

		private static SymmetricAlgorithm OpenAlgorithm(System.Security.Cryptography.Asn1.AlgorithmIdentifierAsn contentEncryptionAlgorithm)
		{
			SymmetricAlgorithm symmetricAlgorithm = OpenAlgorithm(contentEncryptionAlgorithm.Algorithm);
			if (symmetricAlgorithm is RC2)
			{
				if (!contentEncryptionAlgorithm.Parameters.HasValue)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				}
				System.Security.Cryptography.Asn1.Rc2CbcParameters rc2CbcParameters = System.Security.Cryptography.Asn1.Rc2CbcParameters.Decode(contentEncryptionAlgorithm.Parameters.Value, AsnEncodingRules.BER);
				symmetricAlgorithm.KeySize = rc2CbcParameters.GetEffectiveKeyBits();
				symmetricAlgorithm.IV = rc2CbcParameters.Iv.ToArray();
			}
			else
			{
				if (!contentEncryptionAlgorithm.Parameters.HasValue)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
				}
				try
				{
					AsnReader asnReader = new AsnReader(contentEncryptionAlgorithm.Parameters.Value, AsnEncodingRules.BER);
					symmetricAlgorithm.IV = asnReader.ReadOctetString();
					if (symmetricAlgorithm.IV.Length != symmetricAlgorithm.BlockSize / 8)
					{
						throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding);
					}
				}
				catch (AsnContentException inner)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
				}
			}
			return symmetricAlgorithm;
		}

		private static SymmetricAlgorithm OpenAlgorithm(AlgorithmIdentifier algorithmIdentifier)
		{
			SymmetricAlgorithm symmetricAlgorithm = OpenAlgorithm(algorithmIdentifier.Oid.Value);
			if (symmetricAlgorithm is RC2)
			{
				if (algorithmIdentifier.KeyLength != 0)
				{
					symmetricAlgorithm.KeySize = algorithmIdentifier.KeyLength;
				}
				else
				{
					symmetricAlgorithm.KeySize = 128;
				}
			}
			return symmetricAlgorithm;
		}

		private static SymmetricAlgorithm OpenAlgorithm(string algorithmIdentifier)
		{
			SymmetricAlgorithm symmetricAlgorithm;
			switch (algorithmIdentifier)
			{
			case "1.2.840.113549.3.2":
				if (!Internal.Cryptography.Helpers.IsRC2Supported)
				{
					throw new PlatformNotSupportedException(System.SR.Format(System.SR.Cryptography_AlgorithmNotSupported, "RC2"));
				}
				symmetricAlgorithm = RC2.Create();
				break;
			case "1.3.14.3.2.7":
				symmetricAlgorithm = DES.Create();
				break;
			case "1.2.840.113549.3.7":
				symmetricAlgorithm = TripleDES.Create();
				break;
			case "2.16.840.1.101.3.4.1.2":
				symmetricAlgorithm = Aes.Create();
				symmetricAlgorithm.KeySize = 128;
				break;
			case "2.16.840.1.101.3.4.1.22":
				symmetricAlgorithm = Aes.Create();
				symmetricAlgorithm.KeySize = 192;
				break;
			case "2.16.840.1.101.3.4.1.42":
				symmetricAlgorithm = Aes.Create();
				symmetricAlgorithm.KeySize = 256;
				break;
			default:
				throw new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm, algorithmIdentifier);
			}
			symmetricAlgorithm.Padding = PaddingMode.PKCS7;
			symmetricAlgorithm.Mode = CipherMode.CBC;
			return symmetricAlgorithm;
		}

		public unsafe override Oid GetEncodedMessageType(ReadOnlySpan<byte> encodedMessage)
		{
			fixed (byte* pointer = encodedMessage)
			{
				using System.Buffers.PointerMemoryManager<byte> pointerMemoryManager = new System.Buffers.PointerMemoryManager<byte>(pointer, encodedMessage.Length);
				System.Formats.Asn1.AsnValueReader reader = new System.Formats.Asn1.AsnValueReader(encodedMessage, AsnEncodingRules.BER);
				System.Security.Cryptography.Asn1.Pkcs7.ContentInfoAsn.Decode(ref reader, pointerMemoryManager.Memory, out var decoded);
				switch (decoded.ContentType)
				{
				case "1.2.840.113549.1.7.1":
				case "1.2.840.113549.1.7.2":
				case "1.2.840.113549.1.7.3":
				case "1.2.840.113549.1.7.4":
				case "1.2.840.113549.1.7.5":
				case "1.2.840.113549.1.7.6":
					return new Oid(decoded.ContentType);
				default:
					throw new CryptographicException(System.SR.Cryptography_Cms_InvalidMessageType);
				}
			}
		}

		public override DecryptorPal Decode(ReadOnlySpan<byte> encodedMessage, out int version, out ContentInfo contentInfo, out AlgorithmIdentifier contentEncryptionAlgorithm, out X509Certificate2Collection originatorCerts, out CryptographicAttributeObjectCollection unprotectedAttributes)
		{
			byte[] array = CopyContent(encodedMessage);
			EnvelopedDataAsn envelopedDataAsn = EnvelopedDataAsn.Decode(array, AsnEncodingRules.BER);
			version = envelopedDataAsn.Version;
			contentInfo = new ContentInfo(new Oid(envelopedDataAsn.EncryptedContentInfo.ContentType), envelopedDataAsn.EncryptedContentInfo.EncryptedContent?.ToArray() ?? Array.Empty<byte>());
			contentEncryptionAlgorithm = envelopedDataAsn.EncryptedContentInfo.ContentEncryptionAlgorithm.ToPresentationObject();
			originatorCerts = new X509Certificate2Collection();
			if (envelopedDataAsn.OriginatorInfo.HasValue && envelopedDataAsn.OriginatorInfo.Value.CertificateSet != null)
			{
				CertificateChoiceAsn[] certificateSet = envelopedDataAsn.OriginatorInfo.Value.CertificateSet;
				for (int i = 0; i < certificateSet.Length; i++)
				{
					CertificateChoiceAsn certificateChoiceAsn = certificateSet[i];
					if (certificateChoiceAsn.Certificate.HasValue)
					{
						originatorCerts.Add(new X509Certificate2(certificateChoiceAsn.Certificate.Value.ToArray()));
					}
				}
			}
			unprotectedAttributes = SignerInfo.MakeAttributeCollection(envelopedDataAsn.UnprotectedAttributes);
			List<RecipientInfo> list = new List<RecipientInfo>();
			RecipientInfoAsn[] recipientInfos = envelopedDataAsn.RecipientInfos;
			for (int j = 0; j < recipientInfos.Length; j++)
			{
				RecipientInfoAsn recipientInfoAsn = recipientInfos[j];
				if (recipientInfoAsn.Ktri.HasValue)
				{
					list.Add(new KeyTransRecipientInfo(new ManagedKeyTransPal(recipientInfoAsn.Ktri.Value)));
					continue;
				}
				if (recipientInfoAsn.Kari.HasValue)
				{
					for (int k = 0; k < recipientInfoAsn.Kari.Value.RecipientEncryptedKeys.Length; k++)
					{
						list.Add(new KeyAgreeRecipientInfo(new ManagedKeyAgreePal(recipientInfoAsn.Kari.Value, k)));
					}
					continue;
				}
				throw new CryptographicException();
			}
			return new ManagedDecryptorPal(array, envelopedDataAsn, new RecipientInfoCollection(list));
		}

		private unsafe static byte[] CopyContent(ReadOnlySpan<byte> encodedMessage)
		{
			fixed (byte* pointer = encodedMessage)
			{
				using System.Buffers.PointerMemoryManager<byte> pointerMemoryManager = new System.Buffers.PointerMemoryManager<byte>(pointer, encodedMessage.Length);
				System.Formats.Asn1.AsnValueReader reader = new System.Formats.Asn1.AsnValueReader(encodedMessage, AsnEncodingRules.BER);
				System.Security.Cryptography.Asn1.Pkcs7.ContentInfoAsn.Decode(ref reader, pointerMemoryManager.Memory, out var decoded);
				if (decoded.ContentType != "1.2.840.113549.1.7.3")
				{
					throw new CryptographicException(System.SR.Cryptography_Cms_InvalidMessageType);
				}
				return decoded.Content.ToArray();
			}
		}

		public unsafe override byte[] Encrypt(CmsRecipientCollection recipients, ContentInfo contentInfo, AlgorithmIdentifier contentEncryptionAlgorithm, X509Certificate2Collection originatorCerts, CryptographicAttributeObjectCollection unprotectedAttributes)
		{
			byte[] cek;
			byte[] parameterBytes;
			byte[] encryptedContent = EncryptContent(contentInfo, contentEncryptionAlgorithm, out cek, out parameterBytes);
			fixed (byte* ptr = cek)
			{
				try
				{
					return Encrypt(recipients, contentInfo, contentEncryptionAlgorithm, originatorCerts, unprotectedAttributes, encryptedContent, cek, parameterBytes);
				}
				finally
				{
					Array.Clear(cek, 0, cek.Length);
				}
			}
		}

		private byte[] Encrypt(CmsRecipientCollection recipients, ContentInfo contentInfo, AlgorithmIdentifier contentEncryptionAlgorithm, X509Certificate2Collection originatorCerts, CryptographicAttributeObjectCollection unprotectedAttributes, byte[] encryptedContent, byte[] cek, byte[] parameterBytes)
		{
			EnvelopedDataAsn envelopedDataAsn = default(EnvelopedDataAsn);
			envelopedDataAsn.EncryptedContentInfo.ContentType = contentInfo.ContentType.Value;
			envelopedDataAsn.EncryptedContentInfo.ContentEncryptionAlgorithm.Algorithm = contentEncryptionAlgorithm.Oid.Value;
			envelopedDataAsn.EncryptedContentInfo.ContentEncryptionAlgorithm.Parameters = parameterBytes;
			envelopedDataAsn.EncryptedContentInfo.EncryptedContent = encryptedContent;
			EnvelopedDataAsn envelopedDataAsn2 = envelopedDataAsn;
			if (unprotectedAttributes != null && unprotectedAttributes.Count > 0)
			{
				List<System.Security.Cryptography.Asn1.AttributeAsn> list = CmsSigner.BuildAttributes(unprotectedAttributes);
				envelopedDataAsn2.UnprotectedAttributes = PkcsHelpers.NormalizeAttributeSet(list.ToArray());
			}
			if (originatorCerts != null && originatorCerts.Count > 0)
			{
				CertificateChoiceAsn[] array = new CertificateChoiceAsn[originatorCerts.Count];
				for (int i = 0; i < originatorCerts.Count; i++)
				{
					array[i].Certificate = originatorCerts[i].RawData;
				}
				envelopedDataAsn2.OriginatorInfo = new OriginatorInfoAsn
				{
					CertificateSet = array
				};
			}
			envelopedDataAsn2.RecipientInfos = new RecipientInfoAsn[recipients.Count];
			bool flag = true;
			for (int j = 0; j < recipients.Count; j++)
			{
				CmsRecipient cmsRecipient = recipients[j];
				RecipientInfoAsn[] recipientInfos = envelopedDataAsn2.RecipientInfos;
				int num = j;
				_ = ref recipientInfos[num];
				string keyAlgorithm = cmsRecipient.Certificate.GetKeyAlgorithm();
				if (keyAlgorithm == "1.2.840.113549.1.1.1")
				{
					bool v0Recipient;
					KeyTransRecipientInfoAsn value = MakeKtri(cek, cmsRecipient, out v0Recipient);
					recipientInfos[num].Ktri = value;
					flag = flag && v0Recipient;
					continue;
				}
				throw new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm, cmsRecipient.Certificate.GetKeyAlgorithm());
			}
			if (envelopedDataAsn2.OriginatorInfo.HasValue || !flag || envelopedDataAsn2.UnprotectedAttributes != null)
			{
				envelopedDataAsn2.Version = 2;
			}
			AsnWriter asnWriter = new AsnWriter(AsnEncodingRules.DER);
			envelopedDataAsn2.Encode(asnWriter);
			return PkcsHelpers.EncodeContentInfo(asnWriter.Encode(), "1.2.840.113549.1.7.3");
		}

		private static byte[] EncryptContent(ContentInfo contentInfo, AlgorithmIdentifier contentEncryptionAlgorithm, out byte[] cek, out byte[] parameterBytes)
		{
			using (SymmetricAlgorithm symmetricAlgorithm = OpenAlgorithm(contentEncryptionAlgorithm))
			{
				cek = symmetricAlgorithm.Key;
				if (symmetricAlgorithm is RC2)
				{
					System.Security.Cryptography.Asn1.Rc2CbcParameters rc2CbcParameters = new System.Security.Cryptography.Asn1.Rc2CbcParameters(symmetricAlgorithm.IV, symmetricAlgorithm.KeySize);
					AsnWriter asnWriter = new AsnWriter(AsnEncodingRules.DER);
					rc2CbcParameters.Encode(asnWriter);
					parameterBytes = asnWriter.Encode();
				}
				else
				{
					parameterBytes = PkcsHelpers.EncodeOctetString(symmetricAlgorithm.IV);
				}
				byte[] content = contentInfo.Content;
				if (contentInfo.ContentType.Value == "1.2.840.113549.1.7.1" || contentInfo.Content.Length == 0)
				{
					return EncryptOneShot(symmetricAlgorithm, contentInfo.Content);
				}
				try
				{
					AsnDecoder.ReadEncodedValue(contentInfo.Content, AsnEncodingRules.BER, out var contentOffset, out var contentLength, out var _);
					ReadOnlySpan<byte> plaintext2 = contentInfo.Content.AsSpan(contentOffset, contentLength);
					return EncryptOneShot(symmetricAlgorithm, plaintext2);
				}
				catch (AsnContentException inner)
				{
					throw new CryptographicException(System.SR.Cryptography_Der_Invalid_Encoding, inner);
				}
			}
			static byte[] EncryptOneShot(SymmetricAlgorithm alg, ReadOnlySpan<byte> plaintext)
			{
				using ICryptoTransform transform = alg.CreateEncryptor();
				return transform.OneShot(plaintext.ToArray());
			}
		}

		public override Exception CreateRecipientsNotFoundException()
		{
			return new CryptographicException(System.SR.Cryptography_Cms_RecipientNotFound);
		}

		public override Exception CreateRecipientInfosAfterEncryptException()
		{
			return CreateInvalidMessageTypeException();
		}

		public override Exception CreateDecryptAfterEncryptException()
		{
			return CreateInvalidMessageTypeException();
		}

		public override Exception CreateDecryptTwiceException()
		{
			return CreateInvalidMessageTypeException();
		}

		private static CryptographicException CreateInvalidMessageTypeException()
		{
			return new CryptographicException(System.SR.Cryptography_Cms_InvalidMessageType);
		}

		private KeyTransRecipientInfoAsn MakeKtri(byte[] cek, CmsRecipient recipient, out bool v0Recipient)
		{
			KeyTransRecipientInfoAsn result = default(KeyTransRecipientInfoAsn);
			if (recipient.RecipientIdentifierType == SubjectIdentifierType.SubjectKeyIdentifier)
			{
				result.Version = 2;
				result.Rid.SubjectKeyIdentifier = GetSubjectKeyIdentifier(recipient.Certificate);
			}
			else
			{
				if (recipient.RecipientIdentifierType != SubjectIdentifierType.IssuerAndSerialNumber)
				{
					throw new CryptographicException(System.SR.Cryptography_Cms_Invalid_Subject_Identifier_Type, recipient.RecipientIdentifierType.ToString());
				}
				byte[] serialNumber = recipient.Certificate.GetSerialNumber();
				Array.Reverse(serialNumber);
				IssuerAndSerialNumberAsn issuerAndSerialNumberAsn = default(IssuerAndSerialNumberAsn);
				issuerAndSerialNumberAsn.Issuer = recipient.Certificate.IssuerName.RawData;
				issuerAndSerialNumberAsn.SerialNumber = serialNumber;
				IssuerAndSerialNumberAsn value = issuerAndSerialNumberAsn;
				result.Rid.IssuerAndSerialNumber = value;
			}
			RSAEncryptionPadding rSAEncryptionPadding = recipient.RSAEncryptionPadding ?? RSAEncryptionPadding.Pkcs1;
			if (rSAEncryptionPadding == RSAEncryptionPadding.Pkcs1)
			{
				result.KeyEncryptionAlgorithm.Algorithm = "1.2.840.113549.1.1.1";
				result.KeyEncryptionAlgorithm.Parameters = PkcsPal.s_rsaPkcsParameters;
			}
			else if (rSAEncryptionPadding == RSAEncryptionPadding.OaepSHA1)
			{
				result.KeyEncryptionAlgorithm.Algorithm = "1.2.840.113549.1.1.7";
				result.KeyEncryptionAlgorithm.Parameters = PkcsPal.s_rsaOaepSha1Parameters;
			}
			else if (rSAEncryptionPadding == RSAEncryptionPadding.OaepSHA256)
			{
				result.KeyEncryptionAlgorithm.Algorithm = "1.2.840.113549.1.1.7";
				result.KeyEncryptionAlgorithm.Parameters = PkcsPal.s_rsaOaepSha256Parameters;
			}
			else if (rSAEncryptionPadding == RSAEncryptionPadding.OaepSHA384)
			{
				result.KeyEncryptionAlgorithm.Algorithm = "1.2.840.113549.1.1.7";
				result.KeyEncryptionAlgorithm.Parameters = PkcsPal.s_rsaOaepSha384Parameters;
			}
			else
			{
				if (!(rSAEncryptionPadding == RSAEncryptionPadding.OaepSHA512))
				{
					throw new CryptographicException(System.SR.Cryptography_Cms_UnknownAlgorithm);
				}
				result.KeyEncryptionAlgorithm.Algorithm = "1.2.840.113549.1.1.7";
				result.KeyEncryptionAlgorithm.Parameters = PkcsPal.s_rsaOaepSha512Parameters;
			}
			using (RSA rSA = recipient.Certificate.GetRSAPublicKey())
			{
				result.EncryptedKey = rSA.Encrypt(cek, rSAEncryptionPadding);
			}
			v0Recipient = result.Version == 0;
			return result;
		}

		private static byte[] DecryptKey(RSA privateKey, RSAEncryptionPadding encryptionPadding, ReadOnlySpan<byte> encryptedKey, out Exception exception)
		{
			if (privateKey == null)
			{
				exception = new CryptographicException(System.SR.Cryptography_Cms_Signing_RequiresPrivateKey);
				return null;
			}
			byte[] array = null;
			int bytesWritten = 0;
			try
			{
				array = System.Security.Cryptography.CryptoPool.Rent(privateKey.KeySize / 8);
				if (!privateKey.TryDecrypt(encryptedKey, array, encryptionPadding, out bytesWritten))
				{
					exception = new CryptographicException();
					return null;
				}
				exception = null;
				return new Span<byte>(array, 0, bytesWritten).ToArray();
			}
			catch (CryptographicException ex)
			{
				exception = ex;
				return null;
			}
			finally
			{
				if (array != null)
				{
					System.Security.Cryptography.CryptoPool.Return(array, bytesWritten);
				}
			}
		}
	}
}
namespace System
{
	internal static class HexConverter
	{
		public enum Casing : uint
		{
			Upper = 0u,
			Lower = 8224u
		}

		public static ReadOnlySpan<byte> CharToHexLookup => new byte[256]
		{
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 0, 1,
			2, 3, 4, 5, 6, 7, 8, 9, 255, 255,
			255, 255, 255, 255, 255, 10, 11, 12, 13, 14,
			15, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 10, 11, 12,
			13, 14, 15, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255, 255, 255, 255, 255,
			255, 255, 255, 255, 255, 255
		};

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToBytesBuffer(byte value, Span<byte> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
		{
			uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209);
			uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing;
			buffer[startingIndex + 1] = (byte)num2;
			buffer[startingIndex] = (byte)(num2 >> 8);
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static void ToCharsBuffer(byte value, Span<char> buffer, int startingIndex = 0, Casing casing = Casing.Upper)
		{
			uint num = (uint)(((value & 0xF0) << 4) + (value & 0xF) - 35209);
			uint num2 = ((((0 - num) & 0x7070) >> 4) + num + 47545) | (uint)casing;
			buffer[startingIndex + 1] = (char)(num2 & 0xFFu);
			buffer[startingIndex] = (char)(num2 >> 8);
		}

		public static void EncodeToUtf16(ReadOnlySpan<byte> bytes, Span<char> chars, Casing casing = Casing.Upper)
		{
			for (int i = 0; i < bytes.Length; i++)
			{
				ToCharsBuffer(bytes[i], chars, i * 2, casing);
			}
		}

		public unsafe static string ToString(ReadOnlySpan<byte> bytes, Casing casing = Casing.Upper)
		{
			return string.Create(bytes.Length * 2, ((IntPtr)(&bytes), casing), delegate(Span<char> chars, (IntPtr RosPtr, Casing casing) args)
			{
				EncodeToUtf16(*(ReadOnlySpan<byte>*)(void*)args.RosPtr, chars, args.casing);
			});
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToCharUpper(int value)
		{
			value &= 0xF;
			value += 48;
			if (value > 57)
			{
				value += 7;
			}
			return (char)value;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static char ToCharLower(int value)
		{
			value &= 0xF;
			value += 48;
			if (value > 57)
			{
				value += 39;
			}
			return (char)value;
		}

		public static bool TryDecodeFromUtf16(ReadOnlySpan<char> chars, Span<byte> bytes)
		{
			int charsProcessed;
			return TryDecodeFromUtf16(chars, bytes, out charsProcessed);
		}

		public static bool TryDecodeFromUtf16(ReadOnlySpan<char> chars, Span<byte> bytes, out int charsProcessed)
		{
			int num = 0;
			int num2 = 0;
			int num3 = 0;
			int num4 = 0;
			while (num2 < bytes.Length)
			{
				num3 = FromChar(chars[num + 1]);
				num4 = FromChar(chars[num]);
				if ((num3 | num4) == 255)
				{
					break;
				}
				bytes[num2++] = (byte)((num4 << 4) | num3);
				num += 2;
			}
			if (num3 == 255)
			{
				num++;
			}
			charsProcessed = num;
			return (num3 | num4) != 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FromChar(int c)
		{
			if (c < CharToHexLookup.Length)
			{
				return CharToHexLookup[c];
			}
			return 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FromUpperChar(int c)
		{
			if (c <= 71)
			{
				return CharToHexLookup[c];
			}
			return 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static int FromLowerChar(int c)
		{
			switch (c)
			{
			case 48:
			case 49:
			case 50:
			case 51:
			case 52:
			case 53:
			case 54:
			case 55:
			case 56:
			case 57:
				return c - 48;
			case 97:
			case 98:
			case 99:
			case 100:
			case 101:
			case 102:
				return c - 97 + 10;
			default:
				return 255;
			}
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHexChar(int c)
		{
			if (IntPtr.Size == 8)
			{
				ulong num = (uint)(c - 48);
				ulong num2 = (ulong)(-17875860044349952L << (int)num);
				ulong num3 = num - 64;
				return (long)(num2 & num3) < 0L;
			}
			return FromChar(c) != 255;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHexUpperChar(int c)
		{
			if ((uint)(c - 48) > 9u)
			{
				return (uint)(c - 65) <= 5u;
			}
			return true;
		}

		[MethodImpl(MethodImplOptions.AggressiveInlining)]
		public static bool IsHexLowerChar(int c)
		{
			if ((uint)(c - 48) > 9u)
			{
				return (uint)(c - 97) <= 5u;
			}
			return true;
		}
	}
	internal static class Obsoletions
	{
		internal const string SharedUrlFormat = "https://aka.ms/dotnet-warnings/{0}";

		internal const string SystemTextEncodingUTF7Message = "The UTF-7 encoding is insecure and should not be used. Consider using UTF-8 instead.";

		internal const string SystemTextEncodingUTF7DiagId = "SYSLIB0001";

		internal const string PrincipalPermissionAttributeMessage = "PrincipalPermissionAttribute is not honored by the runtime and must not be used.";

		internal const string PrincipalPermissionAttributeDiagId = "SYSLIB0002";

		internal const string CodeAccessSecurityMessage = "Code Access Security is not supported or honored by the runtime.";

		internal const string CodeAccessSecurityDiagId = "SYSLIB0003";

		internal const string ConstrainedExecutionRegionMessage = "The Constrained Execution Region (CER) feature is not supported.";

		internal const string ConstrainedExecutionRegionDiagId = "SYSLIB0004";

		internal const string GlobalAssemblyCacheMessage = "The Global Assembly Cache is not supported.";

		internal const string GlobalAssemblyCacheDiagId = "SYSLIB0005";

		internal const string ThreadAbortMessage = "Thread.Abort is not supported and throws PlatformNotSupportedException.";

		internal const string ThreadResetAbortMessage = "Thread.ResetAbort is not supported and throws PlatformNotSupportedException.";

		internal const string ThreadAbortDiagId = "SYSLIB0006";

		internal const string DefaultCryptoAlgorithmsMessage = "The default implementation of this cryptography algorithm is not supported.";

		internal const string DefaultCryptoAlgorithmsDiagId = "SYSLIB0007";

		internal const string CreatePdbGeneratorMessage = "The CreatePdbGenerator API is not supported and throws PlatformNotSupportedException.";

		internal const string CreatePdbGeneratorDiagId = "SYSLIB0008";

		internal const string AuthenticationManagerMessage = "The AuthenticationManager Authenticate and PreAuthenticate methods are not supported and throw PlatformNotSupportedException.";

		internal const string AuthenticationManagerDiagId = "SYSLIB0009";

		internal const string RemotingApisMessage = "This Remoting API is not supported and throws PlatformNotSupportedException.";

		internal const string RemotingApisDiagId = "SYSLIB0010";

		internal const string BinaryFormatterMessage = "BinaryFormatter serialization is obsolete and should not be used. See https://aka.ms/binaryformatter for more information.";

		internal const string BinaryFormatterDiagId = "SYSLIB0011";

		internal const string CodeBaseMessage = "Assembly.CodeBase and Assembly.EscapedCodeBase are only included for .NET Framework compatibility. Use Assembly.Location instead.";

		internal const string CodeBaseDiagId = "SYSLIB0012";

		internal const string EscapeUriStringMessage = "Uri.EscapeUriString can corrupt the Uri string in some cases. Consider using Uri.EscapeDataString for query string components instead.";

		internal const string EscapeUriStringDiagId = "SYSLIB0013";

		internal const string WebRequestMessage = "WebRequest, HttpWebRequest, ServicePoint, and WebClient are obsolete. Use HttpClient instead.";

		internal const string WebRequestDiagId = "SYSLIB0014";

		internal const string DisablePrivateReflectionAttributeMessage = "DisablePrivateReflectionAttribute has no effect in .NET 6.0+.";

		internal const string DisablePrivateReflectionAttributeDiagId = "SYSLIB0015";

		internal const string GetContextInfoMessage = "Use the Graphics.GetContextInfo overloads that accept arguments for better performance and fewer allocations.";

		internal const string GetContextInfoDiagId = "SYSLIB0016";

		internal const string StrongNameKeyPairMessage = "Strong name signing is not supported and throws PlatformNotSupportedException.";

		internal const string StrongNameKeyPairDiagId = "SYSLIB0017";

		internal const string ReflectionOnlyLoadingMessage = "ReflectionOnly loading is not supported and throws PlatformNotSupportedException.";

		internal const string ReflectionOnlyLoadingDiagId = "SYSLIB0018";

		internal const string RuntimeEnvironmentMessage = "RuntimeEnvironment members SystemConfigurationFile, GetRuntimeInterfaceAsIntPtr, and GetRuntimeInterfaceAsObject are not supported and throw PlatformNotSupportedException.";

		internal const string RuntimeEnvironmentDiagId = "SYSLIB0019";

		internal const string JsonSerializerOptionsIgnoreNullValuesMessage = "JsonSerializerOptions.IgnoreNullValues is obsolete. To ignore null values when serializing, set DefaultIgnoreCondition to JsonIgnoreCondition.WhenWritingNull.";

		internal const string JsonSerializerOptionsIgnoreNullValuesDiagId = "SYSLIB0020";

		internal const string DerivedCryptographicTypesMessage = "Derived cryptographic types are obsolete. Use the Create method on the base type instead.";

		internal const string DerivedCryptographicTypesDiagId = "SYSLIB0021";

		internal const string RijndaelMessage = "The Rijndael and RijndaelManaged types are obsolete. Use Aes instead.";

		internal const string RijndaelDiagId = "SYSLIB0022";

		internal const string RNGCryptoServiceProviderMessage = "RNGCryptoServiceProvider is obsolete. To generate a random number, use one of the RandomNumberGenerator static methods instead.";

		internal const string RNGCryptoServiceProviderDiagId = "SYSLIB0023";

		internal const string AppDomainCreateUnloadMessage = "Creating and unloading AppDomains is not supported and throws an exception.";

		internal const string AppDomainCreateUnloadDiagId = "SYSLIB0024";

		internal const string SuppressIldasmAttributeMessage = "SuppressIldasmAttribute has no effect in .NET 6.0+.";

		internal const string SuppressIldasmAttributeDiagId = "SYSLIB0025";

		internal const string X509CertificateImmutableMessage = "X509Certificate and X509Certificate2 are immutable. Use the appropriate constructor to create a new certificate.";

		internal const string X509CertificateImmutableDiagId = "SYSLIB0026";

		internal const string PublicKeyPropertyMessage = "PublicKey.Key is obsolete. Use the appropriate method to get the public key, such as GetRSAPublicKey.";

		internal const string PublicKeyPropertyDiagId = "SYSLIB0027";

		internal const string X509CertificatePrivateKeyMessage = "X509Certificate2.PrivateKey is obsolete. Use the appropriate method to get the private key, such as GetRSAPrivateKey, or use the CopyWithPrivateKey method to create a new instance with a private key.";

		internal const string X509CertificatePrivateKeyDiagId = "SYSLIB0028";

		internal const string ProduceLegacyHmacValuesMessage = "ProduceLegacyHmacValues is obsolete. Producing legacy HMAC values is not supported.";

		internal const string ProduceLegacyHmacValuesDiagId = "SYSLIB0029";

		internal const string UseManagedSha1Message = "HMACSHA1 always uses the algorithm implementation provided by the platform. Use a constructor without the useManagedSha1 parameter.";

		internal const string UseManagedSha1DiagId = "SYSLIB0030";

		internal const string CryptoConfigEncodeOIDMessage = "EncodeOID is obsolete. Use the ASN.1 functionality provided in System.Formats.Asn1.";

		internal const string CryptoConfigEncodeOIDDiagId = "SYSLIB0031";

		internal const string CorruptedStateRecoveryMessage = "Recovery from corrupted process state exceptions is not supported; HandleProcessCorruptedStateExceptionsAttribute is ignored.";

		internal const string CorruptedStateRecoveryDiagId = "SYSLIB0032";

		internal const string Rfc2898CryptDeriveKeyMessage = "Rfc2898DeriveBytes.CryptDeriveKey is obsolete and is not supported. Use PasswordDeriveBytes.CryptDeriveKey instead.";

		internal const string Rfc2898CryptDeriveKeyDiagId = "SYSLIB0033";

		internal const string CmsSignerCspParamsCtorMessage = "CmsSigner(CspParameters) is obsolete and is not supported. Use an alternative constructor instead.";

		internal const string CmsSignerCspParamsCtorDiagId = "SYSLIB0034";

		internal const string SignerInfoCounterSigMessage = "ComputeCounterSignature without specifying a CmsSigner is obsolete and is not supported. Use the overload that accepts a CmsSigner.";

		internal const string SignerInfoCounterSigDiagId = "SYSLIB0035";

		internal const string RegexCompileToAssemblyMessage = "Regex.CompileToAssembly is obsolete and not supported. Use the GeneratedRegexAttribute with the regular expression source generator instead.";

		internal const string RegexCompileToAssemblyDiagId = "SYSLIB0036";

		internal const string AssemblyNameMembersMessage = "AssemblyName members HashAlgorithm, ProcessorArchitecture, and VersionCompatibility are obsolete and not supported.";

		internal const string AssemblyNameMembersDiagId = "SYSLIB0037";

		internal const string SystemDataSerializationFormatBinaryMessage = "SerializationFormat.Binary is obsolete and should not be used. See https://aka.ms/serializationformat-binary-obsolete for more information.";

		internal const string SystemDataSerializationFormatBinaryDiagId = "SYSLIB0038";

		internal const string TlsVersion10and11Message = "TLS versions 1.0 and 1.1 have known vulnerabilities and are not recommended. Use a newer TLS version instead, or use SslProtocols.None to defer to OS defaults.";

		internal const string TlsVersion10and11DiagId = "SYSLIB0039";

		internal const string EncryptionPolicyMessage = "EncryptionPolicy.NoEncryption and AllowEncryption significantly reduce security and should not be used in production code.";

		internal const string EncryptionPolicyDiagId = "SYSLIB0040";

		internal const string Rfc2898OutdatedCtorMessage = "The default hash algorithm and iteration counts in Rfc2898DeriveBytes constructors are outdated and insecure. Use a constructor that accepts the hash algorithm and the number of iterations.";

		internal const string Rfc2898OutdatedCtorDiagId = "SYSLIB0041";

		internal const string EccXmlExportImportMessage = "ToXmlString and FromXmlString have no implementation for ECC types, and are obsolete. Use a standard import and export format such as ExportSubjectPublicKeyInfo or ImportSubjectPublicKeyInfo for public keys and ExportPkcs8PrivateKey or ImportPkcs8PrivateKey for private keys.";

		internal const string EccXmlExportImportDiagId = "SYSLIB0042";

		internal const string EcDhPublicKeyBlobMessage = "ECDiffieHellmanPublicKey.ToByteArray() and the associated constructor do not have a consistent and interoperable implementation on all platforms. Use ECDiffieHellmanPublicKey.ExportSubjectPublicKeyInfo() instead.";

		internal const string EcDhPublicKeyBlobDiagId = "SYSLIB0043";

		internal const string AssemblyNameCodeBaseMessage = "AssemblyName.CodeBase and AssemblyName.EscapedCodeBase are obsolete. Using them for loading an assembly is not supported.";

		internal const string AssemblyNameCodeBaseDiagId = "SYSLIB0044";

		internal const string CryptoStringFactoryMessage = "Cryptographic factory methods accepting an algorithm name are obsolete. Use the parameterless Create factory method on the algorithm type instead.";

		internal const string CryptoStringFactoryDiagId = "SYSLIB0045";

		internal const string ControlledExecutionRunMessage = "ControlledExecution.Run method may corrupt the process and should not be used in production code.";

		internal const string ControlledExecutionRunDiagId = "SYSLIB0046";

		internal const string XmlSecureResolverMessage = "XmlSecureResolver is obsolete. Use XmlResolver.ThrowingResolver instead when attempting to forbid XML external entity resolution.";

		internal const string XmlSecureResolverDiagId = "SYSLIB0047";

		internal const string RsaEncryptDecryptValueMessage = "RSA.EncryptValue and DecryptValue are not supported and throw NotSupportedException. Use RSA.Encrypt and RSA.Decrypt instead.";

		internal const string RsaEncryptDecryptDiagId = "SYSLIB0048";

		internal const string JsonSerializerOptionsAddContextMessage = "JsonSerializerOptions.AddContext is obsolete. To register a JsonSerializerContext, use either the TypeInfoResolver or TypeInfoResolverChain properties.";

		internal const string JsonSerializerOptionsAddContextDiagId = "SYSLIB0049";

		internal const string LegacyFormatterMessage = "Formatter-based serialization is obsolete and should not be used.";

		internal const string LegacyFormatterDiagId = "SYSLIB0050";

		internal const string LegacyFormatterImplMessage = "This API supports obsolete formatter-based serialization. It should not be called or extended by application code.";

		internal const string LegacyFormatterImplDiagId = "SYSLIB0051";

		internal const string RegexExtensibilityImplMessage = "This API supports obsolete mechanisms for Regex extensibility. It is not supported.";

		internal const string RegexExtensibilityDiagId = "SYSLIB0052";

		internal const string AesGcmTagConstructorMessage = "AesGcm should indicate the required tag size for encryption and decryption. Use a constructor that accepts the tag size.";

		internal const string AesGcmTagConstructorDiagId = "SYSLIB0053";
	}
	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 Arg_EmptyOrNullString_Named => GetResourceString("Arg_EmptyOrNullString_Named");

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

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

		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 Argument_InvalidRsaSignaturePadding => GetResourceString("Argument_InvalidRsaSignaturePadding");

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

		internal static bool UsingResourceKeys()
		{
			return s_usingResourceKeys;
		}

		private static string GetResourceString(string resourceKey)
		{
			if (UsingResourceKeys())
			{
				return resourceKey;
			}
			string result = null;
			try
			{
				result = ResourceManager.GetString(resourceKey);
			}
			catch (MissingManifestResourceException)
			{
			}
			return result;
		}

		private static string GetResourceString(string resourceKey, string defaultString)
		{
			string resourceString = GetResourceString(resourceKey);
			if (!(resourceKey == resourceString) && resourceString != null)
			{
				return resourceString;
			}
			return defaultString;
		}

		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.Diagnostics.CodeAnalysis
{
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullAttribute : Attribute
	{
		public string[] Members { get; }

		public MemberNotNullAttribute(string member)
		{
			Members = new string[1] { member };
		}

		public MemberNotNullAttribute(params string[] members)
		{
			Members = members;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property, Inherited = false, AllowMultiple = true)]
	internal sealed class MemberNotNullWhenAttribute : Attribute
	{
		public bool ReturnValue { get; }

		public string[] Members { get; }

		public MemberNotNullWhenAttribute(bool returnValue, string member)
		{
			ReturnValue = returnValue;
			Members = new string[1] { member };
		}

		public MemberNotNullWhenAttribute(bool returnValue, params string[] members)
		{
			ReturnValue = returnValue;
			Members = members;
		}
	}
}
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 | AttributeTargets.Interface, 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 | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	internal sealed class UnsupportedOSPlatformAttribute : OSPlatformAttribute
	{
		public string Message { get; }

		public UnsupportedOSPlatformAttribute(string platformName)
			: base(platformName)
		{
		}

		public UnsupportedOSPlatformAttribute(string platformName, string message)
			: base(platformName)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Assembly | AttributeTargets.Module | AttributeTargets.Class | AttributeTargets.Struct | AttributeTargets.Enum | AttributeTargets.Constructor | AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field | AttributeTargets.Event | AttributeTargets.Interface, AllowMultiple = true, Inherited = false)]
	internal sealed class ObsoletedOSPlatformAttribute : OSPlatformAttribute
	{
		public string Message { get; }

		public string Url { get; set; }

		public ObsoletedOSPlatformAttribute(string platformName)
			: base(platformName)
		{
		}

		public ObsoletedOSPlatformAttribute(string platformName, string message)
			: base(platformName)
		{
			Message = message;
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	internal sealed class SupportedOSPlatformGuardAttribute : OSPlatformAttribute
	{
		public SupportedOSPlatformGuardAttribute(string platformName)
			: base(platformName)
		{
		}
	}
	[AttributeUsage(AttributeTargets.Method | AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = true, Inherited = false)]
	internal sealed class UnsupportedOSPlatformGuardAttribute : OSPlatformAttribute
	{
		public UnsupportedOSPlatformGuardAttribute(string platformName)
			: base(platformName)
		{
		}
	}
}
namespace System.Runtime.InteropServices
{
	[AttributeUsage(AttributeTargets.Method, AllowMultiple = false, Inherited = false)]
	internal sealed class LibraryImportAttribute : Attribute
	{
		public string LibraryName { get; }

		public string EntryPoint { get; set; }

		public StringMarshalling StringMarshalling { get; set; }

		public Type StringMarshallingCustomType { get; set; }

		public bool SetLastError { get; set; }

		public LibraryImportAttribute(string libraryName)
		{
			LibraryName = libraryName;
		}
	}
	internal enum StringMarshalling
	{
		Custom,
		Utf8,
		Utf16
	}
}
namespace System.Buffers
{
	internal sealed class PointerMemoryManager<T> : MemoryManager<T> where T : struct
	{
		private unsafe readonly void* _pointer;

		private readonly int _length;

		internal unsafe PointerMemoryManager(void* pointer, int length)
		{
			_pointer = pointer;
			_length = length;
		}

		protected override void Dispose(bool disposing)
		{
		}

		public unsafe override Span<T> GetSpan()
		{
			return new Span<T>(_pointer, _length);
		}

		public override MemoryHandle Pin(int elementIndex = 0)
		{
			throw new NotSupportedException();
		}

		public override void Unpin()
		{
		}
	}
}
namespace System.Security.Cryptography
{
	public sealed class CryptographicAttributeObject
	{
		private readonly Oid _oid;

		public Oid Oid => _oid.CopyOid();

		public AsnEncodedDataCollection Values { get; }

		public CryptographicAttributeObject(Oid oid)
			: this(oid, new AsnEncodedDataCollection())
		{
		}

		public CryptographicAttributeObject(Oid oid, AsnEncodedDataCollection? values)
		{
			_oid = oid.CopyOid();
			if (values == null)
			{
				Values = new AsnEncodedDataCollection();
				return;
			}
			AsnEncodedDataEnumerator enumerator = values.GetEnumerator();
			while (enumerator.MoveNext())
			{
				AsnEncodedData current = enumerator.Current;
				if (current.Oid == null)
				{
					throw new ArgumentException(System.SR.Argument_InvalidOidValue, "values");
				}
				if (!string.Equals(current.Oid.Value, oid.Value, StringComparison.Ordinal))
				{
					throw new InvalidOperationException(System.SR.Format(System.SR.InvalidOperation_WrongOidInAsnCollection, oid.Value, current.Oid.Value));
				}
			}
			Values = values;
		}
	}
	public sealed class CryptographicAttributeObjectCollection : ICollection, IEnumerable
	{
		private readonly List<CryptographicAttributeObject> _list;

		public CryptographicAttributeObject this[int index] => _list[index];

		public int Count => _list.Count;

		public bool IsSynchronized => false;

		public object SyncRoot => this;

		public CryptographicAttributeObjectCollection()
		{
			_list = new List<CryptographicAttributeObject>();
		}

		public CryptographicAttributeObjectCollection(CryptographicAttributeObject attribute)
		{
			_list = new List<CryptographicAttributeObject>();
			_list.Add(attribute);
		}

		public int Add(AsnEncodedData asnEncodedData)
		{
			if (asnEncodedData == null)
			{
				throw new ArgumentNullException("asnEncodedData");
			}
			return Add(new CryptographicAttributeObject(asnEncodedData.Oid, new AsnEncodedDataCollection(asnEncodedData)));
		}

		public int Add(CryptographicAttributeObject attribute)
		{
			if (attribute == null)
			{
				throw new ArgumentNullException("attribute");
			}
			string value = attribute.Oid.Value;
			for (int i = 0; i < _list.Count; i++)
			{
				CryptographicAttributeObject cryptographicAttributeObject = _list[i];
				if (cryptographicAttributeObject.Values == attribute.Values)
				{
					throw new InvalidOperationException(System.SR.InvalidOperation_DuplicateItemNotAllowed);
				}
				string value2 = cryptographicAttributeObject.Oid.Value;
				if (string.Equals(value, value2, StringComparison.OrdinalIgnoreCase))
				{
					if (string.Equals(value, "1.2.840.113549.1.9.5", StringComparison.OrdinalIgnoreCase))
					{
						throw new CryptographicException(System.SR.Cryptography_Pkcs9_MultipleSigningTimeNotAllowed);
					}
					AsnEncodedDataEnumerator enumerator = attribute.Values.GetEnumerator();
					while (enumerator.MoveNext())
					{
						AsnEncodedData current = enumerator.Current;
						cryptographicAttributeObject.Values.Add(current);
					}
					return i;
				}
			}
			int count = _list.Count;
			_list.Add(attribute);
			return count;
		}

		internal void AddWithoutMerge(CryptographicAttributeObject attribute)
		{
			_list.Add(attribute);
		}

		public void Remove(CryptographicAttributeObject attribute)
		{
			if (attribute == null)
			{
				throw new ArgumentNullException("attribute");
			}
			_list.Remove(attribute);
		}

		public CryptographicAttributeObjectEnumerator GetEnumerator()
		{
			return new CryptographicAttributeObjectEnumerator(this);
		}

		IEnumerator IEnumerable.GetEnumerator()
		{
			return new CryptographicAttributeObjectEnumerator(this);
		}

		void ICollection.CopyTo(Array array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (array.Rank != 1)
			{
				throw new ArgumentException(System.SR.Arg_RankMultiDimNotSupported);
			}
			if (index < 0 || index >= array.Length)
			{
				throw new ArgumentOutOfRangeException("index", System.SR.ArgumentOutOfRange_IndexMustBeLess);
			}
			if (index > array.Length - Count)
			{
				throw new ArgumentException(System.SR.Argument_InvalidOffLen);
			}
			for (int i = 0; i < Count; i++)
			{
				array.SetValue(this[i], index);
				index++;
			}
		}

		public void CopyTo(CryptographicAttributeObject[] array, int index)
		{
			if (array == null)
			{
				throw new ArgumentNullException("array");
			}
			if (index < 0 || index >= array.Length)
			{
				throw new ArgumentOutOfRangeException("index", System.SR.ArgumentOutOfRange_IndexMustBeLess);
			}
			if (index > array.Length - Count)
			{
				throw new ArgumentException(System.SR.Argument_InvalidOffLen);
			}
			_list.CopyTo(array, index);
		}
	}
	public sealed class CryptographicAttributeObjectEnumerator : IEnumerator
	{
		private readonly CryptographicAttributeObjectCollection _attributes;

		private int _current;

		public CryptographicAttributeObject Current => _attributes[_current];

		object IEnumerator.Current => _attributes[_current];

		internal CryptographicAttributeObjectEnumerator(CryptographicAttributeObjectCollection attributes)
		{
			_attributes = attributes;
			_current = -1;
		}

		public bool MoveNext()
		{
			if (_current >= _attributes.Count - 1)
			{
				return false;
			}
			_current++;
			return true;
		}

		public void Reset()
		{
			_current = -1;
		}
	}
	internal static class CryptoPool
	{
		internal const int ClearAll = -1;

		internal static byte[] Rent(int minimumLength)
		{
			return ArrayPool<byte>.Shared.Rent(minimumLength);
		}

		internal static void Return(ArraySegment<byte> arraySegment)
		{
			Return(arraySegment.Array, arraySegment.Count);
		}

		internal static void Return(byte[] array, int clearSize = -1)
		{
			bool flag = clearSize < 0;
			if (!flag && clearSize != 0)
			{
				CryptographicOperations.ZeroMemory(array.AsSpan(0, clearSize));
			}
			ArrayPool<byte>.Shared.Return(array, flag);
		}
	}
	internal static class Oids
	{
		internal const string Rc2Cbc = "1.2.840.113549.3.2";

		internal const string Rc4 = "1.2.840.113549.3.4";

		internal const string TripleDesCbc = "1.2.840.113549.3.7";

		internal const string DesCbc = "1.3.14.3.2.7";

		internal const string Aes128Cbc = "2.16.840.1.101.3.4.1.2";

		internal const string Aes192Cbc = "2.16.840.1.101.3.4.1.22";

		internal const string Aes256Cbc = "2.16.840.1.101.3.4.1.42";

		internal const string Dsa = "1.2.840.10040.4.1";

		internal const string Rsa = "1.2.840.113549.1.1.1";

		internal const string RsaOaep = "1.2.840.113549.1.1.7";

		internal const string RsaPss = "1.2.840.113549.1.1.10";

		internal const string RsaPkcs1Md5 = "1.2.840.113549.1.1.4";

		internal const string RsaPkcs1Sha1 = "1.2.840.113549.1.1.5";

		internal const string RsaPkcs1Sha256 = "1.2.840.113549.1.1.11";

		internal const string RsaPkcs1Sha384 = "1.2.840.113549.1.1.12";

		internal const string RsaPkcs1Sha512 = "1.2.840.113549.1.1.13";

		internal const string RsaPkcs1Sha3_256 = "2.16.840.1.101.3.4.3.14";

		internal const string RsaPkcs1Sha3_384 = "2.16.840.1.101.3.4.3.15";

		internal const string RsaPkcs1Sha3_512 = "2.16.840.1.101.3.4.3.16";

		internal const string Esdh = "1.2.840.113549.1.9.16.3.5";

		internal const string EcDiffieHellman = "1.3.132.1.12";

		internal const string DiffieHellman = "1.2.840.10046.2.1";

		internal const string DiffieHellmanPkcs3 = "1.2.840.113549.1.3.1";

		internal const string SigningTime = "1.2.840.113549.1.9.5";

		internal const string ContentType = "1.2.840.113549.1.9.3";

		internal const string DocumentDescription = "1.3.6.1.4.1.311.88.2.2";

		internal const string MessageDigest = "1.2.840.113549.1.9.4";

		internal const string CounterSigner = "1.2.840.113549.1.9.6";

		internal const string SigningCertificate = "1.2.840.113549.1.9.16.2.12";

		internal const string SigningCertificateV2 = "1.2.840.113549.1.9.16.2.47";

		internal const string DocumentName = "1.3.6.1.4.1.311.88.2.1";

		internal const string LocalKeyId = "1.2.840.113549.1.9.21";

		internal const string EnrollCertTypeExtension = "1.3.6.1.4.1.311.20.2";

		internal const string UserPrincipalName = "1.3.6.1.4.1.311.20.2.3";

		internal const string CertificateTemplate = "1.3.6.1.4.1.311.21.7";

		internal const string ApplicationCertPolicies = "1.3.6.1.4.1.311.21.10";

		internal const string AuthorityInformationAccess = "1.3.6.1.5.5.7.1.1";

		internal const string OcspEndpoint = "1.3.6.1.5.5.7.48.1";

		internal const string CertificateAuthorityIssuers = "1.3.6.1.5.5.7.48.2";

		internal const string Pkcs9ExtensionRequest = "1.2.840.113549.1.9.14";

		internal const string CmsRc2Wrap = "1.2.840.113549.1.9.16.3.7";

		internal const string Cms3DesWrap = "1.2.840.113549.1.9.16.3.6";

		internal const string Pkcs7Data = "1.2.840.113549.1.7.1";

		internal const string Pkcs