X-Git-Url: https://git.openssl.org/?p=openssl.git;a=blobdiff_plain;f=test%2Fmodes_internal_test.c;h=e2eb3b65d0a725f3e00617a5cd80ab1738659aea;hp=a1ed8c73ea5dadcf8cb17f7edbd1b37066096db1;hb=fa9ad41476d40185b6fe06fa6564ea01cd527dad;hpb=f2ae2348cef7cdc9bc7bcff8f5cf19384bad45fd

diff --git a/test/modes_internal_test.c b/test/modes_internal_test.c
index a1ed8c73ea..e2eb3b65d0 100644
--- a/test/modes_internal_test.c
+++ b/test/modes_internal_test.c
@@ -1,5 +1,5 @@
 /*
- * Copyright 2016 The OpenSSL Project Authors. All Rights Reserved.
+ * Copyright 2016-2017 The OpenSSL Project Authors. 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
@@ -29,318 +29,6 @@ typedef struct {
  *
  ***/
 
-typedef struct {
-    const char *case_name;
-    int num;
-    const AES_KEY *encrypt_key_schedule;
-    const AES_KEY *decrypt_key_schedule;
-    const unsigned char *input;
-    SIZED_DATA iv;
-    const SIZED_DATA *vector;
-} CTS128_FIXTURE;
-
-static CTS128_FIXTURE setup_cts128(const char *const test_case_name)
-{
-    CTS128_FIXTURE fixture;
-    fixture.case_name = test_case_name;
-    return fixture;
-}
-
-static int execute_cts128(CTS128_FIXTURE fixture)
-{
-    const unsigned char *test_iv = fixture.iv.data;
-    size_t test_iv_len = fixture.iv.size;
-    const unsigned char *vector = fixture.vector->data;
-    size_t len = fixture.vector->size;
-    const unsigned char *test_input = fixture.input;
-    const AES_KEY *encrypt_key_schedule = fixture.encrypt_key_schedule;
-    const AES_KEY *decrypt_key_schedule = fixture.decrypt_key_schedule;
-    unsigned char iv[16];
-    unsigned char cleartext[64], ciphertext[64];
-    size_t tail;
-
-    fprintf(stderr, "vector_%" OSSLzu "\n", len);
-    fflush(stdout);
-
-    if ((tail = len % 16) == 0)
-        tail = 16;
-    tail += 16;
-
-    /* test block-based encryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_cts128_encrypt_block(test_input, ciphertext, len,
-                                encrypt_key_schedule, iv,
-                                (block128_f)AES_encrypt);
-    if (memcmp(ciphertext, vector, len)) {
-        fprintf(stderr, "block encrypt: output_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, vector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "block encrypt: iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    /* test block-based decryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_cts128_decrypt_block(ciphertext, cleartext, len,
-                                decrypt_key_schedule, iv,
-                                (block128_f)AES_decrypt);
-    if (memcmp(cleartext, test_input, len)) {
-        fprintf(stderr, "block decrypt: input_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, vector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "block decrypt: iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    /* test streamed encryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_cts128_encrypt(test_input, ciphertext, len, encrypt_key_schedule,
-                          iv, (cbc128_f) AES_cbc_encrypt);
-    if (memcmp(ciphertext, vector, len)) {
-        fprintf(stderr, "stream encrypt: output_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, vector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "stream encrypt: iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    /* test streamed decryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_cts128_decrypt(ciphertext, cleartext, len, decrypt_key_schedule, iv,
-                          (cbc128_f)AES_cbc_encrypt);
-    if (memcmp(cleartext, test_input, len)) {
-        fprintf(stderr, "stream decrypt: input_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, vector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "stream decrypt: iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    return 1;
-}
-
-static int execute_cts128_nist(CTS128_FIXTURE fixture)
-{
-    const unsigned char *test_iv = fixture.iv.data;
-    size_t test_iv_len = fixture.iv.size;
-    const unsigned char *vector = fixture.vector->data;
-    size_t len = fixture.vector->size;
-    const unsigned char *test_input = fixture.input;
-    const AES_KEY *encrypt_key_schedule = fixture.encrypt_key_schedule;
-    const AES_KEY *decrypt_key_schedule = fixture.decrypt_key_schedule;
-    unsigned char iv[16];
-    unsigned char cleartext[64], ciphertext[64], nistvector[64];
-    size_t tail;
-
-    fprintf(stderr, "nistvector_%" OSSLzu "\n", len);
-    fflush(stdout);
-
-    if ((tail = len % 16) == 0)
-        tail = 16;
-
-    len -= 16 + tail;
-    memcpy(nistvector, vector, len);
-    /* flip two last blocks */
-    memcpy(nistvector + len, vector + len + 16, tail);
-    memcpy(nistvector + len + tail, vector + len, 16);
-    len += 16 + tail;
-    tail = 16;
-
-    /* test block-based encryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_nistcts128_encrypt_block(test_input, ciphertext, len,
-                                    encrypt_key_schedule, iv,
-                                    (block128_f)AES_encrypt);
-    if (memcmp(ciphertext, nistvector, len)) {
-        fprintf(stderr, "output_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, nistvector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    /* test block-based decryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_nistcts128_decrypt_block(ciphertext, cleartext, len,
-                                    decrypt_key_schedule, iv,
-                                    (block128_f)AES_decrypt);
-    if (memcmp(cleartext, test_input, len)) {
-        fprintf(stderr, "input_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, nistvector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    /* test streamed encryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_nistcts128_encrypt(test_input, ciphertext, len,
-                              encrypt_key_schedule, iv,
-                              (cbc128_f)AES_cbc_encrypt);
-    if (memcmp(ciphertext, nistvector, len)) {
-        fprintf(stderr, "output_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, nistvector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    /* test streamed decryption */
-    memcpy(iv, test_iv, test_iv_len);
-    CRYPTO_nistcts128_decrypt(ciphertext, cleartext, len, decrypt_key_schedule,
-                              iv, (cbc128_f)AES_cbc_encrypt);
-    if (memcmp(cleartext, test_input, len)) {
-        fprintf(stderr, "input_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-    if (memcmp(iv, nistvector + len - tail, sizeof(iv))) {
-        fprintf(stderr, "iv_%" OSSLzu " mismatch\n", len);
-        return 0;
-    }
-
-    return 1;
-}
-
-static void teardown_cts128(CTS128_FIXTURE fixture)
-{
-    ERR_print_errors_fp(stderr);
-}
-
-/**********************************************************************
- *
- * Test of gcm128
- *
- ***/
-
-typedef struct {
-    const char *case_name;
-    int num;
-    SIZED_DATA K;
-    SIZED_DATA IV;
-    SIZED_DATA A;
-    SIZED_DATA P;
-    SIZED_DATA C;
-    SIZED_DATA T;
-} GCM128_FIXTURE;
-
-static GCM128_FIXTURE setup_gcm128(const char *const test_case_name)
-{
-    GCM128_FIXTURE fixture;
-    fixture.case_name = test_case_name;
-    return fixture;
-}
-
-static int execute_gcm128(GCM128_FIXTURE fixture)
-{
-    unsigned char out[512];
-    SIZED_DATA *K = &fixture.K;
-    SIZED_DATA *IV = &fixture.IV;
-    SIZED_DATA *A = &fixture.A;
-    SIZED_DATA *P = &fixture.P;
-    SIZED_DATA *C = &fixture.C;
-    SIZED_DATA *T = &fixture.T;
-    int n = fixture.num;
-    GCM128_CONTEXT ctx;
-    AES_KEY key;
-    int err = 0;
-
-    AES_set_encrypt_key(K->data, K->size * 8, &key);
-
-    CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);
-    CRYPTO_gcm128_setiv(&ctx, IV->data, IV->size);
-    memset(out, 0, P->size);
-    if (A->data)
-        CRYPTO_gcm128_aad(&ctx, A->data, A->size);
-    if (P->data)
-        CRYPTO_gcm128_encrypt( &ctx, P->data, out, P->size);
-    if (CRYPTO_gcm128_finish(&ctx, T->data, 16)
-        || (C->data && memcmp(out, C->data, P->size)))
-        err++, fprintf(stderr, "encrypt test#%d failed.\n", n);
-
-    CRYPTO_gcm128_setiv(&ctx, IV->data, IV->size);
-    memset(out, 0, P->size);
-    if (A->data)
-        CRYPTO_gcm128_aad(&ctx, A->data, A->size);
-    if (C->data)
-        CRYPTO_gcm128_decrypt(&ctx, C->data, out, P->size);
-    if (CRYPTO_gcm128_finish(&ctx, T->data, 16)
-        || (P->data && memcmp(out, P->data, P->size)))
-        err++, fprintf(stderr, "decrypt test#%d failed.\n", n);
-
-    return err == 0;
-}
-
-static void teardown_gcm128(GCM128_FIXTURE fixture)
-{
-    ERR_print_errors_fp(stderr);
-}
-
-static void benchmark_gcm128(const unsigned char *K, size_t Klen,
-                             const unsigned char *IV, size_t IVlen)
-{
-#ifdef OPENSSL_CPUID_OBJ
-    GCM128_CONTEXT ctx;
-    AES_KEY key;
-    size_t start, gcm_t, ctr_t, OPENSSL_rdtsc();
-    union {
-        u64 u;
-        u8 c[1024];
-    } buf;
-
-    AES_set_encrypt_key(K, Klen * 8, &key);
-    CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);
-    CRYPTO_gcm128_setiv(&ctx, IV, IVlen);
-
-    CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
-    start = OPENSSL_rdtsc();
-    CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
-    gcm_t = OPENSSL_rdtsc() - start;
-
-    CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
-                          &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
-                          (block128_f) AES_encrypt);
-    start = OPENSSL_rdtsc();
-    CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
-                          &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
-                          (block128_f) AES_encrypt);
-    ctr_t = OPENSSL_rdtsc() - start;
-
-    printf("%.2f-%.2f=%.2f\n",
-           gcm_t / (double)sizeof(buf),
-           ctr_t / (double)sizeof(buf),
-           (gcm_t - ctr_t) / (double)sizeof(buf));
-# ifdef GHASH
-    {
-        void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
-                             const u8 *inp, size_t len) = ctx.ghash;
-
-        GHASH((&ctx), buf.c, sizeof(buf));
-        start = OPENSSL_rdtsc();
-        for (i = 0; i < 100; ++i)
-            GHASH((&ctx), buf.c, sizeof(buf));
-        gcm_t = OPENSSL_rdtsc() - start;
-        printf("%.2f\n", gcm_t / (double)sizeof(buf) / (double)i);
-    }
-# endif
-#else
-    fprintf(stderr,
-            "Benchmarking of modes isn't available on this platform\n");
-#endif
-}
-
-/**********************************************************************
- *
- * Test driver
- *
- ***/
-
 /* cts128 test vectors from RFC 3962 */
 static const unsigned char cts128_test_key[16] = "chicken teriyaki";
 static const unsigned char cts128_test_input[64] =
