Return to dh_speed.c CVS log

Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / strongswan / scripts

Strongswan

    1: /*
    2:  * Copyright (C) 2009 Martin Willi
    3:  * HSR Hochschule fuer Technik Rapperswil
    4:  *
    5:  * This program is free software; you can redistribute it and/or modify it
    6:  * under the terms of the GNU General Public License as published by the
    7:  * Free Software Foundation; either version 2 of the License, or (at your
    8:  * option) any later version.  See <http://www.fsf.org/copyleft/gpl.txt>.
    9:  *
   10:  * This program is distributed in the hope that it will be useful, but
   11:  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
   12:  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
   13:  * for more details.
   14:  */
   15: 
   16: #include <stdio.h>
   17: #include <time.h>
   18: #include <assert.h>
   19: #include <library.h>
   20: #include <utils/debug.h>
   21: #include <crypto/diffie_hellman.h>
   22: 
   23: static void usage()
   24: {
   25: 	printf("usage: dh_speed plugins rounds group1 [group2 [...]]\n");
   26: 	exit(1);
   27: }
   28: 
   29: struct {
   30: 	char *name;
   31: 	diffie_hellman_group_t group;
   32: } groups[] = {
   33: 	{"modp768",			MODP_768_BIT},
   34: 	{"modp1024",		MODP_1024_BIT},
   35: 	{"modp1024s160",	MODP_1024_160},
   36: 	{"modp1536",		MODP_1536_BIT},
   37: 	{"modp2048",		MODP_2048_BIT},
   38: 	{"modp2048s224",	MODP_2048_224},
   39: 	{"modp2048s256",	MODP_2048_256},
   40: 	{"modp3072",		MODP_3072_BIT},
   41: 	{"modp4096",		MODP_4096_BIT},
   42: 	{"modp6144",		MODP_6144_BIT},
   43: 	{"modp8192",		MODP_8192_BIT},
   44: 	{"ecp256",			ECP_256_BIT},
   45: 	{"ecp384",			ECP_384_BIT},
   46: 	{"ecp521",			ECP_521_BIT},
   47: 	{"ecp192",			ECP_192_BIT},
   48: 	{"ecp224",			ECP_224_BIT},
   49: 	{"curve25519",		CURVE_25519},
   50: 	{"curve448",		CURVE_448},
   51: };
   52: 
   53: static void start_timing(struct timespec *start)
   54: {
   55: 	clock_gettime(CLOCK_THREAD_CPUTIME_ID, start);
   56: }
   57: 
   58: static double end_timing(struct timespec *start)
   59: {
   60: 	struct timespec end;
   61: 
   62: 	clock_gettime(CLOCK_THREAD_CPUTIME_ID, &end);
   63: 	return (end.tv_nsec - start->tv_nsec) / 1000000000.0 +
   64: 			(end.tv_sec - start->tv_sec) * 1.0;
   65: }
   66: 
   67: static void run_test(diffie_hellman_group_t group, int rounds)
   68: {
   69: 	diffie_hellman_t *l[rounds], *r;
   70: 	chunk_t chunk, chunks[rounds], lsecrets[rounds], rsecrets[rounds];
   71: 	struct timespec timing;
   72: 	int round;
   73: 
   74: 	r = lib->crypto->create_dh(lib->crypto, group);
   75: 	if (!r)
   76: 	{
   77: 		printf("skipping %N, not supported\n",
   78: 				diffie_hellman_group_names, group);
   79: 		return;
   80: 	}
   81: 
   82: 	printf("%N:\t", diffie_hellman_group_names, group);
   83: 
   84: 	start_timing(&timing);
   85: 	for (round = 0; round < rounds; round++)
   86: 	{
   87: 		l[round] = lib->crypto->create_dh(lib->crypto, group);
   88: 		assert(l[round]->get_my_public_value(l[round], &chunks[round]));
   89: 	}
   90: 	printf("A = g^a/s: %8.1f", rounds / end_timing(&timing));
   91: 
   92: 	for (round = 0; round < rounds; round++)
   93: 	{
   94: 		assert(r->set_other_public_value(r, chunks[round]));
   95: 		assert(r->get_shared_secret(r, &rsecrets[round]));
   96: 		chunk_free(&chunks[round]);
   97: 	}
   98: 
   99: 	assert(r->get_my_public_value(r, &chunk));
  100: 	start_timing(&timing);
  101: 	for (round = 0; round < rounds; round++)
  102: 	{
  103: 		assert(l[round]->set_other_public_value(l[round], chunk));
  104: 		assert(l[round]->get_shared_secret(l[round], &lsecrets[round]));
  105: 	}
  106: 	printf(" | S = B^a/s: %8.1f\n", rounds / end_timing(&timing));
  107: 	chunk_free(&chunk);
  108: 
  109: 	for (round = 0; round < rounds; round++)
  110: 	{
  111: 		assert(chunk_equals(rsecrets[round], lsecrets[round]));
  112: 		free(lsecrets[round].ptr);
  113: 		free(rsecrets[round].ptr);
  114: 		l[round]->destroy(l[round]);
  115: 	}
  116: 	r->destroy(r);
  117: }
  118: 
  119: int main(int argc, char *argv[])
  120: {
  121: 	int rounds, i, j;
  122: 
  123: 	if (argc < 4)
  124: 	{
  125: 		usage();
  126: 	}
  127: 
  128: 	library_init(NULL, "dh_speed");
  129: 	lib->plugins->load(lib->plugins, argv[1]);
  130: 	atexit(library_deinit);
  131: 
  132: 	rounds = atoi(argv[2]);
  133: 
  134: 	for (i = 3; i < argc; i++)
  135: 	{
  136: 		bool found = FALSE;
  137: 
  138: 		for (j = 0; j < countof(groups); j++)
  139: 		{
  140: 			if (streq(groups[j].name, argv[i]))
  141: 			{
  142: 				run_test(groups[j].group, rounds);
  143: 				found = TRUE;
  144: 			}
  145: 		}
  146: 		if (!found)
  147: 		{
  148: 			printf("group %s not found\n", argv[i]);
  149: 		}
  150: 	}
  151: 	return 0;
  152: }