The Tor Browser: security/nss/lib/freebl/mpi/mpi-test.c@6474c204b198

Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.

     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/. */

    13 #include <stdio.h>

    14 #include <stdlib.h>

    15 #include <string.h>

    16 #include <stdarg.h>

    17 #include <limits.h>

    18 #include <time.h>

    20 #include "mpi.h"

    21 #include "mpprime.h"

    23 #include "test-info.c"

    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

    36 /*

    37   Test vectors

    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).

    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";

   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;

   115 /*

   116    Solutions of the form x_mpABC, where:

   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

   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  */

   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";

   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";

   198 const char *ms_mp345 = "1E71E292";

   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";

   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";

   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";

   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";

   268 const char *e_mpc2d3 = "100000000000000000000000000000000";

   270 const char *t_mp9    = "FB9B6E32FF0452A34746";

   271 const char *i_mp27   = "B6AD8DCCDAF92B6FE57D062FFEE3A99";

   272 const char *i_mp2019 =

   273 "BDF3D88DC373A63EED92903115B03FC8501910AF68297B4C41870AED3EA9F839";

   274 /* "15E3FE09E8AE5523AABA197BD2D16318D3CA148EDF4AE1C1C52FC96AFAF5680B"; */

   277 const char *t_mp15 =

   278 "795853094E59B0008093BCA8DECF68587C64BDCA2F3F7F8963DABC12F1CFFFA9B8C4"

   279 "365232FD4751870A0EF6CA619287C5D8B7F1747D95076AB19645EF309773E9EACEA0"

   280 "975FA4AE16251A8DA5865349C3A903E3B8A2C0DEA3C0720B6020C7FED69AFF62BB72"

   281 "10FAC443F9FFA2950776F949E819260C2AF8D94E8A1431A40F8C23C1973DE5D49AA2"

   282 "0B3FF5DA5C1D5324E712A78FF33A9B1748F83FA529905924A31DF38643B3F693EF9B"

   283 "58D846BB1AEAE4523ECC843FF551C1B300A130B65C1677402778F98C51C10813250E"

   284 "2496882877B069E877B59740DC1226F18A5C0F66F64A5F59A9FAFC5E9FC45AEC0E7A"

   285 "BEE244F7DD3AC268CF512A0E52E4F5BE5B94";

   287 const char *g_mp71   = "1";

   288 const char *g_mp25   = "7";

   289 const char *l_mp1011 = "C589E3D7D64A6942A000";

   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 };

   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 };

   369 /* Search for a test suite name in the names table  */

   370 int  find_name(char *name);

   371 void reason(char *fmt, ...);

   373 /*------------------------------------------------------------------------*/

   374 /*------------------------------------------------------------------------*/

   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;

   381 #define IFOK(x) { if (MP_OKAY > (res = (x))) { \

   382   reason("test %s failed: error %d\n", #x, res); return 1; }}

   384 int main(int argc, char *argv[])

   385 {

   386   int which, res;

   388   srand((unsigned int)time(NULL));

   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   }

   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   }

   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   }

   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   }

   427 }

   429 /*------------------------------------------------------------------------*/

   431 int find_name(char *name)

   432 {

   433   int ix = 0;

   435   while(ix < g_count) {

   436     if (strcmp(name, g_names[ix]) == 0)

   437       return ix;

   439     ++ix;

   440   }

   442   return -1;

   443 }

   445 /*------------------------------------------------------------------------*/

   447 int test_list(void)

   448 {

   449   int ix;

   451   fprintf(stderr, "There are currently %d test suites available\n",

   452 	  g_count);

   454   for(ix = 1; ix < g_count; ix++)

   455     fprintf(stdout, "%-20s %s\n", g_names[ix], g_descs[ix]);

   457   return 0;

   458 }

   460 /*------------------------------------------------------------------------*/

   462 int test_copy(void)

   463 {

   464   mp_int  a, b;

   465   int     ix;

   467   mp_init(&a); mp_init(&b);

   469   mp_read_radix(&a, mp3, 16);

   470   mp_copy(&a, &b);

   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   }

   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   }

   493   mp_clear(&a); mp_clear(&b);

   494   return 0;

   495 }

   497 /*------------------------------------------------------------------------*/

   499 int test_exch(void)

   500 {

   501   mp_int  a, b;

   503   mp_init(&a); mp_init(&b);

   504   mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp1, 16);

   506   mp_exch(&a, &b);

   507   mp_toradix(&a, g_intbuf, 16);

   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   }

   516   mp_toradix(&b, g_intbuf, 16);

   518   mp_clear(&b);

   519   if(strcmp(g_intbuf, mp7) != 0) {

   520     reason("error: exchange failed\n");

   521     return 1;

   522   }

   524   return 0;

   525 }

   527 /*------------------------------------------------------------------------*/

   529 int test_zero(void)

   530 {

   531   mp_int   a;

   533   mp_init(&a); mp_read_radix(&a, mp7, 16);

   534   mp_zero(&a);

   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   }

   543   mp_clear(&a);

   544   return 0;

   545 }

   547 /*------------------------------------------------------------------------*/

   549 int test_set(void)

   550 {

   551   mp_int   a;

   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   }

   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   }

   571   return 0;

   572 }

   574 /*------------------------------------------------------------------------*/

   576 int test_abs(void)

   577 {

   578   mp_int  a;

   580   mp_init(&a); mp_read_radix(&a, mp4, 16);

   581   mp_abs(&a, &a);

   583   if(SIGN(&a) != ZPOS) {

   584     reason("error: sign of result is negative\n");

   585     mp_clear(&a);

   586     return 1;

   587   }

   589   mp_clear(&a);

   590   return 0;

   591 }

   593 /*------------------------------------------------------------------------*/

   595 int test_neg(void)

   596 {

   597   mp_int  a;

   598   mp_sign s;

   600   mp_init(&a); mp_read_radix(&a, mp4, 16);

   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   }

   610   mp_clear(&a);

   611   return 0;

   612 }

   614 /*------------------------------------------------------------------------*/

   616 int test_add_d(void)

   617 {

   618   mp_int  a;

   620   mp_init(&a);

   622   mp_read_radix(&a, mp5, 16);

   623   mp_add_d(&a, md4, &a);

   624   mp_toradix(&a, g_intbuf, 16);

   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   }

   632   mp_read_radix(&a, mp2, 16);

   633   mp_add_d(&a, md5, &a);

   634   mp_toradix(&a, g_intbuf, 16);

   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   }

   642   mp_clear(&a);

   643   return 0;

   644 }

   646 /*------------------------------------------------------------------------*/

   648 int test_add(void)

   649 {

   650   mp_int  a, b;

   651   int     res = 0;

   653   mp_init(&a); mp_init(&b);

   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);

   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   }

   664   mp_read_radix(&a, mp4, 16);

   665   mp_add(&a, &b, &a);

   666   mp_toradix(&a, g_intbuf, 16);

   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   }

   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);

   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   }

   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);

   686   if(strcmp(g_intbuf, s_mp1415) != 0) {

   687     reason("error: computed %s, expected %s\n", g_intbuf, s_mp1415);

   688     res = 1;

   689   }

   691  CLEANUP:

   692   mp_clear(&a); mp_clear(&b);

   693   return res;

   694 }

   696 /*------------------------------------------------------------------------*/

   698 int test_sub_d(void)

   699 {

   700   mp_int   a;

   702   mp_init(&a);

   703   mp_read_radix(&a, mp5, 16);

   705   mp_sub_d(&a, md4, &a);

   706   mp_toradix(&a, g_intbuf, 16);

   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   }

   714   mp_read_radix(&a, mp6, 16);

   716   mp_sub_d(&a, md2, &a);

   717   mp_toradix(&a, g_intbuf, 16);

   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   }

   725   return 0;

   726 }

   728 /*------------------------------------------------------------------------*/

   730 int test_sub(void)

   731 {

   732   mp_int  a, b;

   734   mp_init(&a); mp_init(&b);

   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);

   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   }

   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);

   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   }

   756   mp_clear(&a); mp_clear(&b);

   757   return 0;

   758 }

   760 /*------------------------------------------------------------------------*/

   762 int test_mul_d(void)

   763 {

   764   mp_int   a;

   766   mp_init(&a);

   767   mp_read_radix(&a, mp1, 16);

   769   IFOK( mp_mul_d(&a, md4, &a) );

   770   mp_toradix(&a, g_intbuf, 16);

   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   }

   778   mp_read_radix(&a, mp8, 16);

   779   IFOK( mp_mul_d(&a, md6, &a) );

   780   mp_toradix(&a, g_intbuf, 16);

   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   }

   788   return 0;

   789 }

   791 /*------------------------------------------------------------------------*/

   793 int test_mul(void)

   794 {

   795   mp_int   a, b;

   796   int      res = 0;

   798   mp_init(&a); mp_init(&b);

   799   mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp2, 16);

   801   IFOK( mp_mul(&a, &b, &a) );

   802   mp_toradix(&a, g_intbuf, 16);

   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   }

   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);

   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   }

   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);

   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   }

   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);

   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   }

   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);

   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);

   846   IFOK( mp_mul(&a, &b, &a) );

   847   mp_toradix(&a, g_intbuf, 10);

   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   }

   854  CLEANUP:

   855   mp_clear(&a); mp_clear(&b);

   856   return res;

   858 }

   860 /*------------------------------------------------------------------------*/

   862 int test_sqr(void)

   863 {

   864   mp_int  a;

   866   mp_init(&a); mp_read_radix(&a, mp2, 16);

   868   mp_sqr(&a, &a);

   869   mp_toradix(&a, g_intbuf, 16);

   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   }

   877   return 0;

   878 }

   880 /*------------------------------------------------------------------------*/

   882 int test_div_d(void)

   883 {

   884   mp_int    a, q;

   885   mp_digit  r;

   886   int       err = 0;

   888   mp_init(&a); mp_init(&q);

   889   mp_read_radix(&a, mp3, 16);

   891   IFOK( mp_div_d(&a, md6, &q, &r) );

   892   mp_toradix(&q, g_intbuf, 16);

   894   if(strcmp(g_intbuf, q_mp3d6) != 0) {

   895     reason("error: computed q = %s, expected %s\n", g_intbuf, q_mp3d6);

   896     ++err;

   897   }

   899   sprintf(g_intbuf, ZS_DIGIT_FMT, r);

   901   if(strcmp(g_intbuf, r_mp3d6) != 0) {

   902     reason("error: computed r = %s, expected %s\n", g_intbuf, r_mp3d6);

   903     ++err;

   904   }

   906   mp_read_radix(&a, mp9, 16);

   907   IFOK( mp_div_d(&a, 16, &q, &r) );

   908   mp_toradix(&q, g_intbuf, 16);

   910   if(strcmp(g_intbuf, q_mp9c16) != 0) {

   911     reason("error: computed q = %s, expected %s\n", g_intbuf, q_mp9c16);

   912     ++err;

   913   }

   915   sprintf(g_intbuf, ZS_DIGIT_FMT, r);

   917   if(strcmp(g_intbuf, r_mp9c16) != 0) {

   918     reason("error: computed r = %s, expected %s\n", g_intbuf, r_mp9c16);

   919     ++err;

   920   }

   922   mp_clear(&a); mp_clear(&q);

   923   return err;

   924 }

   926 /*------------------------------------------------------------------------*/

   928 int test_div_2(void)

   929 {

   930   mp_int  a;

   932   mp_init(&a); mp_read_radix(&a, mp7, 16);

   933   IFOK( mp_div_2(&a, &a) );

   934   mp_toradix(&a, g_intbuf, 16);

   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   }

   942   return 0;

   943 }

   945 /*------------------------------------------------------------------------*/

   947 int test_div_2d(void)

   948 {

   949   mp_int  a, q, r;

   951   mp_init(&q); mp_init(&r);

   952   mp_init(&a); mp_read_radix(&a, mp13, 16);

   954   IFOK( mp_div_2d(&a, 64, &q, &r) );

   955   mp_clear(&a);

   957   mp_toradix(&q, g_intbuf, 16);

   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   }

   965   mp_clear(&q);

   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   }

   974   mp_clear(&r);

   976   return 0;

   977 }

   979 /*------------------------------------------------------------------------*/

   981 int test_div(void)

   982 {

   983   mp_int  a, b, r;

   984   int     err = 0;

   986   mp_init(&a); mp_init(&b); mp_init(&r);

   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);

   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   }

   997   mp_toradix(&r, g_intbuf, 16);

   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   }

  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);

  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   }

  1013   mp_toradix(&r, g_intbuf, 16);

  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   }

  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);

  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   }

  1029   mp_toradix(&r, g_intbuf, 16);

  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   }

  1036   mp_clear(&a); mp_clear(&b); mp_clear(&r);

  1038   return err;

  1039 }

  1041 /*------------------------------------------------------------------------*/

  1043 int test_expt_d(void)

  1044 {

  1045   mp_int   a;

  1047   mp_init(&a); mp_read_radix(&a, mp5, 16);

  1048   mp_expt_d(&a, md9, &a);

  1049   mp_toradix(&a, g_intbuf, 16);

  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   }

  1057   return 0;

  1058 }

  1060 /*------------------------------------------------------------------------*/

  1062 int test_expt(void)

  1063 {

  1064   mp_int   a, b;

  1066   mp_init(&a); mp_init(&b);

  1067   mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp8, 16);

  1069   mp_expt(&a, &b, &a);

  1070   mp_toradix(&a, g_intbuf, 16);

  1071   mp_clear(&a); mp_clear(&b);

  1073   if(strcmp(g_intbuf, e_mp78) != 0) {

  1074     reason("error: computed %s, expected %s\n", g_intbuf, e_mp78);

  1075     return 1;

  1076   }

  1078   return 0;

  1079 }

  1081 /*------------------------------------------------------------------------*/

  1083 int test_2expt(void)

  1084 {

  1085   mp_int   a;

  1087   mp_init(&a);

  1088   mp_2expt(&a, md3);

  1089   mp_toradix(&a, g_intbuf, 16);

  1090   mp_clear(&a);

  1092   if(strcmp(g_intbuf, e_mpc2d3) != 0) {

  1093     reason("error: computed %s, expected %s\n", g_intbuf, e_mpc2d3);

  1094     return 1;

  1095   }

  1097   return 0;

  1098 }

  1100 /*------------------------------------------------------------------------*/

  1102 int test_sqrt(void)

  1103 {

  1104   mp_int  a;

  1105   int     res = 0;

  1107   mp_init(&a); mp_read_radix(&a, mp9, 16);

  1108   mp_sqrt(&a, &a);

  1109   mp_toradix(&a, g_intbuf, 16);

  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   }

  1116   mp_read_radix(&a, mp15, 16);

  1117   mp_sqrt(&a, &a);

  1118   mp_toradix(&a, g_intbuf, 16);

  1120   if(strcmp(g_intbuf, t_mp15) != 0) {

  1121     reason("error: computed %s, expected %s\n", g_intbuf, t_mp15);

  1122     res = 1;

  1123   }

  1125  CLEANUP:

  1126   mp_clear(&a);

  1127   return res;

  1128 }

  1130 /*------------------------------------------------------------------------*/

  1132 int test_mod_d(void)

  1133 {

  1134   mp_int     a;

  1135   mp_digit   r;

  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);

  1142   if(strcmp(g_intbuf, r_mp5d5) != 0) {

  1143     reason("error: computed %s, expected %s\n", g_intbuf, r_mp5d5);

  1144     return 1;

  1145   }

  1147   return 0;

  1148 }

  1150 /*------------------------------------------------------------------------*/

  1152 int test_mod(void)

  1153 {

  1154   mp_int  a, m;

  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);

  1162   if(strcmp(g_intbuf, r_mp47) != 0) {

  1163     reason("error: computed %s, expected %s\n", g_intbuf, r_mp47);

  1164     return 1;

  1165   }

  1167   return 0;

  1168 }

  1170 /*------------------------------------------------------------------------*/

  1172 int test_addmod(void)

  1173 {

  1174   mp_int a, b, m;

  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);

  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);

  1184   if(strcmp(g_intbuf, ms_mp345) != 0) {

  1185     reason("error: computed %s, expected %s\n", g_intbuf, ms_mp345);

  1186     return 1;

  1187   }

  1189   return 0;

  1190 }

  1192 /*------------------------------------------------------------------------*/

  1194 int test_submod(void)

  1195 {

  1196   mp_int a, b, m;

  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);

  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);

  1206   if(strcmp(g_intbuf, md_mp345) != 0) {

  1207     reason("error: computed %s, expected %s\n", g_intbuf, md_mp345);

  1208     return 1;

  1209   }

  1211   return 0;

  1212 }

  1214 /*------------------------------------------------------------------------*/

  1216 int test_mulmod(void)

  1217 {

  1218   mp_int a, b, m;

  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);

  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);

  1228   if(strcmp(g_intbuf, mp_mp345) != 0) {

  1229     reason("error: computed %s, expected %s\n", g_intbuf, mp_mp345);

  1230     return 1;

  1231   }

  1233   return 0;

  1234 }

  1236 /*------------------------------------------------------------------------*/

  1238 int test_sqrmod(void)

  1239 {

  1240   mp_int a, m;

  1242   mp_init(&a); mp_init(&m);

  1243   mp_read_radix(&a, mp3, 16); mp_read_radix(&m, mp5, 16);

  1245   IFOK( mp_sqrmod(&a, &m, &a) );

  1246   mp_toradix(&a, g_intbuf, 16);

  1247   mp_clear(&a); mp_clear(&m);

  1249   if(strcmp(g_intbuf, mp_mp335) != 0) {

  1250     reason("error: computed %s, expected %s\n", g_intbuf, mp_mp335);

  1251     return 1;

  1252   }

  1254   return 0;

  1255 }

  1257 /*------------------------------------------------------------------------*/

  1259 int test_exptmod(void)

  1260 {

  1261   mp_int  a, b, m;

  1262   int     res = 0;

  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);

  1268   IFOK( mp_exptmod(&a, &b, &m, &a) );

  1269   mp_toradix(&a, g_intbuf, 16);

  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   }

  1276   mp_read_radix(&a, mp1, 16); mp_read_radix(&b, mp5, 16);

  1277   mp_read_radix(&m, mp12, 16);

  1279   IFOK( mp_exptmod(&a, &b, &m, &a) );

  1280   mp_toradix(&a, g_intbuf, 16);

  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   }

  1287   mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp1, 16);

  1288   mp_read_radix(&m, mp14, 16);

  1290   IFOK( mp_exptmod(&a, &b, &m, &a) );

  1291   mp_toradix(&a, g_intbuf, 16);

  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   }

  1298   mp_read_radix(&a, mp16, 16); mp_read_radix(&b, mp17, 16);

  1299   mp_read_radix(&m, mp18, 16);

  1301   IFOK( mp_exptmod(&a, &b, &m, &a) );

  1302   mp_toradix(&a, g_intbuf, 16);

  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   }

  1309  CLEANUP:

  1310   mp_clear(&a); mp_clear(&b); mp_clear(&m);

  1311   return res;

  1312 }

  1314 /*------------------------------------------------------------------------*/

  1316 int test_exptmod_d(void)

  1317 {

  1318   mp_int  a, m;

  1320   mp_init(&a); mp_init(&m);

  1321   mp_read_radix(&a, mp5, 16); mp_read_radix(&m, mp7, 16);

  1323   IFOK( mp_exptmod_d(&a, md4, &m, &a) );

  1324   mp_toradix(&a, g_intbuf, 16);

  1325   mp_clear(&a); mp_clear(&m);

  1327   if(strcmp(g_intbuf, me_mp5d47) != 0) {

  1328     reason("error: computed %s, expected %s\n", g_intbuf, me_mp5d47);

  1329     return 1;

  1330   }

  1332   return 0;

  1333 }

  1335 /*------------------------------------------------------------------------*/

  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;

  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" };

  1351   mp_init(&a); mp_init(&m);

  1352   mp_read_radix(&a, mp2, 16); mp_read_radix(&m, mp7, 16);

  1354   IFOK( mp_invmod(&a, &m, &a) );

  1356   mp_toradix(&a, g_intbuf, 16);

  1357   mp_clear(&a); mp_clear(&m);

  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   }

  1364   mp_init(&a); mp_init(&m);

  1365   mp_read_radix(&a, mp20, 16); mp_read_radix(&m, mp19, 16);

  1367   IFOK( mp_invmod(&a, &m, &a) );

  1369   mp_toradix(&a, g_intbuf, 16);

  1370   mp_clear(&a); mp_clear(&m);

  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   }

  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 */

  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);

  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);

  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 */

  1409 /* test 3: Odd modulus - a is odd, relatively prime to m */

  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) );

  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);

  1426 /* test 4: Odd modulus - a is odd, NOT relatively prime to m */

  1428   IFOK( mp_mul(&p1, &p3, &a) );

  1429   /* reuse same m as before */

  1431   res = mp_invmod_xgcd(&a, &m, &c);

  1432   if (res != MP_UNDEF)

  1433     goto CLEANUP4;

  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);

  1444 /* test 5: Odd modulus - a is even, relatively prime to m */

  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) );

  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);

  1461 /* test 6: Odd modulus - a is odd, NOT relatively prime to m */

  1463   /* reuse t2 */

  1464   IFOK( mp_mul(&t2, &p3, &a) );

  1465   /* reuse same m as before */

  1467   res = mp_invmod_xgcd(&a, &m, &c);

  1468   if (res != MP_UNDEF)

  1469     goto CLEANUP6;

  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);

  1480 /* test 7: Even modulus, even a, should fail */

  1482   IFOK( mp_mul(&p3, &t3, &m) ); /* even m */

  1483   /* reuse t2 */

  1484   IFOK( mp_mul(&p1, &t2, &a) ); /* even a */

  1486   res = mp_invmod_xgcd(&a, &m, &c);

  1487   if (res != MP_UNDEF)

  1488     goto CLEANUP7;

  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);

  1499 /* test 8: Even modulus    - a is odd,  not relatively prime to m */

  1501   /* reuse m */

  1502   IFOK( mp_mul(&p3, &p1, &a) ); /* even a */

  1504   res = mp_invmod_xgcd(&a, &m, &c);

  1505   if (res != MP_UNDEF)

  1506     goto CLEANUP8;

  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);

  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) );

  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);

  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) );

  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);

  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) );

  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);

  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) );

  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   }

  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);

  1587   return 0;

  1588 }

  1590 /*------------------------------------------------------------------------*/

  1592 int test_cmp_d(void)

  1593 {

  1594   mp_int  a;

  1596   mp_init(&a); mp_read_radix(&a, mp8, 16);

  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   }

  1604   mp_read_radix(&a, mp5, 16);

  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   }

  1612   mp_read_radix(&a, mp6, 16);

  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   }

  1620   mp_clear(&a);

  1621   return 0;

  1623 }

  1625 /*------------------------------------------------------------------------*/

  1627 int test_cmp_z(void)

  1628 {

  1629   mp_int  a;

  1631   mp_init(&a); mp_read_radix(&a, mp6, 16);

  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   }

  1639   mp_read_radix(&a, mp1, 16);

  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   }

  1647   mp_read_radix(&a, mp4, 16);

  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   }

  1655   mp_clear(&a);

  1656   return 0;

  1657 }

  1659 /*------------------------------------------------------------------------*/

  1661 int test_cmp(void)

  1662 {

  1663   mp_int  a, b;

  1665   mp_init(&a); mp_init(&b);

  1666   mp_read_radix(&a, mp3, 16); mp_read_radix(&b, mp4, 16);

  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   }

  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   }

  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   }

  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   }

  1697   mp_clear(&a); mp_clear(&b);

  1698   return 0;

  1699 }

  1701 /*------------------------------------------------------------------------*/

  1703 int test_cmp_mag(void)

  1704 {

  1705   mp_int  a, b;

  1707   mp_init(&a); mp_init(&b);

  1708   mp_read_radix(&a, mp5, 16); mp_read_radix(&b, mp4, 16);

  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   }

  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   }

  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   }

  1730   mp_clear(&a); mp_clear(&b);

  1731   return 0;

  1733 }

  1735 /*------------------------------------------------------------------------*/

  1737 int test_parity(void)

  1738 {

  1739   mp_int  a;

  1741   mp_init(&a); mp_read_radix(&a, mp1, 16);

  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   }

  1749   mp_read_radix(&a, mp6, 16);

  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   }

  1757   mp_clear(&a);

  1758   return 0;

  1759 }

  1761 /*------------------------------------------------------------------------*/

  1763 int test_gcd(void)

  1764 {

  1765   mp_int  a, b;

  1766   int     out = 0;

  1768   mp_init(&a); mp_init(&b);

  1769   mp_read_radix(&a, mp7, 16); mp_read_radix(&b, mp1, 16);

  1771   mp_gcd(&a, &b, &a);

  1772   mp_toradix(&a, g_intbuf, 16);

  1774   if(strcmp(g_intbuf, g_mp71) != 0) {

  1775     reason("error: computed %s, expected %s\n", g_intbuf, g_mp71);

  1776     out = 1;

  1777   }

  1779   mp_clear(&a); mp_clear(&b);

  1780   return out;

  1782 }

  1784 /*------------------------------------------------------------------------*/

  1786 int test_lcm(void)

  1787 {

  1788   mp_int  a, b;

  1789   int     out = 0;

  1791   mp_init(&a); mp_init(&b);

  1792   mp_read_radix(&a, mp10, 16); mp_read_radix(&b, mp11, 16);

  1794   mp_lcm(&a, &b, &a);

  1795   mp_toradix(&a, g_intbuf, 16);

  1797   if(strcmp(g_intbuf, l_mp1011) != 0) {

  1798     reason("error: computed %s, expected%s\n", g_intbuf, l_mp1011);

  1799     out = 1;

  1800   }

  1802   mp_clear(&a); mp_clear(&b);

  1804   return out;

  1806 }

  1808 /*------------------------------------------------------------------------*/

  1810 int test_convert(void)

  1811 {

  1812   int    ix;

  1813   mp_int a;

  1815   mp_init(&a); mp_read_radix(&a, mp9, 16);

  1817   for(ix = LOW_RADIX; ix <= HIGH_RADIX; ix++) {

  1818     mp_toradix(&a, g_intbuf, ix);

  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   }

  1828   mp_clear(&a);

  1829   return 0;

  1830 }

  1832 /*------------------------------------------------------------------------*/

  1834 int test_raw(void)

  1835 {

  1836   int    len, out = 0;

  1837   mp_int a;

  1838   char   *buf;

  1840   mp_init(&a); mp_read_radix(&a, mp4, 16);

  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   }

  1850   buf = calloc(len, sizeof(char));

  1851   mp_toraw(&a, buf);

  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   }

  1858   free(buf);

  1859   mp_clear(&a);

  1861   return out;

  1863 }

  1865 /*------------------------------------------------------------------------*/

  1867 int test_pprime(void)

  1868 {

  1869   mp_int   p;

  1870   int      err = 0;

  1871   mp_err   res;

  1873   mp_init(&p);

  1874   mp_read_radix(&p, mp7, 16);

  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   }

  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   }

  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   }

  1901   mp_clear(&p);

  1903   return err;

  1905 }

  1907 /*------------------------------------------------------------------------*/

  1909 int test_fermat(void)

  1910 {

  1911   mp_int p;

  1912   mp_err res;

  1913   int    err = 0;

  1915   mp_init(&p);

  1916   mp_read_radix(&p, mp7, 16);

  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   }

  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   }

  1930   mp_clear(&p);

  1932   return err;

  1934 }

  1936 /*------------------------------------------------------------------------*/

  1937 /* Like fprintf(), but only if we are behaving in a verbose manner        */

  1939 void reason(char *fmt, ...)

  1940 {

  1941   va_list    ap;

  1943   if(!g_verbose)

  1944     return;

  1946   va_start(ap, fmt);

  1947   vfprintf(stderr, fmt, ap);

  1948   va_end(ap);

  1949 }

  1951 /*------------------------------------------------------------------------*/

  1952 /* HERE THERE BE DRAGONS                                                  */

The Tor Browser / file revision

security/nss/lib/freebl/mpi/mpi-test.c@6474c204b198

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