crypto/dist/heimdal/lib/hcrypto/test_rsa.c

   1 /*
   2  * Copyright (c) 2006 - 2007 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 #ifdef RCSID
  39 __RCSID("$Heimdal: test_rsa.c 20466 2007-04-20 08:29:05Z lha $"
  40         "$NetBSD$");
  41 #endif
  42
  43 #include <stdio.h>
  44
  45 #include <roken.h>
  46 #include <getarg.h>
  47
  48 #include <engine.h>
  49 #include <evp.h>
  50
  51 /*
  52  *
  53  */
  54
  55 static int version_flag;
  56 static int help_flag;
  57 static int time_keygen;
  58 static char *time_key;
  59 static int key_blinding = 1;
  60 static char *rsa_key;
  61 static char *id_flag;
  62 static int loops = 1;
  63
  64 static struct getargs args[] = {
  65     { "loops",          0,      arg_integer,    &loops,
  66       "number of loops",        "loops" },
  67     { "id",             0,      arg_string,     &id_flag,
  68       "selects the engine id",  "engine-id" },
  69     { "time-keygen",    0,      arg_flag,       &time_keygen,
  70       "time rsa generation", NULL },
  71     { "time-key",       0,      arg_string,     &time_key,
  72       "rsa key file", NULL },
  73     { "key-blinding",   0,      arg_negative_flag, &key_blinding,
  74       "key blinding", NULL },
  75     { "key",    0,      arg_string,     &rsa_key,
  76       "rsa key file", NULL },
  77     { "version",        0,      arg_flag,       &version_flag,
  78       "print version", NULL },
  79     { "help",           0,      arg_flag,       &help_flag,
  80       NULL,     NULL }
  81 };
  82
  83 /*
  84  *
  85  */
  86
  87 static void
  88 check_rsa(const unsigned char *in, size_t len, RSA *rsa, int padding)
  89 {
  90     unsigned char *res, *res2;
  91     int keylen;
  92
  93     res = malloc(RSA_size(rsa));
  94     if (res == NULL)
  95         errx(1, "res: ENOMEM");
  96
  97     res2 = malloc(RSA_size(rsa));
  98     if (res2 == NULL)
  99         errx(1, "res2: ENOMEM");
 100
 101     /* signing */
 102
 103     keylen = RSA_private_encrypt(len, in, res, rsa, padding);
 104     if (keylen <= 0)
 105         errx(1, "failed to private encrypt: %d %d", (int)len, (int)keylen);
 106
 107     if (keylen > RSA_size(rsa))
 108         errx(1, "keylen > RSA_size(rsa)");
 109
 110     keylen = RSA_public_decrypt(keylen, res, res2, rsa, padding);
 111     if (keylen <= 0)
 112         errx(1, "failed to public decrypt: %d", (int)keylen);
 113
 114     if (keylen != len)
 115         errx(1, "output buffer not same length: %d", (int)keylen);
 116
 117     if (memcmp(res2, in, len) != 0)
 118         errx(1, "string not the same after decryption");
 119
 120     /* encryption */
 121
 122     keylen = RSA_public_encrypt(len, in, res, rsa, padding);
 123     if (keylen <= 0)
 124         errx(1, "failed to public encrypt: %d", (int)keylen);
 125
 126     if (keylen > RSA_size(rsa))
 127         errx(1, "keylen > RSA_size(rsa)");
 128
 129     keylen = RSA_private_decrypt(keylen, res, res2, rsa, padding);
 130     if (keylen <= 0)
 131         errx(1, "failed to private decrypt: %d", (int)keylen);
 132
 133     if (keylen != len)
 134         errx(1, "output buffer not same length: %d", (int)keylen);
 135
 136     if (memcmp(res2, in, len) != 0)
 137         errx(1, "string not the same after decryption");
 138
 139     free(res);
 140     free(res2);
 141 }
 142
 143 static int
 144 cb_func(int a, int b, BN_GENCB *c)
 145 {
 146     return 1;
 147 }
 148
 149 static RSA *
 150 read_key(ENGINE *engine, const char *rsa_key)
 151 {
 152     unsigned char buf[1024 * 4];
 153     const unsigned char *p;
 154     size_t size;
 155     RSA *rsa;
 156     FILE *f;
 157
 158     f = fopen(rsa_key, "r");
 159     if (f == NULL)
 160         err(1, "could not open file %s", rsa_key);
 161
 162     size = fread(buf, 1, sizeof(buf), f);
 163     fclose(f);
 164     if (size == 0)
 165         err(1, "failed to read file %s", rsa_key);
 166     if (size == sizeof(buf))
 167         err(1, "key too long in file %s!", rsa_key);
 168
 169     p = buf;
 170     rsa = d2i_RSAPrivateKey(NULL, &p, size);
 171     if (rsa == NULL)
 172         err(1, "failed to parse key in file %s", rsa_key);
 173
 174     RSA_set_method(rsa, ENGINE_get_RSA(engine));
 175
 176     if (!key_blinding)
 177         rsa->flags |= RSA_FLAG_NO_BLINDING;
 178
 179     return rsa;
 180 }
 181
 182 /*
 183  *
 184  */
 185
 186 static void
 187 usage (int ret)
 188 {
 189     arg_printusage (args,
 190                     sizeof(args)/sizeof(*args),
 191                     NULL,
 192                     "filename.so");
 193     exit (ret);
 194 }
 195
 196 int
 197 main(int argc, char **argv)
 198 {
 199     ENGINE *engine = NULL;
 200     int i, j, idx = 0;
 201     RSA *rsa;
 202
 203     setprogname(argv[0]);
 204
 205     if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &idx))
 206         usage(1);
 207
 208     if (help_flag)
 209         usage(0);
 210
 211     if(version_flag){
 212         print_version(NULL);
 213         exit(0);
 214     }
 215
 216     argc -= idx;
 217     argv += idx;
 218
 219     OpenSSL_add_all_algorithms();
 220
 221     if (argc == 0) {
 222         OpenSSL_add_all_algorithms();
 223         ENGINE_load_builtin_engines();
 224         engine = ENGINE_by_id("builtin");
 225     } else {
 226         engine = ENGINE_by_dso(argv[0], id_flag);
 227     }
 228     if (engine == NULL)
 229         errx(1, "ENGINE_by_dso failed");
 230
 231     if (ENGINE_get_RSA(engine) == NULL)
 232         return 77;
 233
 234     printf("rsa %s\n", ENGINE_get_RSA(engine)->name);
 235
 236     if (RAND_status() != 1)
 237         errx(77, "no functional random device, refusing to run tests");
 238
 239     if (time_keygen) {
 240         struct timeval tv1, tv2;
 241         const int num = 10;
 242         BIGNUM *e;
 243
 244         rsa = RSA_new_method(engine);
 245         if (!key_blinding)
 246             rsa->flags |= RSA_FLAG_NO_BLINDING;
 247
 248         e = BN_new();
 249         BN_set_word(e, 0x10001);
 250
 251         gettimeofday(&tv1, NULL);
 252
 253         for (i = 0; i < num; i++) {
 254             rsa = RSA_new_method(engine);
 255             if (RSA_generate_key_ex(rsa, 1024, e, NULL) != 1)
 256                 errx(1, "RSA_generate_key_ex");
 257             RSA_free(rsa);
 258         }
 259
 260         gettimeofday(&tv2, NULL);
 261         timevalsub(&tv2, &tv1);
 262
 263         printf("time %lu.%06lu\n",
 264                (unsigned long)tv2.tv_sec,
 265                (unsigned long)tv2.tv_usec);
 266
 267         BN_free(e);
 268         ENGINE_finish(engine);
 269
 270         return 0;
 271     }
 272
 273     if (time_key) {
 274         const int size = 20;
 275         const int num = 128;
 276         struct timeval tv1, tv2;
 277         unsigned char *p;
 278
 279         rsa = read_key(engine, time_key);
 280
 281         p = emalloc(num * size);
 282
 283         RAND_bytes(p, num * size);
 284
 285         gettimeofday(&tv1, NULL);
 286         for (i = 0; i < num; i++)
 287             check_rsa(p + (i * size), size, rsa, RSA_PKCS1_PADDING);
 288         gettimeofday(&tv2, NULL);
 289
 290         timevalsub(&tv2, &tv1);
 291
 292         printf("time %lu.%06lu\n",
 293                (unsigned long)tv2.tv_sec,
 294                (unsigned long)tv2.tv_usec);
 295
 296         RSA_free(rsa);
 297         ENGINE_finish(engine);
 298
 299         return 0;
 300     }
 301
 302     if (rsa_key) {
 303         rsa = read_key(engine, rsa_key);
 304
 305         /*
 306          * Assuming that you use the RSA key in the distribution, this
 307          * test will generate a signature have a starting zero and thus
 308          * will generate a checksum that is 127 byte instead of the
 309          * checksum that is 128 byte (like the key).
 310          */
 311         {
 312             const unsigned char sha1[20] = {
 313                 0x6d, 0x33, 0xf9, 0x40, 0x75, 0x5b, 0x4e, 0xc5, 0x90, 0x35,
 314                 0x48, 0xab, 0x75, 0x02, 0x09, 0x76, 0x9a, 0xb4, 0x7d, 0x6b
 315             };
 316
 317             check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
 318         }
 319
 320         for (i = 0; i < 128; i++) {
 321             unsigned char sha1[20];
 322
 323             RAND_bytes(sha1, sizeof(sha1));
 324             check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
 325         }
 326         for (i = 0; i < 128; i++) {
 327             unsigned char des3[21];
 328
 329             RAND_bytes(des3, sizeof(des3));
 330             check_rsa(des3, sizeof(des3), rsa, RSA_PKCS1_PADDING);
 331         }
 332         for (i = 0; i < 128; i++) {
 333             unsigned char aes[32];
 334
 335             RAND_bytes(aes, sizeof(aes));
 336             check_rsa(aes, sizeof(aes), rsa, RSA_PKCS1_PADDING);
 337         }
 338
 339         RSA_free(rsa);
 340     }
 341
 342     for (i = 0; i < loops; i++) {
 343         BN_GENCB cb;
 344         BIGNUM *e;
 345         unsigned int n;
 346
 347         rsa = RSA_new_method(engine);
 348         if (!key_blinding)
 349             rsa->flags |= RSA_FLAG_NO_BLINDING;
 350
 351         e = BN_new();
 352         BN_set_word(e, 0x10001);
 353
 354         BN_GENCB_set(&cb, cb_func, NULL);
 355
 356         RAND_bytes(&n, sizeof(n));
 357         n &= 0x1ff;
 358         n += 1024;
 359
 360         if (RSA_generate_key_ex(rsa, n, e, &cb) != 1)
 361             errx(1, "RSA_generate_key_ex");
 362
 363         BN_free(e);
 364
 365         for (j = 0; j < 8; j++) {
 366             unsigned char sha1[20];
 367             RAND_bytes(sha1, sizeof(sha1));
 368             check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
 369         }
 370
 371         RSA_free(rsa);
 372     }
 373
 374     ENGINE_finish(engine);
 375
 376     return 0;
 377 }