/*

 * Copyright 1995-2020 The OpenSSL Project Authors. All Rights Reserved.

 * Copyright (c) 2002, Oracle and/or its affiliates. All rights reserved

 *

 * Licensed under the OpenSSL license (the "License").  You may not use

 * this file except in compliance with the License.  You can obtain a copy

 * in the file LICENSE in the source distribution or at

 * https://www.openssl.org/source/license.html

 */

#undef SECONDS

#define SECONDS                 3

#define RSA_SECONDS             10

#define DSA_SECONDS             10

#define ECDSA_SECONDS   10

#define ECDH_SECONDS    10

#define EdDSA_SECONDS   10

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <math.h>

#include "apps.h"

#include "progs.h"

#include <openssl/crypto.h>

#include <openssl/rand.h>

#include <openssl/err.h>

#include <openssl/evp.h>

#include <openssl/objects.h>

#include <openssl/async.h>

#if !defined(OPENSSL_SYS_MSDOS)

# include OPENSSL_UNISTD

#endif

#if defined(_WIN32)

# include <windows.h>

#endif

#include <openssl/bn.h>

#ifndef OPENSSL_NO_DES

# include <openssl/des.h>

#endif

#include <openssl/aes.h>

#ifndef OPENSSL_NO_CAMELLIA

# include <openssl/camellia.h>

#endif

#ifndef OPENSSL_NO_MD2

# include <openssl/md2.h>

#endif

#ifndef OPENSSL_NO_MDC2

# include <openssl/mdc2.h>

#endif

#ifndef OPENSSL_NO_MD4

# include <openssl/md4.h>

#endif

#ifndef OPENSSL_NO_MD5

# include <openssl/md5.h>

#endif

#include <openssl/hmac.h>

#include <openssl/sha.h>

#ifndef OPENSSL_NO_RMD160

# include <openssl/ripemd.h>

#endif

#ifndef OPENSSL_NO_WHIRLPOOL

# include <openssl/whrlpool.h>

#endif

#ifndef OPENSSL_NO_RC4

# include <openssl/rc4.h>

#endif

#ifndef OPENSSL_NO_RC5

# include <openssl/rc5.h>

#endif

#ifndef OPENSSL_NO_RC2

# include <openssl/rc2.h>

#endif

#ifndef OPENSSL_NO_IDEA

# include <openssl/idea.h>

#endif

#ifndef OPENSSL_NO_SEED

# include <openssl/seed.h>

#endif

#ifndef OPENSSL_NO_BF

# include <openssl/blowfish.h>

#endif

#ifndef OPENSSL_NO_CAST

# include <openssl/cast.h>

#endif

#ifndef OPENSSL_NO_RSA

# include <openssl/rsa.h>

# include "./testrsa.h"

#endif

#include <openssl/x509.h>

#ifndef OPENSSL_NO_DSA

# include <openssl/dsa.h>

# include "./testdsa.h"

#endif

#ifndef OPENSSL_NO_EC

# include <openssl/ec.h>

#endif

#include <openssl/modes.h>

#ifndef HAVE_FORK

# if defined(OPENSSL_SYS_VMS) || defined(OPENSSL_SYS_WINDOWS) || defined(OPENSSL_SYS_VXWORKS)

#  define HAVE_FORK 0

# else

#  define HAVE_FORK 1

# endif

#endif

#if HAVE_FORK

# undef NO_FORK

#else

# define NO_FORK

#endif

#define MAX_MISALIGNMENT 63

#define MAX_ECDH_SIZE   256

#define MISALIGN        64

typedef struct openssl_speed_sec_st {

    int sym;

    int rsa;

    int dsa;

    int ecdsa;

    int ecdh;

    int eddsa;

} openssl_speed_sec_t;

static volatile int run = 0;

static int mr = 0;

static int usertime = 1;

#ifndef OPENSSL_NO_MD2

