/// <summary>
/// Creates ECDSA from imported data
/// </summary>
/// <param name="type">0 or 1 (1 faster)</param>
/// <param name="forSign">if created for signing, otherwise for verifying</param>
/// <param name="import">Imporeted public or private key</param>
public ECDSAWrapper(int type, bool forSign, byte[] import)
{
this.initCurveandParams(type);
if (forSign)
{
try
{
//import - D (BigInteger)
SecureRandom random = new SecureRandom();
BigInteger Drec = new BigInteger(import);
ECPrivateKeyParameters ecPrivImported = new ECPrivateKeyParameters(Drec, this.parameters);
ParametersWithRandom ecPrivImportedpwr = new ParametersWithRandom(ecPrivImported, random);
this.ecdsa.Init(true, ecPrivImportedpwr);
}
catch (Exception ex)
{
throw new Exception("Error while creating ECDSAWrapper from import for signing", ex);
}
}
else
{
try
{
//import - Q (ECPoint)
ECPoint Qrec = this.ecCurve.DecodePoint(import);
ECPublicKeyParameters recPub = new ECPublicKeyParameters(Qrec, this.parameters);
this.ecdsa.Init(false, recPub);
}
catch (Exception ex)
{
throw new Exception("Error while creating ECDSAWrapperfom import for verifying", ex);
}
}
}
/// <summary>Initialise the generator for signing.</summary>
public void InitSign(
int sigType,
PgpPrivateKey key,
SecureRandom random)
{
this.privKey = key;
this.signatureType = sigType;
try
{
ICipherParameters cp = key.Key;
if (random != null)
{
cp = new ParametersWithRandom(key.Key, random);
}
sig.Init(true, cp);
}
catch (InvalidKeyException e)
{
throw new PgpException("invalid key.", e);
}
dig.Reset();
lastb = 0;
}
public void TestECDsa192bitPrime()
{
BigInteger r = new BigInteger("3342403536405981729393488334694600415596881826869351677613");
BigInteger s = new BigInteger("5735822328888155254683894997897571951568553642892029982342");
byte[] kData = BigIntegers.AsUnsignedByteArray(new BigInteger("6140507067065001063065065565667405560006161556565665656654"));
SecureRandom k = FixedSecureRandom.From(kData);
FpCurve curve = new FpCurve(
new BigInteger("6277101735386680763835789423207666416083908700390324961279"), // q
new BigInteger("fffffffffffffffffffffffffffffffefffffffffffffffc", 16), // a
new BigInteger("64210519e59c80e70fa7e9ab72243049feb8deecc146b9b1", 16)); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
curve.DecodePoint(Hex.Decode("03188da80eb03090f67cbf20eb43a18800f4ff0afd82ff1012")), // G
new BigInteger("6277101735386680763835789423176059013767194773182842284081")); // n
ECPrivateKeyParameters priKey = new ECPrivateKeyParameters(
"ECDSA",
new BigInteger("651056770906015076056810763456358567190100156695615665659"), // d
parameters);
ParametersWithRandom param = new ParametersWithRandom(priKey, k);
ECDsaSigner ecdsa = new ECDsaSigner();
ecdsa.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
BigInteger[] sig = ecdsa.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong." + SimpleTest.NewLine
+ " expecting: " + r + SimpleTest.NewLine
+ " got : " + sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong." + SimpleTest.NewLine
+ " expecting: " + s + SimpleTest.NewLine
+ " got : " + sig[1]);
}
// Verify the signature
ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
"ECDSA",
curve.DecodePoint(Hex.Decode("0262b12d60690cdcf330babab6e69763b471f994dd702d16a5")), // Q
parameters);
ecdsa.Init(false, pubKey);
if (!ecdsa.VerifySignature(message, sig[0], sig[1]))
{
Fail("verification fails");
}
}
private void ecNR239bitPrime()
{
BigInteger n = new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307");
FpCurve curve = new FpCurve(
new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q
new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a
new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16), // b
n, BigInteger.One);
ECDomainParameters parameters = new ECDomainParameters(
curve,
curve.DecodePoint(Hex.Decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G
n);
ECPrivateKeyParameters priKey = new ECPrivateKeyParameters(
new BigInteger("876300101507107567501066130761671078357010671067781776716671676178726717"), // d
parameters);
ECNRSigner ecnr = new ECNRSigner();
ParametersWithRandom param = new ParametersWithRandom(priKey, k);
ecnr.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
BigInteger[] sig = ecnr.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong.", r, sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong.", s, sig[1]);
}
// Verify the signature
ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
curve.DecodePoint(Hex.Decode("025b6dc53bc61a2548ffb0f671472de6c9521a9d2d2534e65abfcbd5fe0c70")), // Q
parameters);
ecnr.Init(false, pubKey);
if (!ecnr.VerifySignature(message, sig[0], sig[1]))
{
Fail("signature fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("8f79a582513df84dc247bcb624340cc0e5a34c4324a20ce7fe3ab8ff38a9db71",16);
BigInteger s = new BigInteger("7508d22fd6cbb45efd438cb875e43f137247088d0f54b29a7c91f68a65b5fa85",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("90892707282f433398488f19d31ac48523a8e2ded68944e0da91c6895ee7045e",16);
BigInteger s = new BigInteger("3be4620ee88f1ee8f9dd63c7d145b7e554839feeca125049118262ea4651e9de",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("712592d285b792e33b8a9a11e8e6c4f512ddf0042972bbfd1abb0a93e8fc6f54",16);
BigInteger s = new BigInteger("2cf26758321258b130d5612111339f09ceb8668241f3482e38baa56529963f07",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
/**
* Test Sign and Verify with C parameters
* see: http://www.ietf.org/internet-drafts/draft-popov-cryptopro-cpalgs-01.txt
* gostR3410-2001-CryptoPro-C-ParamSet P.48
*/
private void ecGOST3410_CParam()
{
SecureRandom random = new SecureRandom();
BigInteger mod_p = new BigInteger("70390085352083305199547718019018437841079516630045180471284346843705633502619"); //p
FpCurve curve = new FpCurve(
mod_p, // p
new BigInteger("70390085352083305199547718019018437841079516630045180471284346843705633502616"), // a
new BigInteger("32858")); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
new FpPoint(curve,
new FpFieldElement(mod_p,new BigInteger("0")), // x
new FpFieldElement(mod_p,new BigInteger("29818893917731240733471273240314769927240550812383695689146495261604565990247"))), // y
new BigInteger("70390085352083305199547718019018437840920882647164081035322601458352298396601")); // q
ECKeyPairGenerator pGen = new ECKeyPairGenerator("ECGOST3410");
ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(
parameters,
random);
pGen.Init(genParam);
AsymmetricCipherKeyPair pair = pGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
ECGost3410Signer ecgost3410 = new ECGost3410Signer();
ecgost3410.Init(true, param);
BigInteger[] sig = ecgost3410.GenerateSignature(hashmessage);
ecgost3410.Init(false, pair.Public);
if (!ecgost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
Fail("signature fails");
}
}
/**
* Test Sign and Verify with test parameters
* see: http://www.ietf.org/internet-drafts/draft-popov-cryptopro-cpalgs-01.txt
* gostR3410-2001-TestParamSet P.46
*/
private void ecGOST3410_TestParam()
{
SecureRandom random = new SecureRandom();
BigInteger mod_p = new BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564821041"); //p
FpCurve curve = new FpCurve(
mod_p, // p
new BigInteger("7"), // a
new BigInteger("43308876546767276905765904595650931995942111794451039583252968842033849580414")); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
new FpPoint(curve,
new FpFieldElement(mod_p,new BigInteger("2")), // x
new FpFieldElement(mod_p,new BigInteger("4018974056539037503335449422937059775635739389905545080690979365213431566280"))), // y
new BigInteger("57896044618658097711785492504343953927082934583725450622380973592137631069619")); // q
ECKeyPairGenerator pGen = new ECKeyPairGenerator();
ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(
parameters,
random);
pGen.Init(genParam);
AsymmetricCipherKeyPair pair = pGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
ECGost3410Signer ecgost3410 = new ECGost3410Signer();
ecgost3410.Init(true, param);
//get hash message using the digest GOST3411.
byte[] message = Encoding.ASCII.GetBytes("Message for sign");
Gost3411Digest gost3411 = new Gost3411Digest();
gost3411.BlockUpdate(message, 0, message.Length);
byte[] hashmessage = new byte[gost3411.GetDigestSize()];
gost3411.DoFinal(hashmessage, 0);
BigInteger[] sig = ecgost3410.GenerateSignature(hashmessage);
ecgost3410.Init(false, pair.Public);
if (!ecgost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
Fail("signature fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("81d69a192e9c7ac21fc07da41bd07e230ba6a94eb9f3c1fd104c7bd976733ca5",16);
BigInteger s = new BigInteger("315c879c8414f35feb4deb15e7cc0278c48e6ca1596325d6959338d860b0c47a",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("a8790aabbd5a998ff524bad048ac69cd1faff2dab048265c8d60d1471c44a9ee",16);
BigInteger s = new BigInteger("30df5ba32ac77170b9632559bef7d37620017756dff3fea1088b4267db0944b8",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 1, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public void TestECDsa239bitPrime()
{
BigInteger r = new BigInteger("308636143175167811492622547300668018854959378758531778147462058306432176");
BigInteger s = new BigInteger("323813553209797357708078776831250505931891051755007842781978505179448783");
byte[] kData = BigIntegers.AsUnsignedByteArray(new BigInteger("700000017569056646655505781757157107570501575775705779575555657156756655"));
SecureRandom k = FixedSecureRandom.From(kData);
FpCurve curve = new FpCurve(
new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q
new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a
new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
curve.DecodePoint(Hex.Decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G
new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307")); // n
ECPrivateKeyParameters priKey = new ECPrivateKeyParameters(
"ECDSA",
new BigInteger("876300101507107567501066130761671078357010671067781776716671676178726717"), // d
parameters);
ECDsaSigner ecdsa = new ECDsaSigner();
ParametersWithRandom param = new ParametersWithRandom(priKey, k);
ecdsa.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
BigInteger[] sig = ecdsa.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong." + SimpleTest.NewLine
+ " expecting: " + r + SimpleTest.NewLine
+ " got : " + sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong." + SimpleTest.NewLine
+ " expecting: " + s + SimpleTest.NewLine
+ " got : " + sig[1]);
}
// Verify the signature
ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
"ECDSA",
curve.DecodePoint(Hex.Decode("025b6dc53bc61a2548ffb0f671472de6c9521a9d2d2534e65abfcbd5fe0c70")), // Q
parameters);
ecdsa.Init(false, pubKey);
if (!ecdsa.VerifySignature(message, sig[0], sig[1]))
{
Fail("signature fails");
}
}
public void TestECDsa239bitBinaryAndLargeDigest()
{
BigInteger r = new BigInteger("21596333210419611985018340039034612628818151486841789642455876922391552");
BigInteger s = new BigInteger("144940322424411242416373536877786566515839911620497068645600824084578597");
byte[] kData = BigIntegers.AsUnsignedByteArray(
new BigInteger("171278725565216523967285789236956265265265235675811949404040041670216363"));
SecureRandom k = FixedSecureRandom.From(kData);
F2mCurve curve = new F2mCurve(
239, // m
36, //k
new BigInteger("32010857077C5431123A46B808906756F543423E8D27877578125778AC76", 16), // a
new BigInteger("790408F2EEDAF392B012EDEFB3392F30F4327C0CA3F31FC383C422AA8C16", 16)); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
curve.DecodePoint(
Hex.Decode("0457927098FA932E7C0A96D3FD5B706EF7E5F5C156E16B7E7C86038552E91D61D8EE5077C33FECF6F1A16B268DE469C3C7744EA9A971649FC7A9616305")), // G
new BigInteger("220855883097298041197912187592864814557886993776713230936715041207411783"), // n
BigInteger.ValueOf(4)); // h
ECPrivateKeyParameters priKey = new ECPrivateKeyParameters(
"ECDSA",
new BigInteger("145642755521911534651321230007534120304391871461646461466464667494947990"), // d
parameters);
ECDsaSigner ecdsa = new ECDsaSigner();
ParametersWithRandom param = new ParametersWithRandom(priKey, k);
ecdsa.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517968236873715988614170569073515315707566766479517968236873715988614170569073515315707566766479517").ToByteArray();
BigInteger[] sig = ecdsa.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong." + SimpleTest.NewLine
+ " expecting: " + r + SimpleTest.NewLine
+ " got : " + sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong." + SimpleTest.NewLine
+ " expecting: " + s + SimpleTest.NewLine
+ " got : " + sig[1]);
}
// Verify the signature
ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
"ECDSA",
curve.DecodePoint(
Hex.Decode("045894609CCECF9A92533F630DE713A958E96C97CCB8F5ABB5A688A238DEED6DC2D9D0C94EBFB7D526BA6A61764175B99CB6011E2047F9F067293F57F5")), // Q
parameters);
ecdsa.Init(false, pubKey);
if (!ecdsa.VerifySignature(message, sig[0], sig[1]))
{
Fail("signature fails");
}
}
public void TestECDsa191bitBinary()
{
BigInteger r = new BigInteger("87194383164871543355722284926904419997237591535066528048");
BigInteger s = new BigInteger("308992691965804947361541664549085895292153777025772063598");
byte[] kData = BigIntegers.AsUnsignedByteArray(new BigInteger("1542725565216523985789236956265265265235675811949404040041"));
SecureRandom k = FixedSecureRandom.From(kData);
F2mCurve curve = new F2mCurve(
191, // m
9, //k
new BigInteger("2866537B676752636A68F56554E12640276B649EF7526267", 16), // a
new BigInteger("2E45EF571F00786F67B0081B9495A3D95462F5DE0AA185EC", 16)); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
curve.DecodePoint(Hex.Decode("0436B3DAF8A23206F9C4F299D7B21A9C369137F2C84AE1AA0D765BE73433B3F95E332932E70EA245CA2418EA0EF98018FB")), // G
new BigInteger("1569275433846670190958947355803350458831205595451630533029"), // n
BigInteger.Two); // h
ECPrivateKeyParameters priKey = new ECPrivateKeyParameters(
"ECDSA",
new BigInteger("1275552191113212300012030439187146164646146646466749494799"), // d
parameters);
ECDsaSigner ecdsa = new ECDsaSigner();
ParametersWithRandom param = new ParametersWithRandom(priKey, k);
ecdsa.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
BigInteger[] sig = ecdsa.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong." + SimpleTest.NewLine
+ " expecting: " + r + SimpleTest.NewLine
+ " got : " + sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong." + SimpleTest.NewLine
+ " expecting: " + s + SimpleTest.NewLine
+ " got : " + sig[1]);
}
// Verify the signature
ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
"ECDSA",
curve.DecodePoint(Hex.Decode("045DE37E756BD55D72E3768CB396FFEB962614DEA4CE28A2E755C0E0E02F5FB132CAF416EF85B229BBB8E1352003125BA1")), // Q
parameters);
ecdsa.Init(false, pubKey);
if (!ecdsa.VerifySignature(message, sig[0], sig[1]))
{
Fail("signature fails");
}
}
/**
* Test Sign and Verify with A parameters
* see: http://www.ietf.org/internet-drafts/draft-popov-cryptopro-cpalgs-01.txt
* gostR3410-2001-CryptoPro-A-ParamSet P.47
*/
public void ecGOST3410_AParam()
{
SecureRandom random = new SecureRandom();
BigInteger mod_p = new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639319"); //p
FpCurve curve = new FpCurve(
mod_p, // p
new BigInteger("115792089237316195423570985008687907853269984665640564039457584007913129639316"), // a
new BigInteger("166")); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
new FpPoint(curve,
new FpFieldElement(mod_p, new BigInteger("1")), // x
new FpFieldElement(mod_p, new BigInteger("64033881142927202683649881450433473985931760268884941288852745803908878638612"))), // y
new BigInteger("115792089237316195423570985008687907853073762908499243225378155805079068850323")); // q
ECKeyPairGenerator pGen = new ECKeyPairGenerator("ECGOST3410");
ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(
parameters,
random);
pGen.Init(genParam);
AsymmetricCipherKeyPair pair = pGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
ECGost3410Signer ecgost3410 = new ECGost3410Signer();
ecgost3410.Init(true, param);
BigInteger[] sig = ecgost3410.GenerateSignature(hashmessage);
ecgost3410.Init(false, pair.Public);
if (!ecgost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
Fail("signature fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("7c07c8cf035c2a1cb2b7fae5807ac7cd623dfca7a1a68f6d858317822f1ea00d",16);
BigInteger s = new BigInteger("7e9e036a6ff87dbf9b004818252b1f6fc310bdd4d17cb8c37d9c36c7884de60c",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(512, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!init_random.IsExhausted)
{
return new SimpleTestResult(false, Name
+ ": unexpected number of bytes used from 'init_random'.");
}
if (parameters.ValidationParameters == null)
{
return new SimpleTestResult(false, Name + ": validation parameters wrong");
}
if (parameters.ValidationParameters.CL != 13
|| parameters.ValidationParameters.X0L != 1039943409)
{
return new SimpleTestResult(false, Name + ": validation parameters values wrong");
}
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
if (!keyRandom.IsExhausted)
{
return new SimpleTestResult(false, Name
+ ": unexpected number of bytes used from 'keyRandom'.");
}
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!random.IsExhausted)
{
return new SimpleTestResult(false, Name
+ ": unexpected number of bytes used from 'random'.");
}
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (!Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(false, Name + ": verification fails");
}
return new SimpleTestResult(true, Name + ": Okay");
}
public void TestECDsaKeyGenTest()
{
SecureRandom random = new SecureRandom();
FpCurve curve = new FpCurve(
new BigInteger("883423532389192164791648750360308885314476597252960362792450860609699839"), // q
new BigInteger("7fffffffffffffffffffffff7fffffffffff8000000000007ffffffffffc", 16), // a
new BigInteger("6b016c3bdcf18941d0d654921475ca71a9db2fb27d1d37796185c2942c0a", 16)); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
curve.DecodePoint(Hex.Decode("020ffa963cdca8816ccc33b8642bedf905c3d358573d3f27fbbd3b3cb9aaaf")), // G
new BigInteger("883423532389192164791648750360308884807550341691627752275345424702807307")); // n
ECKeyPairGenerator pGen = new ECKeyPairGenerator();
ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(
parameters,
random);
pGen.Init(genParam);
AsymmetricCipherKeyPair pair = pGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
ECDsaSigner ecdsa = new ECDsaSigner();
ecdsa.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArray();
BigInteger[] sig = ecdsa.GenerateSignature(message);
ecdsa.Init(false, pair.Public);
if (!ecdsa.VerifySignature(message, sig[0], sig[1]))
{
Fail("signature fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("169fdb2dc09f690b71332432bfec806042e258fa9a21dafe73c6abfbc71407d9",16);
BigInteger s = new BigInteger("9002551808ae40d19f6f31fb67e4563101243cf07cffd5f2f8ff4c537b0c9866",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("860d82c60e9502cd00c0e9e1f6563feafec304801974d745c5e02079946f729e",16);
BigInteger s = new BigInteger("7ef49264ef022801aaa03033cd97915235fbab4c823ed936b0f360c22114688a",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("3e5f895e276d81d2d52c0763270a458157b784c57abdbd807bc44fd43a32ac06",16);
BigInteger s = new BigInteger("3f0dd5d4400d47c08e4ce505ff7434b6dbf729592e37c74856dab85115a60955",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(512, 1, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (parameters.ValidationParameters == null)
{
return new SimpleTestResult(false, Name + "validation parameters wrong");
}
if (parameters.ValidationParameters.C != 29505
|| parameters.ValidationParameters.X0 != 24265)
{
return new SimpleTestResult(false, Name + "validation parameters values wrong");
}
if (!init_random.IsExhausted)
{
return new SimpleTestResult(false, Name
+ ": unexpected number of bytes used from 'init_random'.");
}
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
if (!keyRandom.IsExhausted)
{
return new SimpleTestResult(false, Name
+ ": unexpected number of bytes used from 'keyRandom'.");
}
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer gost3410 = new Gost3410Signer();
gost3410.Init(true, param);
BigInteger[] sig = gost3410.GenerateSignature(hashmessage);
if (!random.IsExhausted)
{
return new SimpleTestResult(false, Name
+ ": unexpected number of bytes used from 'random'.");
}
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
gost3410.Init(false, pair.Public);
if (gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
public ITestResult Perform()
{
byte[] kek1 = Hex.Decode("fd04fd08060707fb0003fefffd02fe05");
byte[] iv1 = Hex.Decode("c7d90059b29e97f7");
byte[] in1 = Hex.Decode("b70a25fbc9d86a86050ce0d711ead4d9");
byte[] out1 = Hex.Decode("70e699fb5701f7833330fb71e87c85a420bdc99af05d22af5a0e48d35f3138986cbaafb4b28d4f35");
//
// note the RFC 3217 test specifies a key to be used with an effective key size of
// 40 bits which is why it is done here - in practice nothing less than 128 bits should be used.
//
ICipherParameters paramWrap = new ParametersWithRandom(new ParametersWithIV(new RC2Parameters(kek1, 40), iv1), new RFCRandom());
ICipherParameters paramUnwrap = new RC2Parameters(kek1, 40);
ITestResult result = wrapTest(1, paramWrap, paramUnwrap, in1, out1);
if (!result.IsSuccessful())
{
return result;
}
return new SimpleTestResult(true, Name + ": Okay");
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("64a8856628e5669d85f62cd763dd4a99bc56d33dc0e1859122855d141e9e4774",16);
BigInteger s = new BigInteger("319ebac97092b288d469a4b988248794f60c865bc97858d9a3135c6d1a1bf2dd",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
private void ecGOST3410_TEST()
{
BigInteger mod_p = new BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564821041"); //p
FpCurve curve = new FpCurve(
mod_p, // p
new BigInteger("7"), // a
new BigInteger("43308876546767276905765904595650931995942111794451039583252968842033849580414")); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
new FpPoint(curve,
new FpFieldElement(mod_p,new BigInteger("2")), // x
new FpFieldElement(mod_p,new BigInteger("4018974056539037503335449422937059775635739389905545080690979365213431566280"))), // y
new BigInteger("57896044618658097711785492504343953927082934583725450622380973592137631069619")); // q
ECPrivateKeyParameters priKey = new ECPrivateKeyParameters(
"ECGOST3410",
new BigInteger("55441196065363246126355624130324183196576709222340016572108097750006097525544"), // d
parameters);
ParametersWithRandom param = new ParametersWithRandom(priKey, k);
ECGost3410Signer ecgost3410 = new ECGost3410Signer();
ecgost3410.Init(true, param);
byte[] mVal = new BigInteger("20798893674476452017134061561508270130637142515379653289952617252661468872421").ToByteArray();
byte[] message = new byte[mVal.Length];
for (int i = 0; i != mVal.Length; i++)
{
message[i] = mVal[mVal.Length - 1 - i];
}
BigInteger[] sig = ecgost3410.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong.", r, sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong.", s, sig[1]);
}
// Verify the signature
ECPublicKeyParameters pubKey = new ECPublicKeyParameters(
"ECGOST3410",
new FpPoint(curve,
new FpFieldElement(mod_p, new BigInteger("57520216126176808443631405023338071176630104906313632182896741342206604859403")), // x
new FpFieldElement(mod_p, new BigInteger("17614944419213781543809391949654080031942662045363639260709847859438286763994"))), // y
parameters);
ecgost3410.Init(false, pubKey);
if (!ecgost3410.VerifySignature(message, sig[0], sig[1]))
{
Fail("verification fails");
}
}
public ITestResult Perform()
{
BigInteger r = new BigInteger("4deb95a0b35e7ed7edebe9bef5a0f93739e16b7ff27fe794d989d0c13159cfbc",16);
BigInteger s = new BigInteger("e1d0d30345c24cfeb33efde3deee5fbbda78ddc822b719d860cd0ba1fb6bd43b",16);
Gost3410ParametersGenerator pGen = new Gost3410ParametersGenerator();
pGen.Init(1024, 2, init_random);
Gost3410Parameters parameters = pGen.GenerateParameters();
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
return new SimpleTestResult(false, Name + ": p or q wrong");
}
Gost3410KeyPairGenerator Gost3410KeyGen = new Gost3410KeyPairGenerator();
Gost3410KeyGenerationParameters genParam = new Gost3410KeyGenerationParameters(keyRandom, parameters);
Gost3410KeyGen.Init(genParam);
AsymmetricCipherKeyPair pair = Gost3410KeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
Gost3410Signer Gost3410 = new Gost3410Signer();
Gost3410.Init(true, param);
BigInteger[] sig = Gost3410.GenerateSignature(hashmessage);
if (!r.Equals(sig[0]))
{
return new SimpleTestResult(false, Name
+ ": r component wrong." + SimpleTest.NewLine
+ " expecting: " + r.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[0].ToString(16));
}
if (!s.Equals(sig[1]))
{
return new SimpleTestResult(false, Name
+ ": s component wrong." + SimpleTest.NewLine
+ " expecting: " + s.ToString(16) + SimpleTest.NewLine
+ " got : " + sig[1].ToString(16));
}
Gost3410.Init(false, pair.Public);
if (Gost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
return new SimpleTestResult(true, Name + ": Okay");
}
else
{
return new SimpleTestResult(false, Name + ": verification fails");
}
}
private void doTest(
string algorithm,
byte[] input,
byte[] output)
{
KeyParameter key = null;
CipherKeyGenerator keyGen;
SecureRandom rand;
IBufferedCipher inCipher = null, outCipher = null;
byte[] iv = null;
CipherStream cIn, cOut;
MemoryStream bIn, bOut;
rand = new FixedSecureRandom();
string[] parts = algorithm.ToUpper(CultureInfo.InvariantCulture).Split('/');
string baseAlgorithm = parts[0];
string mode = parts.Length > 1 ? parts[1] : null;
#if !INCLUDE_IDEA
if (baseAlgorithm.Equals("IDEA"))
{
return;
}
#endif
try
{
keyGen = GeneratorUtilities.GetKeyGenerator(baseAlgorithm);
// TODO Add Algorithm property to CipherKeyGenerator?
// if (!keyGen.getAlgorithm().Equals(baseAlgorithm))
// {
// Fail("wrong key generator returned!");
// }
// TODO Add new Init method to CipherKeyGenerator?
// keyGen.Init(rand);
keyGen.Init(new KeyGenerationParameters(rand, keyGen.DefaultStrength));
byte[] keyBytes = keyGen.GenerateKey();
if (algorithm.StartsWith("RC5"))
{
key = new RC5Parameters(keyBytes, rc5Rounds);
}
else
{
key = ParameterUtilities.CreateKeyParameter(baseAlgorithm, keyBytes);
}
inCipher = CipherUtilities.GetCipher(algorithm);
outCipher = CipherUtilities.GetCipher(algorithm);
if (!inCipher.AlgorithmName.ToUpper(CultureInfo.InvariantCulture).StartsWith(baseAlgorithm))
{
Fail("wrong cipher returned!");
}
ICipherParameters parameters = key;
int ivLength = GetIVLength(algorithm);
if (ivLength > 0)
{
if (baseAlgorithm == "RC2")
{
iv = rc2IV;
}
else if (baseAlgorithm == "RC5")
{
iv = rc5IV;
}
else if (baseAlgorithm == "RC5-64")
{
iv = rc564IV;
}
else
{
// NB: rand always generates same values each test run
iv = rand.GenerateSeed(ivLength);
}
parameters = new ParametersWithIV(key, iv);
}
// NB: 'rand' still needed e.g. for some paddings
parameters = new ParametersWithRandom(parameters, rand);
outCipher.Init(true, parameters);
}
catch (Exception e)
{
Fail("" + algorithm + " failed initialisation - " + e.ToString(), e);
}
//
// grab the iv if there is one
//
try
{
// The Java version set this implicitly, but we set it explicity
//byte[] iv = outCipher.getIV();
if (iv != null)
{
// TODO Examine short IV handling for these FIPS-compliant modes in Java build
if (mode.StartsWith("CFB")
|| mode.StartsWith("GOFB")
|| mode.StartsWith("OFB")
|| mode.StartsWith("OPENPGPCFB"))
{
// These modes automatically pad out the IV if it is short
}
else
{
try
{
byte[] nIv = new byte[iv.Length- 1];
inCipher.Init(false, new ParametersWithIV(key, nIv));
Fail("failed to pick up short IV");
}
//catch (InvalidAlgorithmParameterException e)
catch (ArgumentException)
{
// ignore - this is what we want...
}
}
//IvParameterSpec spec = new IvParameterSpec(iv);
inCipher.Init(false, new ParametersWithIV(key, iv));
}
else
{
inCipher.Init(false, key);
}
}
catch (Exception e)
{
Fail("" + algorithm + " failed initialisation - " + e.ToString());
}
//
// encryption pass
//
bOut = new MemoryStream();
cOut = new CipherStream(bOut, null, outCipher);
try
{
for (int i = 0; i != input.Length/ 2; i++)
{
cOut.WriteByte(input[i]);
}
cOut.Write(input, input.Length/ 2, input.Length- input.Length/ 2);
cOut.Close();
}
catch (IOException e)
{
Fail("" + algorithm + " failed encryption - " + e.ToString());
}
byte[] bytes = bOut.ToArray();
if (!AreEqual(bytes, output))
{
Fail("" + algorithm + " failed encryption - expected "
+ Hex.ToHexString(output) + " got "
+ Hex.ToHexString(bytes));
}
//
// decryption pass
//
bIn = new MemoryStream(bytes, false);
cIn = new CipherStream(bIn, inCipher, null);
try
{
BinaryReader dIn = new BinaryReader(cIn);
bytes = new byte[input.Length];
for (int i = 0; i != input.Length/ 2; i++)
{
bytes[i] = dIn.ReadByte();
}
int remaining = bytes.Length - input.Length / 2;
byte[] extra = dIn.ReadBytes(remaining);
if (extra.Length < remaining)
throw new EndOfStreamException();
extra.CopyTo(bytes, input.Length / 2);
}
catch (Exception e)
{
Fail("" + algorithm + " failed decryption - " + e.ToString());
}
if (!AreEqual(bytes, input))
{
Fail("" + algorithm + " failed decryption - expected "
+ Hex.ToHexString(input) + " got "
+ Hex.ToHexString(bytes));
}
}
public override void PerformTest()
{
byte[] k1 = Hex.Decode("d5014e4b60ef2ba8b6211b4062ba3224e0427dd3");
byte[] k2 = Hex.Decode("345e8d05c075c3a508df729a1685690e68fcfb8c8117847e89063bca1f85d968fd281540b6e13bd1af989a1fbf17e06462bf511f9d0b140fb48ac1b1baa5bded");
SecureRandom random = FixedSecureRandom.From(k1, k2);
byte[] keyData = Hex.Decode("b5014e4b60ef2ba8b6211b4062ba3224e0427dd3");
SecureRandom keyRandom = FixedSecureRandom.From(keyData, keyData);
IBigInteger r = new BigInteger("68076202252361894315274692543577577550894681403");
IBigInteger s = new BigInteger("1089214853334067536215539335472893651470583479365");
DsaParametersGenerator pGen = new DsaParametersGenerator();
pGen.Init(512, 80, random);
DsaParameters parameters = pGen.GenerateParameters();
DsaValidationParameters pValid = parameters.ValidationParameters;
if (pValid.Counter != 105)
{
Fail("Counter wrong");
}
if (!pValue.Equals(parameters.P) || !qValue.Equals(parameters.Q))
{
Fail("p or q wrong");
}
DsaKeyPairGenerator dsaKeyGen = new DsaKeyPairGenerator();
DsaKeyGenerationParameters genParam = new DsaKeyGenerationParameters(keyRandom, parameters);
dsaKeyGen.Init(genParam);
IAsymmetricCipherKeyPair pair = dsaKeyGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, keyRandom);
DsaSigner dsa = new DsaSigner();
dsa.Init(true, param);
byte[] message = new BigInteger("968236873715988614170569073515315707566766479517").ToByteArrayUnsigned();
IBigInteger[] sig = dsa.GenerateSignature(message);
if (!r.Equals(sig[0]))
{
Fail("r component wrong." + SimpleTest.NewLine
+ " expecting: " + r + SimpleTest.NewLine
+ " got : " + sig[0]);
}
if (!s.Equals(sig[1]))
{
Fail("s component wrong." + SimpleTest.NewLine
+ " expecting: " + s + SimpleTest.NewLine
+ " got : " + sig[1]);
}
dsa.Init(false, pair.Public);
if (!dsa.VerifySignature(message, sig[0], sig[1]))
{
Fail("verification fails");
}
}
/**
* Test Sign and Verify with B parameters
* see: http://www.ietf.org/internet-drafts/draft-popov-cryptopro-cpalgs-01.txt
* gostR3410-2001-CryptoPro-B-ParamSet P.47-48
*/
private void ecGOST3410_BParam()
{
SecureRandom random = new SecureRandom();
BigInteger mod_p = new BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564823193"); //p
FpCurve curve = new FpCurve(
mod_p, // p
new BigInteger("57896044618658097711785492504343953926634992332820282019728792003956564823190"), // a
new BigInteger("28091019353058090096996979000309560759124368558014865957655842872397301267595")); // b
ECDomainParameters parameters = new ECDomainParameters(
curve,
new FpPoint(curve,
new FpFieldElement(mod_p,new BigInteger("1")), // x
new FpFieldElement(mod_p,new BigInteger("28792665814854611296992347458380284135028636778229113005756334730996303888124"))), // y
new BigInteger("57896044618658097711785492504343953927102133160255826820068844496087732066703")); // q
ECKeyPairGenerator pGen = new ECKeyPairGenerator("ECGOST3410");
ECKeyGenerationParameters genParam = new ECKeyGenerationParameters(
parameters,
random);
pGen.Init(genParam);
AsymmetricCipherKeyPair pair = pGen.GenerateKeyPair();
ParametersWithRandom param = new ParametersWithRandom(pair.Private, random);
ECGost3410Signer ecgost3410 = new ECGost3410Signer();
ecgost3410.Init(true, param);
BigInteger[] sig = ecgost3410.GenerateSignature(hashmessage);
ecgost3410.Init(false, pair.Public);
if (!ecgost3410.VerifySignature(hashmessage, sig[0], sig[1]))
{
Fail("signature fails");
}
}
