Return to pubkey_speed.c CVS log

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

Annotation of embedaddon/strongswan/scripts/pubkey_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 <library.h>
        !            19: #include <utils/debug.h>
        !            20: #include <credentials/keys/private_key.h>
        !            21: 
        !            22: void start_timing(struct timespec *start)
        !            23: {
        !            24:        clock_gettime(CLOCK_THREAD_CPUTIME_ID, start);
        !            25: }
        !            26: 
        !            27: double end_timing(struct timespec *start)
        !            28: {
        !            29:        struct timespec end;
        !            30: 
        !            31:        clock_gettime(CLOCK_THREAD_CPUTIME_ID, &end);
        !            32:        return (end.tv_nsec - start->tv_nsec) / 1000000000.0 +
        !            33:                        (end.tv_sec - start->tv_sec) * 1.0;
        !            34: }
        !            35: 
        !            36: static void usage()
        !            37: {
        !            38:        printf("usage: pubkey_speed plugins rsa|ecdsa rounds < key\n");
        !            39:        exit(1);
        !            40: }
        !            41: 
        !            42: int main(int argc, char *argv[])
        !            43: {
        !            44:        private_key_t *private;
        !            45:        public_key_t *public;
        !            46:        struct timespec timing;
        !            47:        int round, rounds, read;
        !            48:        char buf[8096], *pos = buf;
        !            49:        key_type_t type = KEY_ANY;
        !            50:        signature_scheme_t scheme = SIGN_UNKNOWN;
        !            51:        chunk_t keydata, *sigs, data;
        !            52: 
        !            53:        if (argc < 4)
        !            54:        {
        !            55:                usage();
        !            56:        }
        !            57: 
        !            58:        rounds = atoi(argv[3]);
        !            59:        if (rounds < 0 || rounds > (1 << 26))
        !            60:        {       /* arbitrary limit to the number of chunk_t/sigs that fit into 1 GiB */
        !            61:                usage();
        !            62:        }
        !            63: 
        !            64:        if (streq(argv[2], "rsa"))
        !            65:        {
        !            66:                type = KEY_RSA;
        !            67:                scheme = SIGN_RSA_EMSA_PKCS1_SHA1;
        !            68:        }
        !            69:        else if (streq(argv[2], "ecdsa"))
        !            70:        {
        !            71:                type = KEY_ECDSA;
        !            72:        }
        !            73:        else
        !            74:        {
        !            75:                usage();
        !            76:        }
        !            77: 
        !            78:        library_init(NULL, "pubkey_speed");
        !            79:        lib->plugins->load(lib->plugins, argv[1]);
        !            80:        atexit(library_deinit);
        !            81: 
        !            82:        keydata = chunk_create(buf, 0);
        !            83:        while ((read = fread(pos, 1, sizeof(buf) - (pos - buf), stdin)))
        !            84:        {
        !            85:                pos += read;
        !            86:                keydata.len += read;
        !            87:        }
        !            88: 
        !            89:        private = lib->creds->create(lib->creds, CRED_PRIVATE_KEY, type,
        !            90:                                                                 BUILD_BLOB_PEM, keydata, BUILD_END);
        !            91:        if (!private)
        !            92:        {
        !            93:                printf("parsing private key failed.\n");
        !            94:                exit(1);
        !            95:        }
        !            96:        if (type == KEY_ECDSA)
        !            97:        {
        !            98:                switch (private->get_keysize(private))
        !            99:                {
        !           100:                        case 256:
        !           101:                                scheme = SIGN_ECDSA_256;
        !           102:                                break;
        !           103:                        case 384:
        !           104:                                scheme = SIGN_ECDSA_384;
        !           105:                                break;
        !           106:                        case 521:
        !           107:                                scheme = SIGN_ECDSA_521;
        !           108:                                break;
        !           109:                        default:
        !           110:                                printf("%d bit ECDSA private key size not supported",
        !           111:                                                private->get_keysize(private));
        !           112:                                exit(1);
        !           113:                }
        !           114:        }
        !           115: 
        !           116:        printf("%4d bit %N: ", private->get_keysize(private),
        !           117:                key_type_names, type);
        !           118: 
        !           119:        sigs = malloc(sizeof(chunk_t) * rounds);
        !           120: 
        !           121:        data = chunk_from_chars(0x01,0x02,0x03,0x04,0x05,0x06,0x07);
        !           122:        start_timing(&timing);
        !           123:        for (round = 0; round < rounds; round++)
        !           124:        {
        !           125:                if (!private->sign(private, scheme, NULL, data, &sigs[round]))
        !           126:                {
        !           127:                        printf("creating signature failed\n");
        !           128:                        exit(1);
        !           129:                }
        !           130:        };
        !           131:        printf("sign()/s: %8.1f   ", rounds / end_timing(&timing));
        !           132: 
        !           133:        public = private->get_public_key(private);
        !           134:        if (!public)
        !           135:        {
        !           136:                printf("extracting public key failed\n");
        !           137:                exit(1);
        !           138:        }
        !           139:        start_timing(&timing);
        !           140:        for (round = 0; round < rounds; round++)
        !           141:        {
        !           142:                if (!public->verify(public, scheme, NULL, data, sigs[round]))
        !           143:                {
        !           144:                        printf("signature verification failed\n");
        !           145:                        exit(1);
        !           146:                }
        !           147:        }
        !           148:        printf("verify()/s: %8.1f\n", rounds / end_timing(&timing));
        !           149:        public->destroy(public);
        !           150:        private->destroy(private);
        !           151: 
        !           152:        for (round = 0; round < rounds; round++)
        !           153:        {
        !           154:                free(sigs[round].ptr);
        !           155:        }
        !           156:        free(sigs);
        !           157:        return 0;
        !           158: }