static int EVP_Digest_MD2_loop(void *args);

#endif

#ifndef OPENSSL_NO_MDC2

static int EVP_Digest_MDC2_loop(void *args);

#endif

#ifndef OPENSSL_NO_MD4

static int EVP_Digest_MD4_loop(void *args);

#endif

#ifndef OPENSSL_NO_MD5

static int MD5_loop(void *args);

static int HMAC_loop(void *args);

#endif

static int SHA1_loop(void *args);

static int SHA256_loop(void *args);

static int SHA512_loop(void *args);

#ifndef OPENSSL_NO_WHIRLPOOL

static int WHIRLPOOL_loop(void *args);

#endif

#ifndef OPENSSL_NO_RMD160

static int EVP_Digest_RMD160_loop(void *args);

#endif

#ifndef OPENSSL_NO_RC4

static int RC4_loop(void *args);

#endif

#ifndef OPENSSL_NO_DES

static int DES_ncbc_encrypt_loop(void *args);

static int DES_ede3_cbc_encrypt_loop(void *args);

#endif

static int AES_cbc_128_encrypt_loop(void *args);

static int AES_cbc_192_encrypt_loop(void *args);

static int AES_ige_128_encrypt_loop(void *args);

static int AES_cbc_256_encrypt_loop(void *args);

static int AES_ige_192_encrypt_loop(void *args);

static int AES_ige_256_encrypt_loop(void *args);

static int CRYPTO_gcm128_aad_loop(void *args);

static int RAND_bytes_loop(void *args);

static int EVP_Update_loop(void *args);

static int EVP_Update_loop_ccm(void *args);

static int EVP_Update_loop_aead(void *args);

static int EVP_Digest_loop(void *args);

#ifndef OPENSSL_NO_RSA

static int RSA_sign_loop(void *args);

static int RSA_verify_loop(void *args);

#endif

#ifndef OPENSSL_NO_DSA

static int DSA_sign_loop(void *args);

static int DSA_verify_loop(void *args);

#endif

#ifndef OPENSSL_NO_EC

static int ECDSA_sign_loop(void *args);

static int ECDSA_verify_loop(void *args);

static int EdDSA_sign_loop(void *args);

static int EdDSA_verify_loop(void *args);

#endif

static double Time_F(int s);

static void print_message(const char *s, long num, int length, int tm);

static void pkey_print_message(const char *str, const char *str2,

                               long num, unsigned int bits, int sec);

static void print_result(int alg, int run_no, int count, double time_used);

#ifndef NO_FORK

static int do_multi(int multi, int size_num);

#endif

static const int lengths_list[] = {

    16, 64, 256, 1024, 8 * 1024, 16 * 1024

};

static const int *lengths = lengths_list;

static const int aead_lengths_list[] = {

    2, 31, 136, 1024, 8 * 1024, 16 * 1024

};

#define START   0

#define STOP    1

#ifdef SIGALRM

static void alarmed(int sig)

{

    signal(SIGALRM, alarmed);

    run = 0;

}

static double Time_F(int s)

{

    double ret = app_tminterval(s, usertime);

    if (s == STOP)

        alarm(0);

    return ret;

}

#elif defined(_WIN32)

# define SIGALRM -1

static unsigned int lapse;

static volatile unsigned int schlock;

static void alarm_win32(unsigned int secs)

{

    lapse = secs * 1000;

}

# define alarm alarm_win32

static DWORD WINAPI sleepy(VOID * arg)

{

    schlock = 1;

    Sleep(lapse);

    run = 0;

    return 0;

}

static double Time_F(int s)

{

    double ret;

    static HANDLE thr;

    if (s == START) {

        schlock = 0;

        thr = CreateThread(NULL, 4096, sleepy, NULL, 0, NULL);

        if (thr == NULL) {

            DWORD err = GetLastError();

            BIO_printf(bio_err, "unable to CreateThread (%lu)", err);

            ExitProcess(err);

        }

        while (!schlock)

            Sleep(0);           /* scheduler spinlock */

        ret = app_tminterval(s, usertime);

    } else {

        ret = app_tminterval(s, usertime);

        if (run)

            TerminateThread(thr, 0);

        CloseHandle(thr);

    }

    return ret;

}

