public GetEncryptionKeyOperation(string publicKeyExponent, string publicKeyModulus)
{
RequestBody = new PublicKeyData
{
exponent = publicKeyExponent,
modulus = publicKeyModulus
};
}
private static byte[] EncryptWithPublicKey(PublicKeyData info, byte[] data)
{
using (RSACryptoServiceProvider encryptionProvider = new RSACryptoServiceProvider(info.KeySize))
{
encryptionProvider.ImportParameters(info.GetParameters());
return(encryptionProvider.Encrypt(data, true));
}
}
internal static byte[] CreateNewPublicKey(RSAParameters parameters, int keySize)
{
PublicKeyData resultData = new PublicKeyData(parameters, keySize);
MemoryStream resultStream = new MemoryStream();
var resultWriter = new BinaryWriter(resultStream);
resultData.Write(resultWriter);
return(resultStream.ToArray());
}
public async Task EvaluateEmptyPublicKeyProducesCorrectMessage()
{
PublicKeyData publicKeyData = new PublicKeyData("");
PublicKeyType publicKeyType = new PublicKeyType("", KeyType.Rsa);
DkimRecord dkimRecord = new DkimRecord(null, new List <Tag> {
publicKeyData, publicKeyType
});
List <EvaluationError> result = await _selectorShouldBeWellConfigured.Evaluate(dkimRecord);
Assert.AreEqual(1, result.Count);
Assert.AreEqual(Guid.Parse("7150fec3-0464-4cd5-b774-d1d7bcff7ec5"), result[0].Id);
}
public EvaluationResult <Tag> Parse(string value)
{
//first remove all legal folding white space
string trimmedValues = _fwsRegex.Replace(value ?? string.Empty, string.Empty);
//then check if the result if a valid base 64 string
PublicKeyData publicKeyData = new PublicKeyData(value);
if (!_base64Regex.IsMatch(trimmedValues))
{
EvaluationError error = new EvaluationError(Id, EvaluationErrorType.Error,
string.Format(DKimEvaluatorParsersResources.InvalidPublicKeyErrorMessage, value ?? "null"),
string.Format(DKimEvaluatorParsersMarkdownResources.InvalidPublicKeyErrorMessage, value ?? "null"));
return(new EvaluationResult <Tag>(publicKeyData, error));
}
return(new EvaluationResult <Tag>(publicKeyData));
}
internal static IStrongNameKeyInfo LoadStrongNameKeyData(Stream targetStream, bool @private = true)
{
if (@private)
{
PrivateKeyData targetData = new PrivateKeyData();
using (var targetReader = new BinaryReader(targetStream))
targetData.Read(targetReader);
var data = targetData.GetData();
StrongNamePrivateKeyInfo result = new StrongNamePrivateKeyInfo(data.Item3, data.Item2, data.Item1, (int)targetData.header.BitLength);
return(result);
}
else
{
PublicKeyData targetData = new PublicKeyData();
using (var targetReader = new BinaryReader(targetStream))
targetData.Read(targetReader);
return(targetData);
}
}
internal static IStrongNameKeyInfo LoadStrongNameKeyData(byte[] data, bool @private = true)
{
if (@private)
{
using (MemoryStream targetStream = new MemoryStream(data))
{
PrivateKeyData targetData = new PrivateKeyData();
using (var targetReader = new BinaryReader(targetStream))
targetData.Read(targetReader);
var resultData = targetData.GetData();
StrongNamePrivateKeyInfo result = new StrongNamePrivateKeyInfo(resultData.Item3, resultData.Item2, resultData.Item1, (int)targetData.header.BitLength);
return(result);
}
}
else
{
if (data.SequenceEqual(StandardPublicKey))
{
return(StandardPublicKeyStream.StandardPublicKey);
}
else if (PublicKeyData.IsDataProperLength(data))
{
using (MemoryStream targetStream = new MemoryStream(data))
{
PublicKeyData targetData = new PublicKeyData();
using (var targetReader = new BinaryReader(targetStream))
targetData.Read(targetReader);
return(targetData);
}
}
else
{
throw new ArgumentException("publicKey");
}
}
}
public Task <List <EvaluationError> > Evaluate(DkimRecord record)
{
PublicKeyData publicKeyData = record.Tags.OfType <PublicKeyData>().FirstOrDefault();
PublicKeyType publicKeyType = record.Tags.OfType <PublicKeyType>().FirstOrDefault();
List <EvaluationError> errors = new List <EvaluationError>();
if (publicKeyData != null && publicKeyType != null && !string.IsNullOrEmpty(publicKeyData.Value))
{
if (publicKeyType.KeyType != KeyType.Unknown)
{
switch (publicKeyType.KeyType)
{
case KeyType.Ed25519:
break;
case KeyType.Rsa:
string key = publicKeyData.Value.TrimEnd(';');
if (!_publicKeyEvaluator.TryGetKeyLengthSize(key, out int keyLength))
{
Guid Error3Id = Guid.Parse("21B09D43-685C-4CAE-989E-7194CA093863");
errors.Add(new EvaluationError(Error3Id, EvaluationErrorType.Error,
DKimEvaluatorRulesResources.CorruptPublicKeyErrorMessage,
DKimEvaluatorRulesMarkdownResources.CorruptPublicKeyErrorMessage));
}
else if (keyLength < 2048)
{
if (keyLength < 1024)
{
Guid Error1Id = Guid.Parse("C740A1B0-394B-4397-A4E6-178C3137A84D");
errors.Add(new EvaluationError(Error1Id, EvaluationErrorType.Error,
string.Format(DKimEvaluatorRulesResources.PublicKeyIsToShortErrorMessage,
keyLength),
string.Empty));
}
else if (keyLength >= 1024 && keyLength < 2048)
{
Guid Error2Id = Guid.Parse("D16BE8D5-8ED6-4DD0-A8AA-C8F1380A8D3C");
errors.Add(new EvaluationError(Error2Id, EvaluationErrorType.Warning,
string.Format(
DKimEvaluatorRulesResources.PublicKeyIsToShortUseLongerErrorMessage,
keyLength),
string.Empty));
}
}
break;
}
}
else
{
Guid Error3Id = Guid.Parse("FF2380B4-8DE6-4B97-B69A-F3382EBF3DE2");
errors.Add(new EvaluationError(Error3Id, EvaluationErrorType.Error,
DKimEvaluatorRulesResources.IncorrectPublicKeyConfigured,
DKimEvaluatorRulesMarkdownResources.IncorrectPublicKeyConfigured));
}
}
else
{
Guid Error3Id = Guid.Parse("7150FEC3-0464-4CD5-B774-D1D7BCFF7EC5");
errors.Add(new EvaluationError(Error3Id, EvaluationErrorType.Info,
DKimEvaluatorRulesResources.NullPublicKeyConfigured,
DKimEvaluatorRulesMarkdownResources.NullPublicKeyConfigured));
}
return(Task.FromResult(errors));
}
