The Tor Browser / file comparison

comparison: security/nss/lib/freebl/mpi/mpi-test.c

security/nss/lib/freebl/mpi/mpi-test.c

branch
TOR_BUG_9701
changeset 15
b8a032363ba2
equal deleted inserted replaced
-1:000000000000 0:5a1b1ad5a699
1 /*
2 * mpi-test.c
3 *
4 * This is a general test suite for the MPI library, which tests
5 * all the functions in the library with known values. The program
6 * exits with a zero (successful) status if the tests pass, or a
7 * nonzero status if the tests fail.
8 *
9 * This Source Code Form is subject to the terms of the Mozilla Public
10 * License, v. 2.0. If a copy of the MPL was not distributed with this
11 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
12
13 #include <stdio.h>
14 #include <stdlib.h>
15 #include <string.h>
16 #include <stdarg.h>
17 #include <limits.h>
18 #include <time.h>
19
20 #include "mpi.h"
21 #include "mpprime.h"
22
23 #include "test-info.c"
24
25 /* ZS means Zero Suppressed (no leading zeros) */
26 #if MP_USE_LONG_DIGIT
27 #define ZS_DIGIT_FMT "%lX"
28 #elif MP_USE_LONG_LONG_DIGIT
29 #define ZS_DIGIT_FMT "%llX"
30 #elif MP_USE_UINT_DIGIT
31 #define ZS_DIGIT_FMT "%X"
32 #else
33 #error "unknown type of digit"
34 #endif
35
36 /*
37 Test vectors
38
39 If you intend to change any of these values, you must also recompute
40 the corresponding solutions below. Basically, these are just hex
41 strings (for the big integers) or integer values (for the digits).
42
43 The comparison tests think they know what relationships hold between
44 these values. If you change that, you may have to adjust the code
45 for the comparison tests accordingly. Most of the other tests
46 should be fine as long as you re-compute the solutions, though.
47 */
48 const char *mp1 = "639A868CDA0C569861B";
49 const char *mp2 = "AAFC0A3FE45E5E09DBE2C29";
50 const char *mp3 = "B55AA8DF8A7E83241F38AC7A9E479CAEF2E4D7C5";
51 const char *mp4 = "-63DBC2265B88268DC801C10EA68476B7BDE0090F";
52 const char *mp5 = "F595CB42";
53 const char *mp5a = "-4B597E";
54 const char *mp6 = "0";
55 const char *mp7 = "EBFA7121CD838CE6439CC59DDB4CBEF3";
56 const char *mp8 = "5";
57 const char *mp9 = "F74A2876A1432698923B0767DA19DCF3D71795EE";
58 const char *mp10 = "9184E72A000";
59 const char *mp11 = "54D79A3557E8";
60 const char *mp12 = "10000000000000000";
61 const char *mp13 =
62 "34584F700C15A341E40BF7BFDD88A6630C8FF2B2067469372D391342BDAB6163963C"
63 "D5A5C79F708BDE26E0CCF2DB66CD6D6089E29A877C45F2B050D226E6DA88";
64 const char *mp14 =
65 "AC3FA0EABAAC45724814D798942A1E28E14C81E0DE8055CED630E7689DA648683645DB6E"
66 "458D9F5338CC3D4E33A5D1C9BF42780133599E60DEE0049AFA8F9489501AE5C9AA2B8C13"
67 "FD21285A538B2CA87A626BB56E0A654C8707535E637FF4E39174157402BDE3AA30C9F134"
68 "0C1307BAA864B075A9CC828B6A5E2B2BF1AE406D920CC5E7657D7C0E697DEE5375773AF9"
69 "E200A1B8FAD7CD141F9EE47ABB55511FEB9A4D99EBA22F3A3FF6792FA7EE9E5DC0EE94F7"
70 "7A631EDF3D7DD7C2DAAAFDF234D60302AB63D5234CEAE941B9AF0ADDD9E6E3A940A94EE5"
71 "5DB45A7C66E61EDD0477419BBEFA44C325129601C4F45671C6A0E64665DF341D17FBC71F"
72 "77418BD9F4375DDB3B9D56126526D8E5E0F35A121FD4F347013DA880020A752324F31DDD"
73 "9BCDB13A3B86E207A2DE086825E6EEB87B3A64232CFD8205B799BC018634AAE193F19531"
74 "D6EBC19A75F27CFFAA03EB5974898F53FD569AA5CE60F431B53B0CDE715A5F382405C9C4"
75 "761A8E24888328F09F7BCE4E8D80C957DF177629C8421ACCD0C268C63C0DD47C3C0D954F"
76 "D79F7D7297C6788DF4B3E51381759864D880ACA246DF09533739B8BB6085EAF7AE8DC2D9"
77 "F224E6874926C8D24D34B457FD2C9A586C6B99582DC24F787A39E3942786CF1D494B6EB4"
78 "A513498CDA0B217C4E80BCE7DA1C704C35E071AC21E0DA9F57C27C3533F46A8D20B04137"
79 "C1B1384BE4B2EB46";
80 const char *mp15 =
81 "39849CF7FD65AF2E3C4D87FE5526221103D90BA26A6642FFE3C3ECC0887BBBC57E011BF1"
82 "05D822A841653509C68F79EBE51C0099B8CBB04DEF31F36F5954208A3209AC122F0E11D8"
83 "4AE67A494D78336A2066D394D42E27EF6B03DDAF6D69F5112C93E714D27C94F82FC7EF77"
84 "445768C68EAE1C4A1407BE1B303243391D325090449764AE469CC53EC8012C4C02A72F37"
85 "07ED7275D2CC8D0A14B5BCC6BF264941520EBA97E3E6BAE4EE8BC87EE0DDA1F5611A6ECB"
86 "65F8AEF4F184E10CADBDFA5A2FEF828901D18C20785E5CC63473D638762DA80625003711"
87 "9E984AC43E707915B133543AF9D5522C3E7180DC58E1E5381C1FB7DC6A5F4198F3E88FA6"
88 "CBB6DFA8B2D1C763226B253E18BCCB79A29EE82D2DE735078C8AE3C3C86D476AAA08434C"
89 "09C274BDD40A1D8FDE38D6536C22F44E807EB73DE4FB36C9F51E0BC835DDBE3A8EFCF2FE"
90 "672B525769DC39230EE624D5EEDBD837C82A52E153F37378C3AD68A81A7ADBDF3345DBCE"
91 "8FA18CA1DE618EF94DF72EAD928D4F45B9E51632ACF158CF8332C51891D1D12C2A7E6684"
92 "360C4BF177C952579A9F442CFFEC8DAE4821A8E7A31C4861D8464CA9116C60866C5E72F7"
93 "434ADBED36D54ACDFDFF70A4EFB46E285131FE725F1C637D1C62115EDAD01C4189716327"
94 "BFAA79618B1656CBFA22C2C965687D0381CC2FE0245913C4D8D96108213680BD8E93E821"
95 "822AD9DDBFE4BD04";
96 const char *mp16 = "4A724340668DB150339A70";
97 const char *mp17 = "8ADB90F58";
98 const char *mp18 = "C64C230AB20E5";
99 const char *mp19 =
100 "F1C9DACDA287F2E3C88DCE2393B8F53DAAAC1196DC36510962B6B59454CFE64B";
101 const char *mp20 =
102 "D445662C8B6FE394107B867797750C326E0F4A967E135FC430F6CD7207913AC7";
103 const char* mp21 = "2";
104
105 const mp_digit md1 = 0;
106 const mp_digit md2 = 0x1;
107 const mp_digit md3 = 0x80;
108 const mp_digit md4 = 0x9C97;
109 const mp_digit md5 = 0xF5BF;
110 const mp_digit md6 = 0x14A0;
111 const mp_digit md7 = 0x03E8;
112 const mp_digit md8 = 0x0101;
113 const mp_digit md9 = 0xA;
114
115 /*
116 Solutions of the form x_mpABC, where:
117
118 x = (p)roduct, (s)um, (d)ifference, (q)uotient, (r)emainder, (g)cd,
119 (i)nverse, (e)xponent, square roo(t), (g)cd, (l)cm. A
120 leading 'm' indicates a modular operation, e.g. ms_mp12 is the
121 modular sum of operands 1 and 2
122
123 ABC are the operand numbers involved in the computation. If a 'd'
124 precedes the number, it is a digit operand; if a 'c' precedes it,
125 it is a constant; otherwise, it is a full integer.
126 */
127
128 const char *p_mp12 = "4286AD72E095C9FE009938750743174ADDD7FD1E53";
129 const char *p_mp34 = "-46BDBD66CA108C94A8CF46C325F7B6E2F2BA82D35"
130 "A1BFD6934C441EE369B60CA29BADC26845E918B";
131 const char *p_mp57 = "E260C265A0A27C17AD5F4E59D6E0360217A2EBA6";
132 const char *p_mp22 = "7233B5C1097FFC77CCF55928FDC3A5D31B712FDE7A1E91";
133 const char *p_mp1d4 = "3CECEA2331F4220BEF68DED";
134 const char *p_mp8d6 = "6720";
135 const char *p_mp1113 =
136 "11590FC3831C8C3C51813142C88E566408DB04F9E27642F6471A1822E0100B12F7F1"
137 "5699A127C0FA9D26DCBFF458522661F30C6ADA4A07C8C90F9116893F6DBFBF24C3A2"
138 "4340";
139 const char *p_mp1415 =
140 "26B36540DE8B3586699CCEAE218A2842C7D5A01590E70C4A26E789107FBCDB06AA2C"
141 "6DDC39E6FA18B16FCB2E934C9A5F844DAD60EE3B1EA82199EC5E9608F67F860FB965"
142 "736055DF0E8F2540EB28D07F47E309B5F5D7C94FF190AB9C83A6970160CA700B1081"
143 "F60518132AF28C6CEE6B7C473E461ABAC52C39CED50A08DD4E7EA8BA18DAD545126D"
144 "A388F6983C29B6BE3F9DCBC15766E8E6D626A92C5296A9C4653CAE5788350C0E2107"
145 "F57E5E8B6994C4847D727FF1A63A66A6CEF42B9C9E6BD04C92550B85D5527DE8A132"
146 "E6BE89341A9285C7CE7FB929D871BBCBD0ED2863B6B078B0DBB30FCA66D6C64284D6"
147 "57F394A0271E15B6EC7A9D530EBAC6CA262EF6F97E1A29FCE7749240E4AECA591ECF"
148 "272122BC587370F9371B67BB696B3CDC1BC8C5B64B6280994EBA00CDEB8EB0F5D06E"
149 "18F401D65FDCECF23DD7B9BB5B4C5458AEF2CCC09BA7F70EACB844750ACFD027521E"
150 "2E047DE8388B35F8512D3DA46FF1A12D4260213602BF7BFFDB6059439B1BD0676449"
151 "8D98C74F48FB3F548948D5BA0C8ECFCD054465132DC43466D6BBD59FBAF8D6D4E157"
152 "2D612B40A956C7D3E140F3B8562EF18568B24D335707D5BAC7495014DF2444172426"
153 "FD099DED560D30D1F945386604AFC85C64BD1E5F531F5C7840475FC0CF0F79810012"
154 "4572BAF5A9910CDBD02B27FFCC3C7E5E88EF59F3AE152476E33EDA696A4F751E0AE4"
155 "A3D2792DEA78E25B9110E12A19EFD09EA47FF9D6594DA445478BEB6901EAF8A35B2D"
156 "FD59BEE9BF7AA8535B7D326EFA5AA2121B5EBE04DD85827A3D43BD04F4AA6D7B62A2"
157 "B6D7A3077286A511A431E1EF75FCEBA3FAE9D5843A8ED17AA02BBB1B571F904699C5"
158 "A6073F87DDD012E2322AB3F41F2A61F428636FE86914148E19B8EF8314ED83332F2F"
159 "8C2ADE95071E792C0A68B903E060DD322A75FD0C2B992059FCCBB58AFA06B50D1634"
160 "BBD93F187FCE0566609FCC2BABB269C66CEB097598AA17957BB4FDA3E64A1B30402E"
161 "851CF9208E33D52E459A92C63FBB66435BB018E155E2C7F055E0B7AB82CD58FC4889"
162 "372ED9EEAC2A07E8E654AB445B9298D2830D6D4DFD117B9C8ABE3968927DC24B3633"
163 "BAD6E6466DB45DDAE87A0AB00336AC2CCCE176704F7214FCAB55743AB76C2B6CA231"
164 "7984610B27B5786DE55C184DDF556EDFEA79A3652831940DAD941E243F482DC17E50"
165 "284BC2FB1AD712A92542C573E55678878F02DFD9E3A863C7DF863227AEDE14B47AD3"
166 "957190124820ADC19F5353878EDB6BF7D0C77352A6E3BDB53EEB88F5AEF6226D6E68"
167 "756776A8FB49B77564147A641664C2A54F7E5B680CCC6A4D22D894E464DF20537094"
168 "548F1732452F9E7F810C0B4B430C073C0FBCE03F0D03F82630654BCE166AA772E1EE"
169 "DD0C08D3E3EBDF0AF54203B43AFDFC40D8FC79C97A4B0A4E1BEB14D8FCEFDDED8758"
170 "6ED65B18";
171 const char *p_mp2121 = "4";
172 const char *mp_mp345 = "B9B6D3A3";
173 const char *mp_mp335 = "16609C2D";
174
175 const char *s_mp13 = "B55AA8DF8A7E83241F38B2B446B06A4FB84E5DE0";
176 const char *s_mp34 = "517EE6B92EF65C965736EB6BF7C325F73504CEB6";
177 const char *s_mp46 = "-63DBC2265B88268DC801C10EA68476B7BDE0090F";
178 const char *s_mp5d4 = "F59667D9";
179 const char *s_mp2d5 = "AAFC0A3FE45E5E09DBF21E8";
180 const char *s_mp1415 =
181 "E5C43DE2B811F4A084625F96E9504039E5258D8348E698CEB9F4D4292622042DB446"
182 "F75F4B65C1FB7A317257FA354BB5A45E789AEC254EAECE11F80A53E3B513822491DB"
183 "D9399DEC4807A2A3A10360129AC93F4A42388D3BF20B310DD0E9E9F4BE07FC88D53A"
184 "78A26091E0AB506A70813712CCBFBDD440A69A906E650EE090FDD6A42A95AC1A414D"
185 "317F1A9F781E6A30E9EE142ECDA45A1E3454A1417A7B9A613DA90831CF88EA1F2E82"
186 "41AE88CC4053220903C2E05BCDD42F02B8CF8868F84C64C5858BAD356143C5494607"
187 "EE22E11650148BAF65A985F6FC4CA540A55697F2B5AA95D6B8CF96EF638416DE1DD6"
188 "3BA9E2C09E22D03E75B60BE456C642F86B82A709253E5E087B507DE3A45F8392423F"
189 "4DBC284E8DC88C43CA77BC8DCEFB6129A59025F80F90FF978116DEBB9209E306FBB9"
190 "1B6111F8B8CFACB7C7C9BC12691C22EE88303E1713F1DFCEB622B8EA102F6365678B"
191 "C580ED87225467AA78E875868BD53B17574BA59305BC1AC666E4B7E9ED72FCFC200E"
192 "189D98FC8C5C7533739C53F52DDECDDFA5A8668BFBD40DABC9640F8FCAE58F532940"
193 "8162261320A25589E9FB51B50F80056471F24B7E1AEC35D1356FC2747FFC13A04B34"
194 "24FCECE10880BD9D97CA8CDEB2F5969BF4F30256EB5ED2BCD1DC64BDC2EE65217848"
195 "48A37FB13F84ED4FB7ACA18C4639EE64309BDD3D552AEB4AAF44295943DC1229A497"
196 "A84A";
197
198 const char *ms_mp345 = "1E71E292";
199
200 const char *d_mp12 = "-AAFBA6A55DD183FD854A60E";
201 const char *d_mp34 = "119366B05E606A9B1E73A6D8944CC1366B0C4E0D4";
202 const char *d_mp5d4 = "F5952EAB";
203 const char *d_mp6d2 = "-1";
204 const char *md_mp345 = "26596B86";
205
206 const char *q_mp42 = "-95825A1FFA1A155D5";
207 const char *r_mp42 = "-6312E99D7700A3DCB32ADF2";
208 const char *q_mp45a = "15344CDA3D841F661D2B61B6EDF7828CE36";
209 const char *r_mp45a = "-47C47B";
210 const char *q_mp7c2 = "75FD3890E6C1C67321CE62CEEDA65F79";
211 const char *q_mp3d6 = "8CAFD53C272BD6FE8B0847BDC3B539EFAB5C3";
212 const char *r_mp3d6 = "1E5";
213 const char *r_mp5d5 = "1257";
214 const char *r_mp47 = "B3A9018D970281A90FB729A181D95CB8";
215 const char *q_mp1404 =
216 "-1B994D869142D3EF6123A3CBBC3C0114FA071CFCEEF4B7D231D65591D32501AD80F"
217 "FF49AE4EC80514CC071EF6B42521C2508F4CB2FEAD69A2D2EF3934087DCAF88CC4C4"
218 "659F1CA8A7F4D36817D802F778F1392337FE36302D6865BF0D4645625DF8BB044E19"
219 "930635BE2609FAC8D99357D3A9F81F2578DE15A300964188292107DAC980E0A08CD7"
220 "E938A2135FAD45D50CB1D8C2D4C4E60C27AB98B9FBD7E4DBF752C57D2674520E4BB2"
221 "7E42324C0EFE84FB3E38CF6950E699E86FD45FE40D428400F2F94EDF7E94FAE10B45"
222 "89329E1BF61E5A378C7B31C9C6A234F8254D4C24823B84D0BF8D671D8BC9154DFAC9"
223 "49BD8ACABD6BD32DD4DC587F22C86153CB3954BDF7C2A890D623642492C482CF3E2C"
224 "776FC019C3BBC61688B485E6FD35D6376089C1E33F880E84C4E51E8ABEACE1B3FB70"
225 "3EAD0E28D2D44E7F1C0A859C840775E94F8C1369D985A3C5E8114B21D68B3CBB75D2"
226 "791C586153C85B90CAA483E57A40E2D97950AAB84920A4396C950C87C7FFFE748358"
227 "42A0BF65445B26D40F05BE164B822CA96321F41D85A289C5F5CD5F438A78704C9683"
228 "422299D21899A22F853B0C93081CC9925E350132A0717A611DD932A68A0ACC6E4C7F"
229 "7F685EF8C1F4910AEA5DC00BB5A36FCA07FFEAA490C547F6E14A08FE87041AB803E1"
230 "BD9E23E4D367A2C35762F209073DFF48F3";
231 const char *r_mp1404 = "12FF98621ABF63144BFFC3207AC8FC10D8D1A09";
232
233 const char *q_mp13c =
234 "34584F700C15A341E40BF7BFDD88A6630C8FF2B2067469372D391342"
235 "BDAB6163963CD5A5C79F708BDE26E0CCF2DB66CD6D6089E29A877C45";
236 const char *r_mp13c = "F2B050D226E6DA88";
237 const char *q_mp9c16 = "F74A2876A1432698923B0767DA19DCF3D71795E";
238 const char *r_mp9c16 = "E";
239
240 const char *e_mp5d9 = "A8FD7145E727A20E52E73D22990D35D158090307A"
241 "13A5215AAC4E9AB1E96BD34E531209E03310400";
242 const char *e_mp78 = "AA5F72C737DFFD8CCD108008BFE7C79ADC01A819B"
243 "32B75FB82EC0FB8CA83311DA36D4063F1E57857A2"
244 "1AB226563D84A15BB63CE975FF1453BD6750C58D9"
245 "D113175764F5D0B3C89B262D4702F4D9640A3";
246 const char *me_mp817 = "E504493ACB02F7F802B327AB13BF25";
247 const char *me_mp5d47 = "1D45ED0D78F2778157992C951DD2734C";
248 const char *me_mp1512 = "FB5B2A28D902B9D9";
249 const char *me_mp161718 = "423C6AC6DBD74";
250 const char *me_mp5114 =
251 "64F0F72807993578BBA3C7C36FFB184028F9EB9A810C92079E1498D8A80FC848E1F0"
252 "25F1DE43B7F6AC063F5CC29D8A7C2D7A66269D72BF5CDC327AF88AF8EF9E601DCB0A"
253 "3F35BFF3525FB1B61CE3A25182F17C0A0633B4089EA15BDC47664A43FEF639748AAC"
254 "19CF58E83D8FA32CD10661D2D4210CC84792937E6F36CB601851356622E63ADD4BD5"
255 "542412C2E0C4958E51FD2524AABDC7D60CFB5DB332EEC9DC84210F10FAE0BA2018F2"
256 "14C9D6867C9D6E49CF28C18D06CE009FD4D04BFC8837C3FAAA773F5CCF6DED1C22DE"
257 "181786AFE188540586F2D74BF312E595244E6936AE52E45742109BAA76C36F2692F5"
258 "CEF97AD462B138BE92721194B163254CBAAEE9B9864B21CCDD5375BCAD0D24132724"
259 "113D3374B4BCF9AA49BA5ACBC12288C0BCF46DCE6CB4A241A91BD559B130B6E9CD3D"
260 "D7A2C8B280C2A278BA9BF5D93244D563015C9484B86D9FEB602501DC16EEBC3EFF19"
261 "53D7999682BF1A1E3B2E7B21F4BDCA3C355039FEF55B9C0885F98DC355CA7A6D8ECF"
262 "5F7F1A6E11A764F2343C823B879B44616B56BF6AE3FA2ACF5483660E618882018E3F"
263 "C8459313BACFE1F93CECC37B2576A5C0B2714BD3EEDEEC22F0E7E3E77B11396B9B99"
264 "D683F2447A4004BBD4A57F6A616CDDFEC595C4FC19884CC2FC21CF5BF5B0B81E0F83"
265 "B9DDA0CF4DFF35BB8D31245912BF4497FD0BD95F0C604E26EA5A8EA4F5EAE870A5BD"
266 "FE8C";
267
268 const char *e_mpc2d3 = "100000000000000000000000000000000";
269
270 const char *t_mp9 = "FB9B6E32FF0452A34746";
271 const char *i_mp27 = "B6AD8DCCDAF92B6FE57D062FFEE3A99";
272 const char *i_mp2019 =
273 "BDF3D88DC373A63EED92903115B03FC8501910AF68297B4C41870AED3EA9F839";
274 /* "15E3FE09E8AE5523AABA197BD2D16318D3CA148EDF4AE1C1C52FC96AFAF5680B"; */
275
276
277 const char *t_mp15 =
278 "795853094E59B0008093BCA8DECF68587C64BDCA2F3F7F8963DABC12F1CFFFA9B8C4"
279 "365232FD4751870A0EF6CA619287C5D8B7F1747D95076AB19645EF309773E9EACEA0"
280 "975FA4AE16251A8DA5865349C3A903E3B8A2C0DEA3C0720B6020C7FED69AFF62BB72"
281 "10FAC443F9FFA2950776F949E819260C2AF8D94E8A1431A40F8C23C1973DE5D49AA2"
282 "0B3FF5DA5C1D5324E712A78FF33A9B1748F83FA529905924A31DF38643B3F693EF9B"
283 "58D846BB1AEAE4523ECC843FF551C1B300A130B65C1677402778F98C51C10813250E"
284 "2496882877B069E877B59740DC1226F18A5C0F66F64A5F59A9FAFC5E9FC45AEC0E7A"
285 "BEE244F7DD3AC268CF512A0E52E4F5BE5B94";
286
287 const char *g_mp71 = "1";
288 const char *g_mp25 = "7";
289 const char *l_mp1011 = "C589E3D7D64A6942A000";
290
291 /* mp9 in radices from 5 to 64 inclusive */
292 #define LOW_RADIX 5
293 #define HIGH_RADIX 64
294 const char *v_mp9[] = {
295 "404041130042310320100141302000203430214122130002340212132414134210033",
296 "44515230120451152500101352430105520150025145320010504454125502",
297 "644641136612541136016610100564613624243140151310023515322",
298 "173512120732412062323044435407317550316717172705712756",
299 "265785018434285762514442046172754680368422060744852",
300 "1411774500397290569709059837552310354075408897518",
301 "184064268501499311A17746095910428222A241708032A",
302 "47706011B225950B02BB45602AA039893118A85950892",
303 "1A188C826B982353CB58422563AC602B783101671A86",
304 "105957B358B89B018958908A9114BC3DDC410B77982",
305 "CB7B3387E23452178846C55DD9D70C7CA9AEA78E8",
306 "F74A2876A1432698923B0767DA19DCF3D71795EE",
307 "17BF7C3673B76D7G7A5GA836277296F806E7453A",
308 "2EBG8HH3HFA6185D6H0596AH96G24C966DD3HG2",
309 "6G3HGBFEG8I3F25EAF61B904EIA40CFDH2124F",
310 "10AHC3D29EBHDF3HD97905CG0JA8061855C3FI",
311 "3BA5A55J5K699B2D09C38A4B237CH51IHA132",
312 "EDEA90DJ0B5CB3FGG1C8587FEB99D3C143CA",
313 "31M26JI1BBD56K3I028MML4EEDMAJK60LGLE",
314 "GGG5M3142FKKG82EJ28111D70EMHC241E4E",
315 "4446F4D5H10982023N297BF0DKBBHLLJB0I",
316 "12E9DEEOBMKAKEP0IM284MIP7FO1O521M46",
317 "85NN0HD48NN2FDDB1F5BMMKIB8CK20MDPK",
318 "2D882A7A0O0JPCJ4APDRIB77IABAKDGJP2",
319 "MFMCI0R7S27AAA3O3L2S8K44HKA7O02CN",
320 "7IGQS73FFSHC50NNH44B6PTTNLC3M6H78",
321 "2KLUB3U9850CSN6ANIDNIF1LB29MJ43LH",
322 "UT52GTL18CJ9H4HR0TJTK6ESUFBHF5FE",
323 "BTVL87QQBMUGF8PFWU4W3VU7U922QTMW",
324 "4OG10HW0MSWJBIDEE2PDH24GA7RIHIAA",
325 "1W8W9AX2DRUX48GXOLMK0PE42H0FEUWN",
326 "SVWI84VBH069WR15W1U2VTK06USY8Z2",
327 "CPTPNPDa5TYCPPNLALENT9IMX2GL0W2",
328 "5QU21UJMRaUYYYYYN6GHSMPOYOXEEUY",
329 "2O2Q7C6RPPB1SXJ9bR4035SPaQQ3H2W",
330 "18d994IbT4PHbD7cGIPCRP00bbQO0bc",
331 "NcDUEEWRO7XT76260WGeBHPVa72RdA",
332 "BbX2WCF9VfSB5LPdJAdeXKV1fd6LC2",
333 "60QDKW67P4JSQaTdQg7JE9ISafLaVU",
334 "33ba9XbDbRdNF4BeDB2XYMhAVDaBdA",
335 "1RIPZJA8gT5L5H7fTcaRhQ39geMMTc",
336 "d65j70fBATjcDiidPYXUGcaBVVLME",
337 "LKA9jhPabDG612TXWkhfT2gMXNIP2",
338 "BgNaYhjfT0G8PBcYRP8khJCR3C9QE",
339 "6Wk8RhJTAgDh10fYAiUVB1aM0HacG",
340 "3dOCjaf78kd5EQNViUZWj3AfFL90I",
341 "290VWkL3aiJoW4MBbHk0Z0bDo22Ni",
342 "1DbDZ1hpPZNUDBUp6UigcJllEdC26",
343 "dFSOLBUM7UZX8Vnc6qokGIOiFo1h",
344 "NcoUYJOg0HVmKI9fR2ag0S8R2hrK",
345 "EOpiJ5Te7oDe2pn8ZhAUKkhFHlZh",
346 "8nXK8rp8neV8LWta1WDgd1QnlWsU",
347 "5T3d6bcSBtHgrH9bCbu84tblaa7r",
348 "3PlUDIYUvMqOVCir7AtquK5dWanq",
349 "2A70gDPX2AtiicvIGGk9poiMtgvu",
350 "1MjiRxjk10J6SVAxFguv9kZiUnIc",
351 "rpre2vIDeb4h3sp50r1YBbtEx9L",
352 "ZHcoip0AglDAfibrsUcJ9M1C8fm",
353 "NHP18+eoe6uU54W49Kc6ZK7+bT2",
354 "FTAA7QXGoQOaZi7PzePtFFN5vNk"
355 };
356
357 const unsigned char b_mp4[] = {
358 0x01,
359 #if MP_DIGIT_MAX > MP_32BIT_MAX
360 0x00, 0x00, 0x00, 0x00,
361 #endif
362 0x63, 0xDB, 0xC2, 0x26,
363 0x5B, 0x88, 0x26, 0x8D,
364 0xC8, 0x01, 0xC1, 0x0E,
365 0xA6, 0x84, 0x76, 0xB7,
366 0xBD, 0xE0, 0x09, 0x0F
367 };
368
369 /* Search for a test suite name in the names table */
370 int find_name(char *name);
371 void reason(char *fmt, ...);
372
373 /*------------------------------------------------------------------------*/
374 /*------------------------------------------------------------------------*/
375
376 char g_intbuf[4096]; /* buffer for integer comparison */
377 char a_intbuf[4096]; /* buffer for integer comparison */
378 int g_verbose = 1; /* print out reasons for failure? */
379 int res;
380
381 #define IFOK(x) { if (MP_OKAY > (res = (x))) { \
382 reason("test %s failed: error %d\n", #x, res); return 1; }}
383
384 int main(int argc, char *argv[])
385 {
386 int which, res;
387
388 srand((unsigned int)time(NULL));
389
390 if (argc < 2) {
391 fprintf(stderr, "Usage: %s <test-suite> | list\n"
392 "Type '%s help' for assistance\n", argv[0], argv[0]);
393 return 2;
394 } else if(argc > 2) {
395 if(strcmp(argv[2], "quiet") == 0)
396 g_verbose = 0;
397 }
398
399 if(strcmp(argv[1], "help") == 0) {
400 fprintf(stderr, "Help for mpi-test\n\n"
401 "This program is a test driver for the MPI library, which\n"
402 "tests all the various functions in the library to make sure\n"
403 "they are working correctly. The syntax is:\n"
404 " %s <suite-name>\n"
405 "...where <suite-name> is the name of the test you wish to\n"
406 "run. To get a list of the tests, use '%s list'.\n\n"
407 "The program exits with a status of zero if the test passes,\n"
408 "or non-zero if it fails. Ordinarily, failure is accompanied\n"
409 "by a diagnostic message to standard error. To suppress this\n"
410 "add the keyword 'quiet' after the suite-name on the command\n"
411 "line.\n\n", argv[0], argv[0]);
412 return 0;
413 }
414
415 if ((which = find_name(argv[1])) < 0) {
416 fprintf(stderr, "%s: test suite '%s' is not known\n", argv[0], argv[1]);
417 return 2;
418 }
419
420 if((res = (g_tests[which])()) < 0) {
421 fprintf(stderr, "%s: test suite not implemented yet\n", argv[0]);
422 return 2;
423 } else {
424 return res;
425 }
426
427 }
428
429 /*------------------------------------------------------------------------*/
430
431 int find_name(char *name)
432 {
433 int ix = 0;
434
435 while(ix < g_count) {
436 if (strcmp(name, g_names[ix]) == 0)
437 return ix;
438
439 ++ix;
440 }
441
442 return -1;
443 }
444
445 /*------------------------------------------------------------------------*/
446
447 int test_list(void)
448 {
449 int ix;
450
451 fprintf(stderr, "There are currently %d test suites available\n",
452 g_count);
453
454 for(ix = 1; ix < g_count; ix++)
455 fprintf(stdout, "%-20s %s\n", g_names[ix], g_descs[ix]);
456
457 return 0;
458 }
459
460 /*------------------------------------------------------------------------*/
461
462 int test_copy(void)
463 {
464 mp_int a, b;
465 int ix;
466
467 mp_init(&a); mp_init(&b);
468
469 mp_read_radix(&a, mp3, 16);
470 mp_copy(&a, &b);
471
472 if(SIGN(&a) != SIGN(&b) || USED(&a) != USED(&b)) {
473 if(SIGN(&a) != SIGN(&b)) {
474 reason("error: sign of original is %d, sign of copy is %d\n",
475 SIGN(&a), SIGN(&b));
476 } else {
477 reason("error: original precision is %d, copy precision is %d\n",
478 USED(&a), USED(&b));
479 }
480 mp_clear(&a); mp_clear(&b);
481 return 1;
482 }
483
484 for(ix = 0; ix < USED(&b); ix++) {
485 if(DIGIT(&a, ix) != DIGIT(&b, ix)) {
486 reason("error: digit %d " DIGIT_FMT " != " DIGIT_FMT "\n",
487 ix, DIGIT(&a, ix), DIGIT(&b, ix));
488 mp_clear(&a); mp_clear(&b);
489 return 1;
490 }
491 }
492
493 mp_clear(&a); mp_clear(&b);
494 return 0;
495 }
496
497 /*------------------------------------------------------------------------*/
498
499 int test_exch(void)
500 {
501 mp_int a, b;
502
503 mp_init(&a); mp_init(&b);
504 mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp1, 16);
505
506 mp_exch(&a, &b);
507 mp_toradix(&a, g_intbuf, 16);
508
509 mp_clear(&a);
510 if(strcmp(g_intbuf, mp1) != 0) {
511 mp_clear(&b);
512 reason("error: exchange failed\n");
513 return 1;
514 }
515
516 mp_toradix(&b, g_intbuf, 16);
517
518 mp_clear(&b);
519 if(strcmp(g_intbuf, mp7) != 0) {
520 reason("error: exchange failed\n");
521 return 1;
522 }
523
524 return 0;
525 }
526
527 /*------------------------------------------------------------------------*/
528
529 int test_zero(void)
530 {
531 mp_int a;
532
533 mp_init(&a); mp_read_radix(&a, mp7, 16);
534 mp_zero(&a);
535
536 if(USED(&a) != 1 || DIGIT(&a, 1) != 0) {
537 mp_toradix(&a, g_intbuf, 16);
538 reason("error: result is %s\n", g_intbuf);
539 mp_clear(&a);
540 return 1;
541 }
542
543 mp_clear(&a);
544 return 0;
545 }
546
547 /*------------------------------------------------------------------------*/
548
549 int test_set(void)
550 {
551 mp_int a;
552
553 /* Test single digit set */
554 mp_init(&a); mp_set(&a, 5);
555 if(DIGIT(&a, 0) != 5) {
556 mp_toradix(&a, g_intbuf, 16);
557 reason("error: result is %s, expected 5\n", g_intbuf);
558 mp_clear(&a);
559 return 1;
560 }
561
562 /* Test integer set */
563 mp_set_int(&a, -4938110);
564 mp_toradix(&a, g_intbuf, 16);
565 mp_clear(&a);
566 if(strcmp(g_intbuf, mp5a) != 0) {
567 reason("error: result is %s, expected %s\n", g_intbuf, mp5a);
568 return 1;
569 }
570
571 return 0;
572 }
573
574 /*------------------------------------------------------------------------*/
575
576 int test_abs(void)
577 {
578 mp_int a;
579
580 mp_init(&a); mp_read_radix(&a, mp4, 16);
581 mp_abs(&a, &a);
582
583 if(SIGN(&a) != ZPOS) {
584 reason("error: sign of result is negative\n");
585 mp_clear(&a);
586 return 1;
587 }
588
589 mp_clear(&a);
590 return 0;
591 }
592
593 /*------------------------------------------------------------------------*/
594
595 int test_neg(void)
596 {
597 mp_int a;
598 mp_sign s;
599
600 mp_init(&a); mp_read_radix(&a, mp4, 16);
601
602 s = SIGN(&a);
603 mp_neg(&a, &a);
604 if(SIGN(&a) == s) {
605 reason("error: sign of result is same as sign of nonzero input\n");
606 mp_clear(&a);
607 return 1;
608 }
609
610 mp_clear(&a);
611 return 0;
612 }
613
614 /*------------------------------------------------------------------------*/
615
616 int test_add_d(void)
617 {
618 mp_int a;
619
620 mp_init(&a);
621
622 mp_read_radix(&a, mp5, 16);
623 mp_add_d(&a, md4, &a);
624 mp_toradix(&a, g_intbuf, 16);
625
626 if(strcmp(g_intbuf, s_mp5d4) != 0) {
627 reason("error: computed %s, expected %s\n", g_intbuf, s_mp5d4);
628 mp_clear(&a);
629 return 1;
630 }
631
632 mp_read_radix(&a, mp2, 16);
633 mp_add_d(&a, md5, &a);
634 mp_toradix(&a, g_intbuf, 16);
635
636 if(strcmp(g_intbuf, s_mp2d5) != 0) {
637 reason("error: computed %s, expected %s\n", g_intbuf, s_mp2d5);
638 mp_clear(&a);
639 return 1;
640 }
641
642 mp_clear(&a);
643 return 0;
644 }
645
646 /*------------------------------------------------------------------------*/
647
648 int test_add(void)
649 {
650 mp_int a, b;
651 int res = 0;
652
653 mp_init(&a); mp_init(&b);
654
655 mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp3, 16);
656 mp_add(&a, &b, &a);
657 mp_toradix(&a, g_intbuf, 16);
658
659 if(strcmp(g_intbuf, s_mp13) != 0) {
660 reason("error: computed %s, expected %s\n", g_intbuf, s_mp13);
661 res = 1; goto CLEANUP;
662 }
663
664 mp_read_radix(&a, mp4, 16);
665 mp_add(&a, &b, &a);
666 mp_toradix(&a, g_intbuf, 16);
667
668 if(strcmp(g_intbuf, s_mp34) != 0) {
669 reason("error: computed %s, expected %s\n", g_intbuf, s_mp34);
670 res = 1; goto CLEANUP;
671 }
672
673 mp_read_radix(&a, mp4, 16); mp_read_radix(&b, mp6, 16);
674 mp_add(&a, &b, &a);
675 mp_toradix(&a, g_intbuf, 16);
676
677 if(strcmp(g_intbuf, s_mp46) != 0) {
678 reason("error: computed %s, expected %s\n", g_intbuf, s_mp46);
679 res = 1; goto CLEANUP;
680 }
681
682 mp_read_radix(&a, mp14, 16); mp_read_radix(&b, mp15, 16);
683 mp_add(&a, &b, &a);
684 mp_toradix(&a, g_intbuf, 16);
685
686 if(strcmp(g_intbuf, s_mp1415) != 0) {
687 reason("error: computed %s, expected %s\n", g_intbuf, s_mp1415);
688 res = 1;
689 }
690
691 CLEANUP:
692 mp_clear(&a); mp_clear(&b);
693 return res;
694 }
695
696 /*------------------------------------------------------------------------*/
697
698 int test_sub_d(void)
699 {
700 mp_int a;
701
702 mp_init(&a);
703 mp_read_radix(&a, mp5, 16);
704
705 mp_sub_d(&a, md4, &a);
706 mp_toradix(&a, g_intbuf, 16);
707
708 if(strcmp(g_intbuf, d_mp5d4) != 0) {
709 reason("error: computed %s, expected %s\n", g_intbuf, d_mp5d4);
710 mp_clear(&a);
711 return 1;
712 }
713
714 mp_read_radix(&a, mp6, 16);
715
716 mp_sub_d(&a, md2, &a);
717 mp_toradix(&a, g_intbuf, 16);
718
719 mp_clear(&a);
720 if(strcmp(g_intbuf, d_mp6d2) != 0) {
721 reason("error: computed %s, expected %s\n", g_intbuf, d_mp6d2);
722 return 1;
723 }
724
725 return 0;
726 }
727
728 /*------------------------------------------------------------------------*/
729
730 int test_sub(void)
731 {
732 mp_int a, b;
733
734 mp_init(&a); mp_init(&b);
735
736 mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp2, 16);
737 mp_sub(&a, &b, &a);
738 mp_toradix(&a, g_intbuf, 16);
739
740 if(strcmp(g_intbuf, d_mp12) != 0) {
741 reason("error: computed %s, expected %s\n", g_intbuf, d_mp12);
742 mp_clear(&a); mp_clear(&b);
743 return 1;
744 }
745
746 mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
747 mp_sub(&a, &b, &a);
748 mp_toradix(&a, g_intbuf, 16);
749
750 if(strcmp(g_intbuf, d_mp34) != 0) {
751 reason("error: computed %s, expected %s\n", g_intbuf, d_mp34);
752 mp_clear(&a); mp_clear(&b);
753 return 1;
754 }
755
756 mp_clear(&a); mp_clear(&b);
757 return 0;
758 }
759
760 /*------------------------------------------------------------------------*/
761
762 int test_mul_d(void)
763 {
764 mp_int a;
765
766 mp_init(&a);
767 mp_read_radix(&a, mp1, 16);
768
769 IFOK( mp_mul_d(&a, md4, &a) );
770 mp_toradix(&a, g_intbuf, 16);
771
772 if(strcmp(g_intbuf, p_mp1d4) != 0) {
773 reason("error: computed %s, expected %s\n", g_intbuf, p_mp1d4);
774 mp_clear(&a);
775 return 1;
776 }
777
778 mp_read_radix(&a, mp8, 16);
779 IFOK( mp_mul_d(&a, md6, &a) );
780 mp_toradix(&a, g_intbuf, 16);
781
782 mp_clear(&a);
783 if(strcmp(g_intbuf, p_mp8d6) != 0) {
784 reason("error: computed %s, expected %s\n", g_intbuf, p_mp8d6);
785 return 1;
786 }
787
788 return 0;
789 }
790
791 /*------------------------------------------------------------------------*/
792
793 int test_mul(void)
794 {
795 mp_int a, b;
796 int res = 0;
797
798 mp_init(&a); mp_init(&b);
799 mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp2, 16);
800
801 IFOK( mp_mul(&a, &b, &a) );
802 mp_toradix(&a, g_intbuf, 16);
803
804 if(strcmp(g_intbuf, p_mp12) != 0) {
805 reason("error: computed %s, expected %s\n", g_intbuf, p_mp12);
806 res = 1; goto CLEANUP;
807 }
808
809 mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
810 IFOK( mp_mul(&a, &b, &a) );
811 mp_toradix(&a, g_intbuf, 16);
812
813 if(strcmp(g_intbuf, p_mp34) !=0) {
814 reason("error: computed %s, expected %s\n", g_intbuf, p_mp34);
815 res = 1; goto CLEANUP;
816 }
817
818 mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp7, 16);
819 IFOK( mp_mul(&a, &b, &a) );
820 mp_toradix(&a, g_intbuf, 16);
821
822 if(strcmp(g_intbuf, p_mp57) != 0) {
823 reason("error: computed %s, expected %s\n", g_intbuf, p_mp57);
824 res = 1; goto CLEANUP;
825 }
826
827 mp_read_radix(&a, mp11, 16); mp_read_radix(&b, mp13, 16);
828 IFOK( mp_mul(&a, &b, &a) );
829 mp_toradix(&a, g_intbuf, 16);
830
831 if(strcmp(g_intbuf, p_mp1113) != 0) {
832 reason("error: computed %s, expected %s\n", g_intbuf, p_mp1113);
833 res = 1; goto CLEANUP;
834 }
835
836 mp_read_radix(&a, mp14, 16); mp_read_radix(&b, mp15, 16);
837 IFOK( mp_mul(&a, &b, &a) );
838 mp_toradix(&a, g_intbuf, 16);
839
840 if(strcmp(g_intbuf, p_mp1415) != 0) {
841 reason("error: computed %s, expected %s\n", g_intbuf, p_mp1415);
842 res = 1;
843 }
844 mp_read_radix(&a, mp21, 10); mp_read_radix(&b, mp21, 10);
845
846 IFOK( mp_mul(&a, &b, &a) );
847 mp_toradix(&a, g_intbuf, 10);
848
849 if(strcmp(g_intbuf, p_mp2121) != 0) {
850 reason("error: computed %s, expected %s\n", g_intbuf, p_mp2121);
851 res = 1; goto CLEANUP;
852 }
853
854 CLEANUP:
855 mp_clear(&a); mp_clear(&b);
856 return res;
857
858 }
859
860 /*------------------------------------------------------------------------*/
861
862 int test_sqr(void)
863 {
864 mp_int a;
865
866 mp_init(&a); mp_read_radix(&a, mp2, 16);
867
868 mp_sqr(&a, &a);
869 mp_toradix(&a, g_intbuf, 16);
870
871 mp_clear(&a);
872 if(strcmp(g_intbuf, p_mp22) != 0) {
873 reason("error: computed %s, expected %s\n", g_intbuf, p_mp22);
874 return 1;
875 }
876
877 return 0;
878 }
879
880 /*------------------------------------------------------------------------*/
881
882 int test_div_d(void)
883 {
884 mp_int a, q;
885 mp_digit r;
886 int err = 0;
887
888 mp_init(&a); mp_init(&q);
889 mp_read_radix(&a, mp3, 16);
890
891 IFOK( mp_div_d(&a, md6, &q, &r) );
892 mp_toradix(&q, g_intbuf, 16);
893
894 if(strcmp(g_intbuf, q_mp3d6) != 0) {
895 reason("error: computed q = %s, expected %s\n", g_intbuf, q_mp3d6);
896 ++err;
897 }
898
899 sprintf(g_intbuf, ZS_DIGIT_FMT, r);
900
901 if(strcmp(g_intbuf, r_mp3d6) != 0) {
902 reason("error: computed r = %s, expected %s\n", g_intbuf, r_mp3d6);
903 ++err;
904 }
905
906 mp_read_radix(&a, mp9, 16);
907 IFOK( mp_div_d(&a, 16, &q, &r) );
908 mp_toradix(&q, g_intbuf, 16);
909
910 if(strcmp(g_intbuf, q_mp9c16) != 0) {
911 reason("error: computed q = %s, expected %s\n", g_intbuf, q_mp9c16);
912 ++err;
913 }
914
915 sprintf(g_intbuf, ZS_DIGIT_FMT, r);
916
917 if(strcmp(g_intbuf, r_mp9c16) != 0) {
918 reason("error: computed r = %s, expected %s\n", g_intbuf, r_mp9c16);
919 ++err;
920 }
921
922 mp_clear(&a); mp_clear(&q);
923 return err;
924 }
925
926 /*------------------------------------------------------------------------*/
927
928 int test_div_2(void)
929 {
930 mp_int a;
931
932 mp_init(&a); mp_read_radix(&a, mp7, 16);
933 IFOK( mp_div_2(&a, &a) );
934 mp_toradix(&a, g_intbuf, 16);
935
936 mp_clear(&a);
937 if(strcmp(g_intbuf, q_mp7c2) != 0) {
938 reason("error: computed %s, expected %s\n", g_intbuf, q_mp7c2);
939 return 1;
940 }
941
942 return 0;
943 }
944
945 /*------------------------------------------------------------------------*/
946
947 int test_div_2d(void)
948 {
949 mp_int a, q, r;
950
951 mp_init(&q); mp_init(&r);
952 mp_init(&a); mp_read_radix(&a, mp13, 16);
953
954 IFOK( mp_div_2d(&a, 64, &q, &r) );
955 mp_clear(&a);
956
957 mp_toradix(&q, g_intbuf, 16);
958
959 if(strcmp(g_intbuf, q_mp13c) != 0) {
960 reason("error: computed %s, expected %s\n", g_intbuf, q_mp13c);
961 mp_clear(&q); mp_clear(&r);
962 return 1;
963 }
964
965 mp_clear(&q);
966
967 mp_toradix(&r, g_intbuf, 16);
968 if(strcmp(g_intbuf, r_mp13c) != 0) {
969 reason("error, computed %s, expected %s\n", g_intbuf, r_mp13c);
970 mp_clear(&r);
971 return 1;
972 }
973
974 mp_clear(&r);
975
976 return 0;
977 }
978
979 /*------------------------------------------------------------------------*/
980
981 int test_div(void)
982 {
983 mp_int a, b, r;
984 int err = 0;
985
986 mp_init(&a); mp_init(&b); mp_init(&r);
987
988 mp_read_radix(&a, mp4, 16); mp_read_radix(&b, mp2, 16);
989 IFOK( mp_div(&a, &b, &a, &r) );
990 mp_toradix(&a, g_intbuf, 16);
991
992 if(strcmp(g_intbuf, q_mp42) != 0) {
993 reason("error: test 1 computed quot %s, expected %s\n", g_intbuf, q_mp42);
994 ++err;
995 }
996
997 mp_toradix(&r, g_intbuf, 16);
998
999 if(strcmp(g_intbuf, r_mp42) != 0) {
1000 reason("error: test 1 computed rem %s, expected %s\n", g_intbuf, r_mp42);
1001 ++err;
1002 }
1003
1004 mp_read_radix(&a, mp4, 16); mp_read_radix(&b, mp5a, 16);
1005 IFOK( mp_div(&a, &b, &a, &r) );
1006 mp_toradix(&a, g_intbuf, 16);
1007
1008 if(strcmp(g_intbuf, q_mp45a) != 0) {
1009 reason("error: test 2 computed quot %s, expected %s\n", g_intbuf, q_mp45a);
1010 ++err;
1011 }
1012
1013 mp_toradix(&r, g_intbuf, 16);
1014
1015 if(strcmp(g_intbuf, r_mp45a) != 0) {
1016 reason("error: test 2 computed rem %s, expected %s\n", g_intbuf, r_mp45a);
1017 ++err;
1018 }
1019
1020 mp_read_radix(&a, mp14, 16); mp_read_radix(&b, mp4, 16);
1021 IFOK( mp_div(&a, &b, &a, &r) );
1022 mp_toradix(&a, g_intbuf, 16);
1023
1024 if(strcmp(g_intbuf, q_mp1404) != 0) {
1025 reason("error: test 3 computed quot %s, expected %s\n", g_intbuf, q_mp1404);
1026 ++err;
1027 }
1028
1029 mp_toradix(&r, g_intbuf, 16);
1030
1031 if(strcmp(g_intbuf, r_mp1404) != 0) {
1032 reason("error: test 3 computed rem %s, expected %s\n", g_intbuf, r_mp1404);
1033 ++err;
1034 }
1035
1036 mp_clear(&a); mp_clear(&b); mp_clear(&r);
1037
1038 return err;
1039 }
1040
1041 /*------------------------------------------------------------------------*/
1042
1043 int test_expt_d(void)
1044 {
1045 mp_int a;
1046
1047 mp_init(&a); mp_read_radix(&a, mp5, 16);
1048 mp_expt_d(&a, md9, &a);
1049 mp_toradix(&a, g_intbuf, 16);
1050
1051 mp_clear(&a);
1052 if(strcmp(g_intbuf, e_mp5d9) != 0) {
1053 reason("error: computed %s, expected %s\n", g_intbuf, e_mp5d9);
1054 return 1;
1055 }
1056
1057 return 0;
1058 }
1059
1060 /*------------------------------------------------------------------------*/
1061
1062 int test_expt(void)
1063 {
1064 mp_int a, b;
1065
1066 mp_init(&a); mp_init(&b);
1067 mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp8, 16);
1068
1069 mp_expt(&a, &b, &a);
1070 mp_toradix(&a, g_intbuf, 16);
1071 mp_clear(&a); mp_clear(&b);
1072
1073 if(strcmp(g_intbuf, e_mp78) != 0) {
1074 reason("error: computed %s, expected %s\n", g_intbuf, e_mp78);
1075 return 1;
1076 }
1077
1078 return 0;
1079 }
1080
1081 /*------------------------------------------------------------------------*/
1082
1083 int test_2expt(void)
1084 {
1085 mp_int a;
1086
1087 mp_init(&a);
1088 mp_2expt(&a, md3);
1089 mp_toradix(&a, g_intbuf, 16);
1090 mp_clear(&a);
1091
1092 if(strcmp(g_intbuf, e_mpc2d3) != 0) {
1093 reason("error: computed %s, expected %s\n", g_intbuf, e_mpc2d3);
1094 return 1;
1095 }
1096
1097 return 0;
1098 }
1099
1100 /*------------------------------------------------------------------------*/
1101
1102 int test_sqrt(void)
1103 {
1104 mp_int a;
1105 int res = 0;
1106
1107 mp_init(&a); mp_read_radix(&a, mp9, 16);
1108 mp_sqrt(&a, &a);
1109 mp_toradix(&a, g_intbuf, 16);
1110
1111 if(strcmp(g_intbuf, t_mp9) != 0) {
1112 reason("error: computed %s, expected %s\n", g_intbuf, t_mp9);
1113 res = 1; goto CLEANUP;
1114 }
1115
1116 mp_read_radix(&a, mp15, 16);
1117 mp_sqrt(&a, &a);
1118 mp_toradix(&a, g_intbuf, 16);
1119
1120 if(strcmp(g_intbuf, t_mp15) != 0) {
1121 reason("error: computed %s, expected %s\n", g_intbuf, t_mp15);
1122 res = 1;
1123 }
1124
1125 CLEANUP:
1126 mp_clear(&a);
1127 return res;
1128 }
1129
1130 /*------------------------------------------------------------------------*/
1131
1132 int test_mod_d(void)
1133 {
1134 mp_int a;
1135 mp_digit r;
1136
1137 mp_init(&a); mp_read_radix(&a, mp5, 16);
1138 IFOK( mp_mod_d(&a, md5, &r) );
1139 sprintf(g_intbuf, ZS_DIGIT_FMT, r);
1140 mp_clear(&a);
1141
1142 if(strcmp(g_intbuf, r_mp5d5) != 0) {
1143 reason("error: computed %s, expected %s\n", g_intbuf, r_mp5d5);
1144 return 1;
1145 }
1146
1147 return 0;
1148 }
1149
1150 /*------------------------------------------------------------------------*/
1151
1152 int test_mod(void)
1153 {
1154 mp_int a, m;
1155
1156 mp_init(&a); mp_init(&m);
1157 mp_read_radix(&a, mp4, 16); mp_read_radix(&m, mp7, 16);
1158 IFOK( mp_mod(&a, &m, &a) );
1159 mp_toradix(&a, g_intbuf, 16);
1160 mp_clear(&a); mp_clear(&m);
1161
1162 if(strcmp(g_intbuf, r_mp47) != 0) {
1163 reason("error: computed %s, expected %s\n", g_intbuf, r_mp47);
1164 return 1;
1165 }
1166
1167 return 0;
1168 }
1169
1170 /*------------------------------------------------------------------------*/
1171
1172 int test_addmod(void)
1173 {
1174 mp_int a, b, m;
1175
1176 mp_init(&a); mp_init(&b); mp_init(&m);
1177 mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1178 mp_read_radix(&m, mp5, 16);
1179
1180 IFOK( mp_addmod(&a, &b, &m, &a) );
1181 mp_toradix(&a, g_intbuf, 16);
1182 mp_clear(&a); mp_clear(&b); mp_clear(&m);
1183
1184 if(strcmp(g_intbuf, ms_mp345) != 0) {
1185 reason("error: computed %s, expected %s\n", g_intbuf, ms_mp345);
1186 return 1;
1187 }
1188
1189 return 0;
1190 }
1191
1192 /*------------------------------------------------------------------------*/
1193
1194 int test_submod(void)
1195 {
1196 mp_int a, b, m;
1197
1198 mp_init(&a); mp_init(&b); mp_init(&m);
1199 mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1200 mp_read_radix(&m, mp5, 16);
1201
1202 IFOK( mp_submod(&a, &b, &m, &a) );
1203 mp_toradix(&a, g_intbuf, 16);
1204 mp_clear(&a); mp_clear(&b); mp_clear(&m);
1205
1206 if(strcmp(g_intbuf, md_mp345) != 0) {
1207 reason("error: computed %s, expected %s\n", g_intbuf, md_mp345);
1208 return 1;
1209 }
1210
1211 return 0;
1212 }
1213
1214 /*------------------------------------------------------------------------*/
1215
1216 int test_mulmod(void)
1217 {
1218 mp_int a, b, m;
1219
1220 mp_init(&a); mp_init(&b); mp_init(&m);
1221 mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1222 mp_read_radix(&m, mp5, 16);
1223
1224 IFOK( mp_mulmod(&a, &b, &m, &a) );
1225 mp_toradix(&a, g_intbuf, 16);
1226 mp_clear(&a); mp_clear(&b); mp_clear(&m);
1227
1228 if(strcmp(g_intbuf, mp_mp345) != 0) {
1229 reason("error: computed %s, expected %s\n", g_intbuf, mp_mp345);
1230 return 1;
1231 }
1232
1233 return 0;
1234 }
1235
1236 /*------------------------------------------------------------------------*/
1237
1238 int test_sqrmod(void)
1239 {
1240 mp_int a, m;
1241
1242 mp_init(&a); mp_init(&m);
1243 mp_read_radix(&a, mp3, 16); mp_read_radix(&m, mp5, 16);
1244
1245 IFOK( mp_sqrmod(&a, &m, &a) );
1246 mp_toradix(&a, g_intbuf, 16);
1247 mp_clear(&a); mp_clear(&m);
1248
1249 if(strcmp(g_intbuf, mp_mp335) != 0) {
1250 reason("error: computed %s, expected %s\n", g_intbuf, mp_mp335);
1251 return 1;
1252 }
1253
1254 return 0;
1255 }
1256
1257 /*------------------------------------------------------------------------*/
1258
1259 int test_exptmod(void)
1260 {
1261 mp_int a, b, m;
1262 int res = 0;
1263
1264 mp_init(&a); mp_init(&b); mp_init(&m);
1265 mp_read_radix(&a, mp8, 16); mp_read_radix(&b, mp1, 16);
1266 mp_read_radix(&m, mp7, 16);
1267
1268 IFOK( mp_exptmod(&a, &b, &m, &a) );
1269 mp_toradix(&a, g_intbuf, 16);
1270
1271 if(strcmp(g_intbuf, me_mp817) != 0) {
1272 reason("case 1: error: computed %s, expected %s\n", g_intbuf, me_mp817);
1273 res = 1; goto CLEANUP;
1274 }
1275
1276 mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp5, 16);
1277 mp_read_radix(&m, mp12, 16);
1278
1279 IFOK( mp_exptmod(&a, &b, &m, &a) );
1280 mp_toradix(&a, g_intbuf, 16);
1281
1282 if(strcmp(g_intbuf, me_mp1512) != 0) {
1283 reason("case 2: error: computed %s, expected %s\n", g_intbuf, me_mp1512);
1284 res = 1; goto CLEANUP;
1285 }
1286
1287 mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp1, 16);
1288 mp_read_radix(&m, mp14, 16);
1289
1290 IFOK( mp_exptmod(&a, &b, &m, &a) );
1291 mp_toradix(&a, g_intbuf, 16);
1292
1293 if(strcmp(g_intbuf, me_mp5114) != 0) {
1294 reason("case 3: error: computed %s, expected %s\n", g_intbuf, me_mp5114);
1295 res = 1;
1296 }
1297
1298 mp_read_radix(&a, mp16, 16); mp_read_radix(&b, mp17, 16);
1299 mp_read_radix(&m, mp18, 16);
1300
1301 IFOK( mp_exptmod(&a, &b, &m, &a) );
1302 mp_toradix(&a, g_intbuf, 16);
1303
1304 if(strcmp(g_intbuf, me_mp161718) != 0) {
1305 reason("case 4: error: computed %s, expected %s\n", g_intbuf, me_mp161718);
1306 res = 1;
1307 }
1308
1309 CLEANUP:
1310 mp_clear(&a); mp_clear(&b); mp_clear(&m);
1311 return res;
1312 }
1313
1314 /*------------------------------------------------------------------------*/
1315
1316 int test_exptmod_d(void)
1317 {
1318 mp_int a, m;
1319
1320 mp_init(&a); mp_init(&m);
1321 mp_read_radix(&a, mp5, 16); mp_read_radix(&m, mp7, 16);
1322
1323 IFOK( mp_exptmod_d(&a, md4, &m, &a) );
1324 mp_toradix(&a, g_intbuf, 16);
1325 mp_clear(&a); mp_clear(&m);
1326
1327 if(strcmp(g_intbuf, me_mp5d47) != 0) {
1328 reason("error: computed %s, expected %s\n", g_intbuf, me_mp5d47);
1329 return 1;
1330 }
1331
1332 return 0;
1333 }
1334
1335 /*------------------------------------------------------------------------*/
1336
1337 int test_invmod(void)
1338 {
1339 mp_int a, m, c;
1340 mp_int p1, p2, p3, p4, p5;
1341 mp_int t1, t2, t3, t4;
1342 mp_err res;
1343
1344 /* 5 128-bit primes. */
1345 static const char ivp1[] = { "AAD8A5A2A2BEF644BAEE7DB0CA643719" };
1346 static const char ivp2[] = { "CB371AD2B79A90BCC88D0430663E40B9" };
1347 static const char ivp3[] = { "C6C818D4DF2618406CA09280C0400099" };
1348 static const char ivp4[] = { "CE949C04512E68918006B1F0D7E93F27" };
1349 static const char ivp5[] = { "F8EE999B6416645040687440E0B89F51" };
1350
1351 mp_init(&a); mp_init(&m);
1352 mp_read_radix(&a, mp2, 16); mp_read_radix(&m, mp7, 16);
1353
1354 IFOK( mp_invmod(&a, &m, &a) );
1355
1356 mp_toradix(&a, g_intbuf, 16);
1357 mp_clear(&a); mp_clear(&m);
1358
1359 if(strcmp(g_intbuf, i_mp27) != 0) {
1360 reason("error: invmod test 1 computed %s, expected %s\n", g_intbuf, i_mp27);
1361 return 1;
1362 }
1363
1364 mp_init(&a); mp_init(&m);
1365 mp_read_radix(&a, mp20, 16); mp_read_radix(&m, mp19, 16);
1366
1367 IFOK( mp_invmod(&a, &m, &a) );
1368
1369 mp_toradix(&a, g_intbuf, 16);
1370 mp_clear(&a); mp_clear(&m);
1371
1372 if(strcmp(g_intbuf, i_mp2019) != 0) {
1373 reason("error: invmod test 2 computed %s, expected %s\n", g_intbuf, i_mp2019);
1374 return 1;
1375 }
1376
1377 /* Need the following test cases:
1378 Odd modulus
1379 - a is odd, relatively prime to m
1380 - a is odd, not relatively prime to m
1381 - a is even, relatively prime to m
1382 - a is even, not relatively prime to m
1383 Even modulus
1384 - a is even (should fail)
1385 - a is odd, not relatively prime to m
1386 - a is odd, relatively prime to m,
1387 m is not a power of 2
1388 - m has factor 2**k, k < 32
1389 - m has factor 2**k, k > 32
1390 m is a power of 2, 2**k
1391 - k < 32
1392 - k > 32
1393 */
1394
1395 mp_init(&a); mp_init(&m); mp_init(&c);
1396 mp_init(&p1); mp_init(&p2); mp_init(&p3); mp_init(&p4); mp_init(&p5);
1397 mp_init(&t1); mp_init(&t2); mp_init(&t3); mp_init(&t4);
1398
1399 mp_read_radix(&p1, ivp1, 16);
1400 mp_read_radix(&p2, ivp2, 16);
1401 mp_read_radix(&p3, ivp3, 16);
1402 mp_read_radix(&p4, ivp4, 16);
1403 mp_read_radix(&p5, ivp5, 16);
1404
1405 IFOK( mp_2expt(&t2, 68) ); /* t2 = 2**68 */
1406 IFOK( mp_2expt(&t3, 128) ); /* t3 = 2**128 */
1407 IFOK( mp_2expt(&t4, 31) ); /* t4 = 2**31 */
1408
1409 /* test 3: Odd modulus - a is odd, relatively prime to m */
1410
1411 IFOK( mp_mul(&p1, &p2, &a) );
1412 IFOK( mp_mul(&p3, &p4, &m) );
1413 IFOK( mp_invmod(&a, &m, &t1) );
1414 IFOK( mp_invmod_xgcd(&a, &m, &c) );
1415
1416 if (mp_cmp(&t1, &c) != 0) {
1417 mp_toradix(&t1, g_intbuf, 16);
1418 mp_toradix(&c, a_intbuf, 16);
1419 reason("error: invmod test 3 computed %s, expected %s\n",
1420 g_intbuf, a_intbuf);
1421 return 1;
1422 }
1423 mp_clear(&a); mp_clear(&t1); mp_clear(&c);
1424 mp_init(&a); mp_init(&t1); mp_init(&c);
1425
1426 /* test 4: Odd modulus - a is odd, NOT relatively prime to m */
1427
1428 IFOK( mp_mul(&p1, &p3, &a) );
1429 /* reuse same m as before */
1430
1431 res = mp_invmod_xgcd(&a, &m, &c);
1432 if (res != MP_UNDEF)
1433 goto CLEANUP4;
1434
1435 res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1436 if (res != MP_UNDEF) {
1437 CLEANUP4:
1438 reason("error: invmod test 4 succeeded, should have failed.\n");
1439 return 1;
1440 }
1441 mp_clear(&a); mp_clear(&t1); mp_clear(&c);
1442 mp_init(&a); mp_init(&t1); mp_init(&c);
1443
1444 /* test 5: Odd modulus - a is even, relatively prime to m */
1445
1446 IFOK( mp_mul(&p1, &t2, &a) );
1447 /* reuse m */
1448 IFOK( mp_invmod(&a, &m, &t1) );
1449 IFOK( mp_invmod_xgcd(&a, &m, &c) );
1450
1451 if (mp_cmp(&t1, &c) != 0) {
1452 mp_toradix(&t1, g_intbuf, 16);
1453 mp_toradix(&c, a_intbuf, 16);
1454 reason("error: invmod test 5 computed %s, expected %s\n",
1455 g_intbuf, a_intbuf);
1456 return 1;
1457 }
1458 mp_clear(&a); mp_clear(&t1); mp_clear(&c);
1459 mp_init(&a); mp_init(&t1); mp_init(&c);
1460
1461 /* test 6: Odd modulus - a is odd, NOT relatively prime to m */
1462
1463 /* reuse t2 */
1464 IFOK( mp_mul(&t2, &p3, &a) );
1465 /* reuse same m as before */
1466
1467 res = mp_invmod_xgcd(&a, &m, &c);
1468 if (res != MP_UNDEF)
1469 goto CLEANUP6;
1470
1471 res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1472 if (res != MP_UNDEF) {
1473 CLEANUP6:
1474 reason("error: invmod test 6 succeeded, should have failed.\n");
1475 return 1;
1476 }
1477 mp_clear(&a); mp_clear(&m); mp_clear(&c); mp_clear(&t1);
1478 mp_init(&a); mp_init(&m); mp_init(&c); mp_init(&t1);
1479
1480 /* test 7: Even modulus, even a, should fail */
1481
1482 IFOK( mp_mul(&p3, &t3, &m) ); /* even m */
1483 /* reuse t2 */
1484 IFOK( mp_mul(&p1, &t2, &a) ); /* even a */
1485
1486 res = mp_invmod_xgcd(&a, &m, &c);
1487 if (res != MP_UNDEF)
1488 goto CLEANUP7;
1489
1490 res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1491 if (res != MP_UNDEF) {
1492 CLEANUP7:
1493 reason("error: invmod test 7 succeeded, should have failed.\n");
1494 return 1;
1495 }
1496 mp_clear(&a); mp_clear(&c); mp_clear(&t1);
1497 mp_init(&a); mp_init(&c); mp_init(&t1);
1498
1499 /* test 8: Even modulus - a is odd, not relatively prime to m */
1500
1501 /* reuse m */
1502 IFOK( mp_mul(&p3, &p1, &a) ); /* even a */
1503
1504 res = mp_invmod_xgcd(&a, &m, &c);
1505 if (res != MP_UNDEF)
1506 goto CLEANUP8;
1507
1508 res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1509 if (res != MP_UNDEF) {
1510 CLEANUP8:
1511 reason("error: invmod test 8 succeeded, should have failed.\n");
1512 return 1;
1513 }
1514 mp_clear(&a); mp_clear(&m); mp_clear(&c); mp_clear(&t1);
1515 mp_init(&a); mp_init(&m); mp_init(&c); mp_init(&t1);
1516
1517 /* test 9: Even modulus - m has factor 2**k, k < 32
1518 * - a is odd, relatively prime to m,
1519 */
1520 IFOK( mp_mul(&p3, &t4, &m) ); /* even m */
1521 IFOK( mp_mul(&p1, &p2, &a) );
1522 IFOK( mp_invmod(&a, &m, &t1) );
1523 IFOK( mp_invmod_xgcd(&a, &m, &c) );
1524
1525 if (mp_cmp(&t1, &c) != 0) {
1526 mp_toradix(&t1, g_intbuf, 16);
1527 mp_toradix(&c, a_intbuf, 16);
1528 reason("error: invmod test 9 computed %s, expected %s\n",
1529 g_intbuf, a_intbuf);
1530 return 1;
1531 }
1532 mp_clear(&m); mp_clear(&t1); mp_clear(&c);
1533 mp_init(&m); mp_init(&t1); mp_init(&c);
1534
1535 /* test 10: Even modulus - m has factor 2**k, k > 32
1536 * - a is odd, relatively prime to m,
1537 */
1538 IFOK( mp_mul(&p3, &t3, &m) ); /* even m */
1539 /* reuse a */
1540 IFOK( mp_invmod(&a, &m, &t1) );
1541 IFOK( mp_invmod_xgcd(&a, &m, &c) );
1542
1543 if (mp_cmp(&t1, &c) != 0) {
1544 mp_toradix(&t1, g_intbuf, 16);
1545 mp_toradix(&c, a_intbuf, 16);
1546 reason("error: invmod test 10 computed %s, expected %s\n",
1547 g_intbuf, a_intbuf);
1548 return 1;
1549 }
1550 mp_clear(&t1); mp_clear(&c);
1551 mp_init(&t1); mp_init(&c);
1552
1553 /* test 11: Even modulus - m is a power of 2, 2**k | k < 32
1554 * - a is odd, relatively prime to m,
1555 */
1556 IFOK( mp_invmod(&a, &t4, &t1) );
1557 IFOK( mp_invmod_xgcd(&a, &t4, &c) );
1558
1559 if (mp_cmp(&t1, &c) != 0) {
1560 mp_toradix(&t1, g_intbuf, 16);
1561 mp_toradix(&c, a_intbuf, 16);
1562 reason("error: invmod test 11 computed %s, expected %s\n",
1563 g_intbuf, a_intbuf);
1564 return 1;
1565 }
1566 mp_clear(&t1); mp_clear(&c);
1567 mp_init(&t1); mp_init(&c);
1568
1569 /* test 12: Even modulus - m is a power of 2, 2**k | k > 32
1570 * - a is odd, relatively prime to m,
1571 */
1572 IFOK( mp_invmod(&a, &t3, &t1) );
1573 IFOK( mp_invmod_xgcd(&a, &t3, &c) );
1574
1575 if (mp_cmp(&t1, &c) != 0) {
1576 mp_toradix(&t1, g_intbuf, 16);
1577 mp_toradix(&c, a_intbuf, 16);
1578 reason("error: invmod test 12 computed %s, expected %s\n",
1579 g_intbuf, a_intbuf);
1580 return 1;
1581 }
1582
1583 mp_clear(&a); mp_clear(&m); mp_clear(&c);
1584 mp_clear(&t1); mp_clear(&t2); mp_clear(&t3); mp_clear(&t4);
1585 mp_clear(&p1); mp_clear(&p2); mp_clear(&p3); mp_clear(&p4); mp_clear(&p5);
1586
1587 return 0;
1588 }
1589
1590 /*------------------------------------------------------------------------*/
1591
1592 int test_cmp_d(void)
1593 {
1594 mp_int a;
1595
1596 mp_init(&a); mp_read_radix(&a, mp8, 16);
1597
1598 if(mp_cmp_d(&a, md8) >= 0) {
1599 reason("error: %s >= " DIGIT_FMT "\n", mp8, md8);
1600 mp_clear(&a);
1601 return 1;
1602 }
1603
1604 mp_read_radix(&a, mp5, 16);
1605
1606 if(mp_cmp_d(&a, md8) <= 0) {
1607 reason("error: %s <= " DIGIT_FMT "\n", mp5, md8);
1608 mp_clear(&a);
1609 return 1;
1610 }
1611
1612 mp_read_radix(&a, mp6, 16);
1613
1614 if(mp_cmp_d(&a, md1) != 0) {
1615 reason("error: %s != " DIGIT_FMT "\n", mp6, md1);
1616 mp_clear(&a);
1617 return 1;
1618 }
1619
1620 mp_clear(&a);
1621 return 0;
1622
1623 }
1624
1625 /*------------------------------------------------------------------------*/
1626
1627 int test_cmp_z(void)
1628 {
1629 mp_int a;
1630
1631 mp_init(&a); mp_read_radix(&a, mp6, 16);
1632
1633 if(mp_cmp_z(&a) != 0) {
1634 reason("error: someone thinks a zero value is non-zero\n");
1635 mp_clear(&a);
1636 return 1;
1637 }
1638
1639 mp_read_radix(&a, mp1, 16);
1640
1641 if(mp_cmp_z(&a) <= 0) {
1642 reason("error: someone thinks a positive value is non-positive\n");
1643 mp_clear(&a);
1644 return 1;
1645 }
1646
1647 mp_read_radix(&a, mp4, 16);
1648
1649 if(mp_cmp_z(&a) >= 0) {
1650 reason("error: someone thinks a negative value is non-negative\n");
1651 mp_clear(&a);
1652 return 1;
1653 }
1654
1655 mp_clear(&a);
1656 return 0;
1657 }
1658
1659 /*------------------------------------------------------------------------*/
1660
1661 int test_cmp(void)
1662 {
1663 mp_int a, b;
1664
1665 mp_init(&a); mp_init(&b);
1666 mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1667
1668 if(mp_cmp(&a, &b) <= 0) {
1669 reason("error: %s <= %s\n", mp3, mp4);
1670 mp_clear(&a); mp_clear(&b);
1671 return 1;
1672 }
1673
1674 mp_read_radix(&b, mp3, 16);
1675 if(mp_cmp(&a, &b) != 0) {
1676 reason("error: %s != %s\n", mp3, mp3);
1677 mp_clear(&a); mp_clear(&b);
1678 return 1;
1679 }
1680
1681 mp_read_radix(&a, mp5, 16);
1682 if(mp_cmp(&a, &b) >= 0) {
1683 reason("error: %s >= %s\n", mp5, mp3);
1684 mp_clear(&a); mp_clear(&b);
1685 return 1;
1686 }
1687
1688 mp_read_radix(&a, mp5a, 16);
1689 if(mp_cmp_int(&a, 1000000) >= 0 ||
1690 (mp_cmp_int(&a, -5000000) <= 0) ||
1691 (mp_cmp_int(&a, -4938110) != 0)) {
1692 reason("error: long integer comparison failed (%s)", mp5a);
1693 mp_clear(&a); mp_clear(&b);
1694 return 1;
1695 }
1696
1697 mp_clear(&a); mp_clear(&b);
1698 return 0;
1699 }
1700
1701 /*------------------------------------------------------------------------*/
1702
1703 int test_cmp_mag(void)
1704 {
1705 mp_int a, b;
1706
1707 mp_init(&a); mp_init(&b);
1708 mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp4, 16);
1709
1710 if(mp_cmp_mag(&a, &b) >= 0) {
1711 reason("error: %s >= %s\n", mp5, mp4);
1712 mp_clear(&a); mp_clear(&b);
1713 return 1;
1714 }
1715
1716 mp_read_radix(&b, mp5, 16);
1717 if(mp_cmp_mag(&a, &b) != 0) {
1718 reason("error: %s != %s\n", mp5, mp5);
1719 mp_clear(&a); mp_clear(&b);
1720 return 1;
1721 }
1722
1723 mp_read_radix(&a, mp1, 16);
1724 if(mp_cmp_mag(&b, &a) >= 0) {
1725 reason("error: %s >= %s\n", mp5, mp1);
1726 mp_clear(&a); mp_clear(&b);
1727 return 1;
1728 }
1729
1730 mp_clear(&a); mp_clear(&b);
1731 return 0;
1732
1733 }
1734
1735 /*------------------------------------------------------------------------*/
1736
1737 int test_parity(void)
1738 {
1739 mp_int a;
1740
1741 mp_init(&a); mp_read_radix(&a, mp1, 16);
1742
1743 if(!mp_isodd(&a)) {
1744 reason("error: expected operand to be odd, but it isn't\n");
1745 mp_clear(&a);
1746 return 1;
1747 }
1748
1749 mp_read_radix(&a, mp6, 16);
1750
1751 if(!mp_iseven(&a)) {
1752 reason("error: expected operand to be even, but it isn't\n");
1753 mp_clear(&a);
1754 return 1;
1755 }
1756
1757 mp_clear(&a);
1758 return 0;
1759 }
1760
1761 /*------------------------------------------------------------------------*/
1762
1763 int test_gcd(void)
1764 {
1765 mp_int a, b;
1766 int out = 0;
1767
1768 mp_init(&a); mp_init(&b);
1769 mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp1, 16);
1770
1771 mp_gcd(&a, &b, &a);
1772 mp_toradix(&a, g_intbuf, 16);
1773
1774 if(strcmp(g_intbuf, g_mp71) != 0) {
1775 reason("error: computed %s, expected %s\n", g_intbuf, g_mp71);
1776 out = 1;
1777 }
1778
1779 mp_clear(&a); mp_clear(&b);
1780 return out;
1781
1782 }
1783
1784 /*------------------------------------------------------------------------*/
1785
1786 int test_lcm(void)
1787 {
1788 mp_int a, b;
1789 int out = 0;
1790
1791 mp_init(&a); mp_init(&b);
1792 mp_read_radix(&a, mp10, 16); mp_read_radix(&b, mp11, 16);
1793
1794 mp_lcm(&a, &b, &a);
1795 mp_toradix(&a, g_intbuf, 16);
1796
1797 if(strcmp(g_intbuf, l_mp1011) != 0) {
1798 reason("error: computed %s, expected%s\n", g_intbuf, l_mp1011);
1799 out = 1;
1800 }
1801
1802 mp_clear(&a); mp_clear(&b);
1803
1804 return out;
1805
1806 }
1807
1808 /*------------------------------------------------------------------------*/
1809
1810 int test_convert(void)
1811 {
1812 int ix;
1813 mp_int a;
1814
1815 mp_init(&a); mp_read_radix(&a, mp9, 16);
1816
1817 for(ix = LOW_RADIX; ix <= HIGH_RADIX; ix++) {
1818 mp_toradix(&a, g_intbuf, ix);
1819
1820 if(strcmp(g_intbuf, v_mp9[ix - LOW_RADIX]) != 0) {
1821 reason("error: radix %d, computed %s, expected %s\n",
1822 ix, g_intbuf, v_mp9[ix - LOW_RADIX]);
1823 mp_clear(&a);
1824 return 1;
1825 }
1826 }
1827
1828 mp_clear(&a);
1829 return 0;
1830 }
1831
1832 /*------------------------------------------------------------------------*/
1833
1834 int test_raw(void)
1835 {
1836 int len, out = 0;
1837 mp_int a;
1838 char *buf;
1839
1840 mp_init(&a); mp_read_radix(&a, mp4, 16);
1841
1842 len = mp_raw_size(&a);
1843 if(len != sizeof(b_mp4)) {
1844 reason("error: test_raw: expected length %d, computed %d\n", sizeof(b_mp4),
1845 len);
1846 mp_clear(&a);
1847 return 1;
1848 }
1849
1850 buf = calloc(len, sizeof(char));
1851 mp_toraw(&a, buf);
1852
1853 if(memcmp(buf, b_mp4, sizeof(b_mp4)) != 0) {
1854 reason("error: test_raw: binary output does not match test vector\n");
1855 out = 1;
1856 }
1857
1858 free(buf);
1859 mp_clear(&a);
1860
1861 return out;
1862
1863 }
1864
1865 /*------------------------------------------------------------------------*/
1866
1867 int test_pprime(void)
1868 {
1869 mp_int p;
1870 int err = 0;
1871 mp_err res;
1872
1873 mp_init(&p);
1874 mp_read_radix(&p, mp7, 16);
1875
1876 if(mpp_pprime(&p, 5) != MP_YES) {
1877 reason("error: %s failed Rabin-Miller test, but is prime\n", mp7);
1878 err = 1;
1879 }
1880
1881 IFOK( mp_set_int(&p, 9) );
1882 res = mpp_pprime(&p, 50);
1883 if (res == MP_YES) {
1884 reason("error: 9 is composite but passed Rabin-Miller test\n");
1885 err = 1;
1886 } else if (res != MP_NO) {
1887 reason("test mpp_pprime(9, 50) failed: error %d\n", res);
1888 err = 1;
1889 }
1890
1891 IFOK( mp_set_int(&p, 15) );
1892 res = mpp_pprime(&p, 50);
1893 if (res == MP_YES) {
1894 reason("error: 15 is composite but passed Rabin-Miller test\n");
1895 err = 1;
1896 } else if (res != MP_NO) {
1897 reason("test mpp_pprime(15, 50) failed: error %d\n", res);
1898 err = 1;
1899 }
1900
1901 mp_clear(&p);
1902
1903 return err;
1904
1905 }
1906
1907 /*------------------------------------------------------------------------*/
1908
1909 int test_fermat(void)
1910 {
1911 mp_int p;
1912 mp_err res;
1913 int err = 0;
1914
1915 mp_init(&p);
1916 mp_read_radix(&p, mp7, 16);
1917
1918 if((res = mpp_fermat(&p, 2)) != MP_YES) {
1919 reason("error: %s failed Fermat test on 2: %s\n", mp7,
1920 mp_strerror(res));
1921 ++err;
1922 }
1923
1924 if((res = mpp_fermat(&p, 3)) != MP_YES) {
1925 reason("error: %s failed Fermat test on 3: %s\n", mp7,
1926 mp_strerror(res));
1927 ++err;
1928 }
1929
1930 mp_clear(&p);
1931
1932 return err;
1933
1934 }
1935
1936 /*------------------------------------------------------------------------*/
1937 /* Like fprintf(), but only if we are behaving in a verbose manner */
1938
1939 void reason(char *fmt, ...)
1940 {
1941 va_list ap;
1942
1943 if(!g_verbose)
1944 return;
1945
1946 va_start(ap, fmt);
1947 vfprintf(stderr, fmt, ap);
1948 va_end(ap);
1949 }
1950
1951 /*------------------------------------------------------------------------*/
1952 /* HERE THERE BE DRAGONS */

Mercurial Repository: The Tor Browser

Europalab SCM Repository Server

mercurial