#else

static double Time_F(int s)

{

    return app_tminterval(s, usertime);

}

#endif

static void multiblock_speed(const EVP_CIPHER *evp_cipher, int lengths_single,

                             const openssl_speed_sec_t *seconds);

#define found(value, pairs, result)\

    opt_found(value, result, pairs, OSSL_NELEM(pairs))

static int opt_found(const char *name, unsigned int *result,

                     const OPT_PAIR pairs[], unsigned int nbelem)

{

    unsigned int idx;

    for (idx = 0; idx < nbelem; ++idx, pairs++)

        if (strcmp(name, pairs->name) == 0) {

            *result = pairs->retval;

            return 1;

        }

    return 0;

}

typedef enum OPTION_choice {

    OPT_ERR = -1, OPT_EOF = 0, OPT_HELP,

    OPT_ELAPSED, OPT_EVP, OPT_DECRYPT, OPT_ENGINE, OPT_MULTI,

    OPT_MR, OPT_MB, OPT_MISALIGN, OPT_ASYNCJOBS, OPT_R_ENUM,

    OPT_PRIMES, OPT_SECONDS, OPT_BYTES, OPT_AEAD

} OPTION_CHOICE;

const OPTIONS speed_options[] = {

    {OPT_HELP_STR, 1, '-', "Usage: %s [options] ciphers...\n"},

    {OPT_HELP_STR, 1, '-', "Valid options are:\n"},

    {"help", OPT_HELP, '-', "Display this summary"},

    {"evp", OPT_EVP, 's', "Use EVP-named cipher or digest"},

    {"decrypt", OPT_DECRYPT, '-',

     "Time decryption instead of encryption (only EVP)"},

    {"aead", OPT_AEAD, '-',

     "Benchmark EVP-named AEAD cipher in TLS-like sequence"},

    {"mb", OPT_MB, '-',

     "Enable (tls1>=1) multi-block mode on EVP-named cipher"},

    {"mr", OPT_MR, '-', "Produce machine readable output"},

#ifndef NO_FORK

    {"multi", OPT_MULTI, 'p', "Run benchmarks in parallel"},

#endif

#ifndef OPENSSL_NO_ASYNC

    {"async_jobs", OPT_ASYNCJOBS, 'p',

     "Enable async mode and start specified number of jobs"},

#endif

    OPT_R_OPTIONS,

#ifndef OPENSSL_NO_ENGINE

    {"engine", OPT_ENGINE, 's', "Use engine, possibly a hardware device"},

#endif

    {"elapsed", OPT_ELAPSED, '-',

     "Use wall-clock time instead of CPU user time as divisor"},

    {"primes", OPT_PRIMES, 'p', "Specify number of primes (for RSA only)"},

    {"seconds", OPT_SECONDS, 'p',

     "Run benchmarks for specified amount of seconds"},

    {"bytes", OPT_BYTES, 'p',

     "Run [non-PKI] benchmarks on custom-sized buffer"},

    {"misalign", OPT_MISALIGN, 'p',

     "Use specified offset to mis-align buffers"},

    {NULL}

};

#define D_MD2           0

#define D_MDC2          1

#define D_MD4           2

#define D_MD5           3

#define D_HMAC          4

#define D_SHA1          5

#define D_RMD160        6

#define D_RC4           7

#define D_CBC_DES       8

#define D_EDE3_DES      9

#define D_CBC_IDEA      10

#define D_CBC_SEED      11

#define D_CBC_RC2       12

#define D_CBC_RC5       13

#define D_CBC_BF        14

#define D_CBC_CAST      15

