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