diff options
Diffstat (limited to 'utils/zenutils/libraries/beecrypt-4.1.2/beecrypt/mp.h')
-rwxr-xr-x | utils/zenutils/libraries/beecrypt-4.1.2/beecrypt/mp.h | 691 |
1 files changed, 691 insertions, 0 deletions
diff --git a/utils/zenutils/libraries/beecrypt-4.1.2/beecrypt/mp.h b/utils/zenutils/libraries/beecrypt-4.1.2/beecrypt/mp.h new file mode 100755 index 0000000000..57a3e6c502 --- /dev/null +++ b/utils/zenutils/libraries/beecrypt-4.1.2/beecrypt/mp.h | |||
@@ -0,0 +1,691 @@ | |||
1 | /* | ||
2 | * Copyright (c) 2002, 2003 Bob Deblier | ||
3 | * | ||
4 | * This library is free software; you can redistribute it and/or | ||
5 | * modify it under the terms of the GNU Lesser General Public | ||
6 | * License as published by the Free Software Foundation; either | ||
7 | * version 2.1 of the License, or (at your option) any later version. | ||
8 | * | ||
9 | * This library is distributed in the hope that it will be useful, | ||
10 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
11 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
12 | * Lesser General Public License for more details. | ||
13 | * | ||
14 | * You should have received a copy of the GNU Lesser General Public | ||
15 | * License along with this library; if not, write to the Free Software | ||
16 | * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA | ||
17 | * | ||
18 | */ | ||
19 | |||
20 | /*!\file mp.h | ||
21 | * \brief Multi-precision integer routines. | ||
22 | * | ||
23 | * The routines declared here are all low-level operations, most of them | ||
24 | * suitable to be implemented in assembler. Prime candidates are in order | ||
25 | * of importance (according to gprof): | ||
26 | * <ul> | ||
27 | * <li>mpaddmul | ||
28 | * <li>mpsetmul | ||
29 | * <li>mpaddsqrtrc | ||
30 | * <li>mpsub | ||
31 | * <li>mpadd | ||
32 | * </ul> | ||
33 | * | ||
34 | * With some smart use of available assembler instructions, it's possible | ||
35 | * to speed these routines up by a factor of 2 to 4. | ||
36 | * | ||
37 | * \author Bob Deblier <bob.deblier@pandora.be> | ||
38 | * \ingroup MP_m | ||
39 | */ | ||
40 | |||
41 | #ifndef _MP_H | ||
42 | #define _MP_H | ||
43 | |||
44 | #include "beecrypt/api.h" | ||
45 | #include "beecrypt/mpopt.h" | ||
46 | |||
47 | #define MP_HWBITS (MP_WBITS >> 1) | ||
48 | #define MP_WBYTES (MP_WBITS >> 3) | ||
49 | #define MP_WNIBBLES (MP_WBITS >> 2) | ||
50 | |||
51 | #if (MP_WBITS == 64) | ||
52 | # define MP_WORDS_TO_BITS(x) ((x) << 6) | ||
53 | # define MP_WORDS_TO_NIBBLES(x) ((x) << 4) | ||
54 | # define MP_WORDS_TO_BYTES(x) ((x) << 3) | ||
55 | # define MP_BITS_TO_WORDS(x) ((x) >> 6) | ||
56 | # define MP_NIBBLES_TO_WORDS(x) ((x) >> 4) | ||
57 | # define MP_BYTES_TO_WORDS(x) ((x) >> 3) | ||
58 | #elif (MP_WBITS == 32) | ||
59 | # define MP_WORDS_TO_BITS(x) ((x) << 5) | ||
60 | # define MP_WORDS_TO_NIBBLES(x) ((x) << 3) | ||
61 | # define MP_WORDS_TO_BYTES(x) ((x) << 2) | ||
62 | # define MP_BITS_TO_WORDS(x) ((x) >> 5) | ||
63 | # define MP_NIBBLES_TO_WORDS(x) ((x) >> 3) | ||
64 | # define MP_BYTES_TO_WORDS(x) ((x) >> 2) | ||
65 | #else | ||
66 | # error | ||
67 | #endif | ||
68 | |||
69 | #define MP_MSBMASK (((mpw) 0x1) << (MP_WBITS-1)) | ||
70 | #define MP_LSBMASK ((mpw) 0x1) | ||
71 | #define MP_ALLMASK ~((mpw) 0x0) | ||
72 | |||
73 | #ifdef __cplusplus | ||
74 | extern "C" { | ||
75 | #endif | ||
76 | |||
77 | #ifndef ASM_MPCOPY | ||
78 | # define mpcopy(size, dst, src) memcpy(dst, src, MP_WORDS_TO_BYTES(size)) | ||
79 | #else | ||
80 | BEECRYPTAPI | ||
81 | void mpcopy(size_t size, mpw* dest, const mpw* src); | ||
82 | #endif | ||
83 | |||
84 | #ifndef ASM_MPMOVE | ||
85 | # define mpmove(size, dst, src) memmove(dst, src, MP_WORDS_TO_BYTES(size)) | ||
86 | #else | ||
87 | BEECRYPTAPI | ||
88 | void mpmove(size_t size, mpw* dest, const mpw* src); | ||
89 | #endif | ||
90 | |||
91 | /*!\fn void mpzero(size_t size, mpw* data) | ||
92 | * \brief This function zeroes a multi-precision integer of a given size. | ||
93 | * \param size The size of the multi-precision integer. | ||
94 | * \param data The multi-precision integer data. | ||
95 | */ | ||
96 | BEECRYPTAPI | ||
97 | void mpzero(size_t size, mpw* data); | ||
98 | |||
99 | /*!\fn void mpfill(size_t size, mpw* data, mpw fill) | ||
100 | * \brief This function fills each word of a multi-precision integer with a | ||
101 | * given value. | ||
102 | * \param size The size of the multi-precision integer. | ||
103 | * \param data The multi-precision integer data. | ||
104 | * \param fill The value fill the data with. | ||
105 | */ | ||
106 | BEECRYPTAPI | ||
107 | void mpfill(size_t size, mpw* data, mpw fill); | ||
108 | |||
109 | /*!\fn int mpodd(size_t size, const mpw* data) | ||
110 | * \brief This functions tests if a multi-precision integer is odd. | ||
111 | * \param size The size of the multi-precision integer. | ||
112 | * \param data The multi-precision integer data. | ||
113 | * \retval 1 if odd | ||
114 | * \retval 0 if even | ||
115 | */ | ||
116 | BEECRYPTAPI | ||
117 | int mpodd (size_t size, const mpw* data); | ||
118 | |||
119 | /*!\fn int mpeven(size_t size, const mpw* data) | ||
120 | * \brief This function tests if a multi-precision integer is even. | ||
121 | * \param size The size of the multi-precision integer. | ||
122 | * \param data The multi-precision integer data. | ||
123 | * \retval 1 if even | ||
124 | * \retval 0 if odd | ||
125 | */ | ||
126 | BEECRYPTAPI | ||
127 | int mpeven(size_t size, const mpw* data); | ||
128 | |||
129 | /*!\fn int mpz(size_t size, const mpw* data) | ||
130 | * \brief This function tests if a multi-precision integer is zero. | ||
131 | * \param size The size of the multi-precision integer. | ||
132 | * \param data The multi-precision integer data. | ||
133 | * \retval 1 if zero | ||
134 | * \retval 0 if not zero | ||
135 | */ | ||
136 | BEECRYPTAPI | ||
137 | int mpz (size_t size, const mpw* data); | ||
138 | |||
139 | /*!\fn int mpnz(size_t size, const mpw* data) | ||
140 | * \brief This function tests if a multi-precision integer is not zero. | ||
141 | * \param size The size of the multi-precision integer. | ||
142 | * \param data The multi-precision integer data. | ||
143 | * \retval 1 if not zero | ||
144 | * \retval 0 if zero | ||
145 | */ | ||
146 | BEECRYPTAPI | ||
147 | int mpnz (size_t size, const mpw* data); | ||
148 | |||
149 | /*!\fn int mpeq(size_t size, const mpw* xdata, const mpw* ydata) | ||
150 | * \brief This function tests if two multi-precision integers of the same size | ||
151 | * are equal. | ||
152 | * \param size The size of the multi-precision integers. | ||
153 | * \param xdata The first multi-precision integer. | ||
154 | * \param ydata The second multi-precision integer. | ||
155 | * \retval 1 if equal | ||
156 | * \retval 0 if not equal | ||
157 | */ | ||
158 | BEECRYPTAPI | ||
159 | int mpeq (size_t size, const mpw* xdata, const mpw* ydata); | ||
160 | |||
161 | /*!\fn int mpne(size_t size, const mpw* xdata, const mpw* ydata) | ||
162 | * \brief This function tests if two multi-precision integers of the same size | ||
163 | * differ. | ||
164 | * \param size The size of the multi-precision integers. | ||
165 | * \param xdata The first multi-precision integer. | ||
166 | * \param ydata The second multi-precision integer. | ||
167 | * \retval 1 if not equal | ||
168 | * \retval 0 if equal | ||
169 | */ | ||
170 | BEECRYPTAPI | ||
171 | int mpne (size_t size, const mpw* xdata, const mpw* ydata); | ||
172 | |||
173 | /*!\fn int mpgt(size_t size, const mpw* xdata, const mpw* ydata) | ||
174 | * \brief This function tests if the first of two multi-precision integers | ||
175 | * of the same size is greater than the second. | ||
176 | * \note The comparison treats the arguments as unsigned. | ||
177 | * \param size The size of the multi-precision integers. | ||
178 | * \param xdata The first multi-precision integer. | ||
179 | * \param ydata The second multi-precision integer. | ||
180 | * \retval 1 if greater | ||
181 | * \retval 0 if less or equal | ||
182 | */ | ||
183 | BEECRYPTAPI | ||
184 | int mpgt (size_t size, const mpw* xdata, const mpw* ydata); | ||
185 | |||
186 | /*!\fn int mplt(size_t size, const mpw* xdata, const mpw* ydata) | ||
187 | * \brief This function tests if the first of two multi-precision integers | ||
188 | * of the same size is less than the second. | ||
189 | * \note The comparison treats the arguments as unsigned. | ||
190 | * \param size The size of the multi-precision integers. | ||
191 | * \param xdata The first multi-precision integer. | ||
192 | * \param ydata The second multi-precision integer. | ||
193 | * \retval 1 if less | ||
194 | * \retval 0 if greater or equal | ||
195 | */ | ||
196 | BEECRYPTAPI | ||
197 | int mplt (size_t size, const mpw* xdata, const mpw* ydata); | ||
198 | |||
199 | /*!\fn int mpge(size_t size, const mpw* xdata, const mpw* ydata) | ||
200 | * \brief This function tests if the first of two multi-precision integers | ||
201 | * of the same size is greater than or equal to the second. | ||
202 | * \note The comparison treats the arguments as unsigned. | ||
203 | * \param size The size of the multi-precision integers. | ||
204 | * \param xdata The first multi-precision integer. | ||
205 | * \param ydata The second multi-precision integer. | ||
206 | * \retval 1 if greater or equal | ||
207 | * \retval 0 if less | ||
208 | */ | ||
209 | BEECRYPTAPI | ||
210 | int mpge (size_t size, const mpw* xdata, const mpw* ydata); | ||
211 | |||
212 | /*!\fn int mple(size_t size, const mpw* xdata, const mpw* ydata) | ||
213 | * \brief This function tests if the first of two multi-precision integers | ||
214 | * of the same size is less than or equal to the second. | ||
215 | * \note The comparison treats the arguments as unsigned. | ||
216 | * \param size The size of the multi-precision integers. | ||
217 | * \param xdata The first multi-precision integer. | ||
218 | * \param ydata The second multi-precision integer. | ||
219 | * \retval 1 if less or equal | ||
220 | * \retval 0 if greater | ||
221 | */ | ||
222 | BEECRYPTAPI | ||
223 | int mple (size_t size, const mpw* xdata, const mpw* ydata); | ||
224 | |||
225 | /*!\fn int mpeqx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
226 | * \brief This function tests if two multi-precision integers of different | ||
227 | * size are equal. | ||
228 | * \param xsize The size of the first multi-precision integer. | ||
229 | * \param xdata The first multi-precision integer. | ||
230 | * \param ysize The size of the first multi-precision integer. | ||
231 | * \param ydata The second multi-precision integer. | ||
232 | * \retval 1 if equal | ||
233 | * \retval 0 if not equal | ||
234 | */ | ||
235 | BEECRYPTAPI | ||
236 | int mpeqx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
237 | |||
238 | /*!\fn int mpnex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
239 | * \brief This function tests if two multi-precision integers of different | ||
240 | * size are equal. | ||
241 | * \param xsize The size of the first multi-precision integer. | ||
242 | * \param xdata The first multi-precision integer. | ||
243 | * \param ysize The size of the first multi-precision integer. | ||
244 | * \param ydata The second multi-precision integer. | ||
245 | * \retval 1 if equal | ||
246 | * \retval 0 if not equal | ||
247 | */ | ||
248 | BEECRYPTAPI | ||
249 | int mpnex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
250 | |||
251 | /*!\fn int mpgtx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
252 | * \brief This function tests if the first of two multi-precision integers | ||
253 | * of different size is greater than the second. | ||
254 | * \note The comparison treats the arguments as unsigned. | ||
255 | * \param xsize The size of the first multi-precision integer. | ||
256 | * \param xdata The first multi-precision integer. | ||
257 | * \param ysize The size of the second multi-precision integer. | ||
258 | * \param ydata The second multi-precision integer. | ||
259 | * \retval 1 if greater | ||
260 | * \retval 0 if less or equal | ||
261 | */ | ||
262 | BEECRYPTAPI | ||
263 | int mpgtx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
264 | |||
265 | /*!\fn int mpltx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
266 | * \brief This function tests if the first of two multi-precision integers | ||
267 | * of different size is less than the second. | ||
268 | * \note The comparison treats the arguments as unsigned. | ||
269 | * \param xsize The size of the first multi-precision integer. | ||
270 | * \param xdata The first multi-precision integer. | ||
271 | * \param ysize The size of the second multi-precision integer. | ||
272 | * \param ydata The second multi-precision integer. | ||
273 | * \retval 1 if less | ||
274 | * \retval 0 if greater or equal | ||
275 | */ | ||
276 | BEECRYPTAPI | ||
277 | int mpltx(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
278 | |||
279 | /*!\fn int mpgex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
280 | * \brief This function tests if the first of two multi-precision integers | ||
281 | * of different size is greater than or equal to the second. | ||
282 | * \note The comparison treats the arguments as unsigned. | ||
283 | * \param xsize The size of the first multi-precision integer. | ||
284 | * \param xdata The first multi-precision integer. | ||
285 | * \param ysize The size of the second multi-precision integer. | ||
286 | * \param ydata The second multi-precision integer. | ||
287 | * \retval 1 if greater or equal | ||
288 | * \retval 0 if less | ||
289 | */ | ||
290 | BEECRYPTAPI | ||
291 | int mpgex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
292 | |||
293 | /*!\fn int mplex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
294 | * \brief This function tests if the first of two multi-precision integers | ||
295 | * of different size is less than or equal to the second. | ||
296 | * \note The comparison treats the arguments as unsigned. | ||
297 | * \param xsize The size of the first multi-precision integer. | ||
298 | * \param xdata The first multi-precision integer. | ||
299 | * \param ysize The size of the second multi-precision integer. | ||
300 | * \param ydata The second multi-precision integer. | ||
301 | * \retval 1 if less or equal | ||
302 | * \retval 0 if greater | ||
303 | */ | ||
304 | BEECRYPTAPI | ||
305 | int mplex(size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
306 | |||
307 | /*!\fn int mpisone(size_t size, const mpw* data) | ||
308 | * \brief This functions tests if the value of a multi-precision integer is | ||
309 | * equal to one. | ||
310 | * \param size The size of the multi-precision integer. | ||
311 | * \param data The multi-precision integer data. | ||
312 | * \retval 1 if one | ||
313 | * \retval 0 if not one | ||
314 | */ | ||
315 | BEECRYPTAPI | ||
316 | int mpisone(size_t size, const mpw* data); | ||
317 | |||
318 | /*!\fn int mpistwo(size_t size, const mpw* data) | ||
319 | * \brief This function tests if the value of a multi-precision integer is | ||
320 | * equal to two. | ||
321 | * \param size The size of the multi-precision integer. | ||
322 | * \param data The multi-precision integer data. | ||
323 | * \retval 1 if two | ||
324 | * \retval 0 if not two | ||
325 | */ | ||
326 | BEECRYPTAPI | ||
327 | int mpistwo(size_t size, const mpw* data); | ||
328 | |||
329 | /*!\fn int mpleone(size_t size, const mpw* data); | ||
330 | * \brief This function tests if the value of a multi-precision integer is | ||
331 | * less than or equal to one. | ||
332 | * \param size The size of the multi-precision integer. | ||
333 | * \param data The multi-precision integer data. | ||
334 | * \retval 1 if less than or equal to one. | ||
335 | * \retval 0 if greater than one. | ||
336 | */ | ||
337 | BEECRYPTAPI | ||
338 | int mpleone(size_t size, const mpw* data); | ||
339 | |||
340 | /*!\fn int mpeqmone(size_t size, const mpw* xdata, const mpw* ydata); | ||
341 | * \brief This function tests if multi-precision integer x is equal to y | ||
342 | * minus one. | ||
343 | * \param size The size of the multi-precision integers. | ||
344 | * \param xdata The first multi-precision integer. | ||
345 | * \param ydata The second multi-precision integer. | ||
346 | * \retval 1 if less than or equal to one. | ||
347 | * \retval 0 if greater than one. | ||
348 | */ | ||
349 | BEECRYPTAPI | ||
350 | int mpeqmone(size_t size, const mpw* xdata, const mpw* ydata); | ||
351 | |||
352 | /*!\fn int mpmsbset(size_t size, const mpw* data) | ||
353 | * \brief This function tests if the most significant bit of a multi-precision | ||
354 | * integer is set. | ||
355 | * \param size The size of the multi-precision integer. | ||
356 | * \param data The multi-precision integer data. | ||
357 | * \retval 1 if set | ||
358 | * \retval 0 if not set | ||
359 | */ | ||
360 | BEECRYPTAPI | ||
361 | int mpmsbset(size_t size, const mpw* data); | ||
362 | |||
363 | /*!\fn int mplsbset(size_t size, const mpw* data) | ||
364 | * \brief This function tests if the leiast significant bit of a multi-precision | ||
365 | * integer is set. | ||
366 | * \param size The size of the multi-precision integer. | ||
367 | * \param data The multi-precision integer data. | ||
368 | * \retval 1 if set | ||
369 | * \retval 0 if not set | ||
370 | */ | ||
371 | BEECRYPTAPI | ||
372 | int mplsbset(size_t size, const mpw* data); | ||
373 | |||
374 | /*!\fn void mpsetmsb(size_t size, mpw* data) | ||
375 | * \brief This function sets the most significant bit of a multi-precision | ||
376 | * integer. | ||
377 | * \param size The size of the multi-precision integer. | ||
378 | * \param data The multi-precision integer data. | ||
379 | */ | ||
380 | BEECRYPTAPI | ||
381 | void mpsetmsb(size_t size, mpw* data); | ||
382 | |||
383 | /*!\fn void mpsetlsb(size_t size, mpw* data) | ||
384 | * \brief This function sets the least significant bit of a multi-precision | ||
385 | * integer. | ||
386 | * \param size The size of the multi-precision integer. | ||
387 | * \param data The multi-precision integer data. | ||
388 | */ | ||
389 | BEECRYPTAPI | ||
390 | void mpsetlsb(size_t size, mpw* data); | ||
391 | |||
392 | /*!\fn void mpclrmsb(size_t size, mpw* data) | ||
393 | * \brief This function clears the most significant bit of a multi-precision | ||
394 | * integer. | ||
395 | * \param size The size of the multi-precision integer. | ||
396 | * \param data The multi-precision integer data. | ||
397 | */ | ||
398 | BEECRYPTAPI | ||
399 | void mpclrmsb(size_t size, mpw* data); | ||
400 | |||
401 | /*!\fn void mpclrlsb(size_t size, mpw* data) | ||
402 | * \brief This function clears the least significant bit of a multi-precision | ||
403 | * integer. | ||
404 | * \param size The size of the multi-precision integer. | ||
405 | * \param data The multi-precision integer data. | ||
406 | */ | ||
407 | BEECRYPTAPI | ||
408 | void mpclrlsb(size_t size, mpw* data); | ||
409 | |||
410 | /*!\fn mpand(size_t size, mpw* xdata, const mpw* ydata) | ||
411 | * \brief This function computes the bit-wise AND of two multi-precision | ||
412 | * integers. Modifies xdata. | ||
413 | * \param size The size of the multi-precision integers. | ||
414 | * \param xdata The multi-precision integer data. | ||
415 | * \param ydata The multi-precision integer data. | ||
416 | */ | ||
417 | BEECRYPTAPI | ||
418 | void mpand(size_t size, mpw* xdata, const mpw* ydata); | ||
419 | |||
420 | /*!\fn void mpor(size_t size, mpw* xdata, const mpw* ydata) | ||
421 | * \brief This function computes the bit-wise OR of two multi-precision | ||
422 | * integers. Modifies xdata. | ||
423 | * \param size The size of the multi-precision integer. | ||
424 | * \param xdata The multi-precision integer data. | ||
425 | * \param ydata The multi-precision integer data. | ||
426 | */ | ||
427 | BEECRYPTAPI | ||
428 | void mpor(size_t size, mpw* xdata, const mpw* ydata); | ||
429 | |||
430 | /*!\fn void mpxor(size_t size, mpw* xdata, const mpw* ydata) | ||
431 | * \brief This function computes the bit-wise XOR of two multi-precision | ||
432 | * integers. Modifies xdata. | ||
433 | * \param size The size of the multi-precision integer. | ||
434 | * \param xdata The multi-precision integer data. | ||
435 | * \param ydata The multi-precision integer data. | ||
436 | */ | ||
437 | BEECRYPTAPI | ||
438 | void mpxor(size_t size, mpw* xdata, const mpw* ydata); | ||
439 | |||
440 | /*!\fn mpnot(size_t size, mpw* data) | ||
441 | * \brief This function flips all bits of a multi-precision integer. | ||
442 | * \param size The size of the multi-precision integer. | ||
443 | * \param data The multi-precision integer data. | ||
444 | */ | ||
445 | BEECRYPTAPI | ||
446 | void mpnot(size_t size, mpw* data); | ||
447 | |||
448 | /*!\fn void mpsetw(size_t size, mpw* xdata, mpw y) | ||
449 | * \brief This function sets the value of a multi-precision integer to the | ||
450 | * given word. The given value is copied into the least significant word, | ||
451 | * while the most significant words are zeroed. | ||
452 | * \param size The size of the multi-precision integer. | ||
453 | * \param xdata The first multi-precision integer. | ||
454 | * \param y The multi-precision word. | ||
455 | */ | ||
456 | BEECRYPTAPI | ||
457 | void mpsetw(size_t size, mpw* xdata, mpw y); | ||
458 | |||
459 | /*!\fn void mpsetx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata) | ||
460 | * \brief This function set the value of the first multi-precision integer | ||
461 | * to the second, truncating the most significant words if ysize > xsize, or | ||
462 | * zeroing the most significant words if ysize < xsize. | ||
463 | * \param xsize The size of the first multi-precision integer. | ||
464 | * \param xdata The first multi-precision integer. | ||
465 | * \param ysize The size of the second multi-precision integer. | ||
466 | * \param ydata The second multi-precision integer. | ||
467 | */ | ||
468 | void mpsetx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata); | ||
469 | |||
470 | /*!\fn int mpaddw(size_t size, mpw* xdata, mpw y) | ||
471 | * \brief This function adds one word to a multi-precision integer. | ||
472 | * The performed operation is in pseudocode: x += y. | ||
473 | * \param size The size of the multi-precision integer. | ||
474 | * \param xdata The first multi-precision integer. | ||
475 | * \param y The multi-precision word. | ||
476 | * \return The carry-over value of the operation; this value is either 0 or 1. | ||
477 | */ | ||
478 | BEECRYPTAPI | ||
479 | int mpaddw(size_t size, mpw* xdata, mpw y); | ||
480 | |||
481 | /*!\fn int mpadd(size_t size, mpw* xdata, const mpw* ydata) | ||
482 | * \brief This function adds two multi-precision integers of equal size. | ||
483 | * The performed operation is in pseudocode: x += y. | ||
484 | * \param size The size of the multi-precision integers. | ||
485 | * \param xdata The first multi-precision integer. | ||
486 | * \param ydata The second multi-precision integer. | ||
487 | * \return The carry-over value of the operation; this value is either 0 or 1. | ||
488 | */ | ||
489 | BEECRYPTAPI | ||
490 | int mpadd (size_t size, mpw* xdata, const mpw* ydata); | ||
491 | |||
492 | /*!\fn int mpaddx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata) | ||
493 | * \brief This function adds two multi-precision integers of different size. | ||
494 | * The performed operation in pseudocode: x += y. | ||
495 | * \param xsize The size of the first multi-precision integer. | ||
496 | * \param xdata The first multi-precision integer. | ||
497 | * \param ysize The size of the second multi-precision integer. | ||
498 | * \param ydata The second multi-precision integer. | ||
499 | * \return The carry-over value of the operation; this value is either 0 or 1. | ||
500 | */ | ||
501 | BEECRYPTAPI | ||
502 | int mpaddx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata); | ||
503 | |||
504 | /*!\fn int mpsubw(size_t size, mpw* xdata, mpw y) | ||
505 | * \brief This function subtracts one word to a multi-precision integer. | ||
506 | * The performed operation in pseudocode: x -= y | ||
507 | * \param size The size of the multi-precision integers. | ||
508 | * \param xdata The first multi-precision integer. | ||
509 | * \param y The multi-precision word. | ||
510 | * \return The carry-over value of the operation; this value is either 0 or 1. | ||
511 | */ | ||
512 | BEECRYPTAPI | ||
513 | int mpsubw(size_t size, mpw* xdata, mpw y); | ||
514 | |||
515 | /*!\fn int mpsub(size_t size, mpw* xdata, const mpw* ydata) | ||
516 | * \brief This function subtracts two multi-precision integers of equal size. | ||
517 | * The performed operation in pseudocode: x -= y | ||
518 | * \param size The size of the multi-precision integers. | ||
519 | * \param xdata The first multi-precision integer. | ||
520 | * \param ydata The second multi-precision integer. | ||
521 | * \return The carry-over value of the operation; this value is either 0 or 1. | ||
522 | */ | ||
523 | BEECRYPTAPI | ||
524 | int mpsub (size_t size, mpw* xdata, const mpw* ydata); | ||
525 | |||
526 | /*!\fn int mpsubx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata) | ||
527 | * \brief This function subtracts two multi-precision integers of different | ||
528 | * size. The performed operation in pseudocode: x -= y. | ||
529 | * \param xsize The size of the first multi-precision integer. | ||
530 | * \param xdata The first multi-precision integer. | ||
531 | * \param ysize The size of the second multi-precision integer. | ||
532 | * \param ydata The second multi-precision integer. | ||
533 | * \return The carry-over value of the operation; this value is either 0 or 1. | ||
534 | */ | ||
535 | BEECRYPTAPI | ||
536 | int mpsubx(size_t xsize, mpw* xdata, size_t ysize, const mpw* ydata); | ||
537 | |||
538 | BEECRYPTAPI | ||
539 | int mpmultwo(size_t size, mpw* data); | ||
540 | |||
541 | /*!\fn void mpneg(size_t size, mpw* data) | ||
542 | * \brief This function negates a multi-precision integer. | ||
543 | * \param size The size of the multi-precision integer. | ||
544 | * \param data The multi-precision integer data. | ||
545 | */ | ||
546 | BEECRYPTAPI | ||
547 | void mpneg(size_t size, mpw* data); | ||
548 | |||
549 | /*!\fn size_t mpsize(size_t size, const mpw* data) | ||
550 | * \brief This function returns the true size of a multi-precision | ||
551 | * integer, after stripping leading zero words. | ||
552 | * \param size The size of the multi-precision integer. | ||
553 | * \param data The multi-precision integer data. | ||
554 | */ | ||
555 | BEECRYPTAPI | ||
556 | size_t mpsize(size_t size, const mpw* data); | ||
557 | |||
558 | /*!\fn size_t mpbits(size_t size, const mpw* data) | ||
559 | * \brief This function returns the number of significant bits | ||
560 | * in a multi-precision integer. | ||
561 | * \param size The size of the multi-precision integer. | ||
562 | * \param data The multi-precision integer data. | ||
563 | */ | ||
564 | BEECRYPTAPI | ||
565 | size_t mpbits(size_t size, const mpw* data); | ||
566 | |||
567 | BEECRYPTAPI | ||
568 | size_t mpmszcnt(size_t size, const mpw* data); | ||
569 | |||
570 | BEECRYPTAPI | ||
571 | size_t mplszcnt(size_t size, const mpw* data); | ||
572 | |||
573 | BEECRYPTAPI | ||
574 | void mplshift(size_t size, mpw* data, size_t count); | ||
575 | |||
576 | BEECRYPTAPI | ||
577 | void mprshift(size_t size, mpw* data, size_t count); | ||
578 | |||
579 | BEECRYPTAPI | ||
580 | size_t mprshiftlsz(size_t size, mpw* data); | ||
581 | |||
582 | BEECRYPTAPI | ||
583 | size_t mpnorm(size_t size, mpw* data); | ||
584 | |||
585 | BEECRYPTAPI | ||
586 | void mpdivtwo (size_t size, mpw* data); | ||
587 | |||
588 | BEECRYPTAPI | ||
589 | void mpsdivtwo(size_t size, mpw* data); | ||
590 | |||
591 | /*!\fn mpw mpsetmul(size_t size, mpw* result, const mpw* data, mpw y) | ||
592 | * \brief This function performs a multi-precision multiply-setup. | ||
593 | * | ||
594 | * This function is used in the computation of a full multi-precision | ||
595 | * multiplication. By using it we can shave off a few cycles; otherwise we'd | ||
596 | * have to zero the least significant half of the result first and use | ||
597 | * another call to the slightly slower mpaddmul function. | ||
598 | * | ||
599 | * \param size The size of multi-precision integer multiplier. | ||
600 | * \param result The place where result will be accumulated. | ||
601 | * \param data The multi-precision integer multiplier. | ||
602 | * \param y The multiplicand. | ||
603 | * \return The carry-over multi-precision word. | ||
604 | */ | ||
605 | BEECRYPTAPI | ||
606 | mpw mpsetmul (size_t size, mpw* result, const mpw* data, mpw y); | ||
607 | |||
608 | /*!\fn mpw mpaddmul(size_t size, mpw* result, const mpw* data, mpw y) | ||
609 | * \brief This function performs a mult-precision multiply-accumulate. | ||
610 | * | ||
611 | * This function is used in the computation of a full multi-precision | ||
612 | * multiplication. It computes the product-by-one-word and accumulates it with | ||
613 | * the previous result. | ||
614 | * | ||
615 | * \param size The size of multi-precision integer multiplier. | ||
616 | * \param result The place where result will be accumulated. | ||
617 | * \param data The multi-precision integer multiplier. | ||
618 | * \param y The multiplicand. | ||
619 | * \retval The carry-over multi-precision word. | ||
620 | */ | ||
621 | BEECRYPTAPI | ||
622 | mpw mpaddmul (size_t size, mpw* result, const mpw* data, mpw y); | ||
623 | |||
624 | /*!\fn void mpaddsqrtrc(size_t size, mpw* result, const mpw* data) | ||
625 | * \brief This function is used in the calculation of a multi-precision | ||
626 | * squaring. | ||
627 | */ | ||
628 | BEECRYPTAPI | ||
629 | void mpaddsqrtrc(size_t size, mpw* result, const mpw* data); | ||
630 | |||
631 | /*!\fn void mpmul(mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata) | ||
632 | * \brief This function computes a full multi-precision product. | ||
633 | */ | ||
634 | BEECRYPTAPI | ||
635 | void mpmul(mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata); | ||
636 | |||
637 | /*!\fn void mpsqr(mpw* result, size_t size, const mpw* data) | ||
638 | * \brief This function computes a full multi-precision square. | ||
639 | */ | ||
640 | BEECRYPTAPI | ||
641 | void mpsqr(mpw* result, size_t size, const mpw* data); | ||
642 | |||
643 | BEECRYPTAPI | ||
644 | void mpgcd_w(size_t size, const mpw* xdata, const mpw* ydata, mpw* result, mpw* wksp); | ||
645 | |||
646 | BEECRYPTAPI | ||
647 | int mpextgcd_w(size_t size, const mpw* xdata, const mpw* ydata, mpw* result, mpw* wksp); | ||
648 | |||
649 | BEECRYPTAPI | ||
650 | mpw mppndiv(mpw xhi, mpw xlo, mpw y); | ||
651 | |||
652 | BEECRYPTAPI | ||
653 | void mpmod (mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw*ydata, mpw* wksp); | ||
654 | |||
655 | BEECRYPTAPI | ||
656 | void mpndivmod(mpw* result, size_t xsize, const mpw* xdata, size_t ysize, const mpw* ydata, mpw* wksp); | ||
657 | |||
658 | /* | ||
659 | * Output Routines | ||
660 | */ | ||
661 | |||
662 | BEECRYPTAPI | ||
663 | void mpprint(size_t size, const mpw* data); | ||
664 | |||
665 | BEECRYPTAPI | ||
666 | void mpprintln(size_t size, const mpw* data); | ||
667 | |||
668 | BEECRYPTAPI | ||
669 | void mpfprint(FILE* f, size_t size, const mpw* data); | ||
670 | |||
671 | BEECRYPTAPI | ||
672 | void mpfprintln(FILE* f, size_t size, const mpw* data); | ||
673 | |||
674 | /* | ||
675 | * Conversion Routines | ||
676 | */ | ||
677 | |||
678 | BEECRYPTAPI | ||
679 | int os2ip(mpw* idata, size_t isize, const byte* osdata, size_t ossize); | ||
680 | |||
681 | BEECRYPTAPI | ||
682 | int i2osp(byte* osdata, size_t ossize, const mpw* idata, size_t isize); | ||
683 | |||
684 | BEECRYPTAPI | ||
685 | int hs2ip(mpw* idata, size_t isize, const char* hsdata, size_t hssize); | ||
686 | |||
687 | #ifdef __cplusplus | ||
688 | } | ||
689 | #endif | ||
690 | |||
691 | #endif | ||