#define D_CBC_128_AES   16

#define D_CBC_192_AES   17

#define D_CBC_256_AES   18

#define D_CBC_128_CML   19

#define D_CBC_192_CML   20

#define D_CBC_256_CML   21

#define D_EVP           22

#define D_SHA256        23

#define D_SHA512        24

#define D_WHIRLPOOL     25

#define D_IGE_128_AES   26

#define D_IGE_192_AES   27

#define D_IGE_256_AES   28

#define D_GHASH         29

#define D_RAND          30

/* name of algorithms to test */

static const char *names[] = {

    "md2", "mdc2", "md4", "md5", "hmac(md5)", "sha1", "rmd160", "rc4",

    "des cbc", "des ede3", "idea cbc", "seed cbc",

    "rc2 cbc", "rc5-32/12 cbc", "blowfish cbc", "cast cbc",

    "aes-128 cbc", "aes-192 cbc", "aes-256 cbc",

    "camellia-128 cbc", "camellia-192 cbc", "camellia-256 cbc",

    "evp", "sha256", "sha512", "whirlpool",

    "aes-128 ige", "aes-192 ige", "aes-256 ige", "ghash",

    "rand"

};

#define ALGOR_NUM       OSSL_NELEM(names)

/* list of configured algorithm (remaining) */

static const OPT_PAIR doit_choices[] = {

#ifndef OPENSSL_NO_MD2

    {"md2", D_MD2},

#endif

#ifndef OPENSSL_NO_MDC2

    {"mdc2", D_MDC2},

#endif

#ifndef OPENSSL_NO_MD4

    {"md4", D_MD4},

#endif

#ifndef OPENSSL_NO_MD5

    {"md5", D_MD5},

    {"hmac", D_HMAC},

#endif

    {"sha1", D_SHA1},

    {"sha256", D_SHA256},

    {"sha512", D_SHA512},

#ifndef OPENSSL_NO_WHIRLPOOL

    {"whirlpool", D_WHIRLPOOL},

#endif

#ifndef OPENSSL_NO_RMD160

    {"ripemd", D_RMD160},

    {"rmd160", D_RMD160},

    {"ripemd160", D_RMD160},

#endif

#ifndef OPENSSL_NO_RC4

    {"rc4", D_RC4},

#endif

#ifndef OPENSSL_NO_DES

    {"des-cbc", D_CBC_DES},

    {"des-ede3", D_EDE3_DES},

#endif

    {"aes-128-cbc", D_CBC_128_AES},

    {"aes-192-cbc", D_CBC_192_AES},

    {"aes-256-cbc", D_CBC_256_AES},

    {"aes-128-ige", D_IGE_128_AES},

    {"aes-192-ige", D_IGE_192_AES},

    {"aes-256-ige", D_IGE_256_AES},

#ifndef OPENSSL_NO_RC2

    {"rc2-cbc", D_CBC_RC2},

    {"rc2", D_CBC_RC2},

#endif

#ifndef OPENSSL_NO_RC5

    {"rc5-cbc", D_CBC_RC5},

    {"rc5", D_CBC_RC5},

#endif

#ifndef OPENSSL_NO_IDEA

    {"idea-cbc", D_CBC_IDEA},

    {"idea", D_CBC_IDEA},

#endif

#ifndef OPENSSL_NO_SEED

    {"seed-cbc", D_CBC_SEED},

    {"seed", D_CBC_SEED},

#endif

#ifndef OPENSSL_NO_BF

    {"bf-cbc", D_CBC_BF},

    {"blowfish", D_CBC_BF},

    {"bf", D_CBC_BF},

#endif

#ifndef OPENSSL_NO_CAST

    {"cast-cbc", D_CBC_CAST},

    {"cast", D_CBC_CAST},

    {"cast5", D_CBC_CAST},

#endif

    {"ghash", D_GHASH},

    {"rand", D_RAND}

};

