开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
bn_nist.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：22k
源码类别：

其他游戏

开发平台：

Visual C++

bn_nist.c：源码内容
  1. /* crypto/bn/bn_nist.c */
  2. /*
  3.  * Written by Nils Larsch for the OpenSSL project
  4.  */
  5. /* ====================================================================
  6.  * Copyright (c) 1998-2005 The OpenSSL Project.  All rights reserved.
  7.  *
  8.  * Redistribution and use in source and binary forms, with or without
  9.  * modification, are permitted provided that the following conditions
  10.  * are met:
  11.  *
  12.  * 1. Redistributions of source code must retain the above copyright
  13.  *    notice, this list of conditions and the following disclaimer. 
  14.  *
  15.  * 2. Redistributions in binary form must reproduce the above copyright
  16.  *    notice, this list of conditions and the following disclaimer in
  17.  *    the documentation and/or other materials provided with the
  18.  *    distribution.
  19.  *
  20.  * 3. All advertising materials mentioning features or use of this
  21.  *    software must display the following acknowledgment:
  22.  *    "This product includes software developed by the OpenSSL Project
  23.  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  24.  *
  25.  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  26.  *    endorse or promote products derived from this software without
  27.  *    prior written permission. For written permission, please contact
  28.  *    openssl-core@openssl.org.
  29.  *
  30.  * 5. Products derived from this software may not be called "OpenSSL"
  31.  *    nor may "OpenSSL" appear in their names without prior written
  32.  *    permission of the OpenSSL Project.
  33.  *
  34.  * 6. Redistributions of any form whatsoever must retain the following
  35.  *    acknowledgment:
  36.  *    "This product includes software developed by the OpenSSL Project
  37.  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  38.  *
  39.  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  40.  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  41.  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  42.  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  43.  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  44.  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  45.  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  46.  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  47.  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  48.  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  49.  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  50.  * OF THE POSSIBILITY OF SUCH DAMAGE.
  51.  * ====================================================================
  52.  *
  53.  * This product includes cryptographic software written by Eric Young
  54.  * (eay@cryptsoft.com).  This product includes software written by Tim
  55.  * Hudson (tjh@cryptsoft.com).
  56.  *
  57.  */
  59. #include "bn_lcl.h"
  60. #include "cryptlib.h"
  62. #define BN_NIST_192_TOP (192+BN_BITS2-1)/BN_BITS2
  63. #define BN_NIST_224_TOP (224+BN_BITS2-1)/BN_BITS2
  64. #define BN_NIST_256_TOP (256+BN_BITS2-1)/BN_BITS2
  65. #define BN_NIST_384_TOP (384+BN_BITS2-1)/BN_BITS2
  66. #define BN_NIST_521_TOP (521+BN_BITS2-1)/BN_BITS2
  68. #if BN_BITS2 == 64
  69. static const BN_ULONG _nist_p_192[] =
  70. {0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFEULL,
  71. 0xFFFFFFFFFFFFFFFFULL};
  72. static const BN_ULONG _nist_p_224[] =
  73. {0x0000000000000001ULL,0xFFFFFFFF00000000ULL,
  74. 0xFFFFFFFFFFFFFFFFULL,0x00000000FFFFFFFFULL};
  75. static const BN_ULONG _nist_p_256[] =
  76. {0xFFFFFFFFFFFFFFFFULL,0x00000000FFFFFFFFULL,
  77. 0x0000000000000000ULL,0xFFFFFFFF00000001ULL};
  78. static const BN_ULONG _nist_p_384[] =
  79. {0x00000000FFFFFFFFULL,0xFFFFFFFF00000000ULL,
  80. 0xFFFFFFFFFFFFFFFEULL,0xFFFFFFFFFFFFFFFFULL,
  81. 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL};
  82. static const BN_ULONG _nist_p_521[] =
  83. {0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,
  84. 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,
  85. 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,
  86. 0xFFFFFFFFFFFFFFFFULL,0xFFFFFFFFFFFFFFFFULL,
  87. 0x00000000000001FFULL};
  88. #elif BN_BITS2 == 32
  89. static const BN_ULONG _nist_p_192[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFE,
  90. 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
  91. static const BN_ULONG _nist_p_224[] = {0x00000001,0x00000000,0x00000000,
  92. 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
  93. static const BN_ULONG _nist_p_256[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
  94. 0x00000000,0x00000000,0x00000000,0x00000001,0xFFFFFFFF};
  95. static const BN_ULONG _nist_p_384[] = {0xFFFFFFFF,0x00000000,0x00000000,
  96. 0xFFFFFFFF,0xFFFFFFFE,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
  97. 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF};
  98. static const BN_ULONG _nist_p_521[] = {0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
  99. 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
  100. 0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,0xFFFFFFFF,
  101. 0xFFFFFFFF,0x000001FF};
  102. #elif BN_BITS2 == 16
  103. static const BN_ULONG _nist_p_192[] = {0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFE,
  104. 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF};
  105. static const BN_ULONG _nist_p_224[] = {0x0001,0x0000,0x0000,0x0000,0x0000,
  106. 0x0000,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF};
  107. static const BN_ULONG _nist_p_256[] = {0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
  108. 0xFFFF,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,0xFFFF,
  109. 0xFFFF};
  110. static const BN_ULONG _nist_p_384[] = {0xFFFF,0xFFFF,0x0000,0x0000,0x0000,
  111. 0x0000,0xFFFF,0xFFFF,0xFFFE,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
  112. 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF};
  113. static const BN_ULONG _nist_p_521[] = {0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
  114. 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
  115. 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,
  116. 0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0xFFFF,0x01FF};
  117. #elif BN_BITS2 == 8
  118. static const BN_ULONG _nist_p_192[] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  119. 0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  120. 0xFF,0xFF};
  121. static const BN_ULONG _nist_p_224[] = {0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  122. 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  123. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
  124. static const BN_ULONG _nist_p_256[] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  125. 0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  126. 0x00,0x00,0x01,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF};
  127. static const BN_ULONG _nist_p_384[] = {0xFF,0xFF,0xFF,0xFF,0x00,0x00,0x00,0x00,
  128. 0x00,0x00,0x00,0x00,0xFF,0xFF,0xFF,0xFF,0xFE,0xFF,0xFF,0xFF,0xFF,0xFF,
  129. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  130. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF};
  131. static const BN_ULONG _nist_p_521[] = {0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  132. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  133. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  134. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  135. 0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,0xFF,
  136. 0xFF,0x01};
  137. #endif
  139. const BIGNUM *BN_get0_nist_prime_192(void)
  140. {
  141. static BIGNUM const_nist_192 = { (BN_ULONG *)_nist_p_192,
  142. BN_NIST_192_TOP, BN_NIST_192_TOP, 0, BN_FLG_STATIC_DATA };
  143. return &const_nist_192;
  144. }
  146. const BIGNUM *BN_get0_nist_prime_224(void)
  147. {
  148. static BIGNUM const_nist_224 = { (BN_ULONG *)_nist_p_224,
  149. BN_NIST_224_TOP, BN_NIST_224_TOP, 0, BN_FLG_STATIC_DATA };
  150. return &const_nist_224;
  151. }
  153. const BIGNUM *BN_get0_nist_prime_256(void)
  154. {
  155. static BIGNUM const_nist_256 = { (BN_ULONG *)_nist_p_256,
  156. BN_NIST_256_TOP, BN_NIST_256_TOP, 0, BN_FLG_STATIC_DATA };
  157. return &const_nist_256;
  158. }
  160. const BIGNUM *BN_get0_nist_prime_384(void)
  161. {
  162. static BIGNUM const_nist_384 = { (BN_ULONG *)_nist_p_384,
  163. BN_NIST_384_TOP, BN_NIST_384_TOP, 0, BN_FLG_STATIC_DATA };
  164. return &const_nist_384;
  165. }
  167. const BIGNUM *BN_get0_nist_prime_521(void)
  168. {
  169. static BIGNUM const_nist_521 = { (BN_ULONG *)_nist_p_521,
  170. BN_NIST_521_TOP, BN_NIST_521_TOP, 0, BN_FLG_STATIC_DATA };
  171. return &const_nist_521;
  172. }
  174. /* some misc internal functions */
  175. #if BN_BITS2 != 64
  176. static BN_ULONG _256_data[BN_NIST_256_TOP*6];
  177. static int _is_set_256_data = 0;
  178. static void _init_256_data(void);
  180. static BN_ULONG _384_data[BN_NIST_384_TOP*8];
  181. static int _is_set_384_data = 0;
  182. static void _init_384_data(void);
  183. #endif
  185. #define BN_NIST_ADD_ONE(a) while (!(++(*(a)))) ++(a);
  187. static void nist_cp_bn_0(BN_ULONG *buf, BN_ULONG *a, int top, int max)
  188.         {
  189. int i;
  190.         BN_ULONG *_tmp1 = (buf), *_tmp2 = (a);
  191.         for (i = (top); i != 0; i--)
  192.                 *_tmp1++ = *_tmp2++;
  193.         for (i = (max) - (top); i != 0; i--)
  194.                 *_tmp1++ = (BN_ULONG) 0;
  195.         }
  197. static void nist_cp_bn(BN_ULONG *buf, BN_ULONG *a, int top)
  198.         { 
  199. int i;
  200.         BN_ULONG *_tmp1 = (buf), *_tmp2 = (a);
  201.         for (i = (top); i != 0; i--)
  202.                 *_tmp1++ = *_tmp2++;
  203.         }
  205. #if BN_BITS2 == 64
  206. #define bn_cp_64(to, n, from, m) (to)[n] = (from)[m];
  207. #define bn_64_set_0(to, n) (to)[n] = (BN_ULONG)0;
  208. /* TBD */
  209. #define bn_cp_32(to, n, from, m) (to)[n] = (from)[m];
  210. #define bn_32_set_0(to, n) (to)[n] = (BN_ULONG)0;
  211. #else
  212. #define bn_cp_64(to, n, from, m) 
  213. { 
  214. bn_cp_32(to, (n)*2, from, (m)*2); 
  215. bn_cp_32(to, (n)*2+1, from, (m)*2+1); 
  216. }
  217. #define bn_64_set_0(to, n) 
  218. { 
  219. bn_32_set_0(to, (n)*2); 
  220. bn_32_set_0(to, (n)*2+1); 
  221. }
  222. #if BN_BITS2 == 32
  223. #define bn_cp_32(to, n, from, m) (to)[n] = (from)[m];
  224. #define bn_32_set_0(to, n) (to)[n] = (BN_ULONG)0;
  225. #elif BN_BITS2 == 16
  226. #define bn_cp_32(to, n, from, m) 
  227. { 
  228. (to)[(n)*2]   = (from)[(m)*2];  
  229. (to)[(n)*2+1] = (from)[(m)*2+1];
  230. }
  231. #define bn_32_set_0(to, n) { (to)[(n)*2] = 0; (to)[(n)*2+1] = 0; }
  232. #elif BN_BITS2 == 8
  233. #define bn_cp_32(to, n, from, m) 
  234. { 
  235. (to)[(n)*4]   = (from)[(m)*4];  
  236. (to)[(n)*4+1] = (from)[(m)*4+1];
  237. (to)[(n)*4+2] = (from)[(m)*4+2];
  238. (to)[(n)*4+3] = (from)[(m)*4+3];
  239. }
  240. #define bn_32_set_0(to, n) 
  241. { (to)[(n)*4]   = (BN_ULONG)0; (to)[(n)*4+1] = (BN_ULONG)0; 
  242.   (to)[(n)*4+2] = (BN_ULONG)0; (to)[(n)*4+3] = (BN_ULONG)0; }
  243. #endif
  244. #endif /* BN_BITS2 != 64 */
  247. #define nist_set_192(to, from, a1, a2, a3) 
  248. { 
  249. if (a3 != 0) bn_cp_64(to, 0, from, (a3) - 3) else bn_64_set_0(to, 0)
  250. bn_cp_64(to, 1, from, (a2) - 3) 
  251. if (a1 != 0) bn_cp_64(to, 2, from, (a1) - 3) else bn_64_set_0(to, 2)
  252. }
  254. int BN_nist_mod_192(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
  255. BN_CTX *ctx)
  256. {
  257. int      top = a->top, i;
  258. BN_ULONG carry = 0;
  259. register BN_ULONG *r_d, *a_d = a->d;
  260. BN_ULONG t_d[BN_NIST_192_TOP],
  261.          buf[BN_NIST_192_TOP];
  263. i = BN_ucmp(field, a);
  264. if (i == 0)
  265. {
  266. BN_zero(r);
  267. return 1;
  268. }
  269. else if (i > 0)
  270. return (r == a) ? 1 : (BN_copy(r ,a) != NULL);
  272. if (top == BN_NIST_192_TOP)
  273. return BN_usub(r, a, field);
  275. if (r != a)
  276. {
  277. if (!bn_wexpand(r, BN_NIST_192_TOP))
  278. return 0;
  279. r_d = r->d;
  280. nist_cp_bn(r_d, a_d, BN_NIST_192_TOP);
  281. }
  282. else
  283. r_d = a_d;
  285. nist_cp_bn_0(buf, a_d + BN_NIST_192_TOP, top - BN_NIST_192_TOP, BN_NIST_192_TOP);
  287. #if defined(OPENSSL_SYS_VMS) && defined(__DECC)
  288. # pragma message save
  289. # pragma message disable BADSUBSCRIPT
  290. #endif
  292. nist_set_192(t_d, buf, 0, 3, 3);
  293. if (bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP))
  294. ++carry;
  296. nist_set_192(t_d, buf, 4, 4, 0);
  297. if (bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP))
  298. ++carry;
  300. #if defined(OPENSSL_SYS_VMS) && defined(__DECC)
  301. # pragma message restore
  302. #endif
  304. nist_set_192(t_d, buf, 5, 5, 5)
  305. if (bn_add_words(r_d, r_d, t_d, BN_NIST_192_TOP))
  306. ++carry;
  308. while (carry)
  309. {
  310. if (bn_sub_words(r_d, r_d, _nist_p_192, BN_NIST_192_TOP))
  311. --carry; 
  312. }
  313. r->top = BN_NIST_192_TOP;
  314. bn_correct_top(r);
  315. if (BN_ucmp(r, field) >= 0)
  316. {
  317. bn_sub_words(r_d, r_d, _nist_p_192, BN_NIST_192_TOP);
  318. bn_correct_top(r);
  319. }
  321. bn_check_top(r);
  322. return 1;
  323. }
  325. #define nist_set_224(to, from, a1, a2, a3, a4, a5, a6, a7) 
  326. { 
  327. if (a7 != 0) bn_cp_32(to, 0, from, (a7) - 7) else bn_32_set_0(to, 0)
  328. if (a6 != 0) bn_cp_32(to, 1, from, (a6) - 7) else bn_32_set_0(to, 1)
  329. if (a5 != 0) bn_cp_32(to, 2, from, (a5) - 7) else bn_32_set_0(to, 2)
  330. if (a4 != 0) bn_cp_32(to, 3, from, (a4) - 7) else bn_32_set_0(to, 3)
  331. if (a3 != 0) bn_cp_32(to, 4, from, (a3) - 7) else bn_32_set_0(to, 4)
  332. if (a2 != 0) bn_cp_32(to, 5, from, (a2) - 7) else bn_32_set_0(to, 5)
  333. if (a1 != 0) bn_cp_32(to, 6, from, (a1) - 7) else bn_32_set_0(to, 6)
  334. }
  336. int BN_nist_mod_224(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
  337. BN_CTX *ctx)
  338. {
  339. #if BN_BITS2 != 64
  340. int top = a->top, i;
  341. int carry = 0;
  342. BN_ULONG *r_d, *a_d = a->d;
  343. BN_ULONG t_d[BN_NIST_224_TOP],
  344.          buf[BN_NIST_224_TOP];
  346. i = BN_ucmp(field, a);
  347. if (i == 0)
  348. {
  349. BN_zero(r);
  350. return 1;
  351. }
  352. else if (i > 0)
  353. return (r == a)? 1 : (BN_copy(r ,a) != NULL);
  355. if (top == BN_NIST_224_TOP)
  356. return BN_usub(r, a, field);
  358. if (r != a)
  359. {
  360. if (!bn_wexpand(r, BN_NIST_224_TOP))
  361. return 0;
  362. r_d = r->d;
  363. nist_cp_bn(r_d, a_d, BN_NIST_224_TOP);
  364. }
  365. else
  366. r_d = a_d;
  368. nist_cp_bn_0(buf, a_d + BN_NIST_224_TOP, top - BN_NIST_224_TOP, BN_NIST_224_TOP);
  370. nist_set_224(t_d, buf, 10, 9, 8, 7, 0, 0, 0);
  371. if (bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP))
  372. ++carry;
  373. nist_set_224(t_d, buf, 0, 13, 12, 11, 0, 0, 0);
  374. if (bn_add_words(r_d, r_d, t_d, BN_NIST_224_TOP))
  375. ++carry;
  376. nist_set_224(t_d, buf, 13, 12, 11, 10, 9, 8, 7);
  377. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP))
  378. --carry;
  379. nist_set_224(t_d, buf, 0, 0, 0, 0, 13, 12, 11);
  380. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_224_TOP))
  381. --carry;
  383. if (carry > 0)
  384. while (carry)
  385. {
  386. if (bn_sub_words(r_d,r_d,_nist_p_224,BN_NIST_224_TOP))
  387. --carry;
  388. }
  389. else if (carry < 0)
  390. while (carry)
  391. {
  392. if (bn_add_words(r_d,r_d,_nist_p_224,BN_NIST_224_TOP))
  393. ++carry;
  394. }
  396. r->top = BN_NIST_224_TOP;
  397. bn_correct_top(r);
  398. if (BN_ucmp(r, field) >= 0)
  399. {
  400. bn_sub_words(r_d, r_d, _nist_p_224, BN_NIST_224_TOP);
  401. bn_correct_top(r);
  402. }
  403. bn_check_top(r);
  404. return 1;
  405. #else
  406. return 0;
  407. #endif
  408. }
  410. #if BN_BITS2 != 64
  411. static void _init_256_data(void)
  412. {
  413. int i;
  414. BN_ULONG *tmp1 = _256_data;
  415. const BN_ULONG *tmp2 = tmp1;
  417. memcpy(tmp1, _nist_p_256, BN_NIST_256_TOP * sizeof(BN_ULONG));
  418. tmp1 += BN_NIST_256_TOP;
  420. for (i=0; i<5; i++)
  421. {
  422. bn_add_words(tmp1, _nist_p_256, tmp2, BN_NIST_256_TOP);
  423. tmp2  = tmp1;
  424. tmp1 += BN_NIST_256_TOP;
  425. }
  426. _is_set_256_data = 1;
  427. }
  428. #endif
  430. #define nist_set_256(to, from, a1, a2, a3, a4, a5, a6, a7, a8) 
  431. { 
  432. if (a8 != 0) bn_cp_32(to, 0, from, (a8) - 8) else bn_32_set_0(to, 0)
  433. if (a7 != 0) bn_cp_32(to, 1, from, (a7) - 8) else bn_32_set_0(to, 1)
  434. if (a6 != 0) bn_cp_32(to, 2, from, (a6) - 8) else bn_32_set_0(to, 2)
  435. if (a5 != 0) bn_cp_32(to, 3, from, (a5) - 8) else bn_32_set_0(to, 3)
  436. if (a4 != 0) bn_cp_32(to, 4, from, (a4) - 8) else bn_32_set_0(to, 4)
  437. if (a3 != 0) bn_cp_32(to, 5, from, (a3) - 8) else bn_32_set_0(to, 5)
  438. if (a2 != 0) bn_cp_32(to, 6, from, (a2) - 8) else bn_32_set_0(to, 6)
  439. if (a1 != 0) bn_cp_32(to, 7, from, (a1) - 8) else bn_32_set_0(to, 7)
  440. }
  442. int BN_nist_mod_256(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
  443. BN_CTX *ctx)
  444. {
  445. #if BN_BITS2 != 64
  446. int i, top = a->top;
  447. int carry = 0;
  448. register BN_ULONG *a_d = a->d, *r_d;
  449. BN_ULONG t_d[BN_NIST_256_TOP],
  450.          t_d2[BN_NIST_256_TOP],
  451.          buf[BN_NIST_256_TOP];
  453. if (!_is_set_256_data)
  454. {
  455. CRYPTO_w_lock(CRYPTO_LOCK_BN);
  457. if (!_is_set_256_data)
  458. _init_256_data();
  460. CRYPTO_w_unlock(CRYPTO_LOCK_BN);
  461. }
  463. i = BN_ucmp(field, a);
  464. if (i == 0)
  465. {
  466. BN_zero(r);
  467. return 1;
  468. }
  469. else if (i > 0)
  470. return (r == a)? 1 : (BN_copy(r ,a) != NULL);
  472. if (top == BN_NIST_256_TOP)
  473. return BN_usub(r, a, field);
  475. if (r != a)
  476. {
  477. if (!bn_wexpand(r, BN_NIST_256_TOP))
  478. return 0;
  479. r_d = r->d;
  480. nist_cp_bn(r_d, a_d, BN_NIST_256_TOP);
  481. }
  482. else
  483. r_d = a_d;
  485. nist_cp_bn_0(buf, a_d + BN_NIST_256_TOP, top - BN_NIST_256_TOP, BN_NIST_256_TOP);
  487. /*S1*/
  488. nist_set_256(t_d, buf, 15, 14, 13, 12, 11, 0, 0, 0);
  489. /*S2*/
  490. nist_set_256(t_d2,buf, 0, 15, 14, 13, 12, 0, 0, 0);
  491. if (bn_add_words(t_d, t_d, t_d2, BN_NIST_256_TOP))
  492. carry = 2;
  493. /* left shift */
  494. {
  495. register BN_ULONG *ap,t,c;
  496. ap = t_d;
  497. c=0;
  498. for (i = BN_NIST_256_TOP; i != 0; --i)
  499. {
  500. t= *ap;
  501. *(ap++)=((t<<1)|c)&BN_MASK2;
  502. c=(t & BN_TBIT)?1:0;
  503. }
  504. if (c)
  505. ++carry;
  506. }
  508. if (bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  509. ++carry;
  510. /*S3*/
  511. nist_set_256(t_d, buf, 15, 14, 0, 0, 0, 10, 9, 8);
  512. if (bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  513. ++carry;
  514. /*S4*/
  515. nist_set_256(t_d, buf, 8, 13, 15, 14, 13, 11, 10, 9);
  516. if (bn_add_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  517. ++carry;
  518. /*D1*/
  519. nist_set_256(t_d, buf, 10, 8, 0, 0, 0, 13, 12, 11);
  520. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  521. --carry;
  522. /*D2*/
  523. nist_set_256(t_d, buf, 11, 9, 0, 0, 15, 14, 13, 12);
  524. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  525. --carry;
  526. /*D3*/
  527. nist_set_256(t_d, buf, 12, 0, 10, 9, 8, 15, 14, 13);
  528. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  529. --carry;
  530. /*D4*/
  531. nist_set_256(t_d, buf, 13, 0, 11, 10, 9, 0, 15, 14);
  532. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_256_TOP))
  533. --carry;
  535. if (carry)
  536. {
  537. if (carry > 0)
  538. bn_sub_words(r_d, r_d, _256_data + BN_NIST_256_TOP *
  539. --carry, BN_NIST_256_TOP);
  540. else
  541. {
  542. carry = -carry;
  543. bn_add_words(r_d, r_d, _256_data + BN_NIST_256_TOP *
  544. --carry, BN_NIST_256_TOP);
  545. }
  546. }
  548. r->top = BN_NIST_256_TOP;
  549. bn_correct_top(r);
  550. if (BN_ucmp(r, field) >= 0)
  551. {
  552. bn_sub_words(r_d, r_d, _nist_p_256, BN_NIST_256_TOP);
  553. bn_correct_top(r);
  554. }
  555. bn_check_top(r);
  556. return 1;
  557. #else
  558. return 0;
  559. #endif
  560. }
  562. #if BN_BITS2 != 64
  563. static void _init_384_data(void)
  564. {
  565. int i;
  566. BN_ULONG *tmp1 = _384_data;
  567. const BN_ULONG *tmp2 = tmp1;
  569. memcpy(tmp1, _nist_p_384, BN_NIST_384_TOP * sizeof(BN_ULONG));
  570. tmp1 += BN_NIST_384_TOP;
  572. for (i=0; i<7; i++)
  573. {
  574. bn_add_words(tmp1, _nist_p_384, tmp2, BN_NIST_384_TOP);
  575. tmp2  = tmp1;
  576. tmp1 += BN_NIST_384_TOP;
  577. }
  578. _is_set_384_data = 1;
  579. }
  580. #endif
  582. #define nist_set_384(to,from,a1,a2,a3,a4,a5,a6,a7,a8,a9,a10,a11,a12) 
  583. { 
  584. if (a12 != 0) bn_cp_32(to, 0, from,  (a12) - 12) else bn_32_set_0(to, 0)
  585. if (a11 != 0) bn_cp_32(to, 1, from,  (a11) - 12) else bn_32_set_0(to, 1)
  586. if (a10 != 0) bn_cp_32(to, 2, from,  (a10) - 12) else bn_32_set_0(to, 2)
  587. if (a9 != 0)  bn_cp_32(to, 3, from,  (a9) - 12)  else bn_32_set_0(to, 3)
  588. if (a8 != 0)  bn_cp_32(to, 4, from,  (a8) - 12)  else bn_32_set_0(to, 4)
  589. if (a7 != 0)  bn_cp_32(to, 5, from,  (a7) - 12)  else bn_32_set_0(to, 5)
  590. if (a6 != 0)  bn_cp_32(to, 6, from,  (a6) - 12)  else bn_32_set_0(to, 6)
  591. if (a5 != 0)  bn_cp_32(to, 7, from,  (a5) - 12)  else bn_32_set_0(to, 7)
  592. if (a4 != 0)  bn_cp_32(to, 8, from,  (a4) - 12)  else bn_32_set_0(to, 8)
  593. if (a3 != 0)  bn_cp_32(to, 9, from,  (a3) - 12)  else bn_32_set_0(to, 9)
  594. if (a2 != 0)  bn_cp_32(to, 10, from, (a2) - 12)  else bn_32_set_0(to, 10)
  595. if (a1 != 0)  bn_cp_32(to, 11, from, (a1) - 12)  else bn_32_set_0(to, 11)
  596. }
  598. int BN_nist_mod_384(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
  599. BN_CTX *ctx)
  600. {
  601. #if BN_BITS2 != 64
  602. int i, top = a->top;
  603. int carry = 0;
  604. register BN_ULONG *r_d, *a_d = a->d;
  605. BN_ULONG t_d[BN_NIST_384_TOP],
  606.          buf[BN_NIST_384_TOP];
  608. if (!_is_set_384_data)
  609. {
  610. CRYPTO_w_lock(CRYPTO_LOCK_BN);
  612. if (!_is_set_384_data)
  613. _init_384_data();
  615. CRYPTO_w_unlock(CRYPTO_LOCK_BN);
  616. }
  618. i = BN_ucmp(field, a);
  619. if (i == 0)
  620. {
  621. BN_zero(r);
  622. return 1;
  623. }
  624. else if (i > 0)
  625. return (r == a)? 1 : (BN_copy(r ,a) != NULL);
  627. if (top == BN_NIST_384_TOP)
  628. return BN_usub(r, a, field);
  630. if (r != a)
  631. {
  632. if (!bn_wexpand(r, BN_NIST_384_TOP))
  633. return 0;
  634. r_d = r->d;
  635. nist_cp_bn(r_d, a_d, BN_NIST_384_TOP);
  636. }
  637. else
  638. r_d = a_d;
  640. nist_cp_bn_0(buf, a_d + BN_NIST_384_TOP, top - BN_NIST_384_TOP, BN_NIST_384_TOP);
  642. /*S1*/
  643. nist_set_256(t_d, buf, 0, 0, 0, 0, 0, 23-4, 22-4, 21-4);
  644. /* left shift */
  645. {
  646. register BN_ULONG *ap,t,c;
  647. ap = t_d;
  648. c=0;
  649. for (i = BN_NIST_256_TOP; i != 0; --i)
  650. {
  651. t= *ap;
  652. *(ap++)=((t<<1)|c)&BN_MASK2;
  653. c=(t & BN_TBIT)?1:0;
  654. }
  655. }
  656. if (bn_add_words(r_d+(128/BN_BITS2), r_d+(128/BN_BITS2), 
  657. t_d, BN_NIST_256_TOP))
  658. ++carry;
  659. /*S2 */
  660. if (bn_add_words(r_d, r_d, buf, BN_NIST_384_TOP))
  661. ++carry;
  662. /*S3*/
  663. nist_set_384(t_d,buf,20,19,18,17,16,15,14,13,12,23,22,21);
  664. if (bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP))
  665. ++carry;
  666. /*S4*/
  667. nist_set_384(t_d,buf,19,18,17,16,15,14,13,12,20,0,23,0);
  668. if (bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP))
  669. ++carry;
  670. /*S5*/
  671. nist_set_256(t_d, buf, 0, 0, 0, 0, 23-4, 22-4, 21-4, 20-4);
  672. if (bn_add_words(r_d+(128/BN_BITS2), r_d+(128/BN_BITS2), 
  673. t_d, BN_NIST_256_TOP))
  674. ++carry;
  675. /*S6*/
  676. nist_set_384(t_d,buf,0,0,0,0,0,0,23,22,21,0,0,20);
  677. if (bn_add_words(r_d, r_d, t_d, BN_NIST_384_TOP))
  678. ++carry;
  679. /*D1*/
  680. nist_set_384(t_d,buf,22,21,20,19,18,17,16,15,14,13,12,23);
  681. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP))
  682. --carry;
  683. /*D2*/
  684. nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,22,21,20,0);
  685. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP))
  686. --carry;
  687. /*D3*/
  688. nist_set_384(t_d,buf,0,0,0,0,0,0,0,23,23,0,0,0);
  689. if (bn_sub_words(r_d, r_d, t_d, BN_NIST_384_TOP))
  690. --carry;
  692. if (carry)
  693. {
  694. if (carry > 0)
  695. bn_sub_words(r_d, r_d, _384_data + BN_NIST_384_TOP *
  696. --carry, BN_NIST_384_TOP);
  697. else
  698. {
  699. carry = -carry;
  700. bn_add_words(r_d, r_d, _384_data + BN_NIST_384_TOP *
  701. --carry, BN_NIST_384_TOP);
  702. }
  703. }
  705. r->top = BN_NIST_384_TOP;
  706. bn_correct_top(r);
  707. if (BN_ucmp(r, field) >= 0)
  708. {
  709. bn_sub_words(r_d, r_d, _nist_p_384, BN_NIST_384_TOP);
  710. bn_correct_top(r);
  711. }
  712. bn_check_top(r);
  713. return 1;
  714. #else
  715. return 0;
  716. #endif
  717. }
  719. int BN_nist_mod_521(BIGNUM *r, const BIGNUM *a, const BIGNUM *field,
  720. BN_CTX *ctx)
  721. {
  722. #if BN_BITS2 == 64
  723. #define BN_NIST_521_TOP_MASK (BN_ULONG)0x1FF
  724. #elif BN_BITS2 == 32
  725. #define BN_NIST_521_TOP_MASK (BN_ULONG)0x1FF
  726. #elif BN_BITS2 == 16
  727. #define BN_NIST_521_TOP_MASK (BN_ULONG)0x1FF
  728. #elif BN_BITS2 == 8
  729. #define BN_NIST_521_TOP_MASK (BN_ULONG)0x1
  730. #endif
  731. int top, ret = 0;
  732. BN_ULONG *r_d;
  733. BIGNUM *tmp;
  735. /* check whether a reduction is necessary */
  736. top = a->top;
  737. if (top < BN_NIST_521_TOP  || ( top == BN_NIST_521_TOP &&
  738.            (!(a->d[BN_NIST_521_TOP-1] & ~(BN_NIST_521_TOP_MASK)))))
  739. return (r == a)? 1 : (BN_copy(r ,a) != NULL);
  741. BN_CTX_start(ctx);
  742. tmp = BN_CTX_get(ctx);
  743. if (!tmp)
  744. goto err;
  746. if (!bn_wexpand(tmp, BN_NIST_521_TOP))
  747. goto err;
  748. nist_cp_bn(tmp->d, a->d, BN_NIST_521_TOP);
  750. tmp->top = BN_NIST_521_TOP;
  751.         tmp->d[BN_NIST_521_TOP-1]  &= BN_NIST_521_TOP_MASK;
  752. bn_correct_top(tmp);
  754. if (!BN_rshift(r, a, 521))
  755. goto err;
  757. if (!BN_uadd(r, tmp, r))
  758. goto err;
  759. top = r->top;
  760. r_d = r->d;
  761. if (top == BN_NIST_521_TOP  && 
  762.            (r_d[BN_NIST_521_TOP-1] & ~(BN_NIST_521_TOP_MASK)))
  763. {
  764. BN_NIST_ADD_ONE(r_d)
  765. r_d[BN_NIST_521_TOP-1] &= BN_NIST_521_TOP_MASK; 
  766. }
  767. bn_correct_top(r);
  769. ret = 1;
  770. err:
  771. BN_CTX_end(ctx);
  773. bn_check_top(r);
  774. return ret;
  775. }