public void SimpleTest()
{
var generator = new DHParametersGenerator();
generator.Init(1024, 7, new SecureRandom());
var dhParameters = generator.GenerateParameters();
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), dhParameters);
var keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
keyGen.Init(kgp);
var serverKeyPair = keyGen.GenerateKeyPair();
var serverKeyAgree = AgreementUtilities.GetBasicAgreement("DH");
serverKeyAgree.Init(serverKeyPair.Private);
var clientKeyPair = keyGen.GenerateKeyPair();
var clientKeyAgree = AgreementUtilities.GetBasicAgreement("DH");
clientKeyAgree.Init(clientKeyPair.Private);
var serverAgree = serverKeyAgree.CalculateAgreement(clientKeyPair.Public);
var clientAgree = clientKeyAgree.CalculateAgreement(serverKeyPair.Public);
Assert.Equal(serverAgree, clientAgree);
}
internal KeyPairGenerator(KeyGenerationParameters keyGenParameters, SecureRandom random) : base(keyGenParameters)
{
this.param = new DHKeyGenerationParameters(random, getDomainParams(keyGenParameters.DomainParameters));
this.domainParameters = keyGenParameters.DomainParameters;
this.engine.Init(param);
}
public static IServerDHParams GetResponse(RequestReqDHParams reqDhParams, string privateKey, out AsymmetricCipherKeyPair serverKeyPair, out byte[] newNonce)
{
var pqInnerData = DeserializeRequest(reqDhParams, privateKey);
GeneratePandG(out var p, out var g);
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), new DHParameters(p, BigInteger.ValueOf(g)));
var keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
keyGen.Init(kgp);
serverKeyPair = keyGen.GenerateKeyPair();
var publicKey = (DHPublicKeyParameters)serverKeyPair.Public;
var dhInnerData = new TServerDHInnerData
{
DhPrimeAsBinary = publicKey.Parameters.P.ToByteArray(),
Nonce = pqInnerData.Nonce,
ServerNonce = pqInnerData.ServerNonce,
G = publicKey.Parameters.G.IntValue,
GAAsBinary = publicKey.Y.ToByteArray(),
ServerTime = (int)((DateTimeOffset)DateTime.Now).ToUnixTimeSeconds()
};
newNonce = pqInnerData.NewNonce;
return(SerializeResponse(pqInnerData, dhInnerData));
}
public static void TestMethod()
{
//BEGIN SETUP ALICE
var aliceKeyGen = GeneratorUtilities.GetKeyPairGenerator(Algorithm);
var aliceGenerator = new DHParametersGenerator();
aliceGenerator.Init(KeyBitSize, DefaultPrimeProbability, new SecureRandom());
DHParameters aliceParameters = aliceGenerator.GenerateParameters();
var aliceKGP = new DHKeyGenerationParameters(new SecureRandom(), aliceParameters);
aliceKeyGen.Init(aliceKGP);
AsymmetricCipherKeyPair aliceKeyPair = aliceKeyGen.GenerateKeyPair();
var aliceKeyAgree = AgreementUtilities.GetBasicAgreement(Algorithm);
aliceKeyAgree.Init(aliceKeyPair.Private);
//END SETUP ALICE
/////AT THIS POINT, Alice's Public Key, Alice's Parameter P and Alice's Parameter G are sent unsecure to BOB
//BEGIN SETUP BOB
var bobKeyGen = GeneratorUtilities.GetKeyPairGenerator(Algorithm);
DHParameters bobParameters = new DHParameters(aliceParameters.P, aliceParameters.G);
KeyGenerationParameters bobKGP = new DHKeyGenerationParameters(new SecureRandom(), bobParameters);
bobKeyGen.Init(bobKGP);
AsymmetricCipherKeyPair bobKeyPair = bobKeyGen.GenerateKeyPair();
IBasicAgreement bobKeyAgree = AgreementUtilities.GetBasicAgreement(Algorithm);
bobKeyAgree.Init(bobKeyPair.Private);
//END SETUP BOB
BigInteger aliceAgree = aliceKeyAgree.CalculateAgreement(bobKeyPair.Public);
BigInteger bobAgree = bobKeyAgree.CalculateAgreement(aliceKeyPair.Public);
if (!aliceAgree.Equals(bobAgree))
{
throw new Exception("Keys do not match.");
}
byte[] nonSecretMessage = GetBytes("HeaderMessageForASDF");
byte[] secretMessage = GetBytes("Secret message contents");
byte[] decNonSecretBytes;
KeyParameter sharedKey = new KeyParameter(aliceAgree.ToByteArrayUnsigned());
var encMessage = EncryptMessage(sharedKey, nonSecretMessage, secretMessage);
var decMessage = DecryptMessage(sharedKey, encMessage, out decNonSecretBytes);
var decNonSecretMessage = GetString(decNonSecretBytes);
var decSecretMessage = GetString(decMessage);
Debug.WriteLine(decNonSecretMessage + " - " + decSecretMessage);
return;
}
public static AsymmetricCipherKeyPair GenerateKeys(DHParameters parameters)
{
var keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
var kgp = new DHKeyGenerationParameters(new SecureRandom(), parameters);
keyGen.Init(kgp);
return(keyGen.GenerateKeyPair());
}
/**
* this test is can take quiet a while
*/
private void doTestGeneration(
int size)
{
DHParametersGenerator pGen = new DHParametersGenerator();
pGen.Init(size, 10, new SecureRandom());
DHParameters dhParams = pGen.GenerateParameters();
if (dhParams.L != 0)
{
Fail("DHParametersGenerator failed to set J to 0 in generated DHParameters");
}
DHKeyGenerationParameters dhkgParams = new DHKeyGenerationParameters(new SecureRandom(), dhParams);
DHBasicKeyPairGenerator kpGen = new DHBasicKeyPairGenerator();
kpGen.Init(dhkgParams);
//
// generate first pair
//
AsymmetricCipherKeyPair pair = kpGen.GenerateKeyPair();
DHPublicKeyParameters pu1 = (DHPublicKeyParameters)pair.Public;
DHPrivateKeyParameters pv1 = (DHPrivateKeyParameters)pair.Private;
//
// generate second pair
//
dhkgParams = new DHKeyGenerationParameters(new SecureRandom(), pu1.Parameters);
kpGen.Init(dhkgParams);
pair = kpGen.GenerateKeyPair();
DHPublicKeyParameters pu2 = (DHPublicKeyParameters)pair.Public;
DHPrivateKeyParameters pv2 = (DHPrivateKeyParameters)pair.Private;
//
// two way
//
DHBasicAgreement e1 = new DHBasicAgreement();
DHBasicAgreement e2 = new DHBasicAgreement();
e1.Init(new ParametersWithRandom(pv1, new SecureRandom()));
e2.Init(new ParametersWithRandom(pv2, new SecureRandom()));
BigInteger k1 = e1.CalculateAgreement(pu2);
BigInteger k2 = e2.CalculateAgreement(pu1);
if (!k1.Equals(k2))
{
Fail("basic with " + size + " bit 2-way test failed");
}
}
public DHProvider(DHParameters parameters)
{
_parameters = parameters;
IAsymmetricCipherKeyPairGenerator keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), _parameters);
keyGen.Init(kgp);
_kp = keyGen.GenerateKeyPair();
}
private DHKeyPairGenerator getDHKeyPairGenerator(BigInteger g, BigInteger p)
{
DHParameters dhParams = new DHParameters(p, g);
DHKeyGenerationParameters dhkgParams = new DHKeyGenerationParameters(new SecureRandom(), dhParams);
DHKeyPairGenerator kpGen = new DHKeyPairGenerator();
kpGen.Init(dhkgParams);
return(kpGen);
}
private void Init()
{
m_dhParameters = new DHParameters(new BigInteger(1, DH2048_P), BigInteger.Two);
KeyGenerationParameters keyGenerationParameters = new DHKeyGenerationParameters(new SecureRandom(), m_dhParameters);
DHBasicKeyPairGenerator dhKeyPairGenerator = new DHBasicKeyPairGenerator();
dhKeyPairGenerator.Init(keyGenerationParameters);
m_keyPair = dhKeyPairGenerator.GenerateKeyPair();
m_bInited = true;
}
public ServerAuthority(DHParameters parameters)
{
this.parameters = parameters;
IAsymmetricCipherKeyPairGenerator keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), parameters);
keyGen.Init(kgp);
kp = keyGen.GenerateKeyPair();
agreement = AgreementUtilities.GetBasicAgreement("DH");
agreement.Init(kp.Private);
}
/// <summary>
/// Create a key pair for according to the key size
/// </summary>
/// <param name="keySize">the key size in bits</param>
public void CreateKeyPair(int keySize)
{
var dhParamGen = new DHParametersGenerator();
dhParamGen.Init(keySize, 20, new SecureRandom());
var dhParams = dhParamGen.GenerateParameters();
var keyGenerationParameters = new DHKeyGenerationParameters(new SecureRandom(), dhParams);
var keyGenerator = new DHKeyPairGenerator();
keyGenerator.Init(keyGenerationParameters);
keyPair = keyGenerator.GenerateKeyPair();
}
private DHBasicKeyPairGenerator getDHBasicKeyPairGenerator(
BigInteger g,
BigInteger p,
int privateValueSize)
{
DHParameters dhParams = new DHParameters(p, g, null, privateValueSize);
DHKeyGenerationParameters dhkgParams = new DHKeyGenerationParameters(new SecureRandom(), dhParams);
DHBasicKeyPairGenerator kpGen = new DHBasicKeyPairGenerator();
kpGen.Init(dhkgParams);
return(kpGen);
}
public static DHKeyPair Generate(DHParameters param, bool debug = false)
{
//DHParameters pa = new DHParameters();
var generator = new DHParametersGenerator();
generator.Init(Bits, 30, new SecureRandom());
//DHParameters param = new DHParameters(prime, primativeRootModulo);
var keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
var kgp = new DHKeyGenerationParameters(new SecureRandom(), param);
keyGen.Init(kgp);
AsymmetricCipherKeyPair keyPair = keyGen.GenerateKeyPair();
var dhPublicKeyParameters = keyPair.Public as DHPublicKeyParameters;
if (dhPublicKeyParameters != null)
{
if (debug)
{
Console.WriteLine("Public Key: {0}", dhPublicKeyParameters.Y.ToString(16));
}
}
else
{
throw new Exception("Invalid Public Key");
}
var dhPrivateKeyParameters = keyPair.Private as DHPrivateKeyParameters;
if (dhPrivateKeyParameters != null)
{
if (debug)
{
Console.WriteLine("Private Key: {0}", dhPrivateKeyParameters.X.ToString(16));
}
}
else
{
throw new Exception("Invalid Private Key");
}
return(new DHKeyPair()
{
Parameters = param,
PublicKeyParameter = dhPublicKeyParameters,
PublicKey = dhPublicKeyParameters.Y.ToString(16),
PrivateKeyParameter = dhPrivateKeyParameters,
PrivateKey = dhPrivateKeyParameters.X.ToString(16)
});
}
public static RequestSetClientDHParams GetRequest(TServerDHParamsOk serverDhParams, byte[] newNonce, out byte[] clientAgree, out int serverTime)
{
AesHelper.ComputeAesParameters(newNonce, serverDhParams.ServerNonce, out var aesKeyData);
var dhInnerData = DeserializeResponse(serverDhParams, aesKeyData);
serverTime = dhInnerData.ServerTime;
var p = new BigInteger(1, dhInnerData.DhPrimeAsBinary);
var g = BigInteger.ValueOf(dhInnerData.G);
var dhParameters = new DHParameters(p, g);
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), dhParameters);
var keyGen = GeneratorUtilities.GetKeyPairGenerator("DH");
keyGen.Init(kgp);
var clientKeyPair = keyGen.GenerateKeyPair();
var publicKey = ((DHPublicKeyParameters)clientKeyPair.Public);
var y = new BigInteger(1, dhInnerData.GAAsBinary);
Guard.That(y).IsValidDhPublicKey(dhParameters.P);
var serverPublicKey = new DHPublicKeyParameters(y, dhParameters);
var clientKeyAgree = AgreementUtilities.GetBasicAgreement("DH");
clientKeyAgree.Init(clientKeyPair.Private);
clientAgree = clientKeyAgree.CalculateAgreement(serverPublicKey).ToByteArrayUnsigned();
var clientDhInnerData = new TClientDHInnerData
{
RetryId = 0,
Nonce = serverDhParams.Nonce,
ServerNonce = serverDhParams.ServerNonce,
GBAsBinary = publicKey.Y.ToByteArray()
};
return(SerializeRequest(clientDhInnerData, aesKeyData));
}
public virtual void Init(
KeyGenerationParameters parameters)
{
this.param = (DHKeyGenerationParameters)parameters;
}
public void TestDH()
{
BigInteger g512 = new BigInteger("153d5d6172adb43045b68ae8e1de1070b6137005686d29d3d73a7749199681ee5b212c9b96bfdcfa5b20cd5e3fd2044895d609cf9b410b7a0f12ca1cb9a428cc", 16);
BigInteger p512 = new BigInteger("9494fec095f3b85ee286542b3836fc81a5dd0a0349b4c239dd38744d488cf8e31db8bcb7d33b41abb9e5a33cca9144b1cef332c94bf0573bf047a3aca98cdf3b", 16);
DHParameters dhParams = new DHParameters(p512, g512);
DHKeyGenerationParameters parameters = new DHKeyGenerationParameters(new SecureRandom(), dhParams); DHKeyPairGenerator kpGen = new DHKeyPairGenerator();
kpGen.Init(parameters);
AsymmetricCipherKeyPair pair = kpGen.GenerateKeyPair();
DHPublicKeyParameters pu1 = (DHPublicKeyParameters)pair.Public;
DHPrivateKeyParameters pv1 = (DHPrivateKeyParameters)pair.Private;
DHPublicKeyParameters pu2 = new DHPublicKeyParameters(pu1.Y, pu1.Parameters);
DHPrivateKeyParameters pv2 = new DHPrivateKeyParameters(pv1.X, pv1.Parameters);
DHPublicKeyParameters pu3 = new DHPublicKeyParameters(pv1.X, pu1.Parameters);
DHPrivateKeyParameters pv3 = new DHPrivateKeyParameters(pu1.Y, pu1.Parameters);
doTest(pu1, pu2, pu3);
doTest(pv1, pv2, pv3);
DHParameters pr1 = pu1.Parameters;
DHParameters pr2 = new DHParameters(
pr1.P, pr1.G, pr1.Q, pr1.M, pr1.L, pr1.J, pr1.ValidationParameters);
DHParameters pr3 = new DHParameters(
pr1.P.Add(BigInteger.Two), pr1.G, pr1.Q, pr1.M, pr1.L, pr1.J, pr1.ValidationParameters);
doTest(pr1, pr2, pr3);
pr3 = new DHParameters(
pr1.P, pr1.G.Add(BigInteger.One), pr1.Q, pr1.M, pr1.L, pr1.J, pr1.ValidationParameters);
doTest(pr1, pr2, pr3);
pu2 = new DHPublicKeyParameters(pu1.Y, pr2);
pv2 = new DHPrivateKeyParameters(pv1.X, pr2);
doTest(pu1, pu2, pu3);
doTest(pv1, pv2, pv3);
DHValidationParameters vp1 = new DHValidationParameters(new byte[20], 1024);
DHValidationParameters vp2 = new DHValidationParameters(new byte[20], 1024);
DHValidationParameters vp3 = new DHValidationParameters(new byte[24], 1024);
doTest(vp1, vp1, vp3);
doTest(vp1, vp2, vp3);
byte[] bytes = new byte[20];
bytes[0] = 1;
vp3 = new DHValidationParameters(bytes, 1024);
doTest(vp1, vp2, vp3);
vp3 = new DHValidationParameters(new byte[20], 2048);
doTest(vp1, vp2, vp3);
DHTestKeyParameters k1 = new DHTestKeyParameters(false, null);
DHTestKeyParameters k2 = new DHTestKeyParameters(false, null);
DHTestKeyParameters k3 = new DHTestKeyParameters(false, pu1.Parameters);
doTest(k1, k2, k3);
}
private void doTestGP(
string algName,
int size,
int privateValueSize,
IBigInteger g,
IBigInteger p)
{
IAsymmetricCipherKeyPairGenerator keyGen = GeneratorUtilities.GetKeyPairGenerator(algName);
DHParameters dhParams = new DHParameters(p, g, null, privateValueSize);
KeyGenerationParameters kgp = new DHKeyGenerationParameters(new SecureRandom(), dhParams);
keyGen.Init(kgp);
//
// a side
//
IAsymmetricCipherKeyPair aKeyPair = keyGen.GenerateKeyPair();
IBasicAgreement aKeyAgreeBasic = AgreementUtilities.GetBasicAgreement(algName);
checkKeySize(privateValueSize, aKeyPair);
aKeyAgreeBasic.Init(aKeyPair.Private);
//
// b side
//
IAsymmetricCipherKeyPair bKeyPair = keyGen.GenerateKeyPair();
IBasicAgreement bKeyAgreeBasic = AgreementUtilities.GetBasicAgreement(algName);
checkKeySize(privateValueSize, bKeyPair);
bKeyAgreeBasic.Init(bKeyPair.Private);
//
// agreement
//
// aKeyAgreeBasic.doPhase(bKeyPair.Public, true);
// bKeyAgreeBasic.doPhase(aKeyPair.Public, true);
//
// IBigInteger k1 = new BigInteger(aKeyAgreeBasic.generateSecret());
// IBigInteger k2 = new BigInteger(bKeyAgreeBasic.generateSecret());
IBigInteger k1 = aKeyAgreeBasic.CalculateAgreement(bKeyPair.Public);
IBigInteger k2 = bKeyAgreeBasic.CalculateAgreement(aKeyPair.Public);
if (!k1.Equals(k2))
{
Fail(size + " bit 2-way test failed");
}
//
// public key encoding test
//
// byte[] pubEnc = aKeyPair.Public.GetEncoded();
byte[] pubEnc = SubjectPublicKeyInfoFactory.CreateSubjectPublicKeyInfo(aKeyPair.Public).GetDerEncoded();
// KeyFactory keyFac = KeyFactory.getInstance(algName);
// X509EncodedKeySpec pubX509 = new X509EncodedKeySpec(pubEnc);
// DHPublicKey pubKey = (DHPublicKey)keyFac.generatePublic(pubX509);
DHPublicKeyParameters pubKey = (DHPublicKeyParameters)PublicKeyFactory.CreateKey(pubEnc);
// DHParameterSpec spec = pubKey.Parameters;
DHParameters spec = pubKey.Parameters;
if (!spec.G.Equals(dhParams.G) || !spec.P.Equals(dhParams.P))
{
Fail(size + " bit public key encoding/decoding test failed on parameters");
}
if (!((DHPublicKeyParameters)aKeyPair.Public).Y.Equals(pubKey.Y))
{
Fail(size + " bit public key encoding/decoding test failed on y value");
}
//
// public key serialisation test
//
// TODO Put back in
// MemoryStream bOut = new MemoryStream();
// ObjectOutputStream oOut = new ObjectOutputStream(bOut);
//
// oOut.WriteObject(aKeyPair.Public);
//
// MemoryStream bIn = new MemoryStream(bOut.ToArray(), false);
// ObjectInputStream oIn = new ObjectInputStream(bIn);
//
// pubKey = (DHPublicKeyParameters)oIn.ReadObject();
spec = pubKey.Parameters;
if (!spec.G.Equals(dhParams.G) || !spec.P.Equals(dhParams.P))
{
Fail(size + " bit public key serialisation test failed on parameters");
}
if (!((DHPublicKeyParameters)aKeyPair.Public).Y.Equals(pubKey.Y))
{
Fail(size + " bit public key serialisation test failed on y value");
}
//
// private key encoding test
//
// byte[] privEnc = aKeyPair.Private.GetEncoded();
byte[] privEnc = PrivateKeyInfoFactory.CreatePrivateKeyInfo(aKeyPair.Private).GetDerEncoded();
// PKCS8EncodedKeySpec privPKCS8 = new PKCS8EncodedKeySpec(privEnc);
// DHPrivateKeyParameters privKey = (DHPrivateKey)keyFac.generatePrivate(privPKCS8);
DHPrivateKeyParameters privKey = (DHPrivateKeyParameters)PrivateKeyFactory.CreateKey(privEnc);
spec = privKey.Parameters;
if (!spec.G.Equals(dhParams.G) || !spec.P.Equals(dhParams.P))
{
Fail(size + " bit private key encoding/decoding test failed on parameters");
}
if (!((DHPrivateKeyParameters)aKeyPair.Private).X.Equals(privKey.X))
{
Fail(size + " bit private key encoding/decoding test failed on y value");
}
//
// private key serialisation test
//
// TODO Put back in
// bOut = new MemoryStream();
// oOut = new ObjectOutputStream(bOut);
//
// oOut.WriteObject(aKeyPair.Private);
//
// bIn = new MemoryStream(bOut.ToArray(), false);
// oIn = new ObjectInputStream(bIn);
//
// privKey = (DHPrivateKeyParameters)oIn.ReadObject();
spec = privKey.Parameters;
if (!spec.G.Equals(dhParams.G) || !spec.P.Equals(dhParams.P))
{
Fail(size + " bit private key serialisation test failed on parameters");
}
if (!((DHPrivateKeyParameters)aKeyPair.Private).X.Equals(privKey.X))
{
Fail(size + " bit private key serialisation test failed on y value");
}
//
// three party test
//
IAsymmetricCipherKeyPairGenerator aPairGen = GeneratorUtilities.GetKeyPairGenerator(algName);
aPairGen.Init(new DHKeyGenerationParameters(new SecureRandom(), spec));
IAsymmetricCipherKeyPair aPair = aPairGen.GenerateKeyPair();
IAsymmetricCipherKeyPairGenerator bPairGen = GeneratorUtilities.GetKeyPairGenerator(algName);
bPairGen.Init(new DHKeyGenerationParameters(new SecureRandom(), spec));
IAsymmetricCipherKeyPair bPair = bPairGen.GenerateKeyPair();
IAsymmetricCipherKeyPairGenerator cPairGen = GeneratorUtilities.GetKeyPairGenerator(algName);
cPairGen.Init(new DHKeyGenerationParameters(new SecureRandom(), spec));
IAsymmetricCipherKeyPair cPair = cPairGen.GenerateKeyPair();
IBasicAgreement aKeyAgree = AgreementUtilities.GetBasicAgreement(algName);
aKeyAgree.Init(aPair.Private);
IBasicAgreement bKeyAgree = AgreementUtilities.GetBasicAgreement(algName);
bKeyAgree.Init(bPair.Private);
IBasicAgreement cKeyAgree = AgreementUtilities.GetBasicAgreement(algName);
cKeyAgree.Init(cPair.Private);
// Key ac = aKeyAgree.doPhase(cPair.Public, false);
// Key ba = bKeyAgree.doPhase(aPair.Public, false);
// Key cb = cKeyAgree.doPhase(bPair.Public, false);
//
// aKeyAgree.doPhase(cb, true);
// bKeyAgree.doPhase(ac, true);
// cKeyAgree.doPhase(ba, true);
//
// IBigInteger aShared = new BigInteger(aKeyAgree.generateSecret());
// IBigInteger bShared = new BigInteger(bKeyAgree.generateSecret());
// IBigInteger cShared = new BigInteger(cKeyAgree.generateSecret());
DHPublicKeyParameters ac = new DHPublicKeyParameters(aKeyAgree.CalculateAgreement(cPair.Public), spec);
DHPublicKeyParameters ba = new DHPublicKeyParameters(bKeyAgree.CalculateAgreement(aPair.Public), spec);
DHPublicKeyParameters cb = new DHPublicKeyParameters(cKeyAgree.CalculateAgreement(bPair.Public), spec);
IBigInteger aShared = aKeyAgree.CalculateAgreement(cb);
IBigInteger bShared = bKeyAgree.CalculateAgreement(ac);
IBigInteger cShared = cKeyAgree.CalculateAgreement(ba);
if (!aShared.Equals(bShared))
{
Fail(size + " bit 3-way test failed (a and b differ)");
}
if (!cShared.Equals(bShared))
{
Fail(size + " bit 3-way test failed (c and b differ)");
}
}
protected override void OnCreate(Bundle savedInstanceState)
{
base.OnCreate(savedInstanceState);
// Set our view from the "main" layout resource
SetContentView(Resource.Layout.Main);
const string Algorithm = "ECDH"; //What do you think about the other algorithms?
const int KeyBitSize = 2056;
const int NonceBitSize = 128;
const int MacBitSize = 128;
const int DefaultPrimeProbability = 30;
//BEGIN SETUP ALICE
IAsymmetricCipherKeyPairGenerator aliceKeyGen = GeneratorUtilities.GetKeyPairGenerator(Algorithm);
DHParametersGenerator aliceGenerator = new DHParametersGenerator();
aliceGenerator.Init(KeyBitSize, DefaultPrimeProbability, new SecureRandom());
DHParameters aliceParameters = aliceGenerator.GenerateParameters();
KeyGenerationParameters aliceKGP = new DHKeyGenerationParameters(new SecureRandom(), aliceParameters);
aliceKeyGen.Init(aliceKGP);
AsymmetricCipherKeyPair aliceKeyPair = aliceKeyGen.GenerateKeyPair();
IBasicAgreement aliceKeyAgree = AgreementUtilities.GetBasicAgreement(Algorithm);
aliceKeyAgree.Init(aliceKeyPair.Private);
Button a1b = FindViewById <Button>(Resource.Id.a1b);
TextView AliceRandomText = FindViewById <TextView>(Resource.Id.a1t);
Button a2b = FindViewById <Button>(Resource.Id.a2b);
TextView AlicePrivateKeyText = FindViewById <TextView>(Resource.Id.a2t);
Button a3b = FindViewById <Button>(Resource.Id.a3b);
TextView AlicePublicKeyText = FindViewById <TextView>(Resource.Id.a3t);
Button b1b = FindViewById <Button>(Resource.Id.b1b);
TextView BobRandomText = FindViewById <TextView>(Resource.Id.b1t);
Button b2b = FindViewById <Button>(Resource.Id.b2b);
TextView BobPrivateKeyText = FindViewById <TextView>(Resource.Id.b2t);
Button b3b = FindViewById <Button>(Resource.Id.b3b);
TextView BobPublicKeyText = FindViewById <TextView>(Resource.Id.b3t);
Button a4b = FindViewById <Button>(Resource.Id.a4b);
TextView AliceBobSharedKeyText = FindViewById <TextView>(Resource.Id.a4t);
Button b4b = FindViewById <Button>(Resource.Id.b4b);
TextView BobAliceSharedKeyText = FindViewById <TextView>(Resource.Id.b4t);
// what Alice does
byte[] aliceRandomBytes = new byte[32];
RNGCryptoServiceProvider.Create().GetBytes(aliceRandomBytes);
byte[] alicePrivate = Curve25519.(aliceRandomBytes);
byte[] alicePublic = Curve25519.GetPublicKey(alicePrivate);
// what Bob does
byte[] bobRandomBytes = new byte[32];
RNGCryptoServiceProvider.Create().GetBytes(bobRandomBytes);
byte[] bobPrivate = Curve25519.ClampPrivateKey(bobRandomBytes);
byte[] bobPublic = Curve25519.GetPublicKey(bobPrivate);
// what Alice does with Bob's public key
byte[] aliceShared = Curve25519.GetSharedSecret(alicePrivate, bobPublic);
// what Bob does with Alice' public key
byte[] bobShared = Curve25519.GetSharedSecret(bobPrivate, alicePublic);
// aliceShared == bobShared
a1b.Click += delegate {
alicePrivateBytes = null;
AlicePrivateKeyText.Text = "";
alicePublicBytes = null;
AlicePublicKeyText.Text = "";
aliceBobSharedBytes = null;
bobAliceSharedBytes = null;
AliceBobSharedKeyText.Text = "";
BobAliceSharedKeyText.Text = "";
aliceRandomBytes = new byte[32];
RNGCryptoServiceProvider.Create().GetBytes(aliceRandomBytes);
AliceRandomText.Text = BitConverter.ToString(aliceRandomBytes).Replace("-", "");
};
a2b.Click += delegate {
if (aliceRandomBytes != null)
{
alicePrivateBytes = Curve25519.Create(aliceRandomBytes);
AlicePrivateKeyText.Text = BitConverter.ToString(alicePrivateBytes).Replace("-", "");
}
};
a3b.Click += delegate {
if (alicePrivateBytes != null)
{
alicePublicBytes = Curve25519.GetPublicKey(alicePrivateBytes);
AlicePublicKeyText.Text = BitConverter.ToString(alicePublicBytes).Replace("-", "");
}
};
b1b.Click += delegate {
bobPrivateBytes = null;
BobPrivateKeyText.Text = ""; // Reset
bobPublicBytes = null;
BobPublicKeyText.Text = ""; // Reset
aliceBobSharedBytes = null;
bobAliceSharedBytes = null;
AliceBobSharedKeyText.Text = "";
BobAliceSharedKeyText.Text = "";
bobRandomBytes = new byte[32];
RNGCryptoServiceProvider.Create().GetBytes(bobRandomBytes);
BobRandomText.Text = BitConverter.ToString(bobRandomBytes).Replace("-", "");
};
b2b.Click += delegate {
if (bobRandomBytes != null)
{
bobPrivateBytes = Curve25519.ClampPrivateKey(bobRandomBytes);
BobPrivateKeyText.Text = BitConverter.ToString(bobPrivateBytes).Replace("-", "");
}
};
b3b.Click += delegate {
if (bobPrivateBytes != null)
{
bobPublicBytes = Curve25519.GetPublicKey(bobPrivateBytes);
BobPublicKeyText.Text = BitConverter.ToString(bobPublicBytes).Replace("-", "");
}
};
a4b.Click += delegate {
if ((alicePrivateBytes != null) && (bobPublicBytes != null))
{
aliceBobSharedBytes = Curve25519.GetSharedSecret(alicePrivateBytes, bobPublicBytes);
AliceBobSharedKeyText.Text = BitConverter.ToString(aliceBobSharedBytes).Replace("-", "");
}
};
b4b.Click += delegate {
if ((bobPrivateBytes != null) && (alicePublicBytes != null))
{
bobAliceSharedBytes = Curve25519.GetSharedSecret(bobPrivateBytes, alicePublicBytes);
BobAliceSharedKeyText.Text = BitConverter.ToString(bobAliceSharedBytes).Replace("-", "");
}
};
}
public virtual void Init(
KeyGenerationParameters parameters)
{
this.param = (DHKeyGenerationParameters)parameters;
}