static double results[ALGOR_NUM][OSSL_NELEM(lengths_list)];

#ifndef OPENSSL_NO_DSA

# define R_DSA_512       0

# define R_DSA_1024      1

# define R_DSA_2048      2

static const OPT_PAIR dsa_choices[] = {

    {"dsa512", R_DSA_512},

    {"dsa1024", R_DSA_1024},

    {"dsa2048", R_DSA_2048}

};

# define DSA_NUM         OSSL_NELEM(dsa_choices)

static double dsa_results[DSA_NUM][2];  /* 2 ops: sign then verify */

#endif  /* OPENSSL_NO_DSA */

#define R_RSA_512       0

#define R_RSA_1024      1

#define R_RSA_2048      2

#define R_RSA_3072      3

#define R_RSA_4096      4

#define R_RSA_7680      5

#define R_RSA_15360     6

#ifndef OPENSSL_NO_RSA

static const OPT_PAIR rsa_choices[] = {

    {"rsa512", R_RSA_512},

    {"rsa1024", R_RSA_1024},

    {"rsa2048", R_RSA_2048},

    {"rsa3072", R_RSA_3072},

    {"rsa4096", R_RSA_4096},

    {"rsa7680", R_RSA_7680},

    {"rsa15360", R_RSA_15360}

};

# define RSA_NUM OSSL_NELEM(rsa_choices)

static double rsa_results[RSA_NUM][2];  /* 2 ops: sign then verify */

#endif /* OPENSSL_NO_RSA */

enum {

    R_EC_P224,

    R_EC_P256,

    R_EC_P384,

    R_EC_P521,

    R_EC_X25519,

    R_EC_X448

};

#ifndef OPENSSL_NO_EC

static OPT_PAIR ecdsa_choices[] = {

    {"ecdsap224", R_EC_P224},

    {"ecdsap256", R_EC_P256},

    {"ecdsap384", R_EC_P384},

    {"ecdsap521", R_EC_P521},

};

# define ECDSA_NUM       OSSL_NELEM(ecdsa_choices)

static double ecdsa_results[ECDSA_NUM][2];    /* 2 ops: sign then verify */

static const OPT_PAIR ecdh_choices[] = {

    {"ecdhp224", R_EC_P224},

    {"ecdhp256", R_EC_P256},

    {"ecdhp384", R_EC_P384},

    {"ecdhp521", R_EC_P521},

    {"ecdhx25519", R_EC_X25519},

    {"ecdhx448", R_EC_X448}

};

# define EC_NUM       OSSL_NELEM(ecdh_choices)

static double ecdh_results[EC_NUM][1];  /* 1 op: derivation */

#define R_EC_Ed25519    0

#define R_EC_Ed448      1

static OPT_PAIR eddsa_choices[] = {

    {"ed25519", R_EC_Ed25519},

    {"ed448", R_EC_Ed448}

};

# define EdDSA_NUM       OSSL_NELEM(eddsa_choices)

static double eddsa_results[EdDSA_NUM][2];    /* 2 ops: sign then verify */

#endif /* OPENSSL_NO_EC */

#ifndef SIGALRM

# define COND(d) (count < (d))

# define COUNT(d) (d)

#else

# define COND(unused_cond) (run && count<0x7fffffff)

# define COUNT(d) (count)

#endif                          /* SIGALRM */

