OpenWrt – Blame information for rev 1
?pathlinks?
Rev | Author | Line No. | Line |
---|---|---|---|
1 | office | 1 | /* crypto/bn/bn_asm.c */ |
2 | /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) |
||
3 | * All rights reserved. |
||
4 | * |
||
5 | * This package is an SSL implementation written |
||
6 | * by Eric Young (eay@cryptsoft.com). |
||
7 | * The implementation was written so as to conform with Netscapes SSL. |
||
8 | * |
||
9 | * This library is free for commercial and non-commercial use as long as |
||
10 | * the following conditions are aheared to. The following conditions |
||
11 | * apply to all code found in this distribution, be it the RC4, RSA, |
||
12 | * lhash, DES, etc., code; not just the SSL code. The SSL documentation |
||
13 | * included with this distribution is covered by the same copyright terms |
||
14 | * except that the holder is Tim Hudson (tjh@cryptsoft.com). |
||
15 | * |
||
16 | * Copyright remains Eric Young's, and as such any Copyright notices in |
||
17 | * the code are not to be removed. |
||
18 | * If this package is used in a product, Eric Young should be given attribution |
||
19 | * as the author of the parts of the library used. |
||
20 | * This can be in the form of a textual message at program startup or |
||
21 | * in documentation (online or textual) provided with the package. |
||
22 | * |
||
23 | * Redistribution and use in source and binary forms, with or without |
||
24 | * modification, are permitted provided that the following conditions |
||
25 | * are met: |
||
26 | * 1. Redistributions of source code must retain the copyright |
||
27 | * notice, this list of conditions and the following disclaimer. |
||
28 | * 2. Redistributions in binary form must reproduce the above copyright |
||
29 | * notice, this list of conditions and the following disclaimer in the |
||
30 | * documentation and/or other materials provided with the distribution. |
||
31 | * 3. All advertising materials mentioning features or use of this software |
||
32 | * must display the following acknowledgement: |
||
33 | * "This product includes cryptographic software written by |
||
34 | * Eric Young (eay@cryptsoft.com)" |
||
35 | * The word 'cryptographic' can be left out if the rouines from the library |
||
36 | * being used are not cryptographic related :-). |
||
37 | * 4. If you include any Windows specific code (or a derivative thereof) from |
||
38 | * the apps directory (application code) you must include an acknowledgement: |
||
39 | * "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" |
||
40 | * |
||
41 | * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND |
||
42 | * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE |
||
43 | * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE |
||
44 | * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE |
||
45 | * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL |
||
46 | * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS |
||
47 | * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) |
||
48 | * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT |
||
49 | * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY |
||
50 | * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF |
||
51 | * SUCH DAMAGE. |
||
52 | * |
||
53 | * The licence and distribution terms for any publically available version or |
||
54 | * derivative of this code cannot be changed. i.e. this code cannot simply be |
||
55 | * copied and put under another distribution licence |
||
56 | * [including the GNU Public Licence.] |
||
57 | */ |
||
58 | |||
59 | #ifndef BN_DEBUG |
||
60 | # undef NDEBUG /* avoid conflicting definitions */ |
||
61 | # define NDEBUG |
||
62 | #endif |
||
63 | |||
64 | #include <stdio.h> |
||
65 | #include <assert.h> |
||
66 | #include "bn_lcl.h" |
||
67 | |||
68 | #if defined(BN_LLONG) || defined(BN_UMULT_HIGH) |
||
69 | |||
70 | BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) |
||
71 | { |
||
72 | BN_ULONG c1=0; |
||
73 | |||
74 | assert(num >= 0); |
||
75 | if (num <= 0) return(c1); |
||
76 | |||
77 | while (num&~3) |
||
78 | { |
||
79 | mul_add(rp[0],ap[0],w,c1); |
||
80 | mul_add(rp[1],ap[1],w,c1); |
||
81 | mul_add(rp[2],ap[2],w,c1); |
||
82 | mul_add(rp[3],ap[3],w,c1); |
||
83 | ap+=4; rp+=4; num-=4; |
||
84 | } |
||
85 | if (num) |
||
86 | { |
||
87 | mul_add(rp[0],ap[0],w,c1); if (--num==0) return c1; |
||
88 | mul_add(rp[1],ap[1],w,c1); if (--num==0) return c1; |
||
89 | mul_add(rp[2],ap[2],w,c1); return c1; |
||
90 | } |
||
91 | |||
92 | return(c1); |
||
93 | } |
||
94 | |||
95 | BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) |
||
96 | { |
||
97 | BN_ULONG c1=0; |
||
98 | |||
99 | assert(num >= 0); |
||
100 | if (num <= 0) return(c1); |
||
101 | |||
102 | while (num&~3) |
||
103 | { |
||
104 | mul(rp[0],ap[0],w,c1); |
||
105 | mul(rp[1],ap[1],w,c1); |
||
106 | mul(rp[2],ap[2],w,c1); |
||
107 | mul(rp[3],ap[3],w,c1); |
||
108 | ap+=4; rp+=4; num-=4; |
||
109 | } |
||
110 | if (num) |
||
111 | { |
||
112 | mul(rp[0],ap[0],w,c1); if (--num == 0) return c1; |
||
113 | mul(rp[1],ap[1],w,c1); if (--num == 0) return c1; |
||
114 | mul(rp[2],ap[2],w,c1); |
||
115 | } |
||
116 | return(c1); |
||
117 | } |
||
118 | |||
119 | void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n) |
||
120 | { |
||
121 | assert(n >= 0); |
||
122 | if (n <= 0) return; |
||
123 | while (n&~3) |
||
124 | { |
||
125 | sqr(r[0],r[1],a[0]); |
||
126 | sqr(r[2],r[3],a[1]); |
||
127 | sqr(r[4],r[5],a[2]); |
||
128 | sqr(r[6],r[7],a[3]); |
||
129 | a+=4; r+=8; n-=4; |
||
130 | } |
||
131 | if (n) |
||
132 | { |
||
133 | sqr(r[0],r[1],a[0]); if (--n == 0) return; |
||
134 | sqr(r[2],r[3],a[1]); if (--n == 0) return; |
||
135 | sqr(r[4],r[5],a[2]); |
||
136 | } |
||
137 | } |
||
138 | |||
139 | #else /* !(defined(BN_LLONG) || defined(BN_UMULT_HIGH)) */ |
||
140 | |||
141 | BN_ULONG bn_mul_add_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) |
||
142 | { |
||
143 | BN_ULONG c=0; |
||
144 | BN_ULONG bl,bh; |
||
145 | |||
146 | assert(num >= 0); |
||
147 | if (num <= 0) return((BN_ULONG)0); |
||
148 | |||
149 | bl=LBITS(w); |
||
150 | bh=HBITS(w); |
||
151 | |||
152 | for (;;) |
||
153 | { |
||
154 | mul_add(rp[0],ap[0],bl,bh,c); |
||
155 | if (--num == 0) break; |
||
156 | mul_add(rp[1],ap[1],bl,bh,c); |
||
157 | if (--num == 0) break; |
||
158 | mul_add(rp[2],ap[2],bl,bh,c); |
||
159 | if (--num == 0) break; |
||
160 | mul_add(rp[3],ap[3],bl,bh,c); |
||
161 | if (--num == 0) break; |
||
162 | ap+=4; |
||
163 | rp+=4; |
||
164 | } |
||
165 | return(c); |
||
166 | } |
||
167 | |||
168 | BN_ULONG bn_mul_words(BN_ULONG *rp, BN_ULONG *ap, int num, BN_ULONG w) |
||
169 | { |
||
170 | BN_ULONG carry=0; |
||
171 | BN_ULONG bl,bh; |
||
172 | |||
173 | assert(num >= 0); |
||
174 | if (num <= 0) return((BN_ULONG)0); |
||
175 | |||
176 | bl=LBITS(w); |
||
177 | bh=HBITS(w); |
||
178 | |||
179 | for (;;) |
||
180 | { |
||
181 | mul(rp[0],ap[0],bl,bh,carry); |
||
182 | if (--num == 0) break; |
||
183 | mul(rp[1],ap[1],bl,bh,carry); |
||
184 | if (--num == 0) break; |
||
185 | mul(rp[2],ap[2],bl,bh,carry); |
||
186 | if (--num == 0) break; |
||
187 | mul(rp[3],ap[3],bl,bh,carry); |
||
188 | if (--num == 0) break; |
||
189 | ap+=4; |
||
190 | rp+=4; |
||
191 | } |
||
192 | return(carry); |
||
193 | } |
||
194 | |||
195 | void bn_sqr_words(BN_ULONG *r, BN_ULONG *a, int n) |
||
196 | { |
||
197 | assert(n >= 0); |
||
198 | if (n <= 0) return; |
||
199 | for (;;) |
||
200 | { |
||
201 | sqr64(r[0],r[1],a[0]); |
||
202 | if (--n == 0) break; |
||
203 | |||
204 | sqr64(r[2],r[3],a[1]); |
||
205 | if (--n == 0) break; |
||
206 | |||
207 | sqr64(r[4],r[5],a[2]); |
||
208 | if (--n == 0) break; |
||
209 | |||
210 | sqr64(r[6],r[7],a[3]); |
||
211 | if (--n == 0) break; |
||
212 | |||
213 | a+=4; |
||
214 | r+=8; |
||
215 | } |
||
216 | } |
||
217 | |||
218 | #endif /* !(defined(BN_LLONG) || defined(BN_UMULT_HIGH)) */ |
||
219 | |||
220 | #if defined(BN_LLONG) && defined(BN_DIV2W) |
||
221 | |||
222 | BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d) |
||
223 | { |
||
224 | return((BN_ULONG)(((((BN_ULLONG)h)<<BN_BITS2)|l)/(BN_ULLONG)d)); |
||
225 | } |
||
226 | |||
227 | #else |
||
228 | |||
229 | /* Divide h,l by d and return the result. */ |
||
230 | /* I need to test this some more :-( */ |
||
231 | BN_ULONG bn_div_words(BN_ULONG h, BN_ULONG l, BN_ULONG d) |
||
232 | { |
||
233 | BN_ULONG dh,dl,q,ret=0,th,tl,t; |
||
234 | int i,count=2; |
||
235 | |||
236 | if (d == 0) return(BN_MASK2); |
||
237 | |||
238 | i=BN_num_bits_word(d); |
||
239 | assert((i == BN_BITS2) || (h > (BN_ULONG)1<<i)); |
||
240 | |||
241 | i=BN_BITS2-i; |
||
242 | if (h >= d) h-=d; |
||
243 | |||
244 | if (i) |
||
245 | { |
||
246 | d<<=i; |
||
247 | h=(h<<i)|(l>>(BN_BITS2-i)); |
||
248 | l<<=i; |
||
249 | } |
||
250 | dh=(d&BN_MASK2h)>>BN_BITS4; |
||
251 | dl=(d&BN_MASK2l); |
||
252 | for (;;) |
||
253 | { |
||
254 | if ((h>>BN_BITS4) == dh) |
||
255 | q=BN_MASK2l; |
||
256 | else |
||
257 | q=h/dh; |
||
258 | |||
259 | th=q*dh; |
||
260 | tl=dl*q; |
||
261 | for (;;) |
||
262 | { |
||
263 | t=h-th; |
||
264 | if ((t&BN_MASK2h) || |
||
265 | ((tl) <= ( |
||
266 | (t<<BN_BITS4)| |
||
267 | ((l&BN_MASK2h)>>BN_BITS4)))) |
||
268 | break; |
||
269 | q--; |
||
270 | th-=dh; |
||
271 | tl-=dl; |
||
272 | } |
||
273 | t=(tl>>BN_BITS4); |
||
274 | tl=(tl<<BN_BITS4)&BN_MASK2h; |
||
275 | th+=t; |
||
276 | |||
277 | if (l < tl) th++; |
||
278 | l-=tl; |
||
279 | if (h < th) |
||
280 | { |
||
281 | h+=d; |
||
282 | q--; |
||
283 | } |
||
284 | h-=th; |
||
285 | |||
286 | if (--count == 0) break; |
||
287 | |||
288 | ret=q<<BN_BITS4; |
||
289 | h=((h<<BN_BITS4)|(l>>BN_BITS4))&BN_MASK2; |
||
290 | l=(l&BN_MASK2l)<<BN_BITS4; |
||
291 | } |
||
292 | ret|=q; |
||
293 | return(ret); |
||
294 | } |
||
295 | #endif /* !defined(BN_LLONG) && defined(BN_DIV2W) */ |
||
296 | |||
297 | #ifdef BN_LLONG |
||
298 | BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n) |
||
299 | { |
||
300 | BN_ULLONG ll=0; |
||
301 | |||
302 | assert(n >= 0); |
||
303 | if (n <= 0) return((BN_ULONG)0); |
||
304 | |||
305 | for (;;) |
||
306 | { |
||
307 | ll+=(BN_ULLONG)a[0]+b[0]; |
||
308 | r[0]=(BN_ULONG)ll&BN_MASK2; |
||
309 | ll>>=BN_BITS2; |
||
310 | if (--n <= 0) break; |
||
311 | |||
312 | ll+=(BN_ULLONG)a[1]+b[1]; |
||
313 | r[1]=(BN_ULONG)ll&BN_MASK2; |
||
314 | ll>>=BN_BITS2; |
||
315 | if (--n <= 0) break; |
||
316 | |||
317 | ll+=(BN_ULLONG)a[2]+b[2]; |
||
318 | r[2]=(BN_ULONG)ll&BN_MASK2; |
||
319 | ll>>=BN_BITS2; |
||
320 | if (--n <= 0) break; |
||
321 | |||
322 | ll+=(BN_ULLONG)a[3]+b[3]; |
||
323 | r[3]=(BN_ULONG)ll&BN_MASK2; |
||
324 | ll>>=BN_BITS2; |
||
325 | if (--n <= 0) break; |
||
326 | |||
327 | a+=4; |
||
328 | b+=4; |
||
329 | r+=4; |
||
330 | } |
||
331 | return((BN_ULONG)ll); |
||
332 | } |
||
333 | #else /* !BN_LLONG */ |
||
334 | BN_ULONG bn_add_words(BN_ULONG *r, BN_ULONG *a, BN_ULONG *b, int n) |
||
335 | { |
||
336 | BN_ULONG c,l,t; |
||
337 | |||
338 | assert(n >= 0); |
||
339 | if (n <= 0) return((BN_ULONG)0); |
||
340 | |||
341 | c=0; |
||
342 | for (;;) |
||
343 | { |
||
344 | t=a[0]; |
||
345 | t=(t+c)&BN_MASK2; |
||
346 | c=(t < c); |
||
347 | l=(t+b[0])&BN_MASK2; |
||
348 | c+=(l < t); |
||
349 | r[0]=l; |
||
350 | if (--n <= 0) break; |
||
351 | |||
352 | t=a[1]; |
||
353 | t=(t+c)&BN_MASK2; |
||
354 | c=(t < c); |
||
355 | l=(t+b[1])&BN_MASK2; |
||
356 | c+=(l < t); |
||
357 | r[1]=l; |
||
358 | if (--n <= 0) break; |
||
359 | |||
360 | t=a[2]; |
||
361 | t=(t+c)&BN_MASK2; |
||
362 | c=(t < c); |
||
363 | l=(t+b[2])&BN_MASK2; |
||
364 | c+=(l < t); |
||
365 | r[2]=l; |
||
366 | if (--n <= 0) break; |
||
367 | |||
368 | t=a[3]; |
||
369 | t=(t+c)&BN_MASK2; |
||
370 | c=(t < c); |
||
371 | l=(t+b[3])&BN_MASK2; |
||
372 | c+=(l < t); |
||
373 | r[3]=l; |
||
374 | if (--n <= 0) break; |
||
375 | |||
376 | a+=4; |
||
377 | b+=4; |
||
378 | r+=4; |
||
379 | } |
||
380 | return((BN_ULONG)c); |
||
381 | } |
||
382 | #endif /* !BN_LLONG */ |