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