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);
}
}
}
public override void ImportParameters(RSAParameters parameters)
{
ValidateParameters(parameters);
ThrowIfDisposed();
bool isPrivateKey = parameters.D != null;
if (isPrivateKey)
{
// Start with the private key, in case some of the private key fields
// don't match the public key fields.
//
// Public import should go off without a hitch.
ImportPrivateKey(
parameters,
out SafeSecKeyRefHandle privateKey,
out SafeSecKeyRefHandle publicKey);
SetKey(SecKeyPair.PublicPrivatePair(publicKey, privateKey));
}
else
{
SafeSecKeyRefHandle publicKey = ImportKey(parameters);
SetKey(SecKeyPair.PublicOnly(publicKey));
}
}
internal int ImportParameters(ECParameters parameters)
{
parameters.Validate();
ThrowIfDisposed();
bool isPrivateKey = parameters.D != null;
bool hasPublicParameters = parameters.Q.X != null && parameters.Q.Y != null;
SecKeyPair newKeys;
if (isPrivateKey)
{
// Start with the private key, in case some of the private key fields don't
// match the public key fields and the system determines an integrity failure.
//
// Public import should go off without a hitch.
SafeSecKeyRefHandle privateKey = ImportKey(parameters);
ECParameters publicOnly;
if (hasPublicParameters)
{
publicOnly = parameters;
publicOnly.D = null;
}
else
{
publicOnly = ExportPublicParametersFromPrivateKey(privateKey);
}
SafeSecKeyRefHandle publicKey;
try
{
publicKey = ImportKey(publicOnly);
}
catch
{
privateKey.Dispose();
throw;
}
newKeys = SecKeyPair.PublicPrivatePair(publicKey, privateKey);
}
else
{
SafeSecKeyRefHandle publicKey = ImportKey(parameters);
newKeys = SecKeyPair.PublicOnly(publicKey);
}
int size = GetKeySize(newKeys);
SetKey(newKeys);
return(size);
}
public override void ImportParameters(DSAParameters parameters)
{
if (parameters.P == null || parameters.Q == null || parameters.G == null || parameters.Y == null)
throw new ArgumentException(SR.Cryptography_InvalidDsaParameters_MissingFields);
// J is not required and is not even used on CNG blobs.
// It should, however, be less than P (J == (P-1) / Q).
// This validation check is just to maintain parity with DSACng and DSACryptoServiceProvider,
// which also perform this check.
if (parameters.J != null && parameters.J.Length >= parameters.P.Length)
throw new ArgumentException(SR.Cryptography_InvalidDsaParameters_MismatchedPJ);
int keySize = parameters.P.Length;
bool hasPrivateKey = parameters.X != null;
if (parameters.G.Length != keySize || parameters.Y.Length != keySize)
throw new ArgumentException(SR.Cryptography_InvalidDsaParameters_MismatchedPGY);
if (hasPrivateKey && parameters.X.Length != parameters.Q.Length)
throw new ArgumentException(SR.Cryptography_InvalidDsaParameters_MismatchedQX);
if (!(8 * parameters.P.Length).IsLegalSize(LegalKeySizes))
throw new CryptographicException(SR.Cryptography_InvalidKeySize);
if (parameters.Q.Length != 20)
throw new CryptographicException(SR.Cryptography_InvalidDsaParameters_QRestriction_ShortKey);
if (hasPrivateKey)
{
SafeSecKeyRefHandle privateKey = ImportKey(parameters);
DSAParameters publicOnly = parameters;
publicOnly.X = null;
SafeSecKeyRefHandle publicKey;
try
{
publicKey = ImportKey(publicOnly);
}
catch
{
privateKey.Dispose();
throw;
}
SetKey(SecKeyPair.PublicPrivatePair(publicKey, privateKey));
}
else
{
SafeSecKeyRefHandle publicKey = ImportKey(parameters);
SetKey(SecKeyPair.PublicOnly(publicKey));
}
}
internal int ImportParameters(ECParameters parameters)
{
parameters.Validate();
ThrowIfDisposed();
if (!parameters.Curve.IsNamed)
{
throw new PlatformNotSupportedException(SR.Cryptography_ECC_NamedCurvesOnly);
}
switch (parameters.Curve.Oid.Value)
{
case Oids.secp256r1:
case Oids.secp384r1:
case Oids.secp521r1:
break;
default:
throw new PlatformNotSupportedException(
SR.Format(SR.Cryptography_CurveNotSupported, parameters.Curve.Oid.Value ?? parameters.Curve.Oid.FriendlyName));
}
if (parameters.Q.X == null || parameters.Q.Y == null)
{
ExtractPublicKeyFromPrivateKey(ref parameters);
}
bool isPrivateKey = parameters.D != null;
SecKeyPair newKeys;
if (isPrivateKey)
{
// Start with the private key, in case some of the private key fields don't
// match the public key fields and the system determines an integrity failure.
//
// Public import should go off without a hitch.
SafeSecKeyRefHandle privateKey = ImportKey(parameters);
SafeSecKeyRefHandle publicKey = Interop.AppleCrypto.CopyPublicKey(privateKey);
newKeys = SecKeyPair.PublicPrivatePair(publicKey, privateKey);
}
else
{
SafeSecKeyRefHandle publicKey = ImportKey(parameters);
newKeys = SecKeyPair.PublicOnly(publicKey);
}
int size = GetKeySize(newKeys);
SetKey(newKeys);
return(size);
}
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 override void ImportParameters(RSAParameters parameters)
{
ValidateParameters(parameters);
ThrowIfDisposed();
bool isPrivateKey = parameters.D != null;
if (isPrivateKey)
{
// Start with the private key, in case some of the private key fields
// don't match the public key fields.
//
// Public import should go off without a hitch.
SafeSecKeyRefHandle privateKey = ImportKey(parameters);
RSAParameters publicOnly = new RSAParameters
{
Modulus = parameters.Modulus,
Exponent = parameters.Exponent,
};
SafeSecKeyRefHandle publicKey;
try
{
publicKey = ImportKey(publicOnly);
}
catch
{
privateKey.Dispose();
throw;
}
SetKey(SecKeyPair.PublicPrivatePair(publicKey, privateKey));
}
else
{
SafeSecKeyRefHandle publicKey = ImportKey(parameters);
SetKey(SecKeyPair.PublicOnly(publicKey));
}
}
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))
{
// Validate the DER value and get the number of bytes.
RSAKeyFormatHelper.ReadRsaPublicKey(
manager.Memory,
out int localRead);
SafeSecKeyRefHandle publicKey = Interop.AppleCrypto.CreateDataKey(
source.Slice(0, localRead),
Interop.AppleCrypto.PAL_KeyAlgorithm.RSA,
isPublic: true);
SetKey(SecKeyPair.PublicOnly(publicKey));
bytesRead = localRead;
}
}
}
public override void ImportParameters(ECParameters parameters)
{
parameters.Validate();
bool isPrivateKey = parameters.D != null;
if (isPrivateKey)
{
// Start with the private key, in case some of the private key fields don't
// match the public key fields and the system determines an integrity failure.
//
// Public import should go off without a hitch.
SafeSecKeyRefHandle privateKey = ImportKey(parameters);
ECParameters publicOnly = parameters;
publicOnly.D = null;
SafeSecKeyRefHandle publicKey;
try
{
publicKey = ImportKey(publicOnly);
}
catch
{
privateKey.Dispose();
throw;
}
SetKey(SecKeyPair.PublicPrivatePair(publicKey, privateKey));
}
else
{
SafeSecKeyRefHandle publicKey = ImportKey(parameters);
SetKey(SecKeyPair.PublicOnly(publicKey));
}
}
internal RSASecurityTransforms(SafeSecKeyRefHandle publicKey)
{
SetKey(SecKeyPair.PublicOnly(publicKey));
}
internal ECDsaSecurityTransforms(SafeSecKeyRefHandle publicKey)
{
KeySizeValue = _ecc.SetKeyAndGetSize(SecKeyPair.PublicOnly(publicKey));
}