public virtual unsafe void ImportRSAPrivateKey(ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); ReadOnlyMemory <byte> firstValue = reader.PeekEncodedValue(); int localRead = firstValue.Length; AlgorithmIdentifierAsn ignored = default; RSAKeyFormatHelper.FromPkcs1PrivateKey(firstValue, ignored, out RSAParameters rsaParameters); fixed(byte *dPin = rsaParameters.D) fixed(byte *pPin = rsaParameters.P) fixed(byte *qPin = rsaParameters.Q) fixed(byte *dpPin = rsaParameters.DP) fixed(byte *dqPin = rsaParameters.DQ) fixed(byte *qInvPin = rsaParameters.InverseQ) { try { ImportParameters(rsaParameters); } finally { ClearPrivateParameters(rsaParameters); } } bytesRead = localRead; } } }
internal static unsafe byte[] ExportPkcs8(SafeSecKeyRefHandle key, ReadOnlySpan <char> password) { using (SafeCFDataHandle data = Interop.AppleCrypto.SecKeyExportData(key, exportPrivate: true, password)) { ReadOnlySpan <byte> systemExport = Interop.CoreFoundation.CFDataDangerousGetSpan(data); fixed(byte *ptr = systemExport) { using (PointerMemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, systemExport.Length)) { // Apple's PKCS8 export exports using PBES2, which Win7, Win8.1, and Apple all fail to // understand in their PKCS12 readers, so re-encrypt using the Win7 PKCS12-PBE parameters. // // Since Apple only reliably exports keys with encrypted PKCS#8 there's not a // "so export it plaintext and only encrypt it once" option. AsnWriter writer = KeyFormatHelper.ReencryptPkcs8( password, manager.Memory, password, UnixExportProvider.s_windowsPbe); return(writer.Encode()); } } } }
private static unsafe AsnWriter?RewritePkcs8ECPrivateKeyWithZeroPublicKey(ReadOnlySpan <byte> source) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { PrivateKeyInfoAsn privateKeyInfo = PrivateKeyInfoAsn.Decode(manager.Memory, AsnEncodingRules.BER); AlgorithmIdentifierAsn privateAlgorithm = privateKeyInfo.PrivateKeyAlgorithm; if (privateAlgorithm.Algorithm.Value != Oids.EcPublicKey) { return(null); } ECPrivateKey privateKey = ECPrivateKey.Decode(privateKeyInfo.PrivateKey, AsnEncodingRules.BER); EccKeyFormatHelper.FromECPrivateKey(privateKey, privateAlgorithm, out ECParameters ecParameters); fixed(byte *pD = ecParameters.D) { try { if (!ecParameters.Curve.IsExplicit || ecParameters.Q.X != null || ecParameters.Q.Y != null) { return(null); } byte[] zero = new byte[ecParameters.D !.Length];
public virtual unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { try { AsnDecoder.ReadEncodedValue( source, AsnEncodingRules.BER, out _, out _, out int localRead); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, localRead)) { AlgorithmIdentifierAsn ignored = default; RSAKeyFormatHelper.ReadRsaPublicKey(manager.Memory, ignored, out RSAParameters rsaParameters); ImportParameters(rsaParameters); bytesRead = localRead; } } } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
internal unsafe int ImportSubjectPublicKeyInfo( ReadOnlySpan <byte> source, out int bytesRead) { ThrowIfDisposed(); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { // Validate the DER value and get the number of bytes. EccKeyFormatHelper.ReadSubjectPublicKeyInfo( manager.Memory, out int localRead); SafeSecKeyRefHandle publicKey = Interop.AppleCrypto.ImportEphemeralKey(source.Slice(0, localRead), false); SecKeyPair newKeys = SecKeyPair.PublicOnly(publicKey); int size = GetKeySize(newKeys); SetKey(newKeys); bytesRead = localRead; return(size); } } }
internal static unsafe Pkcs8Response ImportEncryptedPkcs8PrivateKey( ReadOnlySpan <byte> passwordBytes, ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { // Since there's no bytes-based-password PKCS8 import in CNG, just do the decryption // here and call the unencrypted PKCS8 import. ArraySegment <byte> decrypted = KeyFormatHelper.DecryptPkcs8( passwordBytes, manager.Memory, out bytesRead); Span <byte> decryptedSpan = decrypted; try { return(ImportPkcs8(decryptedSpan)); } catch (CryptographicException e) { throw new CryptographicException(SR.Cryptography_Pkcs8_EncryptedReadFailed, e); } finally { CryptographicOperations.ZeroMemory(decryptedSpan); CryptoPool.Return(decrypted.Array !); } } } }
protected void ParsePkcs12(ReadOnlySpan <byte> data) { try { // RFC7292 specifies BER instead of DER AsnValueReader reader = new AsnValueReader(data, AsnEncodingRules.BER); // Windows compatibility: Ignore trailing data. ReadOnlySpan <byte> encodedData = reader.PeekEncodedValue(); unsafe { IntPtr tmpPtr = Marshal.AllocHGlobal(encodedData.Length); Span <byte> tmpSpan = new Span <byte>((byte *)tmpPtr, encodedData.Length); encodedData.CopyTo(tmpSpan); _tmpManager = new PointerMemoryManager <byte>((void *)tmpPtr, encodedData.Length); } ReadOnlyMemory <byte> tmpMemory = _tmpManager.Memory; reader = new AsnValueReader(tmpMemory.Span, AsnEncodingRules.BER); PfxAsn.Decode(ref reader, tmpMemory, out PfxAsn pfxAsn); if (pfxAsn.AuthSafe.ContentType != Oids.Pkcs7Data) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } _pfxAsn = pfxAsn; } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
private static byte[] CopyContent(ReadOnlySpan <byte> encodedMessage) { unsafe { fixed(byte *pin = encodedMessage) { using (var manager = new PointerMemoryManager <byte>(pin, encodedMessage.Length)) { AsnValueReader reader = new AsnValueReader(encodedMessage, AsnEncodingRules.BER); ContentInfoAsn.Decode( ref reader, manager.Memory, out ContentInfoAsn parsedContentInfo); if (parsedContentInfo.ContentType != Oids.Pkcs7Enveloped) { throw new CryptographicException(SR.Cryptography_Cms_InvalidMessageType); } return(parsedContentInfo.Content.ToArray()); } } } }
public override unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { ThrowIfDisposed(); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); ReadOnlyMemory <byte> firstElement = reader.PeekEncodedValue(); SubjectPublicKeyInfoAsn spki = new SubjectPublicKeyInfoAsn { Algorithm = new AlgorithmIdentifierAsn { Algorithm = new Oid(Oids.Rsa), Parameters = AlgorithmIdentifierAsn.ExplicitDerNull, }, SubjectPublicKey = firstElement, }; using (AsnWriter writer = new AsnWriter(AsnEncodingRules.DER)) { spki.Encode(writer); ImportSubjectPublicKeyInfo(writer.EncodeAsSpan(), out _); } bytesRead = firstElement.Length; } } }
static byte[] CopyContent(ReadOnlySpan <byte> encodedMessage) { unsafe { fixed(byte *pin = encodedMessage) { using (var manager = new PointerMemoryManager <byte>(pin, encodedMessage.Length)) { AsnValueReader reader = new AsnValueReader(encodedMessage, AsnEncodingRules.BER); // Windows (and thus NetFx) reads the leading data and ignores extra. // So use the Decode overload which doesn't throw on extra data. ContentInfoAsn.Decode( ref reader, manager.Memory, out ContentInfoAsn contentInfo); if (contentInfo.ContentType != Oids.Pkcs7Signed) { throw new CryptographicException(SR.Cryptography_Cms_InvalidMessageType); } return(contentInfo.Content.ToArray()); } } } }
public unsafe override Oid GetEncodedMessageType(ReadOnlySpan <byte> encodedMessage) { fixed(byte *pin = encodedMessage) { using (var manager = new PointerMemoryManager <byte>(pin, encodedMessage.Length)) { AsnValueReader reader = new AsnValueReader(encodedMessage, AsnEncodingRules.BER); ContentInfoAsn.Decode(ref reader, manager.Memory, out ContentInfoAsn contentInfo); switch (contentInfo.ContentType) { case Oids.Pkcs7Data: case Oids.Pkcs7Signed: case Oids.Pkcs7Enveloped: case Oids.Pkcs7SignedEnveloped: case Oids.Pkcs7Hashed: case Oids.Pkcs7Encrypted: return(new Oid(contentInfo.ContentType)); } throw new CryptographicException(SR.Cryptography_Cms_InvalidMessageType); } } }
public override unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { ThrowIfDisposed(); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); ReadOnlyMemory <byte> firstElement = reader.PeekEncodedValue(); SafeRsaHandle key = Interop.Crypto.DecodeRsaPublicKey(firstElement.Span); Interop.Crypto.CheckValidOpenSslHandle(key); FreeKey(); _key = new Lazy <SafeRsaHandle>(key); // Use ForceSet instead of the property setter to ensure that LegalKeySizes doesn't interfere // with the already loaded key. ForceSetKeySize(BitsPerByte * Interop.Crypto.RsaSize(key)); bytesRead = firstElement.Length; } } }
internal static unsafe Pkcs8Response ImportPkcs8PrivateKey(ReadOnlySpan <byte> source, out int bytesRead) { int len; fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); len = reader.ReadEncodedValue().Length; } } bytesRead = len; ReadOnlySpan <byte> pkcs8Source = source.Slice(0, len); try { return(ImportPkcs8(pkcs8Source)); } catch (CryptographicException) { AsnWriter?pkcs8ZeroPublicKey = RewritePkcs8ECPrivateKeyWithZeroPublicKey(pkcs8Source); if (pkcs8ZeroPublicKey == null) { throw; } return(ImportPkcs8(pkcs8ZeroPublicKey.EncodeAsSpan())); } }
internal static unsafe ECParameters FromECPrivateKey(ReadOnlySpan <byte> key, out int bytesRead) { try { AsnDecoder.ReadEncodedValue( key, AsnEncodingRules.BER, out _, out _, out int firstValueLength); fixed(byte *ptr = &MemoryMarshal.GetReference(key)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, firstValueLength)) { AlgorithmIdentifierAsn algId = default; FromECPrivateKey(manager.Memory, algId, out ECParameters ret); bytesRead = firstValueLength; return(ret); } } } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
private static bool IsPkcs7Signed(ReadOnlySpan <byte> rawData) { try { unsafe { fixed(byte *pin = rawData) { using (var manager = new PointerMemoryManager <byte>(pin, rawData.Length)) { AsnValueReader reader = new AsnValueReader(rawData, AsnEncodingRules.BER); ContentInfoAsn.Decode(ref reader, manager.Memory, out ContentInfoAsn contentInfo); switch (contentInfo.ContentType) { case Oids.Pkcs7Signed: case Oids.Pkcs7SignedEnveloped: return(true); } } } } } catch (CryptographicException) { } return(false); }
private static unsafe int DecodeSubjectPublicKeyInfo( ReadOnlySpan <byte> source, out Oid oid, out AsnEncodedData parameters, out AsnEncodedData keyValue) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnValueReader reader = new AsnValueReader(source, AsnEncodingRules.DER); int read; SubjectPublicKeyInfoAsn spki; try { read = reader.PeekEncodedValue().Length; SubjectPublicKeyInfoAsn.Decode(ref reader, manager.Memory, out spki); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } oid = new Oid(spki.Algorithm.Algorithm, null); parameters = new AsnEncodedData(spki.Algorithm.Parameters?.ToArray() ?? Array.Empty <byte>()); keyValue = new AsnEncodedData(spki.SubjectPublicKey.ToArray()); return(read); } }
public static CoseSign1Message DecodeSign1(ReadOnlySpan <byte> cborPayload) { unsafe { fixed(byte *ptr = &MemoryMarshal.GetReference(cborPayload)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, cborPayload.Length)) { return(DecodeCoseSign1Core(new CborReader(manager.Memory))); } } } }
internal static unsafe Pkcs8Response ImportEncryptedPkcs8PrivateKey( ReadOnlySpan <char> password, ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); int len = reader.ReadEncodedValue().Length; source = source.Slice(0, len); try { bytesRead = len; return(ImportPkcs8(source, password)); } catch (CryptographicException) { } ArraySegment <byte> decrypted = KeyFormatHelper.DecryptPkcs8( password, manager.Memory.Slice(0, len), out int innerRead); Span <byte> decryptedSpan = decrypted; try { if (innerRead != len) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding); } bytesRead = len; return(ImportPkcs8(decryptedSpan)); } catch (CryptographicException e) { throw new CryptographicException(SR.Cryptography_Pkcs8_EncryptedReadFailed, e); } finally { CryptographicOperations.ZeroMemory(decryptedSpan); CryptoPool.Return(decrypted.Array !, clearSize: 0); } } } }
public override unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { ThrowIfDisposed(); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { ReadOnlyMemory <byte> subjectPublicKey; try { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); subjectPublicKey = reader.PeekEncodedValue(); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } // Decoding the key on Android requires the encoded SubjectPublicKeyInfo, // not just the SubjectPublicKey, so we construct one. SubjectPublicKeyInfoAsn spki = new SubjectPublicKeyInfoAsn { Algorithm = new AlgorithmIdentifierAsn { Algorithm = Oids.Rsa, Parameters = AlgorithmIdentifierAsn.ExplicitDerNull, }, SubjectPublicKey = subjectPublicKey, }; AsnWriter writer = new AsnWriter(AsnEncodingRules.DER); spki.Encode(writer); SafeRsaHandle key = Interop.AndroidCrypto.DecodeRsaSubjectPublicKeyInfo(writer.Encode()); if (key is null || key.IsInvalid) { key?.Dispose(); throw new CryptographicException(); } FreeKey(); _key = new Lazy <SafeRsaHandle>(key); SetKeySizeFromHandle(key); bytesRead = subjectPublicKey.Length; } } }
public override unsafe void ImportPkcs8PrivateKey(ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { ReadOnlyMemory <byte> pkcs1 = RSAKeyFormatHelper.ReadPkcs8( manager.Memory, out int localRead); ImportRSAPrivateKey(pkcs1.Span, out _); bytesRead = localRead; } } }
internal static unsafe ECParameters FromECPrivateKey(ReadOnlySpan <byte> key, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(key)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, key.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); AlgorithmIdentifierAsn algId = default; ReadOnlyMemory <byte> firstValue = reader.PeekEncodedValue(); FromECPrivateKey(firstValue, algId, out ECParameters ret); bytesRead = firstValue.Length; return(ret); } } }
internal static unsafe Pkcs8Response ImportPkcs8PrivateKey(ReadOnlySpan <byte> source, out int bytesRead) { int len; fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); len = reader.ReadEncodedValue().Length; } } bytesRead = len; return(ImportPkcs8(source.Slice(0, len))); }
internal static unsafe void ReadEncryptedPkcs8 <TRet>( string[] validOids, ReadOnlySpan <byte> source, ReadOnlySpan <char> password, KeyReader <TRet> keyReader, out int bytesRead, out TRet ret) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { ReadEncryptedPkcs8(validOids, manager.Memory, password, keyReader, out bytesRead, out ret); } } }
public override unsafe void ImportSubjectPublicKeyInfo(ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { ReadOnlyMemory <byte> pkcs1 = KeyFormatHelper.ReadSubjectPublicKeyInfo( s_validOids, manager.Memory, out int localRead); ImportRSAPublicKey(pkcs1.Span, out _); bytesRead = localRead; } } }
internal static unsafe ECParameters FromECPrivateKey(ReadOnlySpan <byte> key, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(key)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, key.Length)) { ECPrivateKey parsedKey = AsnSerializer.Deserialize <ECPrivateKey>(manager.Memory, AsnEncodingRules.BER, out bytesRead); ECParameters ret; AlgorithmIdentifierAsn algId = default; FromECPrivateKey(parsedKey, algId, out ret); return(ret); } } }
public virtual unsafe void ImportRSAPrivateKey(ReadOnlySpan <byte> source, out int bytesRead) { try { AsnDecoder.ReadEncodedValue( source, AsnEncodingRules.BER, out _, out _, out int firstValueLength); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, firstValueLength)) { ReadOnlyMemory <byte> firstValue = manager.Memory; int localRead = firstValue.Length; AlgorithmIdentifierAsn ignored = default; RSAKeyFormatHelper.FromPkcs1PrivateKey(firstValue, ignored, out RSAParameters rsaParameters); fixed(byte *dPin = rsaParameters.D) fixed(byte *pPin = rsaParameters.P) fixed(byte *qPin = rsaParameters.Q) fixed(byte *dpPin = rsaParameters.DP) fixed(byte *dqPin = rsaParameters.DQ) fixed(byte *qInvPin = rsaParameters.InverseQ) { try { ImportParameters(rsaParameters); } finally { ClearPrivateParameters(rsaParameters); } } bytesRead = localRead; } } } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
public X509ContentType GetCertContentType(ReadOnlySpan <byte> rawData) { const int errSecUnknownFormat = -25257; if (rawData == null || rawData.Length == 0) { // Throw to match Windows and Unix behavior. throw Interop.AppleCrypto.CreateExceptionForOSStatus(errSecUnknownFormat); } X509ContentType contentType = Interop.AppleCrypto.X509GetContentType(rawData); // Apple doesn't seem to recognize PFX files with no MAC, so try a quick maybe-it's-a-PFX test if (contentType == X509ContentType.Unknown) { try { unsafe { fixed(byte *pin = rawData) { using (var manager = new PointerMemoryManager <byte>(pin, rawData.Length)) { PfxAsn.Decode(manager.Memory, AsnEncodingRules.BER); } contentType = X509ContentType.Pkcs12; } } } catch (CryptographicException) { } } if (contentType == X509ContentType.Unknown) { // Throw to match Windows and Unix behavior. throw Interop.AppleCrypto.CreateExceptionForOSStatus(errSecUnknownFormat); } return(contentType); }
public virtual unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { AsnReader reader = new AsnReader(manager.Memory, AsnEncodingRules.BER); ReadOnlyMemory <byte> firstValue = reader.PeekEncodedValue(); int localRead = firstValue.Length; AlgorithmIdentifierAsn ignored = default; RSAKeyFormatHelper.ReadRsaPublicKey(firstValue, ignored, out RSAParameters rsaParameters); ImportParameters(rsaParameters); bytesRead = localRead; } } }
public override unsafe void ImportSubjectPublicKeyInfo( ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { // Validate the DER value and get the number of bytes. DSAKeyFormatHelper.ReadSubjectPublicKeyInfo( manager.Memory, out int localRead); SafeSecKeyRefHandle publicKey = Interop.AppleCrypto.ImportEphemeralKey(source.Slice(0, localRead), false); SetKey(SecKeyPair.PublicOnly(publicKey)); bytesRead = localRead; } } }
public virtual unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { RSAPublicKey key = AsnSerializer.Deserialize <RSAPublicKey>( manager.Memory, AsnEncodingRules.BER, out int localRead); RSAParameters rsaParameters = new RSAParameters { Modulus = key.Modulus.ToByteArray(isUnsigned: true, isBigEndian: true), Exponent = key.PublicExponent.ToByteArray(isUnsigned: true, isBigEndian: true), }; ImportParameters(rsaParameters); bytesRead = localRead; } } }