public static Rsa Inject(BigInteger e, int keyLen, int certainty, byte[] publicKey)
{
byte[] privateData = new byte[MontgomeryCurve25519.PrivateKeySizeInBytes];
RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
// Генерируем секретное значение для инициализации ГПСЧ
rng.GetBytes(privateData);
// Создаём полезную нагрузку, шифруя seed
byte[] payload = MontgomeryCurve25519.GetPublicKey(privateData);
byte[] seed = MontgomeryCurve25519.KeyExchange(publicKey, privateData);
Rsa rsa = new Rsa(e, keyLen, certainty, new Random(seed.PackToInt()));
Rsa.RsaParams rsap = rsa.Params;
// Вшиваем полезную нагрузку в модуль n
byte[] mod = rsap.n.ToByteArray();
Replace(mod, payload, 80);
BigInteger n = new BigInteger(mod);
// q = NextPrime(n' / p)
rsap.q = (n.Divide(rsap.p)).NextProbablePrime();
if (rsap.p.CompareTo(rsap.q) < 0) // Если q больше p, меняем их местами
{
BigInteger tmp = rsap.p;
rsap.p = rsap.q;
rsap.q = tmp;
}
// Заново считаем остальные параметры
rsa.GenerateKeys(rsap.p, rsap.q);
return(rsa);
}
public MontgomeryCurve25519Tests()
{
//Warmup
MontgomeryCurve25519.GetPublicKey(MontgomeryCurve25519TestVectors.AlicePrivateKey);
MontgomeryCurve25519.KeyExchange(MontgomeryCurve25519TestVectors.AlicePublicKey, MontgomeryCurve25519TestVectors.AlicePrivateKey);
MontgomeryCurve25519.KeyExchange(MontgomeryCurve25519TestVectors.BobPublicKey, MontgomeryCurve25519TestVectors.BobPrivateKey);
}
public static Rsa Extract(BigInteger e, BigInteger mod, int certainty, byte[] privateKey)
{
byte[] modulus = mod.ToByteArray();
byte[] payload = new byte[MontgomeryCurve25519.PublicKeySizeInBytes];
// Вытаскиваем полезную нагрузку и расшифровываем seed
Array.Copy(modulus, 80, payload, 0, 32);
byte[] seed = MontgomeryCurve25519.KeyExchange(payload, privateKey);
Rsa rsa = new Rsa(e, mod.BitLength, certainty, new Random(seed.PackToInt()));
Rsa.RsaParams rsap = rsa.Params;
// Вшиваем полезную нагрузку в модуль n
modulus = rsap.n.ToByteArray();
Replace(modulus, payload, 80);
BigInteger n = new BigInteger(modulus);
// q = NextPrime(n' / p)
rsap.q = (n.Divide(rsap.p)).NextProbablePrime();
if (rsap.p.CompareTo(rsap.q) < 0) // Если q больше p, меняем их местами
{
BigInteger tmp = rsap.p;
rsap.p = rsap.q;
rsap.q = tmp;
}
// Заново считаем остальные параметры
rsa.GenerateKeys(rsap.p, rsap.q);
return(rsa);
}
public void GetPublicKeySegments()
{
var privateKey = MontgomeryCurve25519TestVectors.BobPrivateKey.Pad();
var calculatedBobPublicKey = new byte[32].Pad();
MontgomeryCurve25519.GetPublicKey(calculatedBobPublicKey, privateKey);
TestHelpers.AssertEqualBytes(MontgomeryCurve25519TestVectors.BobPublicKey, calculatedBobPublicKey.UnPad());
}
/// <summary>
/// Get the Curve25519 Shared Key from a senders Public Key byte array.
/// </summary>
/// <param name="PartnerPublicKey"></param>
/// <returns></returns>
public byte[] GetShared(byte[] PartnerPublicKey)
{
if (!Initialized)
{
throw new NullReferenceException("Keys object not initilized with an e-mail address and passphrase.");
}
return(MontgomeryCurve25519.KeyExchange(PartnerPublicKey, Secret));
}
private void MakeSeedAndPayload(out byte[] seed, out byte[] payload)
{
var rnd = new SecureRandom();
var priv = new byte[32];
rnd.NextBytes(priv);
payload = MontgomeryCurve25519.GetPublicKey(priv);
seed = MontgomeryCurve25519.KeyExchange(payload, MY_PRIVATE);
}
public void GetSharedKeySegments()
{
var bobPublic = MontgomeryCurve25519TestVectors.BobPublicKey.Pad();
var alicePrivate = MontgomeryCurve25519TestVectors.AlicePrivateKey.Pad();
var calculatedSharedAlice = new byte[32].Pad();
MontgomeryCurve25519.KeyExchange(calculatedSharedAlice, bobPublic, alicePrivate);
TestHelpers.AssertEqualBytes(MontgomeryCurve25519TestVectors.AliceBobSharedKey, calculatedSharedAlice.UnPad());
}
public void KeyExchange()
{
var seed = new byte[32];
byte[] publicEdwards, privateEdwards;
Ed25519.KeyPairFromSeed(out publicEdwards, out privateEdwards, seed);
var sharedEdwards = Ed25519.KeyExchange(publicEdwards, privateEdwards);
var privateMontgomery = Sha512.Hash(seed).Take(32).ToArray();
var publicMontgomery = MontgomeryCurve25519.GetPublicKey(privateMontgomery);
var sharedMontgomery = MontgomeryCurve25519.KeyExchange(publicMontgomery, privateMontgomery);
TestHelpers.AssertEqualBytes(sharedMontgomery, sharedEdwards);
}
public void KeyExchangeSegments()
{
var seed = new byte[32].Pad();
var publicEdwards = new byte[32].Pad();
var privateEdwards = new byte[64].Pad();
Ed25519.KeyPairFromSeed(publicEdwards, privateEdwards, seed);
var sharedEdwards = new byte[32].Pad();
Ed25519.KeyExchange(sharedEdwards, publicEdwards, privateEdwards);
var privateMontgomery = Sha512.Hash(seed.UnPad()).Take(32).ToArray();
var publicMontgomery = MontgomeryCurve25519.GetPublicKey(privateMontgomery);
var sharedMontgomery = MontgomeryCurve25519.KeyExchange(publicMontgomery, privateMontgomery);
TestHelpers.AssertEqualBytes(sharedMontgomery, sharedEdwards.UnPad());
}
protected override async ValueTask InitializeAsync()
{
var Query = new Message()
{
ID = (ushort)Random.Next(),
MessageType = MessageType.Query,
Truncated = false,
CheckingDisabled = true,
RecursionDesired = true,
Questions = new List <IQuestion>()
{
new Question()
{
Type = RecordType.TXT,
Class = RecordClass.Internet,
Domain = Domain.FromString(Stamp.ProviderName)
}
}
};
var SerializedQuery = await BinarySerializer.SerializeAsync(Query);
await Client.SendAsync(SerializedQuery, SerializedQuery.Length, IPEndPoint);
var Task = Client.ReceiveAsync();
Task.Wait(Options.CurrentValue.Timeout);
var SerializedAnswer = Task.IsCompleted ? Task.Result.Buffer : throw new TimeoutException();
var AnswerMessage = await BinarySerializer.DeserializeAsync <Message>(SerializedAnswer);
var IsValid = await VerifyServer(AnswerMessage);
if (!IsValid)
{
throw new CryptographicUnexpectedOperationException("Invalid Server Certificate.");
}
SharedKey = MontgomeryCurve25519.KeyExchange(Certificate.PublicKey, ClientPrivateKey);
IsInitialized = true;
}
public void GetElligatorPublicKeySegments()
{
var privateKey = MontgomeryCurve25519TestVectors.BobPrivateKey.Pad();
var elligatorKey = new byte[32].Pad();
if (MontgomeryCurve25519.GetElligatorPublicKey(elligatorKey, privateKey))
{
var originalKey = new byte[32].Pad();
MontgomeryCurve25519.GetPublicKeyFromRepresentative(originalKey, elligatorKey);
TestHelpers.AssertEqualBytes(MontgomeryCurve25519TestVectors.BobPublicKey, originalKey.UnPad());
}
privateKey = MontgomeryCurve25519TestVectors.AlicePrivateKey.Pad();
elligatorKey = new byte[32].Pad();
if (MontgomeryCurve25519.GetElligatorPublicKey(elligatorKey, privateKey))
{
throw new Exception("The key is not suitable for Elligator");
}
}
public void ElligatorRandomKeys()
{
var rng = new RNGCryptoServiceProvider();
var priv = new byte[32].Pad();
var elligatorKey = new byte[32].Pad();
var bytes = new byte[32];
var restoredKey = new byte[32].Pad();
var originalKey = new byte[32].Pad();
for (var i = 0; i < 1000; i++)
{
rng.GetBytes(bytes);
Array.Copy(bytes, 0, priv.Array, priv.Offset, 32);
if (MontgomeryCurve25519.GetElligatorPublicKey(elligatorKey, priv))
{
MontgomeryCurve25519.GetPublicKeyFromRepresentative(restoredKey, elligatorKey);
MontgomeryCurve25519.GetPublicKey(originalKey, priv);
TestHelpers.AssertEqualBytes(originalKey.UnPad(), restoredKey.UnPad());
}
}
}
/// <summary>
/// Get the Curve25519 Shared Key from a senders Public miniLock ID.
/// </summary>
/// <param name="PartnerPublicKey"></param>
/// <returns></returns>
public byte[] GetShared(string PartnerPublicID, bool PartnerPublicIDIsBase64Encoded = false)
{
if (string.IsNullOrWhiteSpace(PartnerPublicID))
{
throw new ArgumentNullException("PartnerPublicID");
}
if (!Initialized)
{
throw new NullReferenceException("Keys object not initilized with an e-mail address and passphrase.");
}
if (!PartnerPublicIDIsBase64Encoded)
{
PartnerPublicID = PartnerPublicID.Trim();
if (!ValidatePublicKey(PartnerPublicID))
{
throw new ArgumentException("PartnerPublicID not a valid miniLock ID");
}
return(MontgomeryCurve25519.KeyExchange(Keys.GetBytesFromPublicKey(PartnerPublicID), Secret));
}
else
{
return(MontgomeryCurve25519.KeyExchange(PartnerPublicID.ToBytesFromBase64(), Secret));
}
}
public AsymmetricCipherKeyPair BuildKeyFromPayload(byte[] payload)
{
var seed = MontgomeryCurve25519.KeyExchange(payload, MY_PRIVATE);
return(BuildKey(seed, payload));
}
public static void Main()
{
const int n = 10000;
Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
Console.WriteLine("Architecture: {0} bit", IntPtr.Size * 8);
Console.WriteLine("CPU-Frequency: {0} MHz", Cpu.CpuFreq);
Cpu.Setup();
Console.WriteLine();
Console.ReadKey();
var m = new byte[100];
var seed = new byte[32];
byte[] privateKey;
byte[] publicKey;
Ed25519.KeyPairFromSeed(out publicKey, out privateKey, seed.AsReadOnlySpan());
var sig = Ed25519.Sign(m, privateKey);
Ed25519.Sign(m, privateKey);
if (!Ed25519.Verify(sig.AsReadOnlySpan(), m.AsReadOnlySpan(), publicKey.AsReadOnlySpan()))
{
throw new Exception("Bug");
}
if (Ed25519.Verify(sig.AsReadOnlySpan(), m.Concat(new byte[] { 1 }).ToArray().AsReadOnlySpan(), publicKey.AsReadOnlySpan()))
{
throw new Exception("Bug");
}
Console.BackgroundColor = ConsoleColor.Black;
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("=== Edwards ===");
Benchmark("KeyGen", () => Ed25519.KeyPairFromSeed(out publicKey, out privateKey, seed.AsReadOnlySpan()), n);
Benchmark("Sign", () => Ed25519.Sign(m, privateKey), n);
Benchmark("Verify", () => Ed25519.Verify(sig.AsReadOnlySpan(), m.AsReadOnlySpan(), publicKey.AsReadOnlySpan()), n);
Benchmark("KeyExchange", () => Ed25519.KeyExchange(publicKey, privateKey), n);
Console.WriteLine();
}
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("=== Montgomery ===");
Benchmark("KeyGen", () => MontgomeryCurve25519.GetPublicKey(seed), n);
Benchmark("KeyExchange", () => MontgomeryCurve25519.KeyExchange(publicKey, seed), n);
Console.WriteLine();
}
foreach (var size in new[] { 1, 128 * 1024 })
{
Console.ForegroundColor = ConsoleColor.Yellow;
Console.WriteLine("=== Symmetric ({0}) ===", SizeToString(size));
var message = new byte[size];
var ciphertext = new byte[message.Length + 16];
var key = new byte[32];
var nonce = new byte[24];
//Benchmark("SHA512Managed", () => new SHA512Managed().ComputeHash(message), n, size);
Benchmark("SHA512Cng", () => new SHA512Cng().ComputeHash(message), n, size);
Benchmark("SHA512CSP", () => new SHA512CryptoServiceProvider().ComputeHash(message), n, size);
Benchmark("SHA512Chaos", () => Sha512.Hash(message), n, size);
}
}
public void GetSharedKeyAliceBob()
{
var calculatedSharedAlice = MontgomeryCurve25519.KeyExchange(MontgomeryCurve25519TestVectors.BobPublicKey, MontgomeryCurve25519TestVectors.AlicePrivateKey);
TestHelpers.AssertEqualBytes(MontgomeryCurve25519TestVectors.AliceBobSharedKey, calculatedSharedAlice);
}
public void GetSharedKeyBobFrank()
{
var calculatedSharedBobFrank = MontgomeryCurve25519.KeyExchange(MontgomeryCurve25519TestVectors.FrankPublicKey, MontgomeryCurve25519TestVectors.BobPrivateKey);
TestHelpers.AssertEqualBytes(MontgomeryCurve25519TestVectors.BobFrankSharedKey, calculatedSharedBobFrank);
}
public void GetPublicKeyBob()
{
var calculatedBobPublicKey = MontgomeryCurve25519.GetPublicKey(MontgomeryCurve25519TestVectors.BobPrivateKey);
Assert.IsTrue(MontgomeryCurve25519TestVectors.BobPublicKey.SequenceEqual(calculatedBobPublicKey));
}
