SECNamedCurves.cs 55 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278
  1. #if !BESTHTTP_DISABLE_ALTERNATE_SSL && (!UNITY_WEBGL || UNITY_EDITOR)
  2. #pragma warning disable
  3. using System;
  4. using System.Collections.Generic;
  5. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Asn1.X9;
  6. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math;
  7. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC;
  8. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Endo;
  9. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Math.EC.Multiplier;
  10. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Utilities.Collections;
  11. using Best.HTTP.SecureProtocol.Org.BouncyCastle.Utilities.Encoders;
  12. namespace Best.HTTP.SecureProtocol.Org.BouncyCastle.Asn1.Sec
  13. {
  14. /// <summary>Elliptic curve registry for the SEC standard.</summary>
  15. public static class SecNamedCurves
  16. {
  17. private static X9ECPoint ConfigureBasepoint(ECCurve curve, string encoding)
  18. {
  19. X9ECPoint G = new X9ECPoint(curve, Hex.DecodeStrict(encoding));
  20. WNafUtilities.ConfigureBasepoint(G.Point);
  21. return G;
  22. }
  23. private static ECCurve ConfigureCurve(ECCurve curve)
  24. {
  25. return curve;
  26. }
  27. private static ECCurve ConfigureCurveGlv(ECCurve c, GlvTypeBParameters p)
  28. {
  29. return c.Configure().SetEndomorphism(new GlvTypeBEndomorphism(c, p)).Create();
  30. }
  31. private static BigInteger FromHex(string hex)
  32. {
  33. return new BigInteger(1, Hex.DecodeStrict(hex));
  34. }
  35. internal class Secp112r1Holder
  36. : X9ECParametersHolder
  37. {
  38. private Secp112r1Holder() {}
  39. internal static readonly X9ECParametersHolder Instance = new Secp112r1Holder();
  40. protected override ECCurve CreateCurve()
  41. {
  42. // p = (2^128 - 3) / 76439
  43. BigInteger p = FromHex("DB7C2ABF62E35E668076BEAD208B");
  44. BigInteger a = FromHex("DB7C2ABF62E35E668076BEAD2088");
  45. BigInteger b = FromHex("659EF8BA043916EEDE8911702B22");
  46. BigInteger n = FromHex("DB7C2ABF62E35E7628DFAC6561C5");
  47. BigInteger h = BigInteger.One;
  48. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  49. }
  50. protected override X9ECParameters CreateParameters()
  51. {
  52. byte[] S = Hex.DecodeStrict("00F50B028E4D696E676875615175290472783FB1");
  53. ECCurve curve = Curve;
  54. X9ECPoint G = ConfigureBasepoint(curve,
  55. "0409487239995A5EE76B55F9C2F098A89CE5AF8724C0A23E0E0FF77500");
  56. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  57. }
  58. }
  59. internal class Secp112r2Holder
  60. : X9ECParametersHolder
  61. {
  62. private Secp112r2Holder() {}
  63. internal static readonly X9ECParametersHolder Instance = new Secp112r2Holder();
  64. protected override ECCurve CreateCurve()
  65. {
  66. // p = (2^128 - 3) / 76439
  67. BigInteger p = FromHex("DB7C2ABF62E35E668076BEAD208B");
  68. BigInteger a = FromHex("6127C24C05F38A0AAAF65C0EF02C");
  69. BigInteger b = FromHex("51DEF1815DB5ED74FCC34C85D709");
  70. BigInteger n = FromHex("36DF0AAFD8B8D7597CA10520D04B");
  71. BigInteger h = BigInteger.ValueOf(4);
  72. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  73. }
  74. protected override X9ECParameters CreateParameters()
  75. {
  76. byte[] S = Hex.DecodeStrict("002757A1114D696E6768756151755316C05E0BD4");
  77. ECCurve curve = Curve;
  78. X9ECPoint G = ConfigureBasepoint(curve,
  79. "044BA30AB5E892B4E1649DD0928643ADCD46F5882E3747DEF36E956E97");
  80. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  81. }
  82. }
  83. internal class Secp128r1Holder
  84. : X9ECParametersHolder
  85. {
  86. private Secp128r1Holder() {}
  87. internal static readonly X9ECParametersHolder Instance = new Secp128r1Holder();
  88. protected override ECCurve CreateCurve()
  89. {
  90. // p = 2^128 - 2^97 - 1
  91. BigInteger p = FromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF");
  92. BigInteger a = FromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFC");
  93. BigInteger b = FromHex("E87579C11079F43DD824993C2CEE5ED3");
  94. BigInteger n = FromHex("FFFFFFFE0000000075A30D1B9038A115");
  95. BigInteger h = BigInteger.One;
  96. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  97. }
  98. protected override X9ECParameters CreateParameters()
  99. {
  100. byte[] S = Hex.DecodeStrict("000E0D4D696E6768756151750CC03A4473D03679");
  101. ECCurve curve = Curve;
  102. X9ECPoint G = ConfigureBasepoint(curve,
  103. "04161FF7528B899B2D0C28607CA52C5B86CF5AC8395BAFEB13C02DA292DDED7A83");
  104. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  105. }
  106. }
  107. internal class Secp128r2Holder
  108. : X9ECParametersHolder
  109. {
  110. private Secp128r2Holder() {}
  111. internal static readonly X9ECParametersHolder Instance = new Secp128r2Holder();
  112. protected override ECCurve CreateCurve()
  113. {
  114. // p = 2^128 - 2^97 - 1
  115. BigInteger p = FromHex("FFFFFFFDFFFFFFFFFFFFFFFFFFFFFFFF");
  116. BigInteger a = FromHex("D6031998D1B3BBFEBF59CC9BBFF9AEE1");
  117. BigInteger b = FromHex("5EEEFCA380D02919DC2C6558BB6D8A5D");
  118. BigInteger n = FromHex("3FFFFFFF7FFFFFFFBE0024720613B5A3");
  119. BigInteger h = BigInteger.ValueOf(4);
  120. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  121. }
  122. protected override X9ECParameters CreateParameters()
  123. {
  124. byte[] S = Hex.DecodeStrict("004D696E67687561517512D8F03431FCE63B88F4");
  125. ECCurve curve = Curve;
  126. X9ECPoint G = ConfigureBasepoint(curve,
  127. "047B6AA5D85E572983E6FB32A7CDEBC14027B6916A894D3AEE7106FE805FC34B44");
  128. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  129. }
  130. }
  131. internal class Secp160k1Holder
  132. : X9ECParametersHolder
  133. {
  134. private Secp160k1Holder() {}
  135. internal static readonly X9ECParametersHolder Instance = new Secp160k1Holder();
  136. protected override ECCurve CreateCurve()
  137. {
  138. // p = 2^160 - 2^32 - 2^14 - 2^12 - 2^9 - 2^8 - 2^7 - 2^3 - 2^2 - 1
  139. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73");
  140. BigInteger a = BigInteger.Zero;
  141. BigInteger b = BigInteger.ValueOf(7);
  142. BigInteger n = FromHex("0100000000000000000001B8FA16DFAB9ACA16B6B3");
  143. BigInteger h = BigInteger.One;
  144. GlvTypeBParameters glv = new GlvTypeBParameters(
  145. new BigInteger("9ba48cba5ebcb9b6bd33b92830b2a2e0e192f10a", 16),
  146. new BigInteger("c39c6c3b3a36d7701b9c71a1f5804ae5d0003f4", 16),
  147. new ScalarSplitParameters(
  148. new BigInteger[]{
  149. new BigInteger("9162fbe73984472a0a9e", 16),
  150. new BigInteger("-96341f1138933bc2f505", 16) },
  151. new BigInteger[]{
  152. new BigInteger("127971af8721782ecffa3", 16),
  153. new BigInteger("9162fbe73984472a0a9e", 16) },
  154. new BigInteger("9162fbe73984472a0a9d0590", 16),
  155. new BigInteger("96341f1138933bc2f503fd44", 16),
  156. 176));
  157. return ConfigureCurveGlv(new FpCurve(p, a, b, n, h, true), glv);
  158. }
  159. protected override X9ECParameters CreateParameters()
  160. {
  161. byte[] S = null;
  162. ECCurve curve = Curve;
  163. X9ECPoint G = ConfigureBasepoint(curve,
  164. "043B4C382CE37AA192A4019E763036F4F5DD4D7EBB938CF935318FDCED6BC28286531733C3F03C4FEE");
  165. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  166. }
  167. }
  168. internal class Secp160r1Holder
  169. : X9ECParametersHolder
  170. {
  171. private Secp160r1Holder() {}
  172. internal static readonly X9ECParametersHolder Instance = new Secp160r1Holder();
  173. protected override ECCurve CreateCurve()
  174. {
  175. // p = 2^160 - 2^31 - 1
  176. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFF");
  177. BigInteger a = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF7FFFFFFC");
  178. BigInteger b = FromHex("1C97BEFC54BD7A8B65ACF89F81D4D4ADC565FA45");
  179. BigInteger n = FromHex("0100000000000000000001F4C8F927AED3CA752257");
  180. BigInteger h = BigInteger.One;
  181. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  182. }
  183. protected override X9ECParameters CreateParameters()
  184. {
  185. byte[] S = Hex.DecodeStrict("1053CDE42C14D696E67687561517533BF3F83345");
  186. ECCurve curve = Curve;
  187. X9ECPoint G = ConfigureBasepoint(curve,
  188. "044A96B5688EF573284664698968C38BB913CBFC8223A628553168947D59DCC912042351377AC5FB32");
  189. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  190. }
  191. }
  192. internal class Secp160r2Holder
  193. : X9ECParametersHolder
  194. {
  195. private Secp160r2Holder() {}
  196. internal static readonly X9ECParametersHolder Instance = new Secp160r2Holder();
  197. protected override ECCurve CreateCurve()
  198. {
  199. // p = 2^160 - 2^32 - 2^14 - 2^12 - 2^9 - 2^8 - 2^7 - 2^3 - 2^2 - 1
  200. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC73");
  201. BigInteger a = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFAC70");
  202. BigInteger b = FromHex("B4E134D3FB59EB8BAB57274904664D5AF50388BA");
  203. BigInteger n = FromHex("0100000000000000000000351EE786A818F3A1A16B");
  204. BigInteger h = BigInteger.One;
  205. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  206. }
  207. protected override X9ECParameters CreateParameters()
  208. {
  209. byte[] S = Hex.DecodeStrict("B99B99B099B323E02709A4D696E6768756151751");
  210. ECCurve curve = Curve;
  211. X9ECPoint G = ConfigureBasepoint(curve,
  212. "0452DCB034293A117E1F4FF11B30F7199D3144CE6DFEAFFEF2E331F296E071FA0DF9982CFEA7D43F2E");
  213. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  214. }
  215. }
  216. internal class Secp192k1Holder
  217. : X9ECParametersHolder
  218. {
  219. private Secp192k1Holder() {}
  220. internal static readonly X9ECParametersHolder Instance = new Secp192k1Holder();
  221. protected override ECCurve CreateCurve()
  222. {
  223. // p = 2^192 - 2^32 - 2^12 - 2^8 - 2^7 - 2^6 - 2^3 - 1
  224. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFEE37");
  225. BigInteger a = BigInteger.Zero;
  226. BigInteger b = BigInteger.ValueOf(3);
  227. BigInteger n = FromHex("FFFFFFFFFFFFFFFFFFFFFFFE26F2FC170F69466A74DEFD8D");
  228. BigInteger h = BigInteger.One;
  229. GlvTypeBParameters glv = new GlvTypeBParameters(
  230. new BigInteger("bb85691939b869c1d087f601554b96b80cb4f55b35f433c2", 16),
  231. new BigInteger("3d84f26c12238d7b4f3d516613c1759033b1a5800175d0b1", 16),
  232. new ScalarSplitParameters(
  233. new BigInteger[]{
  234. new BigInteger("71169be7330b3038edb025f1", 16),
  235. new BigInteger("-b3fb3400dec5c4adceb8655c", 16) },
  236. new BigInteger[]{
  237. new BigInteger("12511cfe811d0f4e6bc688b4d", 16),
  238. new BigInteger("71169be7330b3038edb025f1", 16) },
  239. new BigInteger("71169be7330b3038edb025f1d0f9", 16),
  240. new BigInteger("b3fb3400dec5c4adceb8655d4c94", 16),
  241. 208));
  242. return ConfigureCurveGlv(new FpCurve(p, a, b, n, h, true), glv);
  243. }
  244. protected override X9ECParameters CreateParameters()
  245. {
  246. byte[] S = null;
  247. ECCurve curve = Curve;
  248. X9ECPoint G = ConfigureBasepoint(curve,
  249. "04DB4FF10EC057E9AE26B07D0280B7F4341DA5D1B1EAE06C7D9B2F2F6D9C5628A7844163D015BE86344082AA88D95E2F9D");
  250. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  251. }
  252. }
  253. internal class Secp192r1Holder
  254. : X9ECParametersHolder
  255. {
  256. private Secp192r1Holder() {}
  257. internal static readonly X9ECParametersHolder Instance = new Secp192r1Holder();
  258. protected override ECCurve CreateCurve()
  259. {
  260. // p = 2^192 - 2^64 - 1
  261. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFF");
  262. BigInteger a = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFC");
  263. BigInteger b = FromHex("64210519E59C80E70FA7E9AB72243049FEB8DEECC146B9B1");
  264. BigInteger n = FromHex("FFFFFFFFFFFFFFFFFFFFFFFF99DEF836146BC9B1B4D22831");
  265. BigInteger h = BigInteger.One;
  266. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  267. }
  268. protected override X9ECParameters CreateParameters()
  269. {
  270. byte[] S = Hex.DecodeStrict("3045AE6FC8422F64ED579528D38120EAE12196D5");
  271. ECCurve curve = Curve;
  272. X9ECPoint G = ConfigureBasepoint(curve,
  273. "04188DA80EB03090F67CBF20EB43A18800F4FF0AFD82FF101207192B95FFC8DA78631011ED6B24CDD573F977A11E794811");
  274. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  275. }
  276. }
  277. internal class Secp224k1Holder
  278. : X9ECParametersHolder
  279. {
  280. private Secp224k1Holder() {}
  281. internal static readonly X9ECParametersHolder Instance = new Secp224k1Holder();
  282. protected override ECCurve CreateCurve()
  283. {
  284. // p = 2^224 - 2^32 - 2^12 - 2^11 - 2^9 - 2^7 - 2^4 - 2 - 1
  285. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFE56D");
  286. BigInteger a = BigInteger.Zero;
  287. BigInteger b = BigInteger.ValueOf(5);
  288. BigInteger n = FromHex("010000000000000000000000000001DCE8D2EC6184CAF0A971769FB1F7");
  289. BigInteger h = BigInteger.One;
  290. GlvTypeBParameters glv = new GlvTypeBParameters(
  291. new BigInteger("fe0e87005b4e83761908c5131d552a850b3f58b749c37cf5b84d6768", 16),
  292. new BigInteger("60dcd2104c4cbc0be6eeefc2bdd610739ec34e317f9b33046c9e4788", 16),
  293. new ScalarSplitParameters(
  294. new BigInteger[]{
  295. new BigInteger("6b8cf07d4ca75c88957d9d670591", 16),
  296. new BigInteger("-b8adf1378a6eb73409fa6c9c637d", 16) },
  297. new BigInteger[]{
  298. new BigInteger("1243ae1b4d71613bc9f780a03690e", 16),
  299. new BigInteger("6b8cf07d4ca75c88957d9d670591", 16) },
  300. new BigInteger("6b8cf07d4ca75c88957d9d67059037a4", 16),
  301. new BigInteger("b8adf1378a6eb73409fa6c9c637ba7f5", 16),
  302. 240));
  303. return ConfigureCurveGlv(new FpCurve(p, a, b, n, h, true), glv);
  304. }
  305. protected override X9ECParameters CreateParameters()
  306. {
  307. byte[] S = null;
  308. ECCurve curve = Curve;
  309. X9ECPoint G = ConfigureBasepoint(curve,
  310. "04A1455B334DF099DF30FC28A169A467E9E47075A90F7E650EB6B7A45C7E089FED7FBA344282CAFBD6F7E319F7C0B0BD59E2CA4BDB556D61A5");
  311. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  312. }
  313. }
  314. internal class Secp224r1Holder
  315. : X9ECParametersHolder
  316. {
  317. private Secp224r1Holder() {}
  318. internal static readonly X9ECParametersHolder Instance = new Secp224r1Holder();
  319. protected override ECCurve CreateCurve()
  320. {
  321. // p = 2^224 - 2^96 + 1
  322. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF000000000000000000000001");
  323. BigInteger a = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFFFFFFFFFFFFFFFFFE");
  324. BigInteger b = FromHex("B4050A850C04B3ABF54132565044B0B7D7BFD8BA270B39432355FFB4");
  325. BigInteger n = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFF16A2E0B8F03E13DD29455C5C2A3D");
  326. BigInteger h = BigInteger.One;
  327. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  328. }
  329. protected override X9ECParameters CreateParameters()
  330. {
  331. byte[] S = Hex.DecodeStrict("BD71344799D5C7FCDC45B59FA3B9AB8F6A948BC5");
  332. ECCurve curve = Curve;
  333. X9ECPoint G = ConfigureBasepoint(curve,
  334. "04B70E0CBD6BB4BF7F321390B94A03C1D356C21122343280D6115C1D21BD376388B5F723FB4C22DFE6CD4375A05A07476444D5819985007E34");
  335. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  336. }
  337. }
  338. internal class Secp256k1Holder
  339. : X9ECParametersHolder
  340. {
  341. private Secp256k1Holder() {}
  342. internal static readonly X9ECParametersHolder Instance = new Secp256k1Holder();
  343. protected override ECCurve CreateCurve()
  344. {
  345. // p = 2^256 - 2^32 - 2^9 - 2^8 - 2^7 - 2^6 - 2^4 - 1
  346. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFC2F");
  347. BigInteger a = BigInteger.Zero;
  348. BigInteger b = BigInteger.ValueOf(7);
  349. BigInteger n = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141");
  350. BigInteger h = BigInteger.One;
  351. GlvTypeBParameters glv = new GlvTypeBParameters(
  352. new BigInteger("7ae96a2b657c07106e64479eac3434e99cf0497512f58995c1396c28719501ee", 16),
  353. new BigInteger("5363ad4cc05c30e0a5261c028812645a122e22ea20816678df02967c1b23bd72", 16),
  354. new ScalarSplitParameters(
  355. new BigInteger[]{
  356. new BigInteger("3086d221a7d46bcde86c90e49284eb15", 16),
  357. new BigInteger("-e4437ed6010e88286f547fa90abfe4c3", 16) },
  358. new BigInteger[]{
  359. new BigInteger("114ca50f7a8e2f3f657c1108d9d44cfd8", 16),
  360. new BigInteger("3086d221a7d46bcde86c90e49284eb15", 16) },
  361. new BigInteger("3086d221a7d46bcde86c90e49284eb153dab", 16),
  362. new BigInteger("e4437ed6010e88286f547fa90abfe4c42212", 16),
  363. 272));
  364. return ConfigureCurveGlv(new FpCurve(p, a, b, n, h, true), glv);
  365. }
  366. protected override X9ECParameters CreateParameters()
  367. {
  368. byte[] S = null;
  369. ECCurve curve = Curve;
  370. X9ECPoint G = ConfigureBasepoint(curve,
  371. "0479BE667EF9DCBBAC55A06295CE870B07029BFCDB2DCE28D959F2815B16F81798483ADA7726A3C4655DA4FBFC0E1108A8FD17B448A68554199C47D08FFB10D4B8");
  372. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  373. }
  374. }
  375. internal class Secp256r1Holder
  376. : X9ECParametersHolder
  377. {
  378. private Secp256r1Holder() {}
  379. internal static readonly X9ECParametersHolder Instance = new Secp256r1Holder();
  380. protected override ECCurve CreateCurve()
  381. {
  382. // p = 2^224 (2^32 - 1) + 2^192 + 2^96 - 1
  383. BigInteger p = FromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFF");
  384. BigInteger a = FromHex("FFFFFFFF00000001000000000000000000000000FFFFFFFFFFFFFFFFFFFFFFFC");
  385. BigInteger b = FromHex("5AC635D8AA3A93E7B3EBBD55769886BC651D06B0CC53B0F63BCE3C3E27D2604B");
  386. BigInteger n = FromHex("FFFFFFFF00000000FFFFFFFFFFFFFFFFBCE6FAADA7179E84F3B9CAC2FC632551");
  387. BigInteger h = BigInteger.One;
  388. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  389. }
  390. protected override X9ECParameters CreateParameters()
  391. {
  392. byte[] S = Hex.DecodeStrict("C49D360886E704936A6678E1139D26B7819F7E90");
  393. ECCurve curve = Curve;
  394. X9ECPoint G = ConfigureBasepoint(curve,
  395. "046B17D1F2E12C4247F8BCE6E563A440F277037D812DEB33A0F4A13945D898C2964FE342E2FE1A7F9B8EE7EB4A7C0F9E162BCE33576B315ECECBB6406837BF51F5");
  396. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  397. }
  398. }
  399. internal class Secp384r1Holder
  400. : X9ECParametersHolder
  401. {
  402. private Secp384r1Holder() {}
  403. internal static readonly X9ECParametersHolder Instance = new Secp384r1Holder();
  404. protected override ECCurve CreateCurve()
  405. {
  406. // p = 2^384 - 2^128 - 2^96 + 2^32 - 1
  407. BigInteger p = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFF");
  408. BigInteger a = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEFFFFFFFF0000000000000000FFFFFFFC");
  409. BigInteger b = FromHex("B3312FA7E23EE7E4988E056BE3F82D19181D9C6EFE8141120314088F5013875AC656398D8A2ED19D2A85C8EDD3EC2AEF");
  410. BigInteger n = FromHex("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC7634D81F4372DDF581A0DB248B0A77AECEC196ACCC52973");
  411. BigInteger h = BigInteger.One;
  412. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  413. }
  414. protected override X9ECParameters CreateParameters()
  415. {
  416. byte[] S = Hex.DecodeStrict("A335926AA319A27A1D00896A6773A4827ACDAC73");
  417. ECCurve curve = Curve;
  418. X9ECPoint G = ConfigureBasepoint(curve, "04"
  419. + "AA87CA22BE8B05378EB1C71EF320AD746E1D3B628BA79B9859F741E082542A385502F25DBF55296C3A545E3872760AB7"
  420. + "3617DE4A96262C6F5D9E98BF9292DC29F8F41DBD289A147CE9DA3113B5F0B8C00A60B1CE1D7E819D7A431D7C90EA0E5F");
  421. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  422. }
  423. }
  424. internal class Secp521r1Holder
  425. : X9ECParametersHolder
  426. {
  427. private Secp521r1Holder() {}
  428. internal static readonly X9ECParametersHolder Instance = new Secp521r1Holder();
  429. protected override ECCurve CreateCurve()
  430. {
  431. // p = 2^521 - 1
  432. BigInteger p = FromHex("01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
  433. BigInteger a = FromHex("01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFC");
  434. BigInteger b = FromHex("0051953EB9618E1C9A1F929A21A0B68540EEA2DA725B99B315F3B8B489918EF109E156193951EC7E937B1652C0BD3BB1BF073573DF883D2C34F1EF451FD46B503F00");
  435. BigInteger n = FromHex("01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFA51868783BF2F966B7FCC0148F709A5D03BB5C9B8899C47AEBB6FB71E91386409");
  436. BigInteger h = BigInteger.One;
  437. return ConfigureCurve(new FpCurve(p, a, b, n, h, true));
  438. }
  439. protected override X9ECParameters CreateParameters()
  440. {
  441. byte[] S = Hex.DecodeStrict("D09E8800291CB85396CC6717393284AAA0DA64BA");
  442. ECCurve curve = Curve;
  443. X9ECPoint G = ConfigureBasepoint(curve, "04"
  444. + "00C6858E06B70404E9CD9E3ECB662395B4429C648139053FB521F828AF606B4D3DBAA14B5E77EFE75928FE1DC127A2FFA8DE3348B3C1856A429BF97E7E31C2E5BD66"
  445. + "011839296A789A3BC0045C8A5FB42C7D1BD998F54449579B446817AFBD17273E662C97EE72995EF42640C550B9013FAD0761353C7086A272C24088BE94769FD16650");
  446. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  447. }
  448. }
  449. internal class Sect113r1Holder
  450. : X9ECParametersHolder
  451. {
  452. private Sect113r1Holder() {}
  453. internal static readonly X9ECParametersHolder Instance = new Sect113r1Holder();
  454. private const int m = 113;
  455. private const int k = 9;
  456. protected override ECCurve CreateCurve()
  457. {
  458. BigInteger a = FromHex("003088250CA6E7C7FE649CE85820F7");
  459. BigInteger b = FromHex("00E8BEE4D3E2260744188BE0E9C723");
  460. BigInteger n = FromHex("0100000000000000D9CCEC8A39E56F");
  461. BigInteger h = BigInteger.ValueOf(2);
  462. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  463. }
  464. protected override X9ECParameters CreateParameters()
  465. {
  466. byte[] S = Hex.DecodeStrict("10E723AB14D696E6768756151756FEBF8FCB49A9");
  467. ECCurve curve = Curve;
  468. X9ECPoint G = ConfigureBasepoint(curve,
  469. "04009D73616F35F4AB1407D73562C10F00A52830277958EE84D1315ED31886");
  470. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  471. }
  472. }
  473. internal class Sect113r2Holder
  474. : X9ECParametersHolder
  475. {
  476. private Sect113r2Holder() {}
  477. internal static readonly X9ECParametersHolder Instance = new Sect113r2Holder();
  478. private const int m = 113;
  479. private const int k = 9;
  480. protected override ECCurve CreateCurve()
  481. {
  482. BigInteger a = FromHex("00689918DBEC7E5A0DD6DFC0AA55C7");
  483. BigInteger b = FromHex("0095E9A9EC9B297BD4BF36E059184F");
  484. BigInteger n = FromHex("010000000000000108789B2496AF93");
  485. BigInteger h = BigInteger.ValueOf(2);
  486. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  487. }
  488. protected override X9ECParameters CreateParameters()
  489. {
  490. byte[] S = Hex.DecodeStrict("10C0FB15760860DEF1EEF4D696E676875615175D");
  491. ECCurve curve = Curve;
  492. X9ECPoint G = ConfigureBasepoint(curve,
  493. "0401A57A6A7B26CA5EF52FCDB816479700B3ADC94ED1FE674C06E695BABA1D");
  494. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  495. }
  496. }
  497. internal class Sect131r1Holder
  498. : X9ECParametersHolder
  499. {
  500. private Sect131r1Holder() {}
  501. internal static readonly X9ECParametersHolder Instance = new Sect131r1Holder();
  502. private const int m = 131;
  503. private const int k1 = 2;
  504. private const int k2 = 3;
  505. private const int k3 = 8;
  506. protected override ECCurve CreateCurve()
  507. {
  508. BigInteger a = FromHex("07A11B09A76B562144418FF3FF8C2570B8");
  509. BigInteger b = FromHex("0217C05610884B63B9C6C7291678F9D341");
  510. BigInteger n = FromHex("0400000000000000023123953A9464B54D");
  511. BigInteger h = BigInteger.ValueOf(2);
  512. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  513. }
  514. protected override X9ECParameters CreateParameters()
  515. {
  516. byte[] S = Hex.DecodeStrict("4D696E676875615175985BD3ADBADA21B43A97E2");
  517. ECCurve curve = Curve;
  518. X9ECPoint G = ConfigureBasepoint(curve,
  519. "040081BAF91FDF9833C40F9C181343638399078C6E7EA38C001F73C8134B1B4EF9E150");
  520. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  521. }
  522. }
  523. internal class Sect131r2Holder
  524. : X9ECParametersHolder
  525. {
  526. private Sect131r2Holder() {}
  527. internal static readonly X9ECParametersHolder Instance = new Sect131r2Holder();
  528. private const int m = 131;
  529. private const int k1 = 2;
  530. private const int k2 = 3;
  531. private const int k3 = 8;
  532. protected override ECCurve CreateCurve()
  533. {
  534. BigInteger a = FromHex("03E5A88919D7CAFCBF415F07C2176573B2");
  535. BigInteger b = FromHex("04B8266A46C55657AC734CE38F018F2192");
  536. BigInteger n = FromHex("0400000000000000016954A233049BA98F");
  537. BigInteger h = BigInteger.ValueOf(2);
  538. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  539. }
  540. protected override X9ECParameters CreateParameters()
  541. {
  542. byte[] S = Hex.DecodeStrict("985BD3ADBAD4D696E676875615175A21B43A97E3");
  543. ECCurve curve = Curve;
  544. X9ECPoint G = ConfigureBasepoint(curve,
  545. "040356DCD8F2F95031AD652D23951BB366A80648F06D867940A5366D9E265DE9EB240F");
  546. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  547. }
  548. }
  549. internal class Sect163k1Holder
  550. : X9ECParametersHolder
  551. {
  552. private Sect163k1Holder() {}
  553. internal static readonly X9ECParametersHolder Instance = new Sect163k1Holder();
  554. private const int m = 163;
  555. private const int k1 = 3;
  556. private const int k2 = 6;
  557. private const int k3 = 7;
  558. protected override ECCurve CreateCurve()
  559. {
  560. BigInteger a = BigInteger.One;
  561. BigInteger b = BigInteger.One;
  562. BigInteger n = FromHex("04000000000000000000020108A2E0CC0D99F8A5EF");
  563. BigInteger h = BigInteger.ValueOf(2);
  564. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  565. }
  566. protected override X9ECParameters CreateParameters()
  567. {
  568. byte[] S = null;
  569. ECCurve curve = Curve;
  570. X9ECPoint G = ConfigureBasepoint(curve,
  571. "0402FE13C0537BBC11ACAA07D793DE4E6D5E5C94EEE80289070FB05D38FF58321F2E800536D538CCDAA3D9");
  572. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  573. }
  574. }
  575. internal class Sect163r1Holder
  576. : X9ECParametersHolder
  577. {
  578. private Sect163r1Holder() {}
  579. internal static readonly X9ECParametersHolder Instance = new Sect163r1Holder();
  580. private const int m = 163;
  581. private const int k1 = 3;
  582. private const int k2 = 6;
  583. private const int k3 = 7;
  584. protected override ECCurve CreateCurve()
  585. {
  586. BigInteger a = FromHex("07B6882CAAEFA84F9554FF8428BD88E246D2782AE2");
  587. BigInteger b = FromHex("0713612DCDDCB40AAB946BDA29CA91F73AF958AFD9");
  588. BigInteger n = FromHex("03FFFFFFFFFFFFFFFFFFFF48AAB689C29CA710279B");
  589. BigInteger h = BigInteger.ValueOf(2);
  590. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  591. }
  592. protected override X9ECParameters CreateParameters()
  593. {
  594. byte[] S = Hex.DecodeStrict("24B7B137C8A14D696E6768756151756FD0DA2E5C");
  595. ECCurve curve = Curve;
  596. X9ECPoint G = ConfigureBasepoint(curve,
  597. "040369979697AB43897789566789567F787A7876A65400435EDB42EFAFB2989D51FEFCE3C80988F41FF883");
  598. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  599. }
  600. }
  601. internal class Sect163r2Holder
  602. : X9ECParametersHolder
  603. {
  604. private Sect163r2Holder() {}
  605. internal static readonly X9ECParametersHolder Instance = new Sect163r2Holder();
  606. private const int m = 163;
  607. private const int k1 = 3;
  608. private const int k2 = 6;
  609. private const int k3 = 7;
  610. protected override ECCurve CreateCurve()
  611. {
  612. BigInteger a = BigInteger.One;
  613. BigInteger b = FromHex("020A601907B8C953CA1481EB10512F78744A3205FD");
  614. BigInteger n = FromHex("040000000000000000000292FE77E70C12A4234C33");
  615. BigInteger h = BigInteger.ValueOf(2);
  616. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  617. }
  618. protected override X9ECParameters CreateParameters()
  619. {
  620. byte[] S = Hex.DecodeStrict("85E25BFE5C86226CDB12016F7553F9D0E693A268");
  621. ECCurve curve = Curve;
  622. X9ECPoint G = ConfigureBasepoint(curve,
  623. "0403F0EBA16286A2D57EA0991168D4994637E8343E3600D51FBC6C71A0094FA2CDD545B11C5C0C797324F1");
  624. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  625. }
  626. }
  627. internal class Sect193r1Holder
  628. : X9ECParametersHolder
  629. {
  630. private Sect193r1Holder() {}
  631. internal static readonly X9ECParametersHolder Instance = new Sect193r1Holder();
  632. private const int m = 193;
  633. private const int k = 15;
  634. protected override ECCurve CreateCurve()
  635. {
  636. BigInteger a = FromHex("0017858FEB7A98975169E171F77B4087DE098AC8A911DF7B01");
  637. BigInteger b = FromHex("00FDFB49BFE6C3A89FACADAA7A1E5BBC7CC1C2E5D831478814");
  638. BigInteger n = FromHex("01000000000000000000000000C7F34A778F443ACC920EBA49");
  639. BigInteger h = BigInteger.ValueOf(2);
  640. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  641. }
  642. protected override X9ECParameters CreateParameters()
  643. {
  644. byte[] S = Hex.DecodeStrict("103FAEC74D696E676875615175777FC5B191EF30");
  645. ECCurve curve = Curve;
  646. X9ECPoint G = ConfigureBasepoint(curve,
  647. "0401F481BC5F0FF84A74AD6CDF6FDEF4BF6179625372D8C0C5E10025E399F2903712CCF3EA9E3A1AD17FB0B3201B6AF7CE1B05");
  648. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  649. }
  650. }
  651. internal class Sect193r2Holder
  652. : X9ECParametersHolder
  653. {
  654. private Sect193r2Holder() {}
  655. internal static readonly X9ECParametersHolder Instance = new Sect193r2Holder();
  656. private const int m = 193;
  657. private const int k = 15;
  658. protected override ECCurve CreateCurve()
  659. {
  660. BigInteger a = FromHex("0163F35A5137C2CE3EA6ED8667190B0BC43ECD69977702709B");
  661. BigInteger b = FromHex("00C9BB9E8927D4D64C377E2AB2856A5B16E3EFB7F61D4316AE");
  662. BigInteger n = FromHex("010000000000000000000000015AAB561B005413CCD4EE99D5");
  663. BigInteger h = BigInteger.ValueOf(2);
  664. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  665. }
  666. protected override X9ECParameters CreateParameters()
  667. {
  668. byte[] S = Hex.DecodeStrict("10B7B4D696E676875615175137C8A16FD0DA2211");
  669. ECCurve curve = Curve;
  670. X9ECPoint G = ConfigureBasepoint(curve,
  671. "0400D9B67D192E0367C803F39E1A7E82CA14A651350AAE617E8F01CE94335607C304AC29E7DEFBD9CA01F596F927224CDECF6C");
  672. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  673. }
  674. }
  675. internal class Sect233k1Holder
  676. : X9ECParametersHolder
  677. {
  678. private Sect233k1Holder() {}
  679. internal static readonly X9ECParametersHolder Instance = new Sect233k1Holder();
  680. private const int m = 233;
  681. private const int k = 74;
  682. protected override ECCurve CreateCurve()
  683. {
  684. BigInteger a = BigInteger.Zero;
  685. BigInteger b = BigInteger.One;
  686. BigInteger n = FromHex("8000000000000000000000000000069D5BB915BCD46EFB1AD5F173ABDF");
  687. BigInteger h = BigInteger.ValueOf(4);
  688. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  689. }
  690. protected override X9ECParameters CreateParameters()
  691. {
  692. byte[] S = null;
  693. ECCurve curve = Curve;
  694. X9ECPoint G = ConfigureBasepoint(curve,
  695. "04017232BA853A7E731AF129F22FF4149563A419C26BF50A4C9D6EEFAD612601DB537DECE819B7F70F555A67C427A8CD9BF18AEB9B56E0C11056FAE6A3");
  696. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  697. }
  698. }
  699. internal class Sect233r1Holder
  700. : X9ECParametersHolder
  701. {
  702. private Sect233r1Holder() {}
  703. internal static readonly X9ECParametersHolder Instance = new Sect233r1Holder();
  704. private const int m = 233;
  705. private const int k = 74;
  706. protected override ECCurve CreateCurve()
  707. {
  708. BigInteger a = BigInteger.One;
  709. BigInteger b = FromHex("0066647EDE6C332C7F8C0923BB58213B333B20E9CE4281FE115F7D8F90AD");
  710. BigInteger n = FromHex("01000000000000000000000000000013E974E72F8A6922031D2603CFE0D7");
  711. BigInteger h = BigInteger.ValueOf(2);
  712. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  713. }
  714. protected override X9ECParameters CreateParameters()
  715. {
  716. byte[] S = Hex.DecodeStrict("74D59FF07F6B413D0EA14B344B20A2DB049B50C3");
  717. ECCurve curve = Curve;
  718. X9ECPoint G = ConfigureBasepoint(curve,
  719. "0400FAC9DFCBAC8313BB2139F1BB755FEF65BC391F8B36F8F8EB7371FD558B01006A08A41903350678E58528BEBF8A0BEFF867A7CA36716F7E01F81052");
  720. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  721. }
  722. }
  723. internal class Sect239k1Holder
  724. : X9ECParametersHolder
  725. {
  726. private Sect239k1Holder() {}
  727. internal static readonly X9ECParametersHolder Instance = new Sect239k1Holder();
  728. private const int m = 239;
  729. private const int k = 158;
  730. protected override ECCurve CreateCurve()
  731. {
  732. BigInteger a = BigInteger.Zero;
  733. BigInteger b = BigInteger.One;
  734. BigInteger n = FromHex("2000000000000000000000000000005A79FEC67CB6E91F1C1DA800E478A5");
  735. BigInteger h = BigInteger.ValueOf(4);
  736. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  737. }
  738. protected override X9ECParameters CreateParameters()
  739. {
  740. byte[] S = null;
  741. ECCurve curve = Curve;
  742. X9ECPoint G = ConfigureBasepoint(curve,
  743. "0429A0B6A887A983E9730988A68727A8B2D126C44CC2CC7B2A6555193035DC76310804F12E549BDB011C103089E73510ACB275FC312A5DC6B76553F0CA");
  744. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  745. }
  746. }
  747. internal class Sect283k1Holder
  748. : X9ECParametersHolder
  749. {
  750. private Sect283k1Holder() {}
  751. internal static readonly X9ECParametersHolder Instance = new Sect283k1Holder();
  752. private const int m = 283;
  753. private const int k1 = 5;
  754. private const int k2 = 7;
  755. private const int k3 = 12;
  756. protected override ECCurve CreateCurve()
  757. {
  758. BigInteger a = BigInteger.Zero;
  759. BigInteger b = BigInteger.One;
  760. BigInteger n = FromHex("01FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE9AE2ED07577265DFF7F94451E061E163C61");
  761. BigInteger h = BigInteger.ValueOf(4);
  762. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  763. }
  764. protected override X9ECParameters CreateParameters()
  765. {
  766. byte[] S = null;
  767. ECCurve curve = Curve;
  768. X9ECPoint G = ConfigureBasepoint(curve, "04"
  769. + "0503213F78CA44883F1A3B8162F188E553CD265F23C1567A16876913B0C2AC2458492836"
  770. + "01CCDA380F1C9E318D90F95D07E5426FE87E45C0E8184698E45962364E34116177DD2259");
  771. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  772. }
  773. }
  774. internal class Sect283r1Holder
  775. : X9ECParametersHolder
  776. {
  777. private Sect283r1Holder() {}
  778. internal static readonly X9ECParametersHolder Instance = new Sect283r1Holder();
  779. private const int m = 283;
  780. private const int k1 = 5;
  781. private const int k2 = 7;
  782. private const int k3 = 12;
  783. protected override ECCurve CreateCurve()
  784. {
  785. BigInteger a = BigInteger.One;
  786. BigInteger b = FromHex("027B680AC8B8596DA5A4AF8A19A0303FCA97FD7645309FA2A581485AF6263E313B79A2F5");
  787. BigInteger n = FromHex("03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEF90399660FC938A90165B042A7CEFADB307");
  788. BigInteger h = BigInteger.ValueOf(2);
  789. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  790. }
  791. protected override X9ECParameters CreateParameters()
  792. {
  793. byte[] S = Hex.DecodeStrict("77E2B07370EB0F832A6DD5B62DFC88CD06BB84BE");
  794. ECCurve curve = Curve;
  795. X9ECPoint G = ConfigureBasepoint(curve, "04"
  796. + "05F939258DB7DD90E1934F8C70B0DFEC2EED25B8557EAC9C80E2E198F8CDBECD86B12053"
  797. + "03676854FE24141CB98FE6D4B20D02B4516FF702350EDDB0826779C813F0DF45BE8112F4");
  798. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  799. }
  800. }
  801. internal class Sect409k1Holder
  802. : X9ECParametersHolder
  803. {
  804. private Sect409k1Holder() {}
  805. internal static readonly X9ECParametersHolder Instance = new Sect409k1Holder();
  806. private const int m = 409;
  807. private const int k = 87;
  808. protected override ECCurve CreateCurve()
  809. {
  810. BigInteger a = BigInteger.Zero;
  811. BigInteger b = BigInteger.One;
  812. BigInteger n = FromHex("7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE5F83B2D4EA20400EC4557D5ED3E3E7CA5B4B5C83B8E01E5FCF");
  813. BigInteger h = BigInteger.ValueOf(4);
  814. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  815. }
  816. protected override X9ECParameters CreateParameters()
  817. {
  818. byte[] S = null;
  819. ECCurve curve = Curve;
  820. X9ECPoint G = ConfigureBasepoint(curve, "04"
  821. + "0060F05F658F49C1AD3AB1890F7184210EFD0987E307C84C27ACCFB8F9F67CC2C460189EB5AAAA62EE222EB1B35540CFE9023746"
  822. + "01E369050B7C4E42ACBA1DACBF04299C3460782F918EA427E6325165E9EA10E3DA5F6C42E9C55215AA9CA27A5863EC48D8E0286B");
  823. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  824. }
  825. }
  826. internal class Sect409r1Holder
  827. : X9ECParametersHolder
  828. {
  829. private Sect409r1Holder() {}
  830. internal static readonly X9ECParametersHolder Instance = new Sect409r1Holder();
  831. private const int m = 409;
  832. private const int k = 87;
  833. protected override ECCurve CreateCurve()
  834. {
  835. BigInteger a = BigInteger.One;
  836. BigInteger b = FromHex("0021A5C2C8EE9FEB5C4B9A753B7B476B7FD6422EF1F3DD674761FA99D6AC27C8A9A197B272822F6CD57A55AA4F50AE317B13545F");
  837. BigInteger n = FromHex("010000000000000000000000000000000000000000000000000001E2AAD6A612F33307BE5FA47C3C9E052F838164CD37D9A21173");
  838. BigInteger h = BigInteger.ValueOf(2);
  839. return ConfigureCurve(new F2mCurve(m, k, a, b, n, h));
  840. }
  841. protected override X9ECParameters CreateParameters()
  842. {
  843. byte[] S = Hex.DecodeStrict("4099B5A457F9D69F79213D094C4BCD4D4262210B");
  844. ECCurve curve = Curve;
  845. X9ECPoint G = ConfigureBasepoint(curve, "04"
  846. + "015D4860D088DDB3496B0C6064756260441CDE4AF1771D4DB01FFE5B34E59703DC255A868A1180515603AEAB60794E54BB7996A7"
  847. + "0061B1CFAB6BE5F32BBFA78324ED106A7636B9C5A7BD198D0158AA4F5488D08F38514F1FDF4B4F40D2181B3681C364BA0273C706");
  848. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  849. }
  850. }
  851. internal class Sect571k1Holder
  852. : X9ECParametersHolder
  853. {
  854. private Sect571k1Holder() {}
  855. internal static readonly X9ECParametersHolder Instance = new Sect571k1Holder();
  856. private const int m = 571;
  857. private const int k1 = 2;
  858. private const int k2 = 5;
  859. private const int k3 = 10;
  860. protected override ECCurve CreateCurve()
  861. {
  862. BigInteger a = BigInteger.Zero;
  863. BigInteger b = BigInteger.One;
  864. BigInteger n = FromHex("020000000000000000000000000000000000000000000000000000000000000000000000131850E1F19A63E4B391A8DB917F4138B630D84BE5D639381E91DEB45CFE778F637C1001");
  865. BigInteger h = BigInteger.ValueOf(4);
  866. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  867. }
  868. protected override X9ECParameters CreateParameters()
  869. {
  870. byte[] S = null;
  871. ECCurve curve = Curve;
  872. X9ECPoint G = ConfigureBasepoint(curve, "04"
  873. + "026EB7A859923FBC82189631F8103FE4AC9CA2970012D5D46024804801841CA44370958493B205E647DA304DB4CEB08CBBD1BA39494776FB988B47174DCA88C7E2945283A01C8972"
  874. + "0349DC807F4FBF374F4AEADE3BCA95314DD58CEC9F307A54FFC61EFC006D8A2C9D4979C0AC44AEA74FBEBBB9F772AEDCB620B01A7BA7AF1B320430C8591984F601CD4C143EF1C7A3");
  875. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  876. }
  877. }
  878. internal class Sect571r1Holder
  879. : X9ECParametersHolder
  880. {
  881. private Sect571r1Holder() {}
  882. internal static readonly X9ECParametersHolder Instance = new Sect571r1Holder();
  883. private const int m = 571;
  884. private const int k1 = 2;
  885. private const int k2 = 5;
  886. private const int k3 = 10;
  887. protected override ECCurve CreateCurve()
  888. {
  889. BigInteger a = BigInteger.One;
  890. BigInteger b = FromHex("02F40E7E2221F295DE297117B7F3D62F5C6A97FFCB8CEFF1CD6BA8CE4A9A18AD84FFABBD8EFA59332BE7AD6756A66E294AFD185A78FF12AA520E4DE739BACA0C7FFEFF7F2955727A");
  891. BigInteger n = FromHex("03FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE661CE18FF55987308059B186823851EC7DD9CA1161DE93D5174D66E8382E9BB2FE84E47");
  892. BigInteger h = BigInteger.ValueOf(2);
  893. return ConfigureCurve(new F2mCurve(m, k1, k2, k3, a, b, n, h));
  894. }
  895. protected override X9ECParameters CreateParameters()
  896. {
  897. byte[] S = Hex.DecodeStrict("2AA058F73A0E33AB486B0F610410C53A7F132310");
  898. ECCurve curve = Curve;
  899. X9ECPoint G = ConfigureBasepoint(curve, "04"
  900. + "0303001D34B856296C16C0D40D3CD7750A93D1D2955FA80AA5F40FC8DB7B2ABDBDE53950F4C0D293CDD711A35B67FB1499AE60038614F1394ABFA3B4C850D927E1E7769C8EEC2D19"
  901. + "037BF27342DA639B6DCCFFFEB73D69D78C6C27A6009CBBCA1980F8533921E8A684423E43BAB08A576291AF8F461BB2A8B3531D2F0485C19B16E2F1516E23DD3C1A4827AF1B8AC15B");
  902. return new X9ECParameters(curve, G, curve.Order, curve.Cofactor, S);
  903. }
  904. }
  905. private static readonly Dictionary<string, DerObjectIdentifier> objIds =
  906. new Dictionary<string, DerObjectIdentifier>(StringComparer.OrdinalIgnoreCase);
  907. private static readonly Dictionary<DerObjectIdentifier, X9ECParametersHolder> curves =
  908. new Dictionary<DerObjectIdentifier, X9ECParametersHolder>();
  909. private static readonly Dictionary<DerObjectIdentifier, string> names =
  910. new Dictionary<DerObjectIdentifier, string>();
  911. private static void DefineCurve(string name, DerObjectIdentifier oid, X9ECParametersHolder holder)
  912. {
  913. objIds.Add(name, oid);
  914. names.Add(oid, name);
  915. curves.Add(oid, holder);
  916. }
  917. static SecNamedCurves()
  918. {
  919. DefineCurve("secp112r1", SecObjectIdentifiers.SecP112r1, Secp112r1Holder.Instance);
  920. DefineCurve("secp112r2", SecObjectIdentifiers.SecP112r2, Secp112r2Holder.Instance);
  921. DefineCurve("secp128r1", SecObjectIdentifiers.SecP128r1, Secp128r1Holder.Instance);
  922. DefineCurve("secp128r2", SecObjectIdentifiers.SecP128r2, Secp128r2Holder.Instance);
  923. DefineCurve("secp160k1", SecObjectIdentifiers.SecP160k1, Secp160k1Holder.Instance);
  924. DefineCurve("secp160r1", SecObjectIdentifiers.SecP160r1, Secp160r1Holder.Instance);
  925. DefineCurve("secp160r2", SecObjectIdentifiers.SecP160r2, Secp160r2Holder.Instance);
  926. DefineCurve("secp192k1", SecObjectIdentifiers.SecP192k1, Secp192k1Holder.Instance);
  927. DefineCurve("secp192r1", SecObjectIdentifiers.SecP192r1, Secp192r1Holder.Instance);
  928. DefineCurve("secp224k1", SecObjectIdentifiers.SecP224k1, Secp224k1Holder.Instance);
  929. DefineCurve("secp224r1", SecObjectIdentifiers.SecP224r1, Secp224r1Holder.Instance);
  930. DefineCurve("secp256k1", SecObjectIdentifiers.SecP256k1, Secp256k1Holder.Instance);
  931. DefineCurve("secp256r1", SecObjectIdentifiers.SecP256r1, Secp256r1Holder.Instance);
  932. DefineCurve("secp384r1", SecObjectIdentifiers.SecP384r1, Secp384r1Holder.Instance);
  933. DefineCurve("secp521r1", SecObjectIdentifiers.SecP521r1, Secp521r1Holder.Instance);
  934. DefineCurve("sect113r1", SecObjectIdentifiers.SecT113r1, Sect113r1Holder.Instance);
  935. DefineCurve("sect113r2", SecObjectIdentifiers.SecT113r2, Sect113r2Holder.Instance);
  936. DefineCurve("sect131r1", SecObjectIdentifiers.SecT131r1, Sect131r1Holder.Instance);
  937. DefineCurve("sect131r2", SecObjectIdentifiers.SecT131r2, Sect131r2Holder.Instance);
  938. DefineCurve("sect163k1", SecObjectIdentifiers.SecT163k1, Sect163k1Holder.Instance);
  939. DefineCurve("sect163r1", SecObjectIdentifiers.SecT163r1, Sect163r1Holder.Instance);
  940. DefineCurve("sect163r2", SecObjectIdentifiers.SecT163r2, Sect163r2Holder.Instance);
  941. DefineCurve("sect193r1", SecObjectIdentifiers.SecT193r1, Sect193r1Holder.Instance);
  942. DefineCurve("sect193r2", SecObjectIdentifiers.SecT193r2, Sect193r2Holder.Instance);
  943. DefineCurve("sect233k1", SecObjectIdentifiers.SecT233k1, Sect233k1Holder.Instance);
  944. DefineCurve("sect233r1", SecObjectIdentifiers.SecT233r1, Sect233r1Holder.Instance);
  945. DefineCurve("sect239k1", SecObjectIdentifiers.SecT239k1, Sect239k1Holder.Instance);
  946. DefineCurve("sect283k1", SecObjectIdentifiers.SecT283k1, Sect283k1Holder.Instance);
  947. DefineCurve("sect283r1", SecObjectIdentifiers.SecT283r1, Sect283r1Holder.Instance);
  948. DefineCurve("sect409k1", SecObjectIdentifiers.SecT409k1, Sect409k1Holder.Instance);
  949. DefineCurve("sect409r1", SecObjectIdentifiers.SecT409r1, Sect409r1Holder.Instance);
  950. DefineCurve("sect571k1", SecObjectIdentifiers.SecT571k1, Sect571k1Holder.Instance);
  951. DefineCurve("sect571r1", SecObjectIdentifiers.SecT571r1, Sect571r1Holder.Instance);
  952. }
  953. /// <summary>Look up the <see cref="X9ECParameters"/> for the curve with the given name.</summary>
  954. /// <param name="name">The name of the curve.</param>
  955. public static X9ECParameters GetByName(string name)
  956. {
  957. DerObjectIdentifier oid = GetOid(name);
  958. return oid == null ? null : GetByOid(oid);
  959. }
  960. /// <summary>Look up an <see cref="X9ECParametersHolder"/> for the curve with the given name.</summary>
  961. /// <remarks>
  962. /// Allows accessing the <see cref="ECCurve">curve</see> without necessarily triggering the creation of the
  963. /// full <see cref="X9ECParameters"/>.
  964. /// </remarks>
  965. /// <param name="name">The name of the curve.</param>
  966. public static X9ECParametersHolder GetByNameLazy(string name)
  967. {
  968. DerObjectIdentifier oid = GetOid(name);
  969. return oid == null ? null : GetByOidLazy(oid);
  970. }
  971. /// <summary>Look up the <see cref="X9ECParameters"/> for the curve with the given
  972. /// <see cref="DerObjectIdentifier">OID</see>.</summary>
  973. /// <param name="oid">The <see cref="DerObjectIdentifier">OID</see> for the curve.</param>
  974. public static X9ECParameters GetByOid(DerObjectIdentifier oid)
  975. {
  976. return GetByOidLazy(oid)?.Parameters;
  977. }
  978. /// <summary>Look up an <see cref="X9ECParametersHolder"/> for the curve with the given
  979. /// <see cref="DerObjectIdentifier">OID</see>.</summary>
  980. /// <remarks>
  981. /// Allows accessing the <see cref="ECCurve">curve</see> without necessarily triggering the creation of the
  982. /// full <see cref="X9ECParameters"/>.
  983. /// </remarks>
  984. /// <param name="oid">The <see cref="DerObjectIdentifier">OID</see> for the curve.</param>
  985. public static X9ECParametersHolder GetByOidLazy(DerObjectIdentifier oid)
  986. {
  987. return CollectionUtilities.GetValueOrNull(curves, oid);
  988. }
  989. /// <summary>Look up the name of the curve with the given <see cref="DerObjectIdentifier">OID</see>.</summary>
  990. /// <param name="oid">The <see cref="DerObjectIdentifier">OID</see> for the curve.</param>
  991. public static string GetName(DerObjectIdentifier oid)
  992. {
  993. return CollectionUtilities.GetValueOrNull(names, oid);
  994. }
  995. /// <summary>Look up the <see cref="DerObjectIdentifier">OID</see> of the curve with the given name.</summary>
  996. /// <param name="name">The name of the curve.</param>
  997. public static DerObjectIdentifier GetOid(string name)
  998. {
  999. return CollectionUtilities.GetValueOrNull(objIds, name);
  1000. }
  1001. /// <summary>Enumerate the available curve names in this registry.</summary>
  1002. public static IEnumerable<string> Names
  1003. {
  1004. get { return CollectionUtilities.Proxy(objIds.Keys); }
  1005. }
  1006. }
  1007. }
  1008. #pragma warning restore
  1009. #endif