@@ -402,7 +90,7 @@ static const unsigned char vector_64[64] = {
     {                                           \
         sizeof(vector_##len), vector_##len      \
     }
-static const SIZED_DATA cts128_vectors[] = {
+static const SIZED_DATA aes_cts128_vectors[] = {
     CTS128_TEST_VECTOR(17),
     CTS128_TEST_VECTOR(31),
     CTS128_TEST_VECTOR(32),
@@ -435,32 +123,145 @@ static AES_KEY *cts128_decrypt_key_schedule()
     return &ks;
 }
 
-static int drive_cts128_tests(int idx)
+typedef struct {
+    const char *case_name;
+    size_t (*last_blocks_correction)(const unsigned char *in,
+                                     unsigned char *out, size_t len);
+    size_t (*encrypt_block)(const unsigned char *in,
+                            unsigned char *out, size_t len,
+                            const void *key, unsigned char ivec[16],
+                            block128_f block);
+    size_t (*encrypt_stream)(const unsigned char *in, unsigned char *out,
+                             size_t len, const void *key,
+                             unsigned char ivec[16], cbc128_f cbc);
+    size_t (*decrypt_block)(const unsigned char *in,
+                            unsigned char *out, size_t len,
+                            const void *key, unsigned char ivec[16],
+                            block128_f block);
+    size_t (*decrypt_stream)(const unsigned char *in, unsigned char *out,
+                             size_t len, const void *key,
+                             unsigned char ivec[16], cbc128_f cbc);
+} CTS128_FIXTURE;
+
+static size_t last_blocks_correction(const unsigned char *in,
+                                     unsigned char *out, size_t len)
+{
+    size_t tail;
+
+    memcpy(out, in, len);
+    if ((tail = len % 16) == 0)
+        tail = 16;
+    tail += 16;
+
+    return tail;
+}
+
+static size_t last_blocks_correction_nist(const unsigned char *in,
+                                          unsigned char *out, size_t len)
 {
-    SETUP_TEST_FIXTURE(CTS128_FIXTURE, setup_cts128);
-    fixture.num = idx;
-    fixture.encrypt_key_schedule = cts128_encrypt_key_schedule();
-    fixture.decrypt_key_schedule = cts128_decrypt_key_schedule();
-    fixture.input = cts128_test_input;
-    fixture.iv.size = sizeof(cts128_test_iv);
-    fixture.iv.data = cts128_test_iv;
-    fixture.vector = &cts128_vectors[idx];
-    EXECUTE_TEST(execute_cts128, teardown_cts128);
+    size_t tail;
+
+    if ((tail = len % 16) == 0)
+        tail = 16;
+    len -= 16 + tail;
+    memcpy(out, in, len);
+    /* flip two last blocks */
+    memcpy(out + len, in + len + 16, tail);
+    memcpy(out + len + tail, in + len, 16);
+    len += 16 + tail;
+    tail = 16;
+
+    return tail;
+}
+
+static int execute_cts128(const CTS128_FIXTURE *fixture, int num)
+{
+    const unsigned char *test_iv = cts128_test_iv;
+    size_t test_iv_len = sizeof(cts128_test_iv);
+    const unsigned char *orig_vector = aes_cts128_vectors[num].data;
+    size_t len = aes_cts128_vectors[num].size;
+    const unsigned char *test_input = cts128_test_input;
+    const AES_KEY *encrypt_key_schedule = cts128_encrypt_key_schedule();
+    const AES_KEY *decrypt_key_schedule = cts128_decrypt_key_schedule();
+    unsigned char iv[16];
+    /* The largest test inputs are = 64 bytes. */
+    unsigned char cleartext[64], ciphertext[64], vector[64];
+    size_t tail, size;
+
+    TEST_info("%s_vector_%lu", fixture->case_name, (unsigned long)len);
+
+    tail = fixture->last_blocks_correction(orig_vector, vector, len);
+
+    /* test block-based encryption */
+    memcpy(iv, test_iv, test_iv_len);
+    if (!TEST_size_t_eq(fixture->encrypt_block(test_input, ciphertext, len,
+                                               encrypt_key_schedule, iv,
+                                               (block128_f)AES_encrypt), len)
+            || !TEST_mem_eq(ciphertext, len, vector, len)
+            || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
+        return 0;
+
+    /* test block-based decryption */
+    memcpy(iv, test_iv, test_iv_len);
+    size = fixture->decrypt_block(ciphertext, cleartext, len,
+                                  decrypt_key_schedule, iv,
+                                  (block128_f)AES_decrypt);
+    if (!TEST_true(len == size || len + 16 == size)
+            || !TEST_mem_eq(cleartext, len, test_input, len)
+            || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
+        return 0;
+
+    /* test streamed encryption */
+    memcpy(iv, test_iv, test_iv_len);
+    if (!TEST_size_t_eq(fixture->encrypt_stream(test_input, ciphertext, len,
+                                                encrypt_key_schedule, iv,
+                                                (cbc128_f) AES_cbc_encrypt),
+                        len)
+            || !TEST_mem_eq(ciphertext, len, vector, len)
+            || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
+        return 0;
+
+    /* test streamed decryption */
+    memcpy(iv, test_iv, test_iv_len);
+    if (!TEST_size_t_eq(fixture->decrypt_stream(ciphertext, cleartext, len,
+                                                decrypt_key_schedule, iv,
+                                                (cbc128_f)AES_cbc_encrypt),
+                        len)
+            || !TEST_mem_eq(cleartext, len, test_input, len)
+            || !TEST_mem_eq(iv, sizeof(iv), vector + len - tail, sizeof(iv)))
+        return 0;
+
+    return 1;
+}
+
+static int test_aes_cts128(int idx)
+{
+    static const CTS128_FIXTURE fixture_cts128 = {
+        "aes_cts128", last_blocks_correction,
+        CRYPTO_cts128_encrypt_block, CRYPTO_cts128_encrypt,
+        CRYPTO_cts128_decrypt_block, CRYPTO_cts128_decrypt
+    };
+
+    return execute_cts128(&fixture_cts128, idx);
 }
 
-static int drive_cts128_nist_tests(int idx)
+static int test_aes_cts128_nist(int idx)
 {
-    SETUP_TEST_FIXTURE(CTS128_FIXTURE, setup_cts128);
-    fixture.num = idx;
-    fixture.encrypt_key_schedule = cts128_encrypt_key_schedule();
-    fixture.decrypt_key_schedule = cts128_decrypt_key_schedule();
-    fixture.input = cts128_test_input;
-    fixture.iv.size = sizeof(cts128_test_iv);
-    fixture.iv.data = cts128_test_iv;
-    fixture.vector = &cts128_vectors[idx];
-    EXECUTE_TEST(execute_cts128_nist, teardown_cts128);
+    static const CTS128_FIXTURE fixture_cts128_nist = {
+        "aes_cts128_nist", last_blocks_correction_nist,
+        CRYPTO_nistcts128_encrypt_block, CRYPTO_nistcts128_encrypt,
+        CRYPTO_nistcts128_decrypt_block, CRYPTO_nistcts128_decrypt
+    };
+
+    return execute_cts128(&fixture_cts128_nist, idx);
 }
 
+/*
+ *
+ * Test of gcm128
+ *
+ */
+
 /* Test Case 1 */
 static const u8 K1[16], P1[] = { 0 }, A1[] = { 0 }, IV1[12], C1[] = { 0 };
 static const u8 T1[] = {
@@ -1034,52 +835,123 @@ static struct gcm128_data {
     GCM128_TEST_VECTOR(20)
 };
 
-static int drive_gcm128_tests(int idx)
+static int test_gcm128(int idx)
 {
-    SETUP_TEST_FIXTURE(GCM128_FIXTURE, setup_gcm128);
-    fixture.num = idx;
-    fixture.K.size = gcm128_vectors[idx].K.size;
-    fixture.K.data = fixture.K.size == 1 ? NULL : gcm128_vectors[idx].K.data;
-    fixture.IV.size = gcm128_vectors[idx].IV.size;
-    fixture.IV.data = fixture.IV.size == 1 ? NULL : gcm128_vectors[idx].IV.data;
-    fixture.A.size = gcm128_vectors[idx].A.size;
-    fixture.A.data = fixture.A.size == 1 ? NULL : gcm128_vectors[idx].A.data;
-    fixture.P.size = gcm128_vectors[idx].P.size;
-    fixture.P.data = fixture.P.size == 1 ? NULL : gcm128_vectors[idx].P.data;
-    fixture.C.size = gcm128_vectors[idx].C.size;
-    fixture.C.data = fixture.C.size == 1 ? NULL : gcm128_vectors[idx].C.data;
-    fixture.T.size = gcm128_vectors[idx].T.size;
-    fixture.T.data = fixture.T.size == 1 ? NULL : gcm128_vectors[idx].T.data;
-    EXECUTE_TEST(execute_gcm128, teardown_gcm128);
+    unsigned char out[512];
+    SIZED_DATA K = gcm128_vectors[idx].K;
+    SIZED_DATA IV = gcm128_vectors[idx].IV;
+    SIZED_DATA A = gcm128_vectors[idx].A;
+    SIZED_DATA P = gcm128_vectors[idx].P;
+    SIZED_DATA C = gcm128_vectors[idx].C;
+    SIZED_DATA T = gcm128_vectors[idx].T;
+    GCM128_CONTEXT ctx;
+    AES_KEY key;
+
+    /* Size 1 inputs are special-cased to signal NULL. */
+    if (A.size == 1)
+        A.data = NULL;
+    if (P.size == 1)
+        P.data = NULL;
+    if (C.size == 1)
+        C.data = NULL;
+
+    AES_set_encrypt_key(K.data, K.size * 8, &key);
+
+    CRYPTO_gcm128_init(&ctx, &key, (block128_f)AES_encrypt);
+    CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
+    memset(out, 0, P.size);
+    if (A.data != NULL)
+        CRYPTO_gcm128_aad(&ctx, A.data, A.size);
+    if (P.data != NULL)
+        CRYPTO_gcm128_encrypt( &ctx, P.data, out, P.size);
+    if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
+            || (C.data != NULL
+                    && !TEST_mem_eq(out, P.size, C.data, P.size)))
+        return 0;
+
+    CRYPTO_gcm128_setiv(&ctx, IV.data, IV.size);
+    memset(out, 0, P.size);
+    if (A.data != NULL)
+        CRYPTO_gcm128_aad(&ctx, A.data, A.size);
+    if (C.data != NULL)
+        CRYPTO_gcm128_decrypt(&ctx, C.data, out, P.size);
+    if (!TEST_false(CRYPTO_gcm128_finish(&ctx, T.data, 16))
+            || (P.data != NULL
+                    && !TEST_mem_eq(out, P.size, P.data, P.size)))
+        return 0;
+
+    return 1;
 }
 
-int main(int argc, char **argv)
+static void benchmark_gcm128(const unsigned char *K, size_t Klen,
+                             const unsigned char *IV, size_t IVlen)
 {
-    int result = 0;
-    int iter_argv;
-    int benchmark = 0;
-
-    for (iter_argv = 1; iter_argv < argc; iter_argv++) {
-        if (strcmp(argv[iter_argv], "-b") == 0)
-            benchmark = 1;
-        else if (strcmp(argv[iter_argv], "-h") == 0)
-            goto help;
-    }
+#ifdef OPENSSL_CPUID_OBJ
+    GCM128_CONTEXT ctx;
+    AES_KEY key;
+    size_t start, gcm_t, ctr_t, OPENSSL_rdtsc();
+    union {
+        u64 u;
+        u8 c[1024];
+    } buf;
 
-    ADD_ALL_TESTS(drive_cts128_tests, OSSL_NELEM(cts128_vectors));
-    ADD_ALL_TESTS(drive_cts128_nist_tests, OSSL_NELEM(cts128_vectors));
-    ADD_ALL_TESTS(drive_gcm128_tests, OSSL_NELEM(gcm128_vectors));
+    AES_set_encrypt_key(K, Klen * 8, &key);
+    CRYPTO_gcm128_init(&ctx, &key, (block128_f) AES_encrypt);
+    CRYPTO_gcm128_setiv(&ctx, IV, IVlen);
 
-    result = run_tests(argv[0]);
+    CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
+    start = OPENSSL_rdtsc();
+    CRYPTO_gcm128_encrypt(&ctx, buf.c, buf.c, sizeof(buf));
+    gcm_t = OPENSSL_rdtsc() - start;
 
-    if (benchmark)
-        benchmark_gcm128(K1, sizeof(K1), IV1, sizeof(IV1));
+    CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
+                          &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
+                          (block128_f) AES_encrypt);
+    start = OPENSSL_rdtsc();
+    CRYPTO_ctr128_encrypt(buf.c, buf.c, sizeof(buf),
+                          &key, ctx.Yi.c, ctx.EKi.c, &ctx.mres,
+                          (block128_f) AES_encrypt);
+    ctr_t = OPENSSL_rdtsc() - start;
 
-    return result;
+    printf("%.2f-%.2f=%.2f\n",
+           gcm_t / (double)sizeof(buf),
+           ctr_t / (double)sizeof(buf),
+           (gcm_t - ctr_t) / (double)sizeof(buf));
+# ifdef GHASH
+    {
+        void (*gcm_ghash_p) (u64 Xi[2], const u128 Htable[16],
+                             const u8 *inp, size_t len) = ctx.ghash;
 
- help:
-    printf("-h\tThis help\n");
-    printf("-b\tBenchmark gcm128 in addition to the tests\n");
+        GHASH((&ctx), buf.c, sizeof(buf));
+        start = OPENSSL_rdtsc();
+        for (i = 0; i < 100; ++i)
+            GHASH((&ctx), buf.c, sizeof(buf));
+        gcm_t = OPENSSL_rdtsc() - start;
+        printf("%.2f\n", gcm_t / (double)sizeof(buf) / (double)i);
+    }
+# endif
+#else
+    fprintf(stderr,
+            "Benchmarking of modes isn't available on this platform\n");
+#endif
+}
 
-    return 0;
+int setup_tests(void)
+{
+    if (test_has_option("-h")) {
+        printf("-h\tThis help\n");
+        printf("-b\tBenchmark gcm128 in addition to the tests\n");
+        return 1;
+    }
+
+    ADD_ALL_TESTS(test_aes_cts128, OSSL_NELEM(aes_cts128_vectors));
+    ADD_ALL_TESTS(test_aes_cts128_nist, OSSL_NELEM(aes_cts128_vectors));
+    ADD_ALL_TESTS(test_gcm128, OSSL_NELEM(gcm128_vectors));
+    return 1;
+}
+
+void cleanup_tests(void)
+{
+    if (test_has_option("-b"))
+        benchmark_gcm128(K1, sizeof(K1), IV1, sizeof(IV1));
 }