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);
}
}