public void Init()
{
var curves = Enum.GetNames(typeof(BrainpoolEllipticCurve));
for (var i = 0; i < curves.Length; i++)
{
_ecKeypairs.Add(curves [i], new ECTestKPStore {
Initiator = KeypairFactory.GenerateECKeypair(curves[i]),
Responder = KeypairFactory.GenerateECKeypair(curves[i])
});
}
curves = Enum.GetNames(typeof(Sec2EllipticCurve));
for (var i = 0; i < curves.Length; i++)
{
_ecKeypairs.Add(curves [i], new ECTestKPStore {
Initiator = KeypairFactory.GenerateECKeypair(curves[i]),
Responder = KeypairFactory.GenerateECKeypair(curves[i])
});
}
_ecKeypairs.Add(DjbCurve.Curve25519.ToString(), new ECTestKPStore {
Initiator = KeypairFactory.GenerateECKeypair(DjbCurve.Curve25519.ToString()),
Responder = KeypairFactory.GenerateECKeypair(DjbCurve.Curve25519.ToString())
});
_ecKeypairs.Add(DjbCurve.Ed25519.ToString(), new ECTestKPStore {
Initiator = KeypairFactory.GenerateECKeypair(DjbCurve.Ed25519.ToString()),
Responder = KeypairFactory.GenerateECKeypair(DjbCurve.Ed25519.ToString())
});
}
public KeyProvider(int keysToMake = 5)
{
var symKeys = new List <SymmetricKey>();
var ecKeypairs = new List <ECKeypair>();
for (int i = 0; i < keysToMake; i++)
{
// Symmetric key
var newSymKey = new byte[128.BitsToBytes()];
var newSymCanary = new byte[128.BitsToBytes()];
StratCom.EntropySupplier.NextBytes(newSymKey);
StratCom.EntropySupplier.NextBytes(newSymCanary);
symKeys.Add(new SymmetricKey {
Key = newSymKey,
ConfirmationCanary = newSymCanary,
UsePermissions = SymmetricKeyUsePermission.Encryption | SymmetricKeyUsePermission.Authentication,
ContextPermissions = KeyUseContextPermission.ManifestHeader | KeyUseContextPermission.PayloadItem
});
// EC key
int curveIndex = StratCom.EntropySupplier.Next(Athena.Cryptography.EllipticCurves.Count);
string curveName = Athena.Cryptography.EllipticCurves.Keys.ElementAt(curveIndex);
ECKeypair newEcKey = KeypairFactory.GenerateECKeypair(curveName);
ecKeypairs.Add(newEcKey);
}
SymmetricKeys = symKeys;
EcKeypairs = ecKeypairs;
}
/// <summary>
/// Create a key provider with keys based off an existing key provider,
/// aimed at a sender-recipient relationship.
/// </summary>
/// <param name="other">Existing key provider to use as a basis for interoperability.</param>
public KeyProvider(KeyProvider other)
{
SymmetricKeys = other.SymmetricKeys.Reverse().ToList();
EcKeypairs = other.EcKeypairs.Select(
item => {
ECKeypair newEcKeypair = KeypairFactory.GenerateECKeypair(item.CurveName);
var newEcCanary = new byte[128.BitsToBytes()];
StratCom.EntropySupplier.NextBytes(newEcCanary);
newEcKeypair.ConfirmationCanary = newEcCanary;
return(newEcKeypair);
}).ToList();
}
public void DJB_Ed25519_Blake2B512()
{
byte[] data = TEST;
var digest = new Blake2BDigest(512);
var m = new byte[digest.OutputSize];
digest.BlockUpdate(data, 0, data.Length);
digest.DoFinal(m, 0);
ECKeypair keypair = KeypairFactory.GenerateECKeypair(DjbCurve.Ed25519.ToString());
byte[] sig = Ed25519.Sign(m, keypair.EncodedPrivateKey);
bool good = Ed25519.Verify(sig, m, keypair.EncodedPublicKey);
Assert.IsTrue(good);
}
public static byte[] Initiate(ECPublicKeyParameters recipientPublicKey, ECPrivateKeyParameters senderPrivateKey,
out ECPublicKeyParameters ephemeralSenderPublicKey)
{
ECPublicKeyParameters Q_static_V = recipientPublicKey;
ECPrivateKeyParameters d_static_U = senderPrivateKey;
ECPoint QeV;
BigInteger deU;
KeypairFactory.GenerateECKeypair(recipientPublicKey.Parameters, out QeV, out deU);
var Q_ephemeral_V = new ECPublicKeyParameters("ECDHC", QeV, recipientPublicKey.Parameters);
var d_ephemeral_U = new ECPrivateKeyParameters("ECDHC", deU, recipientPublicKey.Parameters);
// Calculate shared ephemeral secret 'Ze'
BigInteger Ze = KeyAgreementFactory.CalculateEcdhcSecret(Q_static_V, d_ephemeral_U); // EC-DHC
byte[] Ze_encoded = Ze.ToByteArrayUnsigned();
// Calculate shared static secret 'Zs'
BigInteger Zs = KeyAgreementFactory.CalculateEcdhcSecret(Q_static_V, d_static_U); // EC-DHC
byte[] Zs_encoded = Zs.ToByteArrayUnsigned();
// Concatenate Ze and Zs byte strings to form shared secret, pre-KDF : Ze||Zs
var Z = new byte[Ze_encoded.Length + Zs_encoded.Length];
Ze_encoded.DeepCopy_NoChecks(0, Z, 0, Ze_encoded.Length);
Zs_encoded.DeepCopy_NoChecks(0, Z, Ze_encoded.Length, Zs_encoded.Length);
ephemeralSenderPublicKey = Q_ephemeral_V;
// Zero intermediate secrets
Ze_encoded.SecureWipe();
Zs_encoded.SecureWipe();
return(Z);
}
/// <summary>
/// Calculate the shared secret in participant U's (initiator) role.
/// </summary>
/// <param name="recipientPublicKey">Public key of the recipient.</param>
/// <param name="senderPrivateKey">Private key of the sender.</param>
/// <param name="ephemeralSenderPublicKey">
/// Ephemeral public key to send to the responder (V, receiver). Output to this
/// parameter.
/// </param>
public static byte[] Initiate(ECKey recipientPublicKey, ECKey senderPrivateKey,
out ECKey ephemeralSenderPublicKey)
{
if (recipientPublicKey.PublicComponent == false)
{
throw new ArgumentException("Recipient key is not public component.", "recipientPublicKey");
}
if (senderPrivateKey.PublicComponent)
{
throw new ArgumentException("Sender key not private component.", "senderPrivateKey");
}
ECKey Q_static_V = recipientPublicKey;
ECKey d_static_U = senderPrivateKey;
ECKeypair kp_ephemeral_U = KeypairFactory.GenerateECKeypair(senderPrivateKey.CurveName);
ECKey Q_ephemeral_U = kp_ephemeral_U.ExportPublicKey();
ECKey d_ephemeral_U = kp_ephemeral_U.GetPrivateKey();
// Calculate shared ephemeral secret 'Ze'
byte[] Ze = KeyAgreementFactory.CalculateEcdhcSecret(Q_static_V, d_ephemeral_U);
// Calculate shared static secret 'Zs'
byte[] Zs = KeyAgreementFactory.CalculateEcdhcSecret(Q_static_V, d_static_U);
// Concatenate Ze and Zs byte strings to form shared secret, pre-KDF : Ze||Zs
var Z = new byte[Ze.Length + Zs.Length];
Ze.DeepCopy_NoChecks(0, Z, 0, Ze.Length);
Zs.DeepCopy_NoChecks(0, Z, Ze.Length, Zs.Length);
ephemeralSenderPublicKey = Q_ephemeral_U;
// Zero intermediate secrets
Ze.SecureWipe();
Zs.SecureWipe();
return(Z);
}
