Return to dh_speed.c CVS log

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

Annotation of embedaddon/strongswan/scripts/dh_speed.c, revision 1.1

1.1     ! misho       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: }