ceph/src/crypto/isa-l/isa-l_crypto/md5_mb/md5_mb_rand_ssl_test.c

   1 /**********************************************************************
   2   Copyright(c) 2011-2016 Intel Corporation All rights reserved.
   3
   4   Redistribution and use in source and binary forms, with or without
   5   modification, are permitted provided that the following conditions
   6   are met:
   7     * Redistributions of source code must retain the above copyright
   8       notice, this list of conditions and the following disclaimer.
   9     * Redistributions in binary form must reproduce the above copyright
  10       notice, this list of conditions and the following disclaimer in
  11       the documentation and/or other materials provided with the
  12       distribution.
  13     * Neither the name of Intel Corporation nor the names of its
  14       contributors may be used to endorse or promote products derived
  15       from this software without specific prior written permission.
  16
  17   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  18   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  19   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  20   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  21   OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  22   SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  23   LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24   DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25   THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26   (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  27   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28 **********************************************************************/
  29
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <openssl/md5.h>
  33 #include "md5_mb.h"
  34
  35 #define TEST_LEN  (1024*1024)
  36 #define TEST_BUFS 200
  37 #ifndef RANDOMS
  38 # define RANDOMS  10
  39 #endif
  40 #ifndef TEST_SEED
  41 # define TEST_SEED 0x1234
  42 #endif
  43
  44 /* Reference digest global to reduce stack usage */
  45 static uint8_t digest_ssl[TEST_BUFS][4 * MD5_DIGEST_NWORDS];
  46
  47 // Generates pseudo-random data
  48 void rand_buffer(unsigned char *buf, const long buffer_size)
  49 {
  50         long i;
  51         for (i = 0; i < buffer_size; i++)
  52                 buf[i] = rand();
  53 }
  54
  55 int main(void)
  56 {
  57         MD5_HASH_CTX_MGR *mgr = NULL;
  58         MD5_HASH_CTX ctxpool[TEST_BUFS];
  59         unsigned char *bufs[TEST_BUFS];
  60         uint32_t i, j, fail = 0;
  61         uint32_t lens[TEST_BUFS];
  62         unsigned int jobs, t;
  63
  64         printf("multibinary_md5 test, %d sets of %dx%d max: ", RANDOMS, TEST_BUFS, TEST_LEN);
  65
  66         srand(TEST_SEED);
  67
  68         posix_memalign((void *)&mgr, 16, sizeof(MD5_HASH_CTX_MGR));
  69         md5_ctx_mgr_init(mgr);
  70
  71         for (i = 0; i < TEST_BUFS; i++) {
  72                 // Allocate and fill buffer
  73                 bufs[i] = (unsigned char *)malloc(TEST_LEN);
  74                 if (bufs[i] == NULL) {
  75                         printf("malloc failed test aborted\n");
  76                         return 1;
  77                 }
  78                 rand_buffer(bufs[i], TEST_LEN);
  79
  80                 // Init ctx contents
  81                 hash_ctx_init(&ctxpool[i]);
  82                 ctxpool[i].user_data = (void *)((uint64_t) i);
  83
  84                 // SSL test
  85                 MD5(bufs[i], TEST_LEN, digest_ssl[i]);
  86
  87                 // sb_md5 test
  88                 md5_ctx_mgr_submit(mgr, &ctxpool[i], bufs[i], TEST_LEN, HASH_ENTIRE);
  89         }
  90
  91         while (md5_ctx_mgr_flush(mgr)) ;
  92
  93         for (i = 0; i < TEST_BUFS; i++) {
  94                 for (j = 0; j < MD5_DIGEST_NWORDS; j++) {
  95                         if (ctxpool[i].job.result_digest[j] != ((uint32_t *) digest_ssl[i])[j]) {
  96                                 fail++;
  97                                 printf("Test%d, digest%d fail %08X <=> %08X\n",
  98                                        i, j, ctxpool[i].job.result_digest[j],
  99                                        ((uint32_t *) digest_ssl[i])[j]);
 100                         }
 101                 }
 102         }
 103         putchar('.');
 104
 105         // Run tests with random size and number of jobs
 106         for (t = 0; t < RANDOMS; t++) {
 107                 jobs = rand() % (TEST_BUFS);
 108
 109                 md5_ctx_mgr_init(mgr);
 110
 111                 for (i = 0; i < jobs; i++) {
 112                         // Ramdom buffer with ramdom len and contents
 113                         lens[i] = rand() % (TEST_LEN);
 114                         rand_buffer(bufs[i], lens[i]);
 115
 116                         // Run SSL test
 117                         MD5(bufs[i], lens[i], digest_ssl[i]);
 118
 119                         // Run sb_md5 test
 120                         md5_ctx_mgr_submit(mgr, &ctxpool[i], bufs[i], lens[i], HASH_ENTIRE);
 121                 }
 122
 123                 while (md5_ctx_mgr_flush(mgr)) ;
 124
 125                 for (i = 0; i < jobs; i++) {
 126                         for (j = 0; j < MD5_DIGEST_NWORDS; j++) {
 127                                 if (ctxpool[i].job.result_digest[j] !=
 128                                     ((uint32_t *) digest_ssl[i])[j]) {
 129                                         fail++;
 130                                         printf("Test%d, digest%d fail %08X <=> %08X\n",
 131                                                i, j, ctxpool[i].job.result_digest[j],
 132                                                ((uint32_t *) digest_ssl[i])[j]);
 133                                 }
 134                         }
 135                 }
 136                 if (fail) {
 137                         printf("Test failed function check %d\n", fail);
 138                         return fail;
 139                 }
 140
 141                 putchar('.');
 142                 fflush(0);
 143         }                       // random test t
 144
 145         if (fail)
 146                 printf("Test failed function check %d\n", fail);
 147         else
 148                 printf(" multibinary_md5_ssl rand: Pass\n");
 149
 150         return fail;
 151 }