typedef struct loopargs_st {

    ASYNC_JOB *inprogress_job;

    ASYNC_WAIT_CTX *wait_ctx;

    unsigned char *buf;

    unsigned char *buf2;

    unsigned char *buf_malloc;

    unsigned char *buf2_malloc;

    unsigned char *key;

    unsigned int siglen;

    size_t sigsize;

#ifndef OPENSSL_NO_RSA

    RSA *rsa_key[RSA_NUM];

#endif

#ifndef OPENSSL_NO_DSA

    DSA *dsa_key[DSA_NUM];

#endif

#ifndef OPENSSL_NO_EC

    EC_KEY *ecdsa[ECDSA_NUM];

    EVP_PKEY_CTX *ecdh_ctx[EC_NUM];

    EVP_MD_CTX *eddsa_ctx[EdDSA_NUM];

    unsigned char *secret_a;

    unsigned char *secret_b;

    size_t outlen[EC_NUM];

#endif

    EVP_CIPHER_CTX *ctx;

    HMAC_CTX *hctx;

    GCM128_CONTEXT *gcm_ctx;

} loopargs_t;

static int run_benchmark(int async_jobs, int (*loop_function) (void *),

                         loopargs_t * loopargs);

static unsigned int testnum;

/* Nb of iterations to do per algorithm and key-size */

static long c[ALGOR_NUM][OSSL_NELEM(lengths_list)];

#ifndef OPENSSL_NO_MD2

static int EVP_Digest_MD2_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char md2[MD2_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_MD2][testnum]); count++) {

        if (!EVP_Digest(buf, (size_t)lengths[testnum], md2, NULL, EVP_md2(),

                        NULL))

            return -1;

    }

    return count;

}

#endif

#ifndef OPENSSL_NO_MDC2

static int EVP_Digest_MDC2_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char mdc2[MDC2_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_MDC2][testnum]); count++) {

        if (!EVP_Digest(buf, (size_t)lengths[testnum], mdc2, NULL, EVP_mdc2(),

                        NULL))

            return -1;

    }

    return count;

}

#endif

#ifndef OPENSSL_NO_MD4

static int EVP_Digest_MD4_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char md4[MD4_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_MD4][testnum]); count++) {

        if (!EVP_Digest(buf, (size_t)lengths[testnum], md4, NULL, EVP_md4(),

                        NULL))

            return -1;

    }

    return count;

}

#endif

#ifndef OPENSSL_NO_MD5

static int MD5_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char md5[MD5_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_MD5][testnum]); count++)

        MD5(buf, lengths[testnum], md5);

    return count;

}

static int HMAC_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    HMAC_CTX *hctx = tempargs->hctx;

    unsigned char hmac[MD5_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_HMAC][testnum]); count++) {

        HMAC_Init_ex(hctx, NULL, 0, NULL, NULL);

        HMAC_Update(hctx, buf, lengths[testnum]);

        HMAC_Final(hctx, hmac, NULL);

    }

    return count;

}

#endif

static int SHA1_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char sha[SHA_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_SHA1][testnum]); count++)

        SHA1(buf, lengths[testnum], sha);

    return count;

}

static int SHA256_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char sha256[SHA256_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_SHA256][testnum]); count++)

        SHA256(buf, lengths[testnum], sha256);

    return count;

}

static int SHA512_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char sha512[SHA512_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_SHA512][testnum]); count++)

        SHA512(buf, lengths[testnum], sha512);

    return count;

}

#ifndef OPENSSL_NO_WHIRLPOOL

static int WHIRLPOOL_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char whirlpool[WHIRLPOOL_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_WHIRLPOOL][testnum]); count++)

        WHIRLPOOL(buf, lengths[testnum], whirlpool);

    return count;

}

#endif

#ifndef OPENSSL_NO_RMD160

static int EVP_Digest_RMD160_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char rmd160[RIPEMD160_DIGEST_LENGTH];

    int count;

    for (count = 0; COND(c[D_RMD160][testnum]); count++) {

        if (!EVP_Digest(buf, (size_t)lengths[testnum], &(rmd160[0]),

                        NULL, EVP_ripemd160(), NULL))

            return -1;

    }

    return count;

}

#endif

#ifndef OPENSSL_NO_RC4

static RC4_KEY rc4_ks;

static int RC4_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_RC4][testnum]); count++)

        RC4(&rc4_ks, (size_t)lengths[testnum], buf, buf);

    return count;

}

