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 #include <config.h>
  35
  36 #include <stdio.h>
  37
  38 #include <roken.h>
  39 #include <getarg.h>
  40
  41 #include <engine.h>
  42 #include <evp.h>
  43
  44 /*
  45  *
  46  */
  47
  48 static int version_flag;
  49 static int help_flag;
  50 static int time_keygen;
  51 static char *time_key;
  52 static int key_blinding = 1;
  53 static char *rsa_key;
  54 static char *id_flag;
  55 static int loops = 1;
  56
  57 static struct getargs args[] = {
  58     { "loops",          0,      arg_integer,    &loops,
  59       "number of loops",        "loops" },
  60     { "id",             0,      arg_string,     &id_flag,
  61       "selects the engine id",  "engine-id" },
  62     { "time-keygen",    0,      arg_flag,       &time_keygen,
  63       "time rsa generation", NULL },
  64     { "time-key",       0,      arg_string,     &time_key,
  65       "rsa key file", NULL },
  66     { "key-blinding",   0,      arg_negative_flag, &key_blinding,
  67       "key blinding", NULL },
  68     { "key",    0,      arg_string,     &rsa_key,
  69       "rsa key file", NULL },
  70     { "version",        0,      arg_flag,       &version_flag,
  71       "print version", NULL },
  72     { "help",           0,      arg_flag,       &help_flag,
  73       NULL,     NULL }
  74 };
  75
  76 /*
  77  *
  78  */
  79
  80 static void
  81 check_rsa(const unsigned char *in, size_t len, RSA *rsa, int padding)
  82 {
  83     unsigned char *res, *res2;
  84     int keylen;
  85
  86     res = malloc(RSA_size(rsa));
  87     if (res == NULL)
  88         errx(1, "res: ENOMEM");
  89
  90     res2 = malloc(RSA_size(rsa));
  91     if (res2 == NULL)
  92         errx(1, "res2: ENOMEM");
  93
  94     /* signing */
  95
  96     keylen = RSA_private_encrypt(len, in, res, rsa, padding);
  97     if (keylen <= 0)
  98         errx(1, "failed to private encrypt: %d %d", (int)len, (int)keylen);
  99
 100     if (keylen > RSA_size(rsa))
 101         errx(1, "keylen > RSA_size(rsa)");
 102
 103     keylen = RSA_public_decrypt(keylen, res, res2, rsa, padding);
 104     if (keylen <= 0)
 105         errx(1, "failed to public decrypt: %d", (int)keylen);
 106
 107     if (keylen != len)
 108         errx(1, "output buffer not same length: %d", (int)keylen);
 109
 110     if (memcmp(res2, in, len) != 0)
 111         errx(1, "string not the same after decryption");
 112
 113     /* encryption */
 114
 115     keylen = RSA_public_encrypt(len, in, res, rsa, padding);
 116     if (keylen <= 0)
 117         errx(1, "failed to public encrypt: %d", (int)keylen);
 118
 119     if (keylen > RSA_size(rsa))
 120         errx(1, "keylen > RSA_size(rsa)");
 121
 122     keylen = RSA_private_decrypt(keylen, res, res2, rsa, padding);
 123     if (keylen <= 0)
 124         errx(1, "failed to private decrypt: %d", (int)keylen);
 125
 126     if (keylen != len)
 127         errx(1, "output buffer not same length: %d", (int)keylen);
 128
 129     if (memcmp(res2, in, len) != 0)
 130         errx(1, "string not the same after decryption");
 131
 132     free(res);
 133     free(res2);
 134 }
 135
 136 static int
 137 cb_func(int a, int b, BN_GENCB *c)
 138 {
 139     return 1;
 140 }
 141
 142 static RSA *
 143 read_key(ENGINE *engine, const char *rsa_key)
 144 {
 145     unsigned char buf[1024 * 4];
 146     const unsigned char *p;
 147     size_t size;
 148     RSA *rsa;
 149     FILE *f;
 150
 151     f = fopen(rsa_key, "r");
 152     if (f == NULL)
 153         err(1, "could not open file %s", rsa_key);
 154     rk_cloexec_file(f);
 155
 156     size = fread(buf, 1, sizeof(buf), f);
 157     fclose(f);
 158     if (size == 0)
 159         err(1, "failed to read file %s", rsa_key);
 160     if (size == sizeof(buf))
 161         err(1, "key too long in file %s!", rsa_key);
 162
 163     p = buf;
 164     rsa = d2i_RSAPrivateKey(NULL, &p, size);
 165     if (rsa == NULL)
 166         err(1, "failed to parse key in file %s", rsa_key);
 167
 168     RSA_set_method(rsa, ENGINE_get_RSA(engine));
 169
 170     if (!key_blinding)
 171         rsa->flags |= RSA_FLAG_NO_BLINDING;
 172
 173     return rsa;
 174 }
 175
 176 /*
 177  *
 178  */
 179
 180 static void
 181 usage (int ret)
 182 {
 183     arg_printusage (args,
 184                     sizeof(args)/sizeof(*args),
 185                     NULL,
 186                     "filename.so");
 187     exit (ret);
 188 }
 189
 190 int
 191 main(int argc, char **argv)
 192 {
 193     ENGINE *engine = NULL;
 194     int i, j, idx = 0;
 195     RSA *rsa;
 196
 197     setprogname(argv[0]);
 198
 199     if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &idx))
 200         usage(1);
 201
 202     if (help_flag)
 203         usage(0);
 204
 205     if(version_flag){
 206         print_version(NULL);
 207         exit(0);
 208     }
 209
 210     argc -= idx;
 211     argv += idx;
 212
 213     OpenSSL_add_all_algorithms();
 214
 215     if (argc == 0) {
 216         OpenSSL_add_all_algorithms();
 217         ENGINE_load_builtin_engines();
 218         engine = ENGINE_by_id("builtin");
 219     } else {
 220         engine = ENGINE_by_dso(argv[0], id_flag);
 221     }
 222     if (engine == NULL)
 223         errx(1, "ENGINE_by_dso failed");
 224
 225     if (ENGINE_get_RSA(engine) == NULL)
 226         return 77;
 227
 228     printf("rsa %s\n", ENGINE_get_RSA(engine)->name);
 229
 230     if (RAND_status() != 1)
 231         errx(77, "no functional random device, refusing to run tests");
 232
 233     if (time_keygen) {
 234         struct timeval tv1, tv2;
 235         const int num = 10;
 236         BIGNUM *e;
 237
 238         rsa = RSA_new_method(engine);
 239         if (!key_blinding)
 240             rsa->flags |= RSA_FLAG_NO_BLINDING;
 241
 242         e = BN_new();
 243         BN_set_word(e, 0x10001);
 244
 245         gettimeofday(&tv1, NULL);
 246
 247         for (i = 0; i < num; i++) {
 248             rsa = RSA_new_method(engine);
 249             if (RSA_generate_key_ex(rsa, 1024, e, NULL) != 1)
 250                 errx(1, "RSA_generate_key_ex");
 251             RSA_free(rsa);
 252         }
 253
 254         gettimeofday(&tv2, NULL);
 255         timevalsub(&tv2, &tv1);
 256
 257         printf("time %lu.%06lu\n",
 258                (unsigned long)tv2.tv_sec,
 259                (unsigned long)tv2.tv_usec);
 260
 261         BN_free(e);
 262         ENGINE_finish(engine);
 263
 264         return 0;
 265     }
 266
 267     if (time_key) {
 268         const int size = 20;
 269         const int num = 128;
 270         struct timeval tv1, tv2;
 271         unsigned char *p;
 272
 273         rsa = read_key(engine, time_key);
 274
 275         p = emalloc(num * size);
 276
 277         RAND_bytes(p, num * size);
 278
 279         gettimeofday(&tv1, NULL);
 280         for (i = 0; i < num; i++)
 281             check_rsa(p + (i * size), size, rsa, RSA_PKCS1_PADDING);
 282         gettimeofday(&tv2, NULL);
 283
 284         timevalsub(&tv2, &tv1);
 285
 286         printf("time %lu.%06lu\n",
 287                (unsigned long)tv2.tv_sec,
 288                (unsigned long)tv2.tv_usec);
 289
 290         RSA_free(rsa);
 291         ENGINE_finish(engine);
 292
 293         return 0;
 294     }
 295
 296     if (rsa_key) {
 297         rsa = read_key(engine, rsa_key);
 298
 299         /*
 300          * Assuming that you use the RSA key in the distribution, this
 301          * test will generate a signature have a starting zero and thus
 302          * will generate a checksum that is 127 byte instead of the
 303          * checksum that is 128 byte (like the key).
 304          */
 305         {
 306             const unsigned char sha1[20] = {
 307                 0x6d, 0x33, 0xf9, 0x40, 0x75, 0x5b, 0x4e, 0xc5, 0x90, 0x35,
 308                 0x48, 0xab, 0x75, 0x02, 0x09, 0x76, 0x9a, 0xb4, 0x7d, 0x6b
 309             };
 310
 311             check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
 312         }
 313
 314         for (i = 0; i < 128; i++) {
 315             unsigned char sha1[20];
 316
 317             RAND_bytes(sha1, sizeof(sha1));
 318             check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
 319         }
 320         for (i = 0; i < 128; i++) {
 321             unsigned char des3[21];
 322
 323             RAND_bytes(des3, sizeof(des3));
 324             check_rsa(des3, sizeof(des3), rsa, RSA_PKCS1_PADDING);
 325         }
 326         for (i = 0; i < 128; i++) {
 327             unsigned char aes[32];
 328
 329             RAND_bytes(aes, sizeof(aes));
 330             check_rsa(aes, sizeof(aes), rsa, RSA_PKCS1_PADDING);
 331         }
 332
 333         RSA_free(rsa);
 334     }
 335
 336     for (i = 0; i < loops; i++) {
 337         BN_GENCB cb;
 338         BIGNUM *e;
 339         unsigned int n;
 340
 341         rsa = RSA_new_method(engine);
 342         if (!key_blinding)
 343             rsa->flags |= RSA_FLAG_NO_BLINDING;
 344
 345         e = BN_new();
 346         BN_set_word(e, 0x10001);
 347
 348         BN_GENCB_set(&cb, cb_func, NULL);
 349
 350         RAND_bytes(&n, sizeof(n));
 351         n &= 0x1ff;
 352         n += 1024;
 353
 354         if (RSA_generate_key_ex(rsa, n, e, &cb) != 1)
 355             errx(1, "RSA_generate_key_ex");
 356
 357         BN_free(e);
 358
 359         for (j = 0; j < 8; j++) {
 360             unsigned char sha1[20];
 361             RAND_bytes(sha1, sizeof(sha1));
 362             check_rsa(sha1, sizeof(sha1), rsa, RSA_PKCS1_PADDING);
 363         }
 364
 365         RSA_free(rsa);
 366     }
 367
 368     ENGINE_finish(engine);
 369
 370     return 0;
 371 }