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); } }
public override unsafe void ImportRSAPublicKey(ReadOnlySpan <byte> source, out int bytesRead) { ThrowIfDisposed(); int read; try { AsnDecoder.ReadEncodedValue( source, AsnEncodingRules.BER, out _, out _, out read); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } SafeRsaHandle key = Interop.Crypto.DecodeRsaPublicKey(source.Slice(0, read)); 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 = read; }
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); } }
internal ReadOnlySpan <byte> GetHashableContentSpan() { Debug.Assert(_heldContent.HasValue); ReadOnlyMemory <byte> content = _heldContent.Value; ReadOnlySpan <byte> contentSpan = content.Span; if (!_hasPkcs7Content) { return(contentSpan); } // In PKCS#7 compat, only return the contents within the outermost tag. // See https://tools.ietf.org/html/rfc5652#section-5.2.1 try { AsnDecoder.ReadEncodedValue( contentSpan, AsnEncodingRules.BER, out int contentOffset, out int contentLength, out _); return(contentSpan.Slice(contentOffset, contentLength)); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
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); } }
internal static Pkcs8Response ImportPkcs8PrivateKey(ReadOnlySpan <byte> source, out int bytesRead) { int len; try { AsnDecoder.ReadEncodedValue( source, AsnEncodingRules.BER, out _, out _, out len); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } 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)); } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }
internal static unsafe Pkcs8Response ImportEncryptedPkcs8PrivateKey( ReadOnlySpan <char> password, ReadOnlySpan <byte> source, out int bytesRead) { try { AsnDecoder.ReadEncodedValue( source, AsnEncodingRules.BER, out _, out _, out int len); source = source.Slice(0, len); fixed(byte *ptr = &MemoryMarshal.GetReference(source)) { using (MemoryManager <byte> manager = new PointerMemoryManager <byte>(ptr, source.Length)) { 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) { AsnWriter?pkcs8ZeroPublicKey = RewritePkcs8ECPrivateKeyWithZeroPublicKey(decryptedSpan); if (pkcs8ZeroPublicKey == null) { throw new CryptographicException(SR.Cryptography_Pkcs8_EncryptedReadFailed, e); } try { bytesRead = len; return(ImportPkcs8(pkcs8ZeroPublicKey)); } catch (CryptographicException) { throw new CryptographicException(SR.Cryptography_Pkcs8_EncryptedReadFailed, e); } } finally { CryptographicOperations.ZeroMemory(decryptedSpan); CryptoPool.Return(decrypted.Array !, clearSize: 0); } } } } catch (AsnContentException e) { throw new CryptographicException(SR.Cryptography_Der_Invalid_Encoding, e); } }