#endif

#ifndef OPENSSL_NO_DES

static unsigned char DES_iv[8];

static DES_key_schedule sch;

static DES_key_schedule sch2;

static DES_key_schedule sch3;

static int DES_ncbc_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_CBC_DES][testnum]); count++)

        DES_ncbc_encrypt(buf, buf, lengths[testnum], &sch,

                         &DES_iv, DES_ENCRYPT);

    return count;

}

static int DES_ede3_cbc_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_EDE3_DES][testnum]); count++)

        DES_ede3_cbc_encrypt(buf, buf, lengths[testnum],

                             &sch, &sch2, &sch3, &DES_iv, DES_ENCRYPT);

    return count;

}

#endif

#define MAX_BLOCK_SIZE 128

static unsigned char iv[2 * MAX_BLOCK_SIZE / 8];

static AES_KEY aes_ks1, aes_ks2, aes_ks3;

static int AES_cbc_128_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_CBC_128_AES][testnum]); count++)

        AES_cbc_encrypt(buf, buf,

                        (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);

    return count;

}

static int AES_cbc_192_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_CBC_192_AES][testnum]); count++)

        AES_cbc_encrypt(buf, buf,

                        (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);

    return count;

}

static int AES_cbc_256_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_CBC_256_AES][testnum]); count++)

        AES_cbc_encrypt(buf, buf,

                        (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);

    return count;

}

static int AES_ige_128_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char *buf2 = tempargs->buf2;

    int count;

    for (count = 0; COND(c[D_IGE_128_AES][testnum]); count++)

        AES_ige_encrypt(buf, buf2,

                        (size_t)lengths[testnum], &aes_ks1, iv, AES_ENCRYPT);

    return count;

}

static int AES_ige_192_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char *buf2 = tempargs->buf2;

    int count;

    for (count = 0; COND(c[D_IGE_192_AES][testnum]); count++)

        AES_ige_encrypt(buf, buf2,

                        (size_t)lengths[testnum], &aes_ks2, iv, AES_ENCRYPT);

    return count;

}

static int AES_ige_256_encrypt_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    unsigned char *buf2 = tempargs->buf2;

    int count;

    for (count = 0; COND(c[D_IGE_256_AES][testnum]); count++)

        AES_ige_encrypt(buf, buf2,

                        (size_t)lengths[testnum], &aes_ks3, iv, AES_ENCRYPT);

    return count;

}

static int CRYPTO_gcm128_aad_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    GCM128_CONTEXT *gcm_ctx = tempargs->gcm_ctx;

    int count;

    for (count = 0; COND(c[D_GHASH][testnum]); count++)

        CRYPTO_gcm128_aad(gcm_ctx, buf, lengths[testnum]);

    return count;

}

static int RAND_bytes_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    int count;

    for (count = 0; COND(c[D_RAND][testnum]); count++)

        RAND_bytes(buf, lengths[testnum]);

    return count;

}

static long save_count = 0;

static int decrypt = 0;

static int EVP_Update_loop(void *args)

{

    loopargs_t *tempargs = *(loopargs_t **) args;

    unsigned char *buf = tempargs->buf;

    EVP_CIPHER_CTX *ctx = tempargs->ctx;

    int outl, count, rc;

#ifndef SIGALRM

    int nb_iter = save_count * 4 * lengths[0] / lengths[testnum];

#endif

    if (decrypt) {

        for (count = 0; COND(nb_iter); count++) {

            rc = EVP_DecryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);

            if (rc != 1) {

                /* reset iv in case of counter overflow */

                EVP_CipherInit_ex(ctx, NULL, NULL, NULL, iv, -1);

            }

        }

    } else {

        for (count = 0; COND(nb_iter); count++) {

            rc = EVP_EncryptUpdate(ctx, buf, &outl, buf, lengths[testnum]);

            if (rc != 1) {

                /* reset iv in case of counter overflow */