1.1 --- /dev/null Thu Jan 01 00:00:00 1970 +0000
1.2 +++ b/security/nss/lib/freebl/mpi/mpi-test.c Wed Dec 31 06:09:35 2014 +0100
1.3 @@ -0,0 +1,1952 @@
1.4 +/*
1.5 + * mpi-test.c
1.6 + *
1.7 + * This is a general test suite for the MPI library, which tests
1.8 + * all the functions in the library with known values. The program
1.9 + * exits with a zero (successful) status if the tests pass, or a
1.10 + * nonzero status if the tests fail.
1.11 + *
1.12 + * This Source Code Form is subject to the terms of the Mozilla Public
1.13 + * License, v. 2.0. If a copy of the MPL was not distributed with this
1.14 + * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
1.15 +
1.16 +#include <stdio.h>
1.17 +#include <stdlib.h>
1.18 +#include <string.h>
1.19 +#include <stdarg.h>
1.20 +#include <limits.h>
1.21 +#include <time.h>
1.22 +
1.23 +#include "mpi.h"
1.24 +#include "mpprime.h"
1.25 +
1.26 +#include "test-info.c"
1.27 +
1.28 +/* ZS means Zero Suppressed (no leading zeros) */
1.29 +#if MP_USE_LONG_DIGIT
1.30 +#define ZS_DIGIT_FMT "%lX"
1.31 +#elif MP_USE_LONG_LONG_DIGIT
1.32 +#define ZS_DIGIT_FMT "%llX"
1.33 +#elif MP_USE_UINT_DIGIT
1.34 +#define ZS_DIGIT_FMT "%X"
1.35 +#else
1.36 +#error "unknown type of digit"
1.37 +#endif
1.38 +
1.39 +/*
1.40 + Test vectors
1.41 +
1.42 + If you intend to change any of these values, you must also recompute
1.43 + the corresponding solutions below. Basically, these are just hex
1.44 + strings (for the big integers) or integer values (for the digits).
1.45 +
1.46 + The comparison tests think they know what relationships hold between
1.47 + these values. If you change that, you may have to adjust the code
1.48 + for the comparison tests accordingly. Most of the other tests
1.49 + should be fine as long as you re-compute the solutions, though.
1.50 + */
1.51 +const char *mp1 = "639A868CDA0C569861B";
1.52 +const char *mp2 = "AAFC0A3FE45E5E09DBE2C29";
1.53 +const char *mp3 = "B55AA8DF8A7E83241F38AC7A9E479CAEF2E4D7C5";
1.54 +const char *mp4 = "-63DBC2265B88268DC801C10EA68476B7BDE0090F";
1.55 +const char *mp5 = "F595CB42";
1.56 +const char *mp5a = "-4B597E";
1.57 +const char *mp6 = "0";
1.58 +const char *mp7 = "EBFA7121CD838CE6439CC59DDB4CBEF3";
1.59 +const char *mp8 = "5";
1.60 +const char *mp9 = "F74A2876A1432698923B0767DA19DCF3D71795EE";
1.61 +const char *mp10 = "9184E72A000";
1.62 +const char *mp11 = "54D79A3557E8";
1.63 +const char *mp12 = "10000000000000000";
1.64 +const char *mp13 =
1.65 +"34584F700C15A341E40BF7BFDD88A6630C8FF2B2067469372D391342BDAB6163963C"
1.66 +"D5A5C79F708BDE26E0CCF2DB66CD6D6089E29A877C45F2B050D226E6DA88";
1.67 +const char *mp14 =
1.68 +"AC3FA0EABAAC45724814D798942A1E28E14C81E0DE8055CED630E7689DA648683645DB6E"
1.69 +"458D9F5338CC3D4E33A5D1C9BF42780133599E60DEE0049AFA8F9489501AE5C9AA2B8C13"
1.70 +"FD21285A538B2CA87A626BB56E0A654C8707535E637FF4E39174157402BDE3AA30C9F134"
1.71 +"0C1307BAA864B075A9CC828B6A5E2B2BF1AE406D920CC5E7657D7C0E697DEE5375773AF9"
1.72 +"E200A1B8FAD7CD141F9EE47ABB55511FEB9A4D99EBA22F3A3FF6792FA7EE9E5DC0EE94F7"
1.73 +"7A631EDF3D7DD7C2DAAAFDF234D60302AB63D5234CEAE941B9AF0ADDD9E6E3A940A94EE5"
1.74 +"5DB45A7C66E61EDD0477419BBEFA44C325129601C4F45671C6A0E64665DF341D17FBC71F"
1.75 +"77418BD9F4375DDB3B9D56126526D8E5E0F35A121FD4F347013DA880020A752324F31DDD"
1.76 +"9BCDB13A3B86E207A2DE086825E6EEB87B3A64232CFD8205B799BC018634AAE193F19531"
1.77 +"D6EBC19A75F27CFFAA03EB5974898F53FD569AA5CE60F431B53B0CDE715A5F382405C9C4"
1.78 +"761A8E24888328F09F7BCE4E8D80C957DF177629C8421ACCD0C268C63C0DD47C3C0D954F"
1.79 +"D79F7D7297C6788DF4B3E51381759864D880ACA246DF09533739B8BB6085EAF7AE8DC2D9"
1.80 +"F224E6874926C8D24D34B457FD2C9A586C6B99582DC24F787A39E3942786CF1D494B6EB4"
1.81 +"A513498CDA0B217C4E80BCE7DA1C704C35E071AC21E0DA9F57C27C3533F46A8D20B04137"
1.82 +"C1B1384BE4B2EB46";
1.83 +const char *mp15 =
1.84 +"39849CF7FD65AF2E3C4D87FE5526221103D90BA26A6642FFE3C3ECC0887BBBC57E011BF1"
1.85 +"05D822A841653509C68F79EBE51C0099B8CBB04DEF31F36F5954208A3209AC122F0E11D8"
1.86 +"4AE67A494D78336A2066D394D42E27EF6B03DDAF6D69F5112C93E714D27C94F82FC7EF77"
1.87 +"445768C68EAE1C4A1407BE1B303243391D325090449764AE469CC53EC8012C4C02A72F37"
1.88 +"07ED7275D2CC8D0A14B5BCC6BF264941520EBA97E3E6BAE4EE8BC87EE0DDA1F5611A6ECB"
1.89 +"65F8AEF4F184E10CADBDFA5A2FEF828901D18C20785E5CC63473D638762DA80625003711"
1.90 +"9E984AC43E707915B133543AF9D5522C3E7180DC58E1E5381C1FB7DC6A5F4198F3E88FA6"
1.91 +"CBB6DFA8B2D1C763226B253E18BCCB79A29EE82D2DE735078C8AE3C3C86D476AAA08434C"
1.92 +"09C274BDD40A1D8FDE38D6536C22F44E807EB73DE4FB36C9F51E0BC835DDBE3A8EFCF2FE"
1.93 +"672B525769DC39230EE624D5EEDBD837C82A52E153F37378C3AD68A81A7ADBDF3345DBCE"
1.94 +"8FA18CA1DE618EF94DF72EAD928D4F45B9E51632ACF158CF8332C51891D1D12C2A7E6684"
1.95 +"360C4BF177C952579A9F442CFFEC8DAE4821A8E7A31C4861D8464CA9116C60866C5E72F7"
1.96 +"434ADBED36D54ACDFDFF70A4EFB46E285131FE725F1C637D1C62115EDAD01C4189716327"
1.97 +"BFAA79618B1656CBFA22C2C965687D0381CC2FE0245913C4D8D96108213680BD8E93E821"
1.98 +"822AD9DDBFE4BD04";
1.99 +const char *mp16 = "4A724340668DB150339A70";
1.100 +const char *mp17 = "8ADB90F58";
1.101 +const char *mp18 = "C64C230AB20E5";
1.102 +const char *mp19 =
1.103 +"F1C9DACDA287F2E3C88DCE2393B8F53DAAAC1196DC36510962B6B59454CFE64B";
1.104 +const char *mp20 =
1.105 +"D445662C8B6FE394107B867797750C326E0F4A967E135FC430F6CD7207913AC7";
1.106 +const char* mp21 = "2";
1.107 +
1.108 +const mp_digit md1 = 0;
1.109 +const mp_digit md2 = 0x1;
1.110 +const mp_digit md3 = 0x80;
1.111 +const mp_digit md4 = 0x9C97;
1.112 +const mp_digit md5 = 0xF5BF;
1.113 +const mp_digit md6 = 0x14A0;
1.114 +const mp_digit md7 = 0x03E8;
1.115 +const mp_digit md8 = 0x0101;
1.116 +const mp_digit md9 = 0xA;
1.117 +
1.118 +/*
1.119 + Solutions of the form x_mpABC, where:
1.120 +
1.121 + x = (p)roduct, (s)um, (d)ifference, (q)uotient, (r)emainder, (g)cd,
1.122 + (i)nverse, (e)xponent, square roo(t), (g)cd, (l)cm. A
1.123 + leading 'm' indicates a modular operation, e.g. ms_mp12 is the
1.124 + modular sum of operands 1 and 2
1.125 +
1.126 + ABC are the operand numbers involved in the computation. If a 'd'
1.127 + precedes the number, it is a digit operand; if a 'c' precedes it,
1.128 + it is a constant; otherwise, it is a full integer.
1.129 + */
1.130 +
1.131 +const char *p_mp12 = "4286AD72E095C9FE009938750743174ADDD7FD1E53";
1.132 +const char *p_mp34 = "-46BDBD66CA108C94A8CF46C325F7B6E2F2BA82D35"
1.133 + "A1BFD6934C441EE369B60CA29BADC26845E918B";
1.134 +const char *p_mp57 = "E260C265A0A27C17AD5F4E59D6E0360217A2EBA6";
1.135 +const char *p_mp22 = "7233B5C1097FFC77CCF55928FDC3A5D31B712FDE7A1E91";
1.136 +const char *p_mp1d4 = "3CECEA2331F4220BEF68DED";
1.137 +const char *p_mp8d6 = "6720";
1.138 +const char *p_mp1113 =
1.139 +"11590FC3831C8C3C51813142C88E566408DB04F9E27642F6471A1822E0100B12F7F1"
1.140 +"5699A127C0FA9D26DCBFF458522661F30C6ADA4A07C8C90F9116893F6DBFBF24C3A2"
1.141 +"4340";
1.142 +const char *p_mp1415 =
1.143 +"26B36540DE8B3586699CCEAE218A2842C7D5A01590E70C4A26E789107FBCDB06AA2C"
1.144 +"6DDC39E6FA18B16FCB2E934C9A5F844DAD60EE3B1EA82199EC5E9608F67F860FB965"
1.145 +"736055DF0E8F2540EB28D07F47E309B5F5D7C94FF190AB9C83A6970160CA700B1081"
1.146 +"F60518132AF28C6CEE6B7C473E461ABAC52C39CED50A08DD4E7EA8BA18DAD545126D"
1.147 +"A388F6983C29B6BE3F9DCBC15766E8E6D626A92C5296A9C4653CAE5788350C0E2107"
1.148 +"F57E5E8B6994C4847D727FF1A63A66A6CEF42B9C9E6BD04C92550B85D5527DE8A132"
1.149 +"E6BE89341A9285C7CE7FB929D871BBCBD0ED2863B6B078B0DBB30FCA66D6C64284D6"
1.150 +"57F394A0271E15B6EC7A9D530EBAC6CA262EF6F97E1A29FCE7749240E4AECA591ECF"
1.151 +"272122BC587370F9371B67BB696B3CDC1BC8C5B64B6280994EBA00CDEB8EB0F5D06E"
1.152 +"18F401D65FDCECF23DD7B9BB5B4C5458AEF2CCC09BA7F70EACB844750ACFD027521E"
1.153 +"2E047DE8388B35F8512D3DA46FF1A12D4260213602BF7BFFDB6059439B1BD0676449"
1.154 +"8D98C74F48FB3F548948D5BA0C8ECFCD054465132DC43466D6BBD59FBAF8D6D4E157"
1.155 +"2D612B40A956C7D3E140F3B8562EF18568B24D335707D5BAC7495014DF2444172426"
1.156 +"FD099DED560D30D1F945386604AFC85C64BD1E5F531F5C7840475FC0CF0F79810012"
1.157 +"4572BAF5A9910CDBD02B27FFCC3C7E5E88EF59F3AE152476E33EDA696A4F751E0AE4"
1.158 +"A3D2792DEA78E25B9110E12A19EFD09EA47FF9D6594DA445478BEB6901EAF8A35B2D"
1.159 +"FD59BEE9BF7AA8535B7D326EFA5AA2121B5EBE04DD85827A3D43BD04F4AA6D7B62A2"
1.160 +"B6D7A3077286A511A431E1EF75FCEBA3FAE9D5843A8ED17AA02BBB1B571F904699C5"
1.161 +"A6073F87DDD012E2322AB3F41F2A61F428636FE86914148E19B8EF8314ED83332F2F"
1.162 +"8C2ADE95071E792C0A68B903E060DD322A75FD0C2B992059FCCBB58AFA06B50D1634"
1.163 +"BBD93F187FCE0566609FCC2BABB269C66CEB097598AA17957BB4FDA3E64A1B30402E"
1.164 +"851CF9208E33D52E459A92C63FBB66435BB018E155E2C7F055E0B7AB82CD58FC4889"
1.165 +"372ED9EEAC2A07E8E654AB445B9298D2830D6D4DFD117B9C8ABE3968927DC24B3633"
1.166 +"BAD6E6466DB45DDAE87A0AB00336AC2CCCE176704F7214FCAB55743AB76C2B6CA231"
1.167 +"7984610B27B5786DE55C184DDF556EDFEA79A3652831940DAD941E243F482DC17E50"
1.168 +"284BC2FB1AD712A92542C573E55678878F02DFD9E3A863C7DF863227AEDE14B47AD3"
1.169 +"957190124820ADC19F5353878EDB6BF7D0C77352A6E3BDB53EEB88F5AEF6226D6E68"
1.170 +"756776A8FB49B77564147A641664C2A54F7E5B680CCC6A4D22D894E464DF20537094"
1.171 +"548F1732452F9E7F810C0B4B430C073C0FBCE03F0D03F82630654BCE166AA772E1EE"
1.172 +"DD0C08D3E3EBDF0AF54203B43AFDFC40D8FC79C97A4B0A4E1BEB14D8FCEFDDED8758"
1.173 +"6ED65B18";
1.174 +const char *p_mp2121 = "4";
1.175 +const char *mp_mp345 = "B9B6D3A3";
1.176 +const char *mp_mp335 = "16609C2D";
1.177 +
1.178 +const char *s_mp13 = "B55AA8DF8A7E83241F38B2B446B06A4FB84E5DE0";
1.179 +const char *s_mp34 = "517EE6B92EF65C965736EB6BF7C325F73504CEB6";
1.180 +const char *s_mp46 = "-63DBC2265B88268DC801C10EA68476B7BDE0090F";
1.181 +const char *s_mp5d4 = "F59667D9";
1.182 +const char *s_mp2d5 = "AAFC0A3FE45E5E09DBF21E8";
1.183 +const char *s_mp1415 =
1.184 +"E5C43DE2B811F4A084625F96E9504039E5258D8348E698CEB9F4D4292622042DB446"
1.185 +"F75F4B65C1FB7A317257FA354BB5A45E789AEC254EAECE11F80A53E3B513822491DB"
1.186 +"D9399DEC4807A2A3A10360129AC93F4A42388D3BF20B310DD0E9E9F4BE07FC88D53A"
1.187 +"78A26091E0AB506A70813712CCBFBDD440A69A906E650EE090FDD6A42A95AC1A414D"
1.188 +"317F1A9F781E6A30E9EE142ECDA45A1E3454A1417A7B9A613DA90831CF88EA1F2E82"
1.189 +"41AE88CC4053220903C2E05BCDD42F02B8CF8868F84C64C5858BAD356143C5494607"
1.190 +"EE22E11650148BAF65A985F6FC4CA540A55697F2B5AA95D6B8CF96EF638416DE1DD6"
1.191 +"3BA9E2C09E22D03E75B60BE456C642F86B82A709253E5E087B507DE3A45F8392423F"
1.192 +"4DBC284E8DC88C43CA77BC8DCEFB6129A59025F80F90FF978116DEBB9209E306FBB9"
1.193 +"1B6111F8B8CFACB7C7C9BC12691C22EE88303E1713F1DFCEB622B8EA102F6365678B"
1.194 +"C580ED87225467AA78E875868BD53B17574BA59305BC1AC666E4B7E9ED72FCFC200E"
1.195 +"189D98FC8C5C7533739C53F52DDECDDFA5A8668BFBD40DABC9640F8FCAE58F532940"
1.196 +"8162261320A25589E9FB51B50F80056471F24B7E1AEC35D1356FC2747FFC13A04B34"
1.197 +"24FCECE10880BD9D97CA8CDEB2F5969BF4F30256EB5ED2BCD1DC64BDC2EE65217848"
1.198 +"48A37FB13F84ED4FB7ACA18C4639EE64309BDD3D552AEB4AAF44295943DC1229A497"
1.199 +"A84A";
1.200 +
1.201 +const char *ms_mp345 = "1E71E292";
1.202 +
1.203 +const char *d_mp12 = "-AAFBA6A55DD183FD854A60E";
1.204 +const char *d_mp34 = "119366B05E606A9B1E73A6D8944CC1366B0C4E0D4";
1.205 +const char *d_mp5d4 = "F5952EAB";
1.206 +const char *d_mp6d2 = "-1";
1.207 +const char *md_mp345 = "26596B86";
1.208 +
1.209 +const char *q_mp42 = "-95825A1FFA1A155D5";
1.210 +const char *r_mp42 = "-6312E99D7700A3DCB32ADF2";
1.211 +const char *q_mp45a = "15344CDA3D841F661D2B61B6EDF7828CE36";
1.212 +const char *r_mp45a = "-47C47B";
1.213 +const char *q_mp7c2 = "75FD3890E6C1C67321CE62CEEDA65F79";
1.214 +const char *q_mp3d6 = "8CAFD53C272BD6FE8B0847BDC3B539EFAB5C3";
1.215 +const char *r_mp3d6 = "1E5";
1.216 +const char *r_mp5d5 = "1257";
1.217 +const char *r_mp47 = "B3A9018D970281A90FB729A181D95CB8";
1.218 +const char *q_mp1404 =
1.219 +"-1B994D869142D3EF6123A3CBBC3C0114FA071CFCEEF4B7D231D65591D32501AD80F"
1.220 +"FF49AE4EC80514CC071EF6B42521C2508F4CB2FEAD69A2D2EF3934087DCAF88CC4C4"
1.221 +"659F1CA8A7F4D36817D802F778F1392337FE36302D6865BF0D4645625DF8BB044E19"
1.222 +"930635BE2609FAC8D99357D3A9F81F2578DE15A300964188292107DAC980E0A08CD7"
1.223 +"E938A2135FAD45D50CB1D8C2D4C4E60C27AB98B9FBD7E4DBF752C57D2674520E4BB2"
1.224 +"7E42324C0EFE84FB3E38CF6950E699E86FD45FE40D428400F2F94EDF7E94FAE10B45"
1.225 +"89329E1BF61E5A378C7B31C9C6A234F8254D4C24823B84D0BF8D671D8BC9154DFAC9"
1.226 +"49BD8ACABD6BD32DD4DC587F22C86153CB3954BDF7C2A890D623642492C482CF3E2C"
1.227 +"776FC019C3BBC61688B485E6FD35D6376089C1E33F880E84C4E51E8ABEACE1B3FB70"
1.228 +"3EAD0E28D2D44E7F1C0A859C840775E94F8C1369D985A3C5E8114B21D68B3CBB75D2"
1.229 +"791C586153C85B90CAA483E57A40E2D97950AAB84920A4396C950C87C7FFFE748358"
1.230 +"42A0BF65445B26D40F05BE164B822CA96321F41D85A289C5F5CD5F438A78704C9683"
1.231 +"422299D21899A22F853B0C93081CC9925E350132A0717A611DD932A68A0ACC6E4C7F"
1.232 +"7F685EF8C1F4910AEA5DC00BB5A36FCA07FFEAA490C547F6E14A08FE87041AB803E1"
1.233 +"BD9E23E4D367A2C35762F209073DFF48F3";
1.234 +const char *r_mp1404 = "12FF98621ABF63144BFFC3207AC8FC10D8D1A09";
1.235 +
1.236 +const char *q_mp13c =
1.237 + "34584F700C15A341E40BF7BFDD88A6630C8FF2B2067469372D391342"
1.238 + "BDAB6163963CD5A5C79F708BDE26E0CCF2DB66CD6D6089E29A877C45";
1.239 +const char *r_mp13c = "F2B050D226E6DA88";
1.240 +const char *q_mp9c16 = "F74A2876A1432698923B0767DA19DCF3D71795E";
1.241 +const char *r_mp9c16 = "E";
1.242 +
1.243 +const char *e_mp5d9 = "A8FD7145E727A20E52E73D22990D35D158090307A"
1.244 + "13A5215AAC4E9AB1E96BD34E531209E03310400";
1.245 +const char *e_mp78 = "AA5F72C737DFFD8CCD108008BFE7C79ADC01A819B"
1.246 + "32B75FB82EC0FB8CA83311DA36D4063F1E57857A2"
1.247 + "1AB226563D84A15BB63CE975FF1453BD6750C58D9"
1.248 + "D113175764F5D0B3C89B262D4702F4D9640A3";
1.249 +const char *me_mp817 = "E504493ACB02F7F802B327AB13BF25";
1.250 +const char *me_mp5d47 = "1D45ED0D78F2778157992C951DD2734C";
1.251 +const char *me_mp1512 = "FB5B2A28D902B9D9";
1.252 +const char *me_mp161718 = "423C6AC6DBD74";
1.253 +const char *me_mp5114 =
1.254 +"64F0F72807993578BBA3C7C36FFB184028F9EB9A810C92079E1498D8A80FC848E1F0"
1.255 +"25F1DE43B7F6AC063F5CC29D8A7C2D7A66269D72BF5CDC327AF88AF8EF9E601DCB0A"
1.256 +"3F35BFF3525FB1B61CE3A25182F17C0A0633B4089EA15BDC47664A43FEF639748AAC"
1.257 +"19CF58E83D8FA32CD10661D2D4210CC84792937E6F36CB601851356622E63ADD4BD5"
1.258 +"542412C2E0C4958E51FD2524AABDC7D60CFB5DB332EEC9DC84210F10FAE0BA2018F2"
1.259 +"14C9D6867C9D6E49CF28C18D06CE009FD4D04BFC8837C3FAAA773F5CCF6DED1C22DE"
1.260 +"181786AFE188540586F2D74BF312E595244E6936AE52E45742109BAA76C36F2692F5"
1.261 +"CEF97AD462B138BE92721194B163254CBAAEE9B9864B21CCDD5375BCAD0D24132724"
1.262 +"113D3374B4BCF9AA49BA5ACBC12288C0BCF46DCE6CB4A241A91BD559B130B6E9CD3D"
1.263 +"D7A2C8B280C2A278BA9BF5D93244D563015C9484B86D9FEB602501DC16EEBC3EFF19"
1.264 +"53D7999682BF1A1E3B2E7B21F4BDCA3C355039FEF55B9C0885F98DC355CA7A6D8ECF"
1.265 +"5F7F1A6E11A764F2343C823B879B44616B56BF6AE3FA2ACF5483660E618882018E3F"
1.266 +"C8459313BACFE1F93CECC37B2576A5C0B2714BD3EEDEEC22F0E7E3E77B11396B9B99"
1.267 +"D683F2447A4004BBD4A57F6A616CDDFEC595C4FC19884CC2FC21CF5BF5B0B81E0F83"
1.268 +"B9DDA0CF4DFF35BB8D31245912BF4497FD0BD95F0C604E26EA5A8EA4F5EAE870A5BD"
1.269 +"FE8C";
1.270 +
1.271 +const char *e_mpc2d3 = "100000000000000000000000000000000";
1.272 +
1.273 +const char *t_mp9 = "FB9B6E32FF0452A34746";
1.274 +const char *i_mp27 = "B6AD8DCCDAF92B6FE57D062FFEE3A99";
1.275 +const char *i_mp2019 =
1.276 +"BDF3D88DC373A63EED92903115B03FC8501910AF68297B4C41870AED3EA9F839";
1.277 +/* "15E3FE09E8AE5523AABA197BD2D16318D3CA148EDF4AE1C1C52FC96AFAF5680B"; */
1.278 +
1.279 +
1.280 +const char *t_mp15 =
1.281 +"795853094E59B0008093BCA8DECF68587C64BDCA2F3F7F8963DABC12F1CFFFA9B8C4"
1.282 +"365232FD4751870A0EF6CA619287C5D8B7F1747D95076AB19645EF309773E9EACEA0"
1.283 +"975FA4AE16251A8DA5865349C3A903E3B8A2C0DEA3C0720B6020C7FED69AFF62BB72"
1.284 +"10FAC443F9FFA2950776F949E819260C2AF8D94E8A1431A40F8C23C1973DE5D49AA2"
1.285 +"0B3FF5DA5C1D5324E712A78FF33A9B1748F83FA529905924A31DF38643B3F693EF9B"
1.286 +"58D846BB1AEAE4523ECC843FF551C1B300A130B65C1677402778F98C51C10813250E"
1.287 +"2496882877B069E877B59740DC1226F18A5C0F66F64A5F59A9FAFC5E9FC45AEC0E7A"
1.288 +"BEE244F7DD3AC268CF512A0E52E4F5BE5B94";
1.289 +
1.290 +const char *g_mp71 = "1";
1.291 +const char *g_mp25 = "7";
1.292 +const char *l_mp1011 = "C589E3D7D64A6942A000";
1.293 +
1.294 +/* mp9 in radices from 5 to 64 inclusive */
1.295 +#define LOW_RADIX 5
1.296 +#define HIGH_RADIX 64
1.297 +const char *v_mp9[] = {
1.298 + "404041130042310320100141302000203430214122130002340212132414134210033",
1.299 + "44515230120451152500101352430105520150025145320010504454125502",
1.300 + "644641136612541136016610100564613624243140151310023515322",
1.301 + "173512120732412062323044435407317550316717172705712756",
1.302 + "265785018434285762514442046172754680368422060744852",
1.303 + "1411774500397290569709059837552310354075408897518",
1.304 + "184064268501499311A17746095910428222A241708032A",
1.305 + "47706011B225950B02BB45602AA039893118A85950892",
1.306 + "1A188C826B982353CB58422563AC602B783101671A86",
1.307 + "105957B358B89B018958908A9114BC3DDC410B77982",
1.308 + "CB7B3387E23452178846C55DD9D70C7CA9AEA78E8",
1.309 + "F74A2876A1432698923B0767DA19DCF3D71795EE",
1.310 + "17BF7C3673B76D7G7A5GA836277296F806E7453A",
1.311 + "2EBG8HH3HFA6185D6H0596AH96G24C966DD3HG2",
1.312 + "6G3HGBFEG8I3F25EAF61B904EIA40CFDH2124F",
1.313 + "10AHC3D29EBHDF3HD97905CG0JA8061855C3FI",
1.314 + "3BA5A55J5K699B2D09C38A4B237CH51IHA132",
1.315 + "EDEA90DJ0B5CB3FGG1C8587FEB99D3C143CA",
1.316 + "31M26JI1BBD56K3I028MML4EEDMAJK60LGLE",
1.317 + "GGG5M3142FKKG82EJ28111D70EMHC241E4E",
1.318 + "4446F4D5H10982023N297BF0DKBBHLLJB0I",
1.319 + "12E9DEEOBMKAKEP0IM284MIP7FO1O521M46",
1.320 + "85NN0HD48NN2FDDB1F5BMMKIB8CK20MDPK",
1.321 + "2D882A7A0O0JPCJ4APDRIB77IABAKDGJP2",
1.322 + "MFMCI0R7S27AAA3O3L2S8K44HKA7O02CN",
1.323 + "7IGQS73FFSHC50NNH44B6PTTNLC3M6H78",
1.324 + "2KLUB3U9850CSN6ANIDNIF1LB29MJ43LH",
1.325 + "UT52GTL18CJ9H4HR0TJTK6ESUFBHF5FE",
1.326 + "BTVL87QQBMUGF8PFWU4W3VU7U922QTMW",
1.327 + "4OG10HW0MSWJBIDEE2PDH24GA7RIHIAA",
1.328 + "1W8W9AX2DRUX48GXOLMK0PE42H0FEUWN",
1.329 + "SVWI84VBH069WR15W1U2VTK06USY8Z2",
1.330 + "CPTPNPDa5TYCPPNLALENT9IMX2GL0W2",
1.331 + "5QU21UJMRaUYYYYYN6GHSMPOYOXEEUY",
1.332 + "2O2Q7C6RPPB1SXJ9bR4035SPaQQ3H2W",
1.333 + "18d994IbT4PHbD7cGIPCRP00bbQO0bc",
1.334 + "NcDUEEWRO7XT76260WGeBHPVa72RdA",
1.335 + "BbX2WCF9VfSB5LPdJAdeXKV1fd6LC2",
1.336 + "60QDKW67P4JSQaTdQg7JE9ISafLaVU",
1.337 + "33ba9XbDbRdNF4BeDB2XYMhAVDaBdA",
1.338 + "1RIPZJA8gT5L5H7fTcaRhQ39geMMTc",
1.339 + "d65j70fBATjcDiidPYXUGcaBVVLME",
1.340 + "LKA9jhPabDG612TXWkhfT2gMXNIP2",
1.341 + "BgNaYhjfT0G8PBcYRP8khJCR3C9QE",
1.342 + "6Wk8RhJTAgDh10fYAiUVB1aM0HacG",
1.343 + "3dOCjaf78kd5EQNViUZWj3AfFL90I",
1.344 + "290VWkL3aiJoW4MBbHk0Z0bDo22Ni",
1.345 + "1DbDZ1hpPZNUDBUp6UigcJllEdC26",
1.346 + "dFSOLBUM7UZX8Vnc6qokGIOiFo1h",
1.347 + "NcoUYJOg0HVmKI9fR2ag0S8R2hrK",
1.348 + "EOpiJ5Te7oDe2pn8ZhAUKkhFHlZh",
1.349 + "8nXK8rp8neV8LWta1WDgd1QnlWsU",
1.350 + "5T3d6bcSBtHgrH9bCbu84tblaa7r",
1.351 + "3PlUDIYUvMqOVCir7AtquK5dWanq",
1.352 + "2A70gDPX2AtiicvIGGk9poiMtgvu",
1.353 + "1MjiRxjk10J6SVAxFguv9kZiUnIc",
1.354 + "rpre2vIDeb4h3sp50r1YBbtEx9L",
1.355 + "ZHcoip0AglDAfibrsUcJ9M1C8fm",
1.356 + "NHP18+eoe6uU54W49Kc6ZK7+bT2",
1.357 + "FTAA7QXGoQOaZi7PzePtFFN5vNk"
1.358 +};
1.359 +
1.360 +const unsigned char b_mp4[] = {
1.361 + 0x01,
1.362 +#if MP_DIGIT_MAX > MP_32BIT_MAX
1.363 + 0x00, 0x00, 0x00, 0x00,
1.364 +#endif
1.365 + 0x63, 0xDB, 0xC2, 0x26,
1.366 + 0x5B, 0x88, 0x26, 0x8D,
1.367 + 0xC8, 0x01, 0xC1, 0x0E,
1.368 + 0xA6, 0x84, 0x76, 0xB7,
1.369 + 0xBD, 0xE0, 0x09, 0x0F
1.370 +};
1.371 +
1.372 +/* Search for a test suite name in the names table */
1.373 +int find_name(char *name);
1.374 +void reason(char *fmt, ...);
1.375 +
1.376 +/*------------------------------------------------------------------------*/
1.377 +/*------------------------------------------------------------------------*/
1.378 +
1.379 +char g_intbuf[4096]; /* buffer for integer comparison */
1.380 +char a_intbuf[4096]; /* buffer for integer comparison */
1.381 +int g_verbose = 1; /* print out reasons for failure? */
1.382 +int res;
1.383 +
1.384 +#define IFOK(x) { if (MP_OKAY > (res = (x))) { \
1.385 + reason("test %s failed: error %d\n", #x, res); return 1; }}
1.386 +
1.387 +int main(int argc, char *argv[])
1.388 +{
1.389 + int which, res;
1.390 +
1.391 + srand((unsigned int)time(NULL));
1.392 +
1.393 + if (argc < 2) {
1.394 + fprintf(stderr, "Usage: %s <test-suite> | list\n"
1.395 + "Type '%s help' for assistance\n", argv[0], argv[0]);
1.396 + return 2;
1.397 + } else if(argc > 2) {
1.398 + if(strcmp(argv[2], "quiet") == 0)
1.399 + g_verbose = 0;
1.400 + }
1.401 +
1.402 + if(strcmp(argv[1], "help") == 0) {
1.403 + fprintf(stderr, "Help for mpi-test\n\n"
1.404 + "This program is a test driver for the MPI library, which\n"
1.405 + "tests all the various functions in the library to make sure\n"
1.406 + "they are working correctly. The syntax is:\n"
1.407 + " %s <suite-name>\n"
1.408 + "...where <suite-name> is the name of the test you wish to\n"
1.409 + "run. To get a list of the tests, use '%s list'.\n\n"
1.410 + "The program exits with a status of zero if the test passes,\n"
1.411 + "or non-zero if it fails. Ordinarily, failure is accompanied\n"
1.412 + "by a diagnostic message to standard error. To suppress this\n"
1.413 + "add the keyword 'quiet' after the suite-name on the command\n"
1.414 + "line.\n\n", argv[0], argv[0]);
1.415 + return 0;
1.416 + }
1.417 +
1.418 + if ((which = find_name(argv[1])) < 0) {
1.419 + fprintf(stderr, "%s: test suite '%s' is not known\n", argv[0], argv[1]);
1.420 + return 2;
1.421 + }
1.422 +
1.423 + if((res = (g_tests[which])()) < 0) {
1.424 + fprintf(stderr, "%s: test suite not implemented yet\n", argv[0]);
1.425 + return 2;
1.426 + } else {
1.427 + return res;
1.428 + }
1.429 +
1.430 +}
1.431 +
1.432 +/*------------------------------------------------------------------------*/
1.433 +
1.434 +int find_name(char *name)
1.435 +{
1.436 + int ix = 0;
1.437 +
1.438 + while(ix < g_count) {
1.439 + if (strcmp(name, g_names[ix]) == 0)
1.440 + return ix;
1.441 +
1.442 + ++ix;
1.443 + }
1.444 +
1.445 + return -1;
1.446 +}
1.447 +
1.448 +/*------------------------------------------------------------------------*/
1.449 +
1.450 +int test_list(void)
1.451 +{
1.452 + int ix;
1.453 +
1.454 + fprintf(stderr, "There are currently %d test suites available\n",
1.455 + g_count);
1.456 +
1.457 + for(ix = 1; ix < g_count; ix++)
1.458 + fprintf(stdout, "%-20s %s\n", g_names[ix], g_descs[ix]);
1.459 +
1.460 + return 0;
1.461 +}
1.462 +
1.463 +/*------------------------------------------------------------------------*/
1.464 +
1.465 +int test_copy(void)
1.466 +{
1.467 + mp_int a, b;
1.468 + int ix;
1.469 +
1.470 + mp_init(&a); mp_init(&b);
1.471 +
1.472 + mp_read_radix(&a, mp3, 16);
1.473 + mp_copy(&a, &b);
1.474 +
1.475 + if(SIGN(&a) != SIGN(&b) || USED(&a) != USED(&b)) {
1.476 + if(SIGN(&a) != SIGN(&b)) {
1.477 + reason("error: sign of original is %d, sign of copy is %d\n",
1.478 + SIGN(&a), SIGN(&b));
1.479 + } else {
1.480 + reason("error: original precision is %d, copy precision is %d\n",
1.481 + USED(&a), USED(&b));
1.482 + }
1.483 + mp_clear(&a); mp_clear(&b);
1.484 + return 1;
1.485 + }
1.486 +
1.487 + for(ix = 0; ix < USED(&b); ix++) {
1.488 + if(DIGIT(&a, ix) != DIGIT(&b, ix)) {
1.489 + reason("error: digit %d " DIGIT_FMT " != " DIGIT_FMT "\n",
1.490 + ix, DIGIT(&a, ix), DIGIT(&b, ix));
1.491 + mp_clear(&a); mp_clear(&b);
1.492 + return 1;
1.493 + }
1.494 + }
1.495 +
1.496 + mp_clear(&a); mp_clear(&b);
1.497 + return 0;
1.498 +}
1.499 +
1.500 +/*------------------------------------------------------------------------*/
1.501 +
1.502 +int test_exch(void)
1.503 +{
1.504 + mp_int a, b;
1.505 +
1.506 + mp_init(&a); mp_init(&b);
1.507 + mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp1, 16);
1.508 +
1.509 + mp_exch(&a, &b);
1.510 + mp_toradix(&a, g_intbuf, 16);
1.511 +
1.512 + mp_clear(&a);
1.513 + if(strcmp(g_intbuf, mp1) != 0) {
1.514 + mp_clear(&b);
1.515 + reason("error: exchange failed\n");
1.516 + return 1;
1.517 + }
1.518 +
1.519 + mp_toradix(&b, g_intbuf, 16);
1.520 +
1.521 + mp_clear(&b);
1.522 + if(strcmp(g_intbuf, mp7) != 0) {
1.523 + reason("error: exchange failed\n");
1.524 + return 1;
1.525 + }
1.526 +
1.527 + return 0;
1.528 +}
1.529 +
1.530 +/*------------------------------------------------------------------------*/
1.531 +
1.532 +int test_zero(void)
1.533 +{
1.534 + mp_int a;
1.535 +
1.536 + mp_init(&a); mp_read_radix(&a, mp7, 16);
1.537 + mp_zero(&a);
1.538 +
1.539 + if(USED(&a) != 1 || DIGIT(&a, 1) != 0) {
1.540 + mp_toradix(&a, g_intbuf, 16);
1.541 + reason("error: result is %s\n", g_intbuf);
1.542 + mp_clear(&a);
1.543 + return 1;
1.544 + }
1.545 +
1.546 + mp_clear(&a);
1.547 + return 0;
1.548 +}
1.549 +
1.550 +/*------------------------------------------------------------------------*/
1.551 +
1.552 +int test_set(void)
1.553 +{
1.554 + mp_int a;
1.555 +
1.556 + /* Test single digit set */
1.557 + mp_init(&a); mp_set(&a, 5);
1.558 + if(DIGIT(&a, 0) != 5) {
1.559 + mp_toradix(&a, g_intbuf, 16);
1.560 + reason("error: result is %s, expected 5\n", g_intbuf);
1.561 + mp_clear(&a);
1.562 + return 1;
1.563 + }
1.564 +
1.565 + /* Test integer set */
1.566 + mp_set_int(&a, -4938110);
1.567 + mp_toradix(&a, g_intbuf, 16);
1.568 + mp_clear(&a);
1.569 + if(strcmp(g_intbuf, mp5a) != 0) {
1.570 + reason("error: result is %s, expected %s\n", g_intbuf, mp5a);
1.571 + return 1;
1.572 + }
1.573 +
1.574 + return 0;
1.575 +}
1.576 +
1.577 +/*------------------------------------------------------------------------*/
1.578 +
1.579 +int test_abs(void)
1.580 +{
1.581 + mp_int a;
1.582 +
1.583 + mp_init(&a); mp_read_radix(&a, mp4, 16);
1.584 + mp_abs(&a, &a);
1.585 +
1.586 + if(SIGN(&a) != ZPOS) {
1.587 + reason("error: sign of result is negative\n");
1.588 + mp_clear(&a);
1.589 + return 1;
1.590 + }
1.591 +
1.592 + mp_clear(&a);
1.593 + return 0;
1.594 +}
1.595 +
1.596 +/*------------------------------------------------------------------------*/
1.597 +
1.598 +int test_neg(void)
1.599 +{
1.600 + mp_int a;
1.601 + mp_sign s;
1.602 +
1.603 + mp_init(&a); mp_read_radix(&a, mp4, 16);
1.604 +
1.605 + s = SIGN(&a);
1.606 + mp_neg(&a, &a);
1.607 + if(SIGN(&a) == s) {
1.608 + reason("error: sign of result is same as sign of nonzero input\n");
1.609 + mp_clear(&a);
1.610 + return 1;
1.611 + }
1.612 +
1.613 + mp_clear(&a);
1.614 + return 0;
1.615 +}
1.616 +
1.617 +/*------------------------------------------------------------------------*/
1.618 +
1.619 +int test_add_d(void)
1.620 +{
1.621 + mp_int a;
1.622 +
1.623 + mp_init(&a);
1.624 +
1.625 + mp_read_radix(&a, mp5, 16);
1.626 + mp_add_d(&a, md4, &a);
1.627 + mp_toradix(&a, g_intbuf, 16);
1.628 +
1.629 + if(strcmp(g_intbuf, s_mp5d4) != 0) {
1.630 + reason("error: computed %s, expected %s\n", g_intbuf, s_mp5d4);
1.631 + mp_clear(&a);
1.632 + return 1;
1.633 + }
1.634 +
1.635 + mp_read_radix(&a, mp2, 16);
1.636 + mp_add_d(&a, md5, &a);
1.637 + mp_toradix(&a, g_intbuf, 16);
1.638 +
1.639 + if(strcmp(g_intbuf, s_mp2d5) != 0) {
1.640 + reason("error: computed %s, expected %s\n", g_intbuf, s_mp2d5);
1.641 + mp_clear(&a);
1.642 + return 1;
1.643 + }
1.644 +
1.645 + mp_clear(&a);
1.646 + return 0;
1.647 +}
1.648 +
1.649 +/*------------------------------------------------------------------------*/
1.650 +
1.651 +int test_add(void)
1.652 +{
1.653 + mp_int a, b;
1.654 + int res = 0;
1.655 +
1.656 + mp_init(&a); mp_init(&b);
1.657 +
1.658 + mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp3, 16);
1.659 + mp_add(&a, &b, &a);
1.660 + mp_toradix(&a, g_intbuf, 16);
1.661 +
1.662 + if(strcmp(g_intbuf, s_mp13) != 0) {
1.663 + reason("error: computed %s, expected %s\n", g_intbuf, s_mp13);
1.664 + res = 1; goto CLEANUP;
1.665 + }
1.666 +
1.667 + mp_read_radix(&a, mp4, 16);
1.668 + mp_add(&a, &b, &a);
1.669 + mp_toradix(&a, g_intbuf, 16);
1.670 +
1.671 + if(strcmp(g_intbuf, s_mp34) != 0) {
1.672 + reason("error: computed %s, expected %s\n", g_intbuf, s_mp34);
1.673 + res = 1; goto CLEANUP;
1.674 + }
1.675 +
1.676 + mp_read_radix(&a, mp4, 16); mp_read_radix(&b, mp6, 16);
1.677 + mp_add(&a, &b, &a);
1.678 + mp_toradix(&a, g_intbuf, 16);
1.679 +
1.680 + if(strcmp(g_intbuf, s_mp46) != 0) {
1.681 + reason("error: computed %s, expected %s\n", g_intbuf, s_mp46);
1.682 + res = 1; goto CLEANUP;
1.683 + }
1.684 +
1.685 + mp_read_radix(&a, mp14, 16); mp_read_radix(&b, mp15, 16);
1.686 + mp_add(&a, &b, &a);
1.687 + mp_toradix(&a, g_intbuf, 16);
1.688 +
1.689 + if(strcmp(g_intbuf, s_mp1415) != 0) {
1.690 + reason("error: computed %s, expected %s\n", g_intbuf, s_mp1415);
1.691 + res = 1;
1.692 + }
1.693 +
1.694 + CLEANUP:
1.695 + mp_clear(&a); mp_clear(&b);
1.696 + return res;
1.697 +}
1.698 +
1.699 +/*------------------------------------------------------------------------*/
1.700 +
1.701 +int test_sub_d(void)
1.702 +{
1.703 + mp_int a;
1.704 +
1.705 + mp_init(&a);
1.706 + mp_read_radix(&a, mp5, 16);
1.707 +
1.708 + mp_sub_d(&a, md4, &a);
1.709 + mp_toradix(&a, g_intbuf, 16);
1.710 +
1.711 + if(strcmp(g_intbuf, d_mp5d4) != 0) {
1.712 + reason("error: computed %s, expected %s\n", g_intbuf, d_mp5d4);
1.713 + mp_clear(&a);
1.714 + return 1;
1.715 + }
1.716 +
1.717 + mp_read_radix(&a, mp6, 16);
1.718 +
1.719 + mp_sub_d(&a, md2, &a);
1.720 + mp_toradix(&a, g_intbuf, 16);
1.721 +
1.722 + mp_clear(&a);
1.723 + if(strcmp(g_intbuf, d_mp6d2) != 0) {
1.724 + reason("error: computed %s, expected %s\n", g_intbuf, d_mp6d2);
1.725 + return 1;
1.726 + }
1.727 +
1.728 + return 0;
1.729 +}
1.730 +
1.731 +/*------------------------------------------------------------------------*/
1.732 +
1.733 +int test_sub(void)
1.734 +{
1.735 + mp_int a, b;
1.736 +
1.737 + mp_init(&a); mp_init(&b);
1.738 +
1.739 + mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp2, 16);
1.740 + mp_sub(&a, &b, &a);
1.741 + mp_toradix(&a, g_intbuf, 16);
1.742 +
1.743 + if(strcmp(g_intbuf, d_mp12) != 0) {
1.744 + reason("error: computed %s, expected %s\n", g_intbuf, d_mp12);
1.745 + mp_clear(&a); mp_clear(&b);
1.746 + return 1;
1.747 + }
1.748 +
1.749 + mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1.750 + mp_sub(&a, &b, &a);
1.751 + mp_toradix(&a, g_intbuf, 16);
1.752 +
1.753 + if(strcmp(g_intbuf, d_mp34) != 0) {
1.754 + reason("error: computed %s, expected %s\n", g_intbuf, d_mp34);
1.755 + mp_clear(&a); mp_clear(&b);
1.756 + return 1;
1.757 + }
1.758 +
1.759 + mp_clear(&a); mp_clear(&b);
1.760 + return 0;
1.761 +}
1.762 +
1.763 +/*------------------------------------------------------------------------*/
1.764 +
1.765 +int test_mul_d(void)
1.766 +{
1.767 + mp_int a;
1.768 +
1.769 + mp_init(&a);
1.770 + mp_read_radix(&a, mp1, 16);
1.771 +
1.772 + IFOK( mp_mul_d(&a, md4, &a) );
1.773 + mp_toradix(&a, g_intbuf, 16);
1.774 +
1.775 + if(strcmp(g_intbuf, p_mp1d4) != 0) {
1.776 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp1d4);
1.777 + mp_clear(&a);
1.778 + return 1;
1.779 + }
1.780 +
1.781 + mp_read_radix(&a, mp8, 16);
1.782 + IFOK( mp_mul_d(&a, md6, &a) );
1.783 + mp_toradix(&a, g_intbuf, 16);
1.784 +
1.785 + mp_clear(&a);
1.786 + if(strcmp(g_intbuf, p_mp8d6) != 0) {
1.787 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp8d6);
1.788 + return 1;
1.789 + }
1.790 +
1.791 + return 0;
1.792 +}
1.793 +
1.794 +/*------------------------------------------------------------------------*/
1.795 +
1.796 +int test_mul(void)
1.797 +{
1.798 + mp_int a, b;
1.799 + int res = 0;
1.800 +
1.801 + mp_init(&a); mp_init(&b);
1.802 + mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp2, 16);
1.803 +
1.804 + IFOK( mp_mul(&a, &b, &a) );
1.805 + mp_toradix(&a, g_intbuf, 16);
1.806 +
1.807 + if(strcmp(g_intbuf, p_mp12) != 0) {
1.808 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp12);
1.809 + res = 1; goto CLEANUP;
1.810 + }
1.811 +
1.812 + mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1.813 + IFOK( mp_mul(&a, &b, &a) );
1.814 + mp_toradix(&a, g_intbuf, 16);
1.815 +
1.816 + if(strcmp(g_intbuf, p_mp34) !=0) {
1.817 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp34);
1.818 + res = 1; goto CLEANUP;
1.819 + }
1.820 +
1.821 + mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp7, 16);
1.822 + IFOK( mp_mul(&a, &b, &a) );
1.823 + mp_toradix(&a, g_intbuf, 16);
1.824 +
1.825 + if(strcmp(g_intbuf, p_mp57) != 0) {
1.826 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp57);
1.827 + res = 1; goto CLEANUP;
1.828 + }
1.829 +
1.830 + mp_read_radix(&a, mp11, 16); mp_read_radix(&b, mp13, 16);
1.831 + IFOK( mp_mul(&a, &b, &a) );
1.832 + mp_toradix(&a, g_intbuf, 16);
1.833 +
1.834 + if(strcmp(g_intbuf, p_mp1113) != 0) {
1.835 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp1113);
1.836 + res = 1; goto CLEANUP;
1.837 + }
1.838 +
1.839 + mp_read_radix(&a, mp14, 16); mp_read_radix(&b, mp15, 16);
1.840 + IFOK( mp_mul(&a, &b, &a) );
1.841 + mp_toradix(&a, g_intbuf, 16);
1.842 +
1.843 + if(strcmp(g_intbuf, p_mp1415) != 0) {
1.844 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp1415);
1.845 + res = 1;
1.846 + }
1.847 + mp_read_radix(&a, mp21, 10); mp_read_radix(&b, mp21, 10);
1.848 +
1.849 + IFOK( mp_mul(&a, &b, &a) );
1.850 + mp_toradix(&a, g_intbuf, 10);
1.851 +
1.852 + if(strcmp(g_intbuf, p_mp2121) != 0) {
1.853 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp2121);
1.854 + res = 1; goto CLEANUP;
1.855 + }
1.856 +
1.857 + CLEANUP:
1.858 + mp_clear(&a); mp_clear(&b);
1.859 + return res;
1.860 +
1.861 +}
1.862 +
1.863 +/*------------------------------------------------------------------------*/
1.864 +
1.865 +int test_sqr(void)
1.866 +{
1.867 + mp_int a;
1.868 +
1.869 + mp_init(&a); mp_read_radix(&a, mp2, 16);
1.870 +
1.871 + mp_sqr(&a, &a);
1.872 + mp_toradix(&a, g_intbuf, 16);
1.873 +
1.874 + mp_clear(&a);
1.875 + if(strcmp(g_intbuf, p_mp22) != 0) {
1.876 + reason("error: computed %s, expected %s\n", g_intbuf, p_mp22);
1.877 + return 1;
1.878 + }
1.879 +
1.880 + return 0;
1.881 +}
1.882 +
1.883 +/*------------------------------------------------------------------------*/
1.884 +
1.885 +int test_div_d(void)
1.886 +{
1.887 + mp_int a, q;
1.888 + mp_digit r;
1.889 + int err = 0;
1.890 +
1.891 + mp_init(&a); mp_init(&q);
1.892 + mp_read_radix(&a, mp3, 16);
1.893 +
1.894 + IFOK( mp_div_d(&a, md6, &q, &r) );
1.895 + mp_toradix(&q, g_intbuf, 16);
1.896 +
1.897 + if(strcmp(g_intbuf, q_mp3d6) != 0) {
1.898 + reason("error: computed q = %s, expected %s\n", g_intbuf, q_mp3d6);
1.899 + ++err;
1.900 + }
1.901 +
1.902 + sprintf(g_intbuf, ZS_DIGIT_FMT, r);
1.903 +
1.904 + if(strcmp(g_intbuf, r_mp3d6) != 0) {
1.905 + reason("error: computed r = %s, expected %s\n", g_intbuf, r_mp3d6);
1.906 + ++err;
1.907 + }
1.908 +
1.909 + mp_read_radix(&a, mp9, 16);
1.910 + IFOK( mp_div_d(&a, 16, &q, &r) );
1.911 + mp_toradix(&q, g_intbuf, 16);
1.912 +
1.913 + if(strcmp(g_intbuf, q_mp9c16) != 0) {
1.914 + reason("error: computed q = %s, expected %s\n", g_intbuf, q_mp9c16);
1.915 + ++err;
1.916 + }
1.917 +
1.918 + sprintf(g_intbuf, ZS_DIGIT_FMT, r);
1.919 +
1.920 + if(strcmp(g_intbuf, r_mp9c16) != 0) {
1.921 + reason("error: computed r = %s, expected %s\n", g_intbuf, r_mp9c16);
1.922 + ++err;
1.923 + }
1.924 +
1.925 + mp_clear(&a); mp_clear(&q);
1.926 + return err;
1.927 +}
1.928 +
1.929 +/*------------------------------------------------------------------------*/
1.930 +
1.931 +int test_div_2(void)
1.932 +{
1.933 + mp_int a;
1.934 +
1.935 + mp_init(&a); mp_read_radix(&a, mp7, 16);
1.936 + IFOK( mp_div_2(&a, &a) );
1.937 + mp_toradix(&a, g_intbuf, 16);
1.938 +
1.939 + mp_clear(&a);
1.940 + if(strcmp(g_intbuf, q_mp7c2) != 0) {
1.941 + reason("error: computed %s, expected %s\n", g_intbuf, q_mp7c2);
1.942 + return 1;
1.943 + }
1.944 +
1.945 + return 0;
1.946 +}
1.947 +
1.948 +/*------------------------------------------------------------------------*/
1.949 +
1.950 +int test_div_2d(void)
1.951 +{
1.952 + mp_int a, q, r;
1.953 +
1.954 + mp_init(&q); mp_init(&r);
1.955 + mp_init(&a); mp_read_radix(&a, mp13, 16);
1.956 +
1.957 + IFOK( mp_div_2d(&a, 64, &q, &r) );
1.958 + mp_clear(&a);
1.959 +
1.960 + mp_toradix(&q, g_intbuf, 16);
1.961 +
1.962 + if(strcmp(g_intbuf, q_mp13c) != 0) {
1.963 + reason("error: computed %s, expected %s\n", g_intbuf, q_mp13c);
1.964 + mp_clear(&q); mp_clear(&r);
1.965 + return 1;
1.966 + }
1.967 +
1.968 + mp_clear(&q);
1.969 +
1.970 + mp_toradix(&r, g_intbuf, 16);
1.971 + if(strcmp(g_intbuf, r_mp13c) != 0) {
1.972 + reason("error, computed %s, expected %s\n", g_intbuf, r_mp13c);
1.973 + mp_clear(&r);
1.974 + return 1;
1.975 + }
1.976 +
1.977 + mp_clear(&r);
1.978 +
1.979 + return 0;
1.980 +}
1.981 +
1.982 +/*------------------------------------------------------------------------*/
1.983 +
1.984 +int test_div(void)
1.985 +{
1.986 + mp_int a, b, r;
1.987 + int err = 0;
1.988 +
1.989 + mp_init(&a); mp_init(&b); mp_init(&r);
1.990 +
1.991 + mp_read_radix(&a, mp4, 16); mp_read_radix(&b, mp2, 16);
1.992 + IFOK( mp_div(&a, &b, &a, &r) );
1.993 + mp_toradix(&a, g_intbuf, 16);
1.994 +
1.995 + if(strcmp(g_intbuf, q_mp42) != 0) {
1.996 + reason("error: test 1 computed quot %s, expected %s\n", g_intbuf, q_mp42);
1.997 + ++err;
1.998 + }
1.999 +
1.1000 + mp_toradix(&r, g_intbuf, 16);
1.1001 +
1.1002 + if(strcmp(g_intbuf, r_mp42) != 0) {
1.1003 + reason("error: test 1 computed rem %s, expected %s\n", g_intbuf, r_mp42);
1.1004 + ++err;
1.1005 + }
1.1006 +
1.1007 + mp_read_radix(&a, mp4, 16); mp_read_radix(&b, mp5a, 16);
1.1008 + IFOK( mp_div(&a, &b, &a, &r) );
1.1009 + mp_toradix(&a, g_intbuf, 16);
1.1010 +
1.1011 + if(strcmp(g_intbuf, q_mp45a) != 0) {
1.1012 + reason("error: test 2 computed quot %s, expected %s\n", g_intbuf, q_mp45a);
1.1013 + ++err;
1.1014 + }
1.1015 +
1.1016 + mp_toradix(&r, g_intbuf, 16);
1.1017 +
1.1018 + if(strcmp(g_intbuf, r_mp45a) != 0) {
1.1019 + reason("error: test 2 computed rem %s, expected %s\n", g_intbuf, r_mp45a);
1.1020 + ++err;
1.1021 + }
1.1022 +
1.1023 + mp_read_radix(&a, mp14, 16); mp_read_radix(&b, mp4, 16);
1.1024 + IFOK( mp_div(&a, &b, &a, &r) );
1.1025 + mp_toradix(&a, g_intbuf, 16);
1.1026 +
1.1027 + if(strcmp(g_intbuf, q_mp1404) != 0) {
1.1028 + reason("error: test 3 computed quot %s, expected %s\n", g_intbuf, q_mp1404);
1.1029 + ++err;
1.1030 + }
1.1031 +
1.1032 + mp_toradix(&r, g_intbuf, 16);
1.1033 +
1.1034 + if(strcmp(g_intbuf, r_mp1404) != 0) {
1.1035 + reason("error: test 3 computed rem %s, expected %s\n", g_intbuf, r_mp1404);
1.1036 + ++err;
1.1037 + }
1.1038 +
1.1039 + mp_clear(&a); mp_clear(&b); mp_clear(&r);
1.1040 +
1.1041 + return err;
1.1042 +}
1.1043 +
1.1044 +/*------------------------------------------------------------------------*/
1.1045 +
1.1046 +int test_expt_d(void)
1.1047 +{
1.1048 + mp_int a;
1.1049 +
1.1050 + mp_init(&a); mp_read_radix(&a, mp5, 16);
1.1051 + mp_expt_d(&a, md9, &a);
1.1052 + mp_toradix(&a, g_intbuf, 16);
1.1053 +
1.1054 + mp_clear(&a);
1.1055 + if(strcmp(g_intbuf, e_mp5d9) != 0) {
1.1056 + reason("error: computed %s, expected %s\n", g_intbuf, e_mp5d9);
1.1057 + return 1;
1.1058 + }
1.1059 +
1.1060 + return 0;
1.1061 +}
1.1062 +
1.1063 +/*------------------------------------------------------------------------*/
1.1064 +
1.1065 +int test_expt(void)
1.1066 +{
1.1067 + mp_int a, b;
1.1068 +
1.1069 + mp_init(&a); mp_init(&b);
1.1070 + mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp8, 16);
1.1071 +
1.1072 + mp_expt(&a, &b, &a);
1.1073 + mp_toradix(&a, g_intbuf, 16);
1.1074 + mp_clear(&a); mp_clear(&b);
1.1075 +
1.1076 + if(strcmp(g_intbuf, e_mp78) != 0) {
1.1077 + reason("error: computed %s, expected %s\n", g_intbuf, e_mp78);
1.1078 + return 1;
1.1079 + }
1.1080 +
1.1081 + return 0;
1.1082 +}
1.1083 +
1.1084 +/*------------------------------------------------------------------------*/
1.1085 +
1.1086 +int test_2expt(void)
1.1087 +{
1.1088 + mp_int a;
1.1089 +
1.1090 + mp_init(&a);
1.1091 + mp_2expt(&a, md3);
1.1092 + mp_toradix(&a, g_intbuf, 16);
1.1093 + mp_clear(&a);
1.1094 +
1.1095 + if(strcmp(g_intbuf, e_mpc2d3) != 0) {
1.1096 + reason("error: computed %s, expected %s\n", g_intbuf, e_mpc2d3);
1.1097 + return 1;
1.1098 + }
1.1099 +
1.1100 + return 0;
1.1101 +}
1.1102 +
1.1103 +/*------------------------------------------------------------------------*/
1.1104 +
1.1105 +int test_sqrt(void)
1.1106 +{
1.1107 + mp_int a;
1.1108 + int res = 0;
1.1109 +
1.1110 + mp_init(&a); mp_read_radix(&a, mp9, 16);
1.1111 + mp_sqrt(&a, &a);
1.1112 + mp_toradix(&a, g_intbuf, 16);
1.1113 +
1.1114 + if(strcmp(g_intbuf, t_mp9) != 0) {
1.1115 + reason("error: computed %s, expected %s\n", g_intbuf, t_mp9);
1.1116 + res = 1; goto CLEANUP;
1.1117 + }
1.1118 +
1.1119 + mp_read_radix(&a, mp15, 16);
1.1120 + mp_sqrt(&a, &a);
1.1121 + mp_toradix(&a, g_intbuf, 16);
1.1122 +
1.1123 + if(strcmp(g_intbuf, t_mp15) != 0) {
1.1124 + reason("error: computed %s, expected %s\n", g_intbuf, t_mp15);
1.1125 + res = 1;
1.1126 + }
1.1127 +
1.1128 + CLEANUP:
1.1129 + mp_clear(&a);
1.1130 + return res;
1.1131 +}
1.1132 +
1.1133 +/*------------------------------------------------------------------------*/
1.1134 +
1.1135 +int test_mod_d(void)
1.1136 +{
1.1137 + mp_int a;
1.1138 + mp_digit r;
1.1139 +
1.1140 + mp_init(&a); mp_read_radix(&a, mp5, 16);
1.1141 + IFOK( mp_mod_d(&a, md5, &r) );
1.1142 + sprintf(g_intbuf, ZS_DIGIT_FMT, r);
1.1143 + mp_clear(&a);
1.1144 +
1.1145 + if(strcmp(g_intbuf, r_mp5d5) != 0) {
1.1146 + reason("error: computed %s, expected %s\n", g_intbuf, r_mp5d5);
1.1147 + return 1;
1.1148 + }
1.1149 +
1.1150 + return 0;
1.1151 +}
1.1152 +
1.1153 +/*------------------------------------------------------------------------*/
1.1154 +
1.1155 +int test_mod(void)
1.1156 +{
1.1157 + mp_int a, m;
1.1158 +
1.1159 + mp_init(&a); mp_init(&m);
1.1160 + mp_read_radix(&a, mp4, 16); mp_read_radix(&m, mp7, 16);
1.1161 + IFOK( mp_mod(&a, &m, &a) );
1.1162 + mp_toradix(&a, g_intbuf, 16);
1.1163 + mp_clear(&a); mp_clear(&m);
1.1164 +
1.1165 + if(strcmp(g_intbuf, r_mp47) != 0) {
1.1166 + reason("error: computed %s, expected %s\n", g_intbuf, r_mp47);
1.1167 + return 1;
1.1168 + }
1.1169 +
1.1170 + return 0;
1.1171 +}
1.1172 +
1.1173 +/*------------------------------------------------------------------------*/
1.1174 +
1.1175 +int test_addmod(void)
1.1176 +{
1.1177 + mp_int a, b, m;
1.1178 +
1.1179 + mp_init(&a); mp_init(&b); mp_init(&m);
1.1180 + mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1.1181 + mp_read_radix(&m, mp5, 16);
1.1182 +
1.1183 + IFOK( mp_addmod(&a, &b, &m, &a) );
1.1184 + mp_toradix(&a, g_intbuf, 16);
1.1185 + mp_clear(&a); mp_clear(&b); mp_clear(&m);
1.1186 +
1.1187 + if(strcmp(g_intbuf, ms_mp345) != 0) {
1.1188 + reason("error: computed %s, expected %s\n", g_intbuf, ms_mp345);
1.1189 + return 1;
1.1190 + }
1.1191 +
1.1192 + return 0;
1.1193 +}
1.1194 +
1.1195 +/*------------------------------------------------------------------------*/
1.1196 +
1.1197 +int test_submod(void)
1.1198 +{
1.1199 + mp_int a, b, m;
1.1200 +
1.1201 + mp_init(&a); mp_init(&b); mp_init(&m);
1.1202 + mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1.1203 + mp_read_radix(&m, mp5, 16);
1.1204 +
1.1205 + IFOK( mp_submod(&a, &b, &m, &a) );
1.1206 + mp_toradix(&a, g_intbuf, 16);
1.1207 + mp_clear(&a); mp_clear(&b); mp_clear(&m);
1.1208 +
1.1209 + if(strcmp(g_intbuf, md_mp345) != 0) {
1.1210 + reason("error: computed %s, expected %s\n", g_intbuf, md_mp345);
1.1211 + return 1;
1.1212 + }
1.1213 +
1.1214 + return 0;
1.1215 +}
1.1216 +
1.1217 +/*------------------------------------------------------------------------*/
1.1218 +
1.1219 +int test_mulmod(void)
1.1220 +{
1.1221 + mp_int a, b, m;
1.1222 +
1.1223 + mp_init(&a); mp_init(&b); mp_init(&m);
1.1224 + mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1.1225 + mp_read_radix(&m, mp5, 16);
1.1226 +
1.1227 + IFOK( mp_mulmod(&a, &b, &m, &a) );
1.1228 + mp_toradix(&a, g_intbuf, 16);
1.1229 + mp_clear(&a); mp_clear(&b); mp_clear(&m);
1.1230 +
1.1231 + if(strcmp(g_intbuf, mp_mp345) != 0) {
1.1232 + reason("error: computed %s, expected %s\n", g_intbuf, mp_mp345);
1.1233 + return 1;
1.1234 + }
1.1235 +
1.1236 + return 0;
1.1237 +}
1.1238 +
1.1239 +/*------------------------------------------------------------------------*/
1.1240 +
1.1241 +int test_sqrmod(void)
1.1242 +{
1.1243 + mp_int a, m;
1.1244 +
1.1245 + mp_init(&a); mp_init(&m);
1.1246 + mp_read_radix(&a, mp3, 16); mp_read_radix(&m, mp5, 16);
1.1247 +
1.1248 + IFOK( mp_sqrmod(&a, &m, &a) );
1.1249 + mp_toradix(&a, g_intbuf, 16);
1.1250 + mp_clear(&a); mp_clear(&m);
1.1251 +
1.1252 + if(strcmp(g_intbuf, mp_mp335) != 0) {
1.1253 + reason("error: computed %s, expected %s\n", g_intbuf, mp_mp335);
1.1254 + return 1;
1.1255 + }
1.1256 +
1.1257 + return 0;
1.1258 +}
1.1259 +
1.1260 +/*------------------------------------------------------------------------*/
1.1261 +
1.1262 +int test_exptmod(void)
1.1263 +{
1.1264 + mp_int a, b, m;
1.1265 + int res = 0;
1.1266 +
1.1267 + mp_init(&a); mp_init(&b); mp_init(&m);
1.1268 + mp_read_radix(&a, mp8, 16); mp_read_radix(&b, mp1, 16);
1.1269 + mp_read_radix(&m, mp7, 16);
1.1270 +
1.1271 + IFOK( mp_exptmod(&a, &b, &m, &a) );
1.1272 + mp_toradix(&a, g_intbuf, 16);
1.1273 +
1.1274 + if(strcmp(g_intbuf, me_mp817) != 0) {
1.1275 + reason("case 1: error: computed %s, expected %s\n", g_intbuf, me_mp817);
1.1276 + res = 1; goto CLEANUP;
1.1277 + }
1.1278 +
1.1279 + mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp5, 16);
1.1280 + mp_read_radix(&m, mp12, 16);
1.1281 +
1.1282 + IFOK( mp_exptmod(&a, &b, &m, &a) );
1.1283 + mp_toradix(&a, g_intbuf, 16);
1.1284 +
1.1285 + if(strcmp(g_intbuf, me_mp1512) != 0) {
1.1286 + reason("case 2: error: computed %s, expected %s\n", g_intbuf, me_mp1512);
1.1287 + res = 1; goto CLEANUP;
1.1288 + }
1.1289 +
1.1290 + mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp1, 16);
1.1291 + mp_read_radix(&m, mp14, 16);
1.1292 +
1.1293 + IFOK( mp_exptmod(&a, &b, &m, &a) );
1.1294 + mp_toradix(&a, g_intbuf, 16);
1.1295 +
1.1296 + if(strcmp(g_intbuf, me_mp5114) != 0) {
1.1297 + reason("case 3: error: computed %s, expected %s\n", g_intbuf, me_mp5114);
1.1298 + res = 1;
1.1299 + }
1.1300 +
1.1301 + mp_read_radix(&a, mp16, 16); mp_read_radix(&b, mp17, 16);
1.1302 + mp_read_radix(&m, mp18, 16);
1.1303 +
1.1304 + IFOK( mp_exptmod(&a, &b, &m, &a) );
1.1305 + mp_toradix(&a, g_intbuf, 16);
1.1306 +
1.1307 + if(strcmp(g_intbuf, me_mp161718) != 0) {
1.1308 + reason("case 4: error: computed %s, expected %s\n", g_intbuf, me_mp161718);
1.1309 + res = 1;
1.1310 + }
1.1311 +
1.1312 + CLEANUP:
1.1313 + mp_clear(&a); mp_clear(&b); mp_clear(&m);
1.1314 + return res;
1.1315 +}
1.1316 +
1.1317 +/*------------------------------------------------------------------------*/
1.1318 +
1.1319 +int test_exptmod_d(void)
1.1320 +{
1.1321 + mp_int a, m;
1.1322 +
1.1323 + mp_init(&a); mp_init(&m);
1.1324 + mp_read_radix(&a, mp5, 16); mp_read_radix(&m, mp7, 16);
1.1325 +
1.1326 + IFOK( mp_exptmod_d(&a, md4, &m, &a) );
1.1327 + mp_toradix(&a, g_intbuf, 16);
1.1328 + mp_clear(&a); mp_clear(&m);
1.1329 +
1.1330 + if(strcmp(g_intbuf, me_mp5d47) != 0) {
1.1331 + reason("error: computed %s, expected %s\n", g_intbuf, me_mp5d47);
1.1332 + return 1;
1.1333 + }
1.1334 +
1.1335 + return 0;
1.1336 +}
1.1337 +
1.1338 +/*------------------------------------------------------------------------*/
1.1339 +
1.1340 +int test_invmod(void)
1.1341 +{
1.1342 + mp_int a, m, c;
1.1343 + mp_int p1, p2, p3, p4, p5;
1.1344 + mp_int t1, t2, t3, t4;
1.1345 + mp_err res;
1.1346 +
1.1347 + /* 5 128-bit primes. */
1.1348 + static const char ivp1[] = { "AAD8A5A2A2BEF644BAEE7DB0CA643719" };
1.1349 + static const char ivp2[] = { "CB371AD2B79A90BCC88D0430663E40B9" };
1.1350 + static const char ivp3[] = { "C6C818D4DF2618406CA09280C0400099" };
1.1351 + static const char ivp4[] = { "CE949C04512E68918006B1F0D7E93F27" };
1.1352 + static const char ivp5[] = { "F8EE999B6416645040687440E0B89F51" };
1.1353 +
1.1354 + mp_init(&a); mp_init(&m);
1.1355 + mp_read_radix(&a, mp2, 16); mp_read_radix(&m, mp7, 16);
1.1356 +
1.1357 + IFOK( mp_invmod(&a, &m, &a) );
1.1358 +
1.1359 + mp_toradix(&a, g_intbuf, 16);
1.1360 + mp_clear(&a); mp_clear(&m);
1.1361 +
1.1362 + if(strcmp(g_intbuf, i_mp27) != 0) {
1.1363 + reason("error: invmod test 1 computed %s, expected %s\n", g_intbuf, i_mp27);
1.1364 + return 1;
1.1365 + }
1.1366 +
1.1367 + mp_init(&a); mp_init(&m);
1.1368 + mp_read_radix(&a, mp20, 16); mp_read_radix(&m, mp19, 16);
1.1369 +
1.1370 + IFOK( mp_invmod(&a, &m, &a) );
1.1371 +
1.1372 + mp_toradix(&a, g_intbuf, 16);
1.1373 + mp_clear(&a); mp_clear(&m);
1.1374 +
1.1375 + if(strcmp(g_intbuf, i_mp2019) != 0) {
1.1376 + reason("error: invmod test 2 computed %s, expected %s\n", g_intbuf, i_mp2019);
1.1377 + return 1;
1.1378 + }
1.1379 +
1.1380 +/* Need the following test cases:
1.1381 + Odd modulus
1.1382 + - a is odd, relatively prime to m
1.1383 + - a is odd, not relatively prime to m
1.1384 + - a is even, relatively prime to m
1.1385 + - a is even, not relatively prime to m
1.1386 + Even modulus
1.1387 + - a is even (should fail)
1.1388 + - a is odd, not relatively prime to m
1.1389 + - a is odd, relatively prime to m,
1.1390 + m is not a power of 2
1.1391 + - m has factor 2**k, k < 32
1.1392 + - m has factor 2**k, k > 32
1.1393 + m is a power of 2, 2**k
1.1394 + - k < 32
1.1395 + - k > 32
1.1396 +*/
1.1397 +
1.1398 + mp_init(&a); mp_init(&m); mp_init(&c);
1.1399 + mp_init(&p1); mp_init(&p2); mp_init(&p3); mp_init(&p4); mp_init(&p5);
1.1400 + mp_init(&t1); mp_init(&t2); mp_init(&t3); mp_init(&t4);
1.1401 +
1.1402 + mp_read_radix(&p1, ivp1, 16);
1.1403 + mp_read_radix(&p2, ivp2, 16);
1.1404 + mp_read_radix(&p3, ivp3, 16);
1.1405 + mp_read_radix(&p4, ivp4, 16);
1.1406 + mp_read_radix(&p5, ivp5, 16);
1.1407 +
1.1408 + IFOK( mp_2expt(&t2, 68) ); /* t2 = 2**68 */
1.1409 + IFOK( mp_2expt(&t3, 128) ); /* t3 = 2**128 */
1.1410 + IFOK( mp_2expt(&t4, 31) ); /* t4 = 2**31 */
1.1411 +
1.1412 +/* test 3: Odd modulus - a is odd, relatively prime to m */
1.1413 +
1.1414 + IFOK( mp_mul(&p1, &p2, &a) );
1.1415 + IFOK( mp_mul(&p3, &p4, &m) );
1.1416 + IFOK( mp_invmod(&a, &m, &t1) );
1.1417 + IFOK( mp_invmod_xgcd(&a, &m, &c) );
1.1418 +
1.1419 + if (mp_cmp(&t1, &c) != 0) {
1.1420 + mp_toradix(&t1, g_intbuf, 16);
1.1421 + mp_toradix(&c, a_intbuf, 16);
1.1422 + reason("error: invmod test 3 computed %s, expected %s\n",
1.1423 + g_intbuf, a_intbuf);
1.1424 + return 1;
1.1425 + }
1.1426 + mp_clear(&a); mp_clear(&t1); mp_clear(&c);
1.1427 + mp_init(&a); mp_init(&t1); mp_init(&c);
1.1428 +
1.1429 +/* test 4: Odd modulus - a is odd, NOT relatively prime to m */
1.1430 +
1.1431 + IFOK( mp_mul(&p1, &p3, &a) );
1.1432 + /* reuse same m as before */
1.1433 +
1.1434 + res = mp_invmod_xgcd(&a, &m, &c);
1.1435 + if (res != MP_UNDEF)
1.1436 + goto CLEANUP4;
1.1437 +
1.1438 + res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1.1439 + if (res != MP_UNDEF) {
1.1440 +CLEANUP4:
1.1441 + reason("error: invmod test 4 succeeded, should have failed.\n");
1.1442 + return 1;
1.1443 + }
1.1444 + mp_clear(&a); mp_clear(&t1); mp_clear(&c);
1.1445 + mp_init(&a); mp_init(&t1); mp_init(&c);
1.1446 +
1.1447 +/* test 5: Odd modulus - a is even, relatively prime to m */
1.1448 +
1.1449 + IFOK( mp_mul(&p1, &t2, &a) );
1.1450 + /* reuse m */
1.1451 + IFOK( mp_invmod(&a, &m, &t1) );
1.1452 + IFOK( mp_invmod_xgcd(&a, &m, &c) );
1.1453 +
1.1454 + if (mp_cmp(&t1, &c) != 0) {
1.1455 + mp_toradix(&t1, g_intbuf, 16);
1.1456 + mp_toradix(&c, a_intbuf, 16);
1.1457 + reason("error: invmod test 5 computed %s, expected %s\n",
1.1458 + g_intbuf, a_intbuf);
1.1459 + return 1;
1.1460 + }
1.1461 + mp_clear(&a); mp_clear(&t1); mp_clear(&c);
1.1462 + mp_init(&a); mp_init(&t1); mp_init(&c);
1.1463 +
1.1464 +/* test 6: Odd modulus - a is odd, NOT relatively prime to m */
1.1465 +
1.1466 + /* reuse t2 */
1.1467 + IFOK( mp_mul(&t2, &p3, &a) );
1.1468 + /* reuse same m as before */
1.1469 +
1.1470 + res = mp_invmod_xgcd(&a, &m, &c);
1.1471 + if (res != MP_UNDEF)
1.1472 + goto CLEANUP6;
1.1473 +
1.1474 + res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1.1475 + if (res != MP_UNDEF) {
1.1476 +CLEANUP6:
1.1477 + reason("error: invmod test 6 succeeded, should have failed.\n");
1.1478 + return 1;
1.1479 + }
1.1480 + mp_clear(&a); mp_clear(&m); mp_clear(&c); mp_clear(&t1);
1.1481 + mp_init(&a); mp_init(&m); mp_init(&c); mp_init(&t1);
1.1482 +
1.1483 +/* test 7: Even modulus, even a, should fail */
1.1484 +
1.1485 + IFOK( mp_mul(&p3, &t3, &m) ); /* even m */
1.1486 + /* reuse t2 */
1.1487 + IFOK( mp_mul(&p1, &t2, &a) ); /* even a */
1.1488 +
1.1489 + res = mp_invmod_xgcd(&a, &m, &c);
1.1490 + if (res != MP_UNDEF)
1.1491 + goto CLEANUP7;
1.1492 +
1.1493 + res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1.1494 + if (res != MP_UNDEF) {
1.1495 +CLEANUP7:
1.1496 + reason("error: invmod test 7 succeeded, should have failed.\n");
1.1497 + return 1;
1.1498 + }
1.1499 + mp_clear(&a); mp_clear(&c); mp_clear(&t1);
1.1500 + mp_init(&a); mp_init(&c); mp_init(&t1);
1.1501 +
1.1502 +/* test 8: Even modulus - a is odd, not relatively prime to m */
1.1503 +
1.1504 + /* reuse m */
1.1505 + IFOK( mp_mul(&p3, &p1, &a) ); /* even a */
1.1506 +
1.1507 + res = mp_invmod_xgcd(&a, &m, &c);
1.1508 + if (res != MP_UNDEF)
1.1509 + goto CLEANUP8;
1.1510 +
1.1511 + res = mp_invmod(&a, &m, &t1); /* we expect this to fail. */
1.1512 + if (res != MP_UNDEF) {
1.1513 +CLEANUP8:
1.1514 + reason("error: invmod test 8 succeeded, should have failed.\n");
1.1515 + return 1;
1.1516 + }
1.1517 + mp_clear(&a); mp_clear(&m); mp_clear(&c); mp_clear(&t1);
1.1518 + mp_init(&a); mp_init(&m); mp_init(&c); mp_init(&t1);
1.1519 +
1.1520 +/* test 9: Even modulus - m has factor 2**k, k < 32
1.1521 + * - a is odd, relatively prime to m,
1.1522 + */
1.1523 + IFOK( mp_mul(&p3, &t4, &m) ); /* even m */
1.1524 + IFOK( mp_mul(&p1, &p2, &a) );
1.1525 + IFOK( mp_invmod(&a, &m, &t1) );
1.1526 + IFOK( mp_invmod_xgcd(&a, &m, &c) );
1.1527 +
1.1528 + if (mp_cmp(&t1, &c) != 0) {
1.1529 + mp_toradix(&t1, g_intbuf, 16);
1.1530 + mp_toradix(&c, a_intbuf, 16);
1.1531 + reason("error: invmod test 9 computed %s, expected %s\n",
1.1532 + g_intbuf, a_intbuf);
1.1533 + return 1;
1.1534 + }
1.1535 + mp_clear(&m); mp_clear(&t1); mp_clear(&c);
1.1536 + mp_init(&m); mp_init(&t1); mp_init(&c);
1.1537 +
1.1538 +/* test 10: Even modulus - m has factor 2**k, k > 32
1.1539 + * - a is odd, relatively prime to m,
1.1540 + */
1.1541 + IFOK( mp_mul(&p3, &t3, &m) ); /* even m */
1.1542 + /* reuse a */
1.1543 + IFOK( mp_invmod(&a, &m, &t1) );
1.1544 + IFOK( mp_invmod_xgcd(&a, &m, &c) );
1.1545 +
1.1546 + if (mp_cmp(&t1, &c) != 0) {
1.1547 + mp_toradix(&t1, g_intbuf, 16);
1.1548 + mp_toradix(&c, a_intbuf, 16);
1.1549 + reason("error: invmod test 10 computed %s, expected %s\n",
1.1550 + g_intbuf, a_intbuf);
1.1551 + return 1;
1.1552 + }
1.1553 + mp_clear(&t1); mp_clear(&c);
1.1554 + mp_init(&t1); mp_init(&c);
1.1555 +
1.1556 +/* test 11: Even modulus - m is a power of 2, 2**k | k < 32
1.1557 + * - a is odd, relatively prime to m,
1.1558 + */
1.1559 + IFOK( mp_invmod(&a, &t4, &t1) );
1.1560 + IFOK( mp_invmod_xgcd(&a, &t4, &c) );
1.1561 +
1.1562 + if (mp_cmp(&t1, &c) != 0) {
1.1563 + mp_toradix(&t1, g_intbuf, 16);
1.1564 + mp_toradix(&c, a_intbuf, 16);
1.1565 + reason("error: invmod test 11 computed %s, expected %s\n",
1.1566 + g_intbuf, a_intbuf);
1.1567 + return 1;
1.1568 + }
1.1569 + mp_clear(&t1); mp_clear(&c);
1.1570 + mp_init(&t1); mp_init(&c);
1.1571 +
1.1572 +/* test 12: Even modulus - m is a power of 2, 2**k | k > 32
1.1573 + * - a is odd, relatively prime to m,
1.1574 + */
1.1575 + IFOK( mp_invmod(&a, &t3, &t1) );
1.1576 + IFOK( mp_invmod_xgcd(&a, &t3, &c) );
1.1577 +
1.1578 + if (mp_cmp(&t1, &c) != 0) {
1.1579 + mp_toradix(&t1, g_intbuf, 16);
1.1580 + mp_toradix(&c, a_intbuf, 16);
1.1581 + reason("error: invmod test 12 computed %s, expected %s\n",
1.1582 + g_intbuf, a_intbuf);
1.1583 + return 1;
1.1584 + }
1.1585 +
1.1586 + mp_clear(&a); mp_clear(&m); mp_clear(&c);
1.1587 + mp_clear(&t1); mp_clear(&t2); mp_clear(&t3); mp_clear(&t4);
1.1588 + mp_clear(&p1); mp_clear(&p2); mp_clear(&p3); mp_clear(&p4); mp_clear(&p5);
1.1589 +
1.1590 + return 0;
1.1591 +}
1.1592 +
1.1593 +/*------------------------------------------------------------------------*/
1.1594 +
1.1595 +int test_cmp_d(void)
1.1596 +{
1.1597 + mp_int a;
1.1598 +
1.1599 + mp_init(&a); mp_read_radix(&a, mp8, 16);
1.1600 +
1.1601 + if(mp_cmp_d(&a, md8) >= 0) {
1.1602 + reason("error: %s >= " DIGIT_FMT "\n", mp8, md8);
1.1603 + mp_clear(&a);
1.1604 + return 1;
1.1605 + }
1.1606 +
1.1607 + mp_read_radix(&a, mp5, 16);
1.1608 +
1.1609 + if(mp_cmp_d(&a, md8) <= 0) {
1.1610 + reason("error: %s <= " DIGIT_FMT "\n", mp5, md8);
1.1611 + mp_clear(&a);
1.1612 + return 1;
1.1613 + }
1.1614 +
1.1615 + mp_read_radix(&a, mp6, 16);
1.1616 +
1.1617 + if(mp_cmp_d(&a, md1) != 0) {
1.1618 + reason("error: %s != " DIGIT_FMT "\n", mp6, md1);
1.1619 + mp_clear(&a);
1.1620 + return 1;
1.1621 + }
1.1622 +
1.1623 + mp_clear(&a);
1.1624 + return 0;
1.1625 +
1.1626 +}
1.1627 +
1.1628 +/*------------------------------------------------------------------------*/
1.1629 +
1.1630 +int test_cmp_z(void)
1.1631 +{
1.1632 + mp_int a;
1.1633 +
1.1634 + mp_init(&a); mp_read_radix(&a, mp6, 16);
1.1635 +
1.1636 + if(mp_cmp_z(&a) != 0) {
1.1637 + reason("error: someone thinks a zero value is non-zero\n");
1.1638 + mp_clear(&a);
1.1639 + return 1;
1.1640 + }
1.1641 +
1.1642 + mp_read_radix(&a, mp1, 16);
1.1643 +
1.1644 + if(mp_cmp_z(&a) <= 0) {
1.1645 + reason("error: someone thinks a positive value is non-positive\n");
1.1646 + mp_clear(&a);
1.1647 + return 1;
1.1648 + }
1.1649 +
1.1650 + mp_read_radix(&a, mp4, 16);
1.1651 +
1.1652 + if(mp_cmp_z(&a) >= 0) {
1.1653 + reason("error: someone thinks a negative value is non-negative\n");
1.1654 + mp_clear(&a);
1.1655 + return 1;
1.1656 + }
1.1657 +
1.1658 + mp_clear(&a);
1.1659 + return 0;
1.1660 +}
1.1661 +
1.1662 +/*------------------------------------------------------------------------*/
1.1663 +
1.1664 +int test_cmp(void)
1.1665 +{
1.1666 + mp_int a, b;
1.1667 +
1.1668 + mp_init(&a); mp_init(&b);
1.1669 + mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);
1.1670 +
1.1671 + if(mp_cmp(&a, &b) <= 0) {
1.1672 + reason("error: %s <= %s\n", mp3, mp4);
1.1673 + mp_clear(&a); mp_clear(&b);
1.1674 + return 1;
1.1675 + }
1.1676 +
1.1677 + mp_read_radix(&b, mp3, 16);
1.1678 + if(mp_cmp(&a, &b) != 0) {
1.1679 + reason("error: %s != %s\n", mp3, mp3);
1.1680 + mp_clear(&a); mp_clear(&b);
1.1681 + return 1;
1.1682 + }
1.1683 +
1.1684 + mp_read_radix(&a, mp5, 16);
1.1685 + if(mp_cmp(&a, &b) >= 0) {
1.1686 + reason("error: %s >= %s\n", mp5, mp3);
1.1687 + mp_clear(&a); mp_clear(&b);
1.1688 + return 1;
1.1689 + }
1.1690 +
1.1691 + mp_read_radix(&a, mp5a, 16);
1.1692 + if(mp_cmp_int(&a, 1000000) >= 0 ||
1.1693 + (mp_cmp_int(&a, -5000000) <= 0) ||
1.1694 + (mp_cmp_int(&a, -4938110) != 0)) {
1.1695 + reason("error: long integer comparison failed (%s)", mp5a);
1.1696 + mp_clear(&a); mp_clear(&b);
1.1697 + return 1;
1.1698 + }
1.1699 +
1.1700 + mp_clear(&a); mp_clear(&b);
1.1701 + return 0;
1.1702 +}
1.1703 +
1.1704 +/*------------------------------------------------------------------------*/
1.1705 +
1.1706 +int test_cmp_mag(void)
1.1707 +{
1.1708 + mp_int a, b;
1.1709 +
1.1710 + mp_init(&a); mp_init(&b);
1.1711 + mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp4, 16);
1.1712 +
1.1713 + if(mp_cmp_mag(&a, &b) >= 0) {
1.1714 + reason("error: %s >= %s\n", mp5, mp4);
1.1715 + mp_clear(&a); mp_clear(&b);
1.1716 + return 1;
1.1717 + }
1.1718 +
1.1719 + mp_read_radix(&b, mp5, 16);
1.1720 + if(mp_cmp_mag(&a, &b) != 0) {
1.1721 + reason("error: %s != %s\n", mp5, mp5);
1.1722 + mp_clear(&a); mp_clear(&b);
1.1723 + return 1;
1.1724 + }
1.1725 +
1.1726 + mp_read_radix(&a, mp1, 16);
1.1727 + if(mp_cmp_mag(&b, &a) >= 0) {
1.1728 + reason("error: %s >= %s\n", mp5, mp1);
1.1729 + mp_clear(&a); mp_clear(&b);
1.1730 + return 1;
1.1731 + }
1.1732 +
1.1733 + mp_clear(&a); mp_clear(&b);
1.1734 + return 0;
1.1735 +
1.1736 +}
1.1737 +
1.1738 +/*------------------------------------------------------------------------*/
1.1739 +
1.1740 +int test_parity(void)
1.1741 +{
1.1742 + mp_int a;
1.1743 +
1.1744 + mp_init(&a); mp_read_radix(&a, mp1, 16);
1.1745 +
1.1746 + if(!mp_isodd(&a)) {
1.1747 + reason("error: expected operand to be odd, but it isn't\n");
1.1748 + mp_clear(&a);
1.1749 + return 1;
1.1750 + }
1.1751 +
1.1752 + mp_read_radix(&a, mp6, 16);
1.1753 +
1.1754 + if(!mp_iseven(&a)) {
1.1755 + reason("error: expected operand to be even, but it isn't\n");
1.1756 + mp_clear(&a);
1.1757 + return 1;
1.1758 + }
1.1759 +
1.1760 + mp_clear(&a);
1.1761 + return 0;
1.1762 +}
1.1763 +
1.1764 +/*------------------------------------------------------------------------*/
1.1765 +
1.1766 +int test_gcd(void)
1.1767 +{
1.1768 + mp_int a, b;
1.1769 + int out = 0;
1.1770 +
1.1771 + mp_init(&a); mp_init(&b);
1.1772 + mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp1, 16);
1.1773 +
1.1774 + mp_gcd(&a, &b, &a);
1.1775 + mp_toradix(&a, g_intbuf, 16);
1.1776 +
1.1777 + if(strcmp(g_intbuf, g_mp71) != 0) {
1.1778 + reason("error: computed %s, expected %s\n", g_intbuf, g_mp71);
1.1779 + out = 1;
1.1780 + }
1.1781 +
1.1782 + mp_clear(&a); mp_clear(&b);
1.1783 + return out;
1.1784 +
1.1785 +}
1.1786 +
1.1787 +/*------------------------------------------------------------------------*/
1.1788 +
1.1789 +int test_lcm(void)
1.1790 +{
1.1791 + mp_int a, b;
1.1792 + int out = 0;
1.1793 +
1.1794 + mp_init(&a); mp_init(&b);
1.1795 + mp_read_radix(&a, mp10, 16); mp_read_radix(&b, mp11, 16);
1.1796 +
1.1797 + mp_lcm(&a, &b, &a);
1.1798 + mp_toradix(&a, g_intbuf, 16);
1.1799 +
1.1800 + if(strcmp(g_intbuf, l_mp1011) != 0) {
1.1801 + reason("error: computed %s, expected%s\n", g_intbuf, l_mp1011);
1.1802 + out = 1;
1.1803 + }
1.1804 +
1.1805 + mp_clear(&a); mp_clear(&b);
1.1806 +
1.1807 + return out;
1.1808 +
1.1809 +}
1.1810 +
1.1811 +/*------------------------------------------------------------------------*/
1.1812 +
1.1813 +int test_convert(void)
1.1814 +{
1.1815 + int ix;
1.1816 + mp_int a;
1.1817 +
1.1818 + mp_init(&a); mp_read_radix(&a, mp9, 16);
1.1819 +
1.1820 + for(ix = LOW_RADIX; ix <= HIGH_RADIX; ix++) {
1.1821 + mp_toradix(&a, g_intbuf, ix);
1.1822 +
1.1823 + if(strcmp(g_intbuf, v_mp9[ix - LOW_RADIX]) != 0) {
1.1824 + reason("error: radix %d, computed %s, expected %s\n",
1.1825 + ix, g_intbuf, v_mp9[ix - LOW_RADIX]);
1.1826 + mp_clear(&a);
1.1827 + return 1;
1.1828 + }
1.1829 + }
1.1830 +
1.1831 + mp_clear(&a);
1.1832 + return 0;
1.1833 +}
1.1834 +
1.1835 +/*------------------------------------------------------------------------*/
1.1836 +
1.1837 +int test_raw(void)
1.1838 +{
1.1839 + int len, out = 0;
1.1840 + mp_int a;
1.1841 + char *buf;
1.1842 +
1.1843 + mp_init(&a); mp_read_radix(&a, mp4, 16);
1.1844 +
1.1845 + len = mp_raw_size(&a);
1.1846 + if(len != sizeof(b_mp4)) {
1.1847 + reason("error: test_raw: expected length %d, computed %d\n", sizeof(b_mp4),
1.1848 + len);
1.1849 + mp_clear(&a);
1.1850 + return 1;
1.1851 + }
1.1852 +
1.1853 + buf = calloc(len, sizeof(char));
1.1854 + mp_toraw(&a, buf);
1.1855 +
1.1856 + if(memcmp(buf, b_mp4, sizeof(b_mp4)) != 0) {
1.1857 + reason("error: test_raw: binary output does not match test vector\n");
1.1858 + out = 1;
1.1859 + }
1.1860 +
1.1861 + free(buf);
1.1862 + mp_clear(&a);
1.1863 +
1.1864 + return out;
1.1865 +
1.1866 +}
1.1867 +
1.1868 +/*------------------------------------------------------------------------*/
1.1869 +
1.1870 +int test_pprime(void)
1.1871 +{
1.1872 + mp_int p;
1.1873 + int err = 0;
1.1874 + mp_err res;
1.1875 +
1.1876 + mp_init(&p);
1.1877 + mp_read_radix(&p, mp7, 16);
1.1878 +
1.1879 + if(mpp_pprime(&p, 5) != MP_YES) {
1.1880 + reason("error: %s failed Rabin-Miller test, but is prime\n", mp7);
1.1881 + err = 1;
1.1882 + }
1.1883 +
1.1884 + IFOK( mp_set_int(&p, 9) );
1.1885 + res = mpp_pprime(&p, 50);
1.1886 + if (res == MP_YES) {
1.1887 + reason("error: 9 is composite but passed Rabin-Miller test\n");
1.1888 + err = 1;
1.1889 + } else if (res != MP_NO) {
1.1890 + reason("test mpp_pprime(9, 50) failed: error %d\n", res);
1.1891 + err = 1;
1.1892 + }
1.1893 +
1.1894 + IFOK( mp_set_int(&p, 15) );
1.1895 + res = mpp_pprime(&p, 50);
1.1896 + if (res == MP_YES) {
1.1897 + reason("error: 15 is composite but passed Rabin-Miller test\n");
1.1898 + err = 1;
1.1899 + } else if (res != MP_NO) {
1.1900 + reason("test mpp_pprime(15, 50) failed: error %d\n", res);
1.1901 + err = 1;
1.1902 + }
1.1903 +
1.1904 + mp_clear(&p);
1.1905 +
1.1906 + return err;
1.1907 +
1.1908 +}
1.1909 +
1.1910 +/*------------------------------------------------------------------------*/
1.1911 +
1.1912 +int test_fermat(void)
1.1913 +{
1.1914 + mp_int p;
1.1915 + mp_err res;
1.1916 + int err = 0;
1.1917 +
1.1918 + mp_init(&p);
1.1919 + mp_read_radix(&p, mp7, 16);
1.1920 +
1.1921 + if((res = mpp_fermat(&p, 2)) != MP_YES) {
1.1922 + reason("error: %s failed Fermat test on 2: %s\n", mp7,
1.1923 + mp_strerror(res));
1.1924 + ++err;
1.1925 + }
1.1926 +
1.1927 + if((res = mpp_fermat(&p, 3)) != MP_YES) {
1.1928 + reason("error: %s failed Fermat test on 3: %s\n", mp7,
1.1929 + mp_strerror(res));
1.1930 + ++err;
1.1931 + }
1.1932 +
1.1933 + mp_clear(&p);
1.1934 +
1.1935 + return err;
1.1936 +
1.1937 +}
1.1938 +
1.1939 +/*------------------------------------------------------------------------*/
1.1940 +/* Like fprintf(), but only if we are behaving in a verbose manner */
1.1941 +
1.1942 +void reason(char *fmt, ...)
1.1943 +{
1.1944 + va_list ap;
1.1945 +
1.1946 + if(!g_verbose)
1.1947 + return;
1.1948 +
1.1949 + va_start(ap, fmt);
1.1950 + vfprintf(stderr, fmt, ap);
1.1951 + va_end(ap);
1.1952 +}
1.1953 +
1.1954 +/*------------------------------------------------------------------------*/
1.1955 +/* HERE THERE BE DRAGONS */
