crypto/dist/heimdal/lib/krb5/test_crypto.c

   1 /*
   2  * Copyright (c) 2003-2005 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 KTH nor the names of its contributors may be
  18  *    used to endorse or promote products derived from this software without
  19  *    specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
  22  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  24  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
  25  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  26  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  27  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  28  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  29  * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  30  * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  31  * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
  32
  33 #include "krb5_locl.h"
  34 #include <err.h>
  35 #include <getarg.h>
  36
  37 __RCSID("$Heimdal: test_crypto.c 16290 2005-11-24 09:57:50Z lha $"
  38         "$NetBSD$");
  39
  40 static void
  41 time_encryption(krb5_context context, size_t size,
  42                 krb5_enctype etype, int iterations)
  43 {
  44     struct timeval tv1, tv2;
  45     krb5_error_code ret;
  46     krb5_keyblock key;
  47     krb5_crypto crypto;
  48     krb5_data data;
  49     char *etype_name;
  50     void *buf;
  51     int i;
  52
  53     ret = krb5_generate_random_keyblock(context, etype, &key);
  54     if (ret)
  55         krb5_err(context, 1, ret, "krb5_generate_random_keyblock");
  56
  57     ret = krb5_enctype_to_string(context, etype, &etype_name);
  58     if (ret)
  59         krb5_err(context, 1, ret, "krb5_enctype_to_string");
  60
  61     buf = malloc(size);
  62     if (buf == NULL)
  63         krb5_errx(context, 1, "out of memory");
  64     memset(buf, 0, size);
  65
  66     ret = krb5_crypto_init(context, &key, 0, &crypto);
  67     if (ret)
  68         krb5_err(context, 1, ret, "krb5_crypto_init");
  69
  70     gettimeofday(&tv1, NULL);
  71
  72     for (i = 0; i < iterations; i++) {
  73         ret = krb5_encrypt(context, crypto, 0, buf, size, &data);
  74         if (ret)
  75             krb5_err(context, 1, ret, "encrypt: %d", i);
  76         krb5_data_free(&data);
  77     }
  78
  79     gettimeofday(&tv2, NULL);
  80
  81     timevalsub(&tv2, &tv1);
  82
  83     printf("%s size: %7lu iterations: %d time: %3ld.%06ld\n",
  84            etype_name, (unsigned long)size, iterations,
  85            (long)tv2.tv_sec, (long)tv2.tv_usec);
  86
  87     free(buf);
  88     free(etype_name);
  89     krb5_crypto_destroy(context, crypto);
  90     krb5_free_keyblock_contents(context, &key);
  91 }
  92
  93 static void
  94 time_s2k(krb5_context context,
  95          krb5_enctype etype,
  96          const char *password,
  97          krb5_salt salt,
  98          int iterations)
  99 {
 100     struct timeval tv1, tv2;
 101     krb5_error_code ret;
 102     krb5_keyblock key;
 103     krb5_data opaque;
 104     char *etype_name;
 105     int i;
 106
 107     ret = krb5_enctype_to_string(context, etype, &etype_name);
 108     if (ret)
 109         krb5_err(context, 1, ret, "krb5_enctype_to_string");
 110
 111     opaque.data = NULL;
 112     opaque.length = 0;
 113
 114     gettimeofday(&tv1, NULL);
 115
 116     for (i = 0; i < iterations; i++) {
 117         ret = krb5_string_to_key_salt_opaque(context, etype, password, salt,
 118                                          opaque, &key);
 119         if (ret)
 120             krb5_err(context, 1, ret, "krb5_string_to_key_data_salt_opaque");
 121         krb5_free_keyblock_contents(context, &key);
 122     }
 123
 124     gettimeofday(&tv2, NULL);
 125
 126     timevalsub(&tv2, &tv1);
 127
 128     printf("%s string2key %d iterations time: %3ld.%06ld\n",
 129            etype_name, iterations, (long)tv2.tv_sec, (long)tv2.tv_usec);
 130     free(etype_name);
 131
 132 }
 133
 134 static int version_flag = 0;
 135 static int help_flag    = 0;
 136
 137 static struct getargs args[] = {
 138     {"version", 0,      arg_flag,       &version_flag,
 139      "print version", NULL },
 140     {"help",    0,      arg_flag,       &help_flag,
 141      NULL, NULL }
 142 };
 143
 144 static void
 145 usage (int ret)
 146 {
 147     arg_printusage (args,
 148                     sizeof(args)/sizeof(*args),
 149                     NULL,
 150                     "");
 151     exit (ret);
 152 }
 153
 154 int
 155 main(int argc, char **argv)
 156 {
 157     krb5_context context;
 158     krb5_error_code ret;
 159     int i, enciter, s2kiter;
 160     int optidx = 0;
 161     krb5_salt salt;
 162
 163     krb5_enctype enctypes[] = {
 164         ETYPE_DES_CBC_CRC,
 165         ETYPE_DES3_CBC_SHA1,
 166         ETYPE_ARCFOUR_HMAC_MD5,
 167         ETYPE_AES128_CTS_HMAC_SHA1_96,
 168         ETYPE_AES256_CTS_HMAC_SHA1_96
 169     };
 170
 171     setprogname(argv[0]);
 172
 173     if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &optidx))
 174         usage(1);
 175
 176     if (help_flag)
 177         usage (0);
 178
 179     if(version_flag){
 180         print_version(NULL);
 181         exit(0);
 182     }
 183
 184     argc -= optidx;
 185     argv += optidx;
 186
 187     salt.salttype = KRB5_PW_SALT;
 188     salt.saltvalue.data = NULL;
 189     salt.saltvalue.length = 0;
 190
 191     ret = krb5_init_context(&context);
 192     if (ret)
 193         errx (1, "krb5_init_context failed: %d", ret);
 194
 195     enciter = 1000;
 196     s2kiter = 100;
 197
 198     for (i = 0; i < sizeof(enctypes)/sizeof(enctypes[0]); i++) {
 199
 200         time_encryption(context, 16, enctypes[i], enciter);
 201         time_encryption(context, 32, enctypes[i], enciter);
 202         time_encryption(context, 512, enctypes[i], enciter);
 203         time_encryption(context, 1024, enctypes[i], enciter);
 204         time_encryption(context, 2048, enctypes[i], enciter);
 205         time_encryption(context, 4096, enctypes[i], enciter);
 206         time_encryption(context, 8192, enctypes[i], enciter);
 207         time_encryption(context, 16384, enctypes[i], enciter);
 208         time_encryption(context, 32768, enctypes[i], enciter);
 209
 210         time_s2k(context, enctypes[i], "mYsecreitPassword", salt, s2kiter);
 211     }
 212
 213     krb5_free_context(context);
 214
 215     return 0;
 216 }