oysteikt/heimdal
0
0
Fork 0
Code Issues 5 Pull Requests Releases Activity
Files
ef1d63a997a672096312bfe29131fc53e8abbe9b
heimdal/lib/krb5/test_rfc3961.c
Simon Wilkinson e50faea7f0 krb5: Store a digest context in the crypto structure 
Creating and destroying an EVP_CTX_MD structure with every hash
operation is very expensive. Speed things up by caching one within
the krb5_crypto structure. krb5_crypto can already only be safely
used by one thread at a time - adding a message digest context here
shouldn't introduce any further threading risks.

Users of the stashed context must be careful to ensure that they
call no other hash functions whilst they are in the middle of using
the context.
2018-05-23 09:54:27 -04:00

522 lines
14 KiB
C
Raw Blame History

/*
* Copyright (c) 2003-2005 Kungliga Tekniska Högskolan
* (Royal Institute of Technology, Stockholm, Sweden).
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of KTH nor the names of its contributors may be
* used to endorse or promote products derived from this software without
* specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY KTH AND ITS CONTRIBUTORS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL KTH OR ITS CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
* BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
* WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
* OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
* ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. */
#include "krb5_locl.h"
#include <err.h>
#include <getarg.h>
static void
time_hmac(krb5_context context, size_t size, int iterations)
{
struct timeval tv1, tv2;
krb5_error_code ret;
krb5_keyblock key;
char sha1_data[20];
Checksum result;
char *buf;
int i;
ret = krb5_generate_random_keyblock(context,
ETYPE_AES128_CTS_HMAC_SHA1_96,
&key);
if (ret)
krb5_err(context, 1, ret, "krb5_generate_random_keyblock");
buf = calloc(1, size);
if (buf == NULL)
krb5_errx(context, 1, "out of memory");
gettimeofday(&tv1, NULL);
result.checksum.data = &sha1_data;
result.checksum.length = sizeof(sha1_data);
for (i = 0; i < iterations; i++) {
ret = krb5_hmac(context, CKSUMTYPE_SHA1, buf, size, 0, &key, &result);
if (ret)
krb5_err(context, 1, ret, "hmac: %d", i);
}
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("HMAC-SHA1 size: %7lu iterations: %d time: %3ld.%06ld\n",
(unsigned long)size, iterations,
(long)tv2.tv_sec, (long)tv2.tv_usec);
free(buf);
krb5_free_keyblock_contents(context, &key);
}
static void
time_hmac_evp(krb5_context context, size_t size, int iterations)
{
struct timeval tv1, tv2;
struct krb5_crypto_iov iov;
struct _krb5_key_data kd;
krb5_error_code ret;
krb5_keyblock key;
krb5_crypto crypto;
char sha1_data[20];
Checksum result;
char *buf;
int i;
ret = krb5_generate_random_keyblock(context,
ETYPE_AES128_CTS_HMAC_SHA1_96,
&key);
if (ret)
krb5_err(context, 1, ret, "krb5_generate_random_keyblock");
buf = calloc(1, size);
if (buf == NULL)
krb5_errx(context, 1, "out of memory");
gettimeofday(&tv1, NULL);
result.checksum.data = &sha1_data;
result.checksum.length = sizeof(sha1_data);
iov.data.data = buf;
iov.data.length = size;
iov.flags = KRB5_CRYPTO_TYPE_DATA;
kd.key = &key;
kd.schedule = NULL;
ret = krb5_crypto_init(context, &key, ETYPE_AES128_CTS_HMAC_SHA1_96,
&crypto);
if (ret)
krb5_err(context, 1, ret, "krb5_crypto_init");
for (i = 0; i < iterations; i++) {
ret = _krb5_SP_HMAC_SHA1_checksum(context, crypto, &kd, 0,
&iov, 1, &result);
if (ret)
krb5_err(context, 1, ret, "hmac: %d", i);
}
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("HMAC-SHA1 (evp) size: %7lu iterations: %d time: %3ld.%06ld\n",
(unsigned long)size, iterations,
(long)tv2.tv_sec, (long)tv2.tv_usec);
free(buf);
krb5_free_keyblock_contents(context, &key);
}
static void
time_encryption(krb5_context context, size_t size,
krb5_enctype etype, int iterations)
{
struct timeval tv1, tv2;
krb5_error_code ret;
krb5_keyblock key;
krb5_crypto crypto;
krb5_data data;
char *etype_name;
void *buf;
int i;
ret = krb5_generate_random_keyblock(context, etype, &key);
if (ret)
krb5_err(context, 1, ret, "krb5_generate_random_keyblock");
ret = krb5_enctype_to_string(context, etype, &etype_name);
if (ret)
krb5_err(context, 1, ret, "krb5_enctype_to_string");
buf = malloc(size);
if (buf == NULL)
krb5_errx(context, 1, "out of memory");
memset(buf, 0, size);
ret = krb5_crypto_init(context, &key, 0, &crypto);
if (ret)
krb5_err(context, 1, ret, "krb5_crypto_init");
gettimeofday(&tv1, NULL);
for (i = 0; i < iterations; i++) {
ret = krb5_encrypt(context, crypto, 0, buf, size, &data);
if (ret)
krb5_err(context, 1, ret, "encrypt: %d", i);
krb5_data_free(&data);
}
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("%s size: %7lu iterations: %d time: %3ld.%06ld\n",
etype_name, (unsigned long)size, iterations,
(long)tv2.tv_sec, (long)tv2.tv_usec);
free(buf);
free(etype_name);
krb5_crypto_destroy(context, crypto);
krb5_free_keyblock_contents(context, &key);
}
static void
time_s2k(krb5_context context,
krb5_enctype etype,
const char *password,
krb5_salt salt,
int iterations)
{
struct timeval tv1, tv2;
krb5_error_code ret;
krb5_keyblock key;
krb5_data opaque;
char *etype_name;
int i;
ret = krb5_enctype_to_string(context, etype, &etype_name);
if (ret)
krb5_err(context, 1, ret, "krb5_enctype_to_string");
opaque.data = NULL;
opaque.length = 0;
gettimeofday(&tv1, NULL);
for (i = 0; i < iterations; i++) {
ret = krb5_string_to_key_salt_opaque(context, etype, password, salt,
opaque, &key);
if (ret)
krb5_err(context, 1, ret, "krb5_string_to_key_data_salt_opaque");
krb5_free_keyblock_contents(context, &key);
}
gettimeofday(&tv2, NULL);
timevalsub(&tv2, &tv1);
printf("%s string2key %d iterations time: %3ld.%06ld\n",
etype_name, iterations, (long)tv2.tv_sec, (long)tv2.tv_usec);
free(etype_name);
}
static int version_flag = 0;
static int help_flag = 0;
static struct getargs args[] = {
{"version", 0, arg_flag, &version_flag,
"print version", NULL },
{"help", 0, arg_flag, &help_flag,
NULL, NULL }
};
static void
usage (int ret)
{
arg_printusage (args,
sizeof(args)/sizeof(*args),
NULL,
"");
exit (ret);
}
/* SHA1 test vectors from RFC2202 */
struct rfc2202 {
char key[80];
int keylen;
char data[80];
int datalen;
char digest[20];
int digestlen;
};
static struct rfc2202 rfc2202_vectors[] =
{
{
{0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
0x0b, 0x0b, 0x0b, 0x0b},
20,
"Hi There",
8,
{0xb6, 0x17, 0x31, 0x86, 0x55, 0x05, 0x72, 0x64,
0xe2, 0x8b, 0xc0, 0xb6, 0xfb, 0x37, 0x8c, 0x8e,
0xf1, 0x46, 0xbe, 0x00},
20
},
{
"Jefe",
4,
"what do ya want for nothing?",
28,
{0xef, 0xfc, 0xdf, 0x6a, 0xe5, 0xeb, 0x2f, 0xa2,
0xd2, 0x74, 0x16, 0xd5, 0xf1, 0x84, 0xdf, 0x9c,
0x25, 0x9a, 0x7c, 0x79},
20
},
{
{0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa},
20,
{0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd, 0xdd,
0xdd, 0xdd},
50,
{0x12, 0x5d, 0x73, 0x42, 0xb9, 0xac, 0x11, 0xcd,
0x91, 0xa3, 0x9a, 0xf4, 0x8a, 0xa1, 0x7b, 0x4f,
0x63, 0xf1, 0x75, 0xd3},
20
},
{
{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08,
0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0x10,
0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18,
0x19},
25,
{0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd, 0xcd,
0xcd, 0xcd},
50,
{0x4c, 0x90, 0x07, 0xf4, 0x02, 0x62, 0x50, 0xc6,
0xbc, 0x84, 0x14, 0xf9, 0xbf, 0x50, 0xc8, 0x6c,
0x2d, 0x72, 0x35, 0xda},
20
},
{
{0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
0x0c, 0x0c, 0x0c, 0x0c},
20,
"Test With Truncation",
20,
{0x4c, 0x1a, 0x03, 0x42, 0x4b, 0x55, 0xe0, 0x7f,
0xe7, 0xf2, 0x7b, 0xe1, 0xd5, 0x8b, 0xb9, 0x32,
0x4a, 0x9a, 0x5a, 0x04},
20
},
{
{0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa},
80,
"Test Using Larger Than Block-Size Key - Hash Key First",
54,
{0xaa, 0x4a, 0xe5, 0xe1, 0x52, 0x72, 0xd0, 0x0e,
0x95, 0x70, 0x56, 0x37, 0xce, 0x8a, 0x3b, 0x55,
0xed, 0x40, 0x21, 0x12},
20
},
{
{0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa,
0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa, 0xaa},
80,
"Test Using Larger Than Block-Size Key and Larger Than One Block-Size Data",
73,
{0xe8, 0xe9, 0x9d, 0x0f, 0x45, 0x23, 0x7d, 0x78,
0x6d, 0x6b, 0xba, 0xa7, 0x96, 0x5c, 0x78, 0x08,
0xbb, 0xff, 0x1a, 0x91},
20
}
};
/* RFC 2202 test vectors for HMAC-SHA1 */
static void
test_rfc2202(krb5_context context)
{
int num_tests;
int i;
num_tests = sizeof(rfc2202_vectors) / sizeof(struct rfc2202);
printf("Running %d RFC2202 HMAC-SHA1 tests\n", num_tests);
for (i = 0; i < num_tests; i++) {
krb5_keyblock keyblock;
Checksum result;
struct krb5_crypto_iov iov;
struct _krb5_key_data kd;
char sha1_data[20];
int code;
memset(&keyblock, 0, sizeof(keyblock));
memset(&result, 0, sizeof(result));
keyblock.keyvalue.length = rfc2202_vectors[i].keylen;
keyblock.keyvalue.data = &rfc2202_vectors[i].key;
result.checksum.data = &sha1_data;
result.checksum.length = sizeof(sha1_data);
code = krb5_hmac(context, CKSUMTYPE_SHA1,
&rfc2202_vectors[i].data, rfc2202_vectors[i].datalen,
0, &keyblock, &result);
if (code != 0)
errx(1, "HMAC-SHA1 failed with %d on test %d", code, i + 1);
if (memcmp(&sha1_data, rfc2202_vectors[i].digest, sizeof(sha1_data)) !=0)
errx(1, "Digests don't match on test %d", i);
printf("Test %d okay\n", (i * 2) + 1);
/* Now check the same using the internal HMAC function */
iov.data.data = rfc2202_vectors[i].data;
iov.data.length = rfc2202_vectors[i].datalen;
iov.flags = KRB5_CRYPTO_TYPE_DATA;
kd.key = &keyblock;
kd.schedule = NULL;
code = _krb5_SP_HMAC_SHA1_checksum(context, NULL, &kd, 0,
&iov, 1, &result);
if (code != 0)
errx(1, "HMAC-SHA1 failed with %d on test %d", code, i + 1);
if (memcmp(&sha1_data, rfc2202_vectors[i].digest, sizeof(sha1_data)) !=0)
errx(1, "Digests don't match on test %d", i);
printf("Test %d okay\n", (i * 2) + 2);
}
}
int
main(int argc, char **argv)
{
krb5_context context;
krb5_error_code ret;
int i, enciter, s2kiter, hmaciter;
int optidx = 0;
krb5_salt salt;
krb5_enctype enctypes[] = {
ETYPE_DES_CBC_CRC,
ETYPE_DES3_CBC_SHA1,
ETYPE_ARCFOUR_HMAC_MD5,
ETYPE_AES128_CTS_HMAC_SHA1_96,
ETYPE_AES256_CTS_HMAC_SHA1_96,
ETYPE_AES128_CTS_HMAC_SHA256_128,
ETYPE_AES256_CTS_HMAC_SHA384_192
};
setprogname(argv[0]);
if(getarg(args, sizeof(args) / sizeof(args[0]), argc, argv, &optidx))
usage(1);
if (help_flag)
usage (0);
if(version_flag){
print_version(NULL);
exit(0);
}
salt.salttype = KRB5_PW_SALT;
salt.saltvalue.data = NULL;
salt.saltvalue.length = 0;
ret = krb5_init_context(&context);
if (ret)
errx (1, "krb5_init_context failed: %d", ret);
test_rfc2202(context);
enciter = 1000;
hmaciter = 10000;
s2kiter = 100;
time_hmac(context, 16, hmaciter);
time_hmac(context, 32, hmaciter);
time_hmac(context, 512, hmaciter);
time_hmac(context, 1024, hmaciter);
time_hmac(context, 2048, hmaciter);
time_hmac(context, 4096, hmaciter);
time_hmac(context, 8192, hmaciter);
time_hmac(context, 16384, hmaciter);
time_hmac(context, 32768, hmaciter);
time_hmac_evp(context, 16, hmaciter);
time_hmac_evp(context, 32, hmaciter);
time_hmac_evp(context, 512, hmaciter);
time_hmac_evp(context, 1024, hmaciter);
time_hmac_evp(context, 2048, hmaciter);
time_hmac_evp(context, 4096, hmaciter);
time_hmac_evp(context, 8192, hmaciter);
time_hmac_evp(context, 16384, hmaciter);
time_hmac_evp(context, 32768, hmaciter);
for (i = 0; i < sizeof(enctypes)/sizeof(enctypes[0]); i++) {
krb5_enctype_enable(context, enctypes[i]);
time_encryption(context, 16, enctypes[i], enciter);
time_encryption(context, 32, enctypes[i], enciter);
time_encryption(context, 512, enctypes[i], enciter);
time_encryption(context, 1024, enctypes[i], enciter);
time_encryption(context, 2048, enctypes[i], enciter);
time_encryption(context, 4096, enctypes[i], enciter);
time_encryption(context, 8192, enctypes[i], enciter);
time_encryption(context, 16384, enctypes[i], enciter);
time_encryption(context, 32768, enctypes[i], enciter);
time_s2k(context, enctypes[i], "mYsecreitPassword", salt, s2kiter);
}
krb5_free_context(context);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink