apps/speed.c: add multi-block benchmark.

diff --git a/apps/speed.c b/apps/speed.c
index b5b7d50b06cdf311ccf343a2053ddff2c18fd039..6201a84985af9612d09936c402a46a5b94c03404 100644 (file)
--- a/apps/speed.c
+++ b/apps/speed.c
@@ -357,6 +357,7 @@ static void *KDF1_SHA1(const void *in, size_t inlen, void *out, size_t *outlen)
        }
 #endif /* OPENSSL_NO_ECDH */
 
+static void multiblock_speed(const EVP_CIPHER *evp_cipher);
 
 int MAIN(int, char **);
 
@@ -641,6 +642,7 @@ int MAIN(int argc, char **argv)
 #ifndef NO_FORK
        int multi=0;
 #endif
+       int multiblock=0;
 
 #ifndef TIMES
        usertime=-1;
@@ -791,6 +793,11 @@ int MAIN(int argc, char **argv)
                        j--;    /* Otherwise, -mr gets confused with
                                   an algorithm. */
                        }
+               else if (argc > 0 && !strcmp(*argv,"-mb"))
+                       {
+                       multiblock=1;
+                       j--;
+                       }
                else
 #ifndef OPENSSL_NO_MD2
                if      (strcmp(*argv,"md2") == 0) doit[D_MD2]=1;
@@ -1993,6 +2000,19 @@ int MAIN(int argc, char **argv)
 
        if (doit[D_EVP])
                {
+#ifdef EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK
+               if (multiblock && evp_cipher)
+                       {
+                       if (!(EVP_CIPHER_flags(evp_cipher)&EVP_CIPH_FLAG_TLS1_1_MULTIBLOCK))
+                               {
+                               fprintf(stderr,"%s is not multi-block capable\n",OBJ_nid2ln(evp_cipher->nid));
+                               goto end;
+                               }
+                       multiblock_speed(evp_cipher);
+                       mret=0;
+                       goto end;
+                       }
+#endif
                for (j=0; j<SIZE_NUM; j++)
                        {
                        if (evp_cipher)
@@ -2968,4 +2988,108 @@ static int do_multi(int multi)
        return 1;
        }
 #endif
+
+static void multiblock_speed(const EVP_CIPHER *evp_cipher)
+       {
+       static int mblengths[]={8*1024,2*8*1024,4*8*1024,8*8*1024,8*16*1024};
+       int j,count,num=sizeof(lengths)/sizeof(lengths[0]);
+       const char *alg_name;
+       unsigned char *inp,*out,no_key[32],no_iv[16];
+       EVP_CIPHER_CTX ctx;
+       double d=0.0;
+
+       inp = OPENSSL_malloc(mblengths[num-1]);
+       out = OPENSSL_malloc(mblengths[num-1]+1024);
+
+       EVP_CIPHER_CTX_init(&ctx);
+       EVP_EncryptInit_ex(&ctx,evp_cipher,NULL,no_key,no_iv);
+       EVP_CIPHER_CTX_ctrl(&ctx,EVP_CTRL_AEAD_SET_MAC_KEY,sizeof(no_key),no_key);
+       alg_name=OBJ_nid2ln(evp_cipher->nid);
+
+       for (j=0; j<num; j++)
+               {
+               print_message(alg_name,0,mblengths[j]);
+               Time_F(START);
+               for (count=0,run=1; run && count<0x7fffffff; count++)
+                       {
+                       unsigned char aad[13];
+                       EVP_CTRL_TLS1_1_MULTIBLOCK_PARAM mb_param = {NULL,aad,sizeof(aad),0};
+                       size_t len = mblengths[j];
+                       int packlen;
+
+                       aad[8] = 23;
+                       aad[9] = 3;
+                       aad[10] = 2;
+                       aad[11] = 0;
+                       aad[12] = 0;
+                       mb_param.out = NULL;
+                       mb_param.inp = aad;
+                       mb_param.len = len;
+                       mb_param.interleave = 8;
+
+                       packlen=EVP_CIPHER_CTX_ctrl(&ctx,
+                                       EVP_CTRL_TLS1_1_MULTIBLOCK_AAD,
+                                       sizeof(mb_param),&mb_param);
+
+                       if (packlen>0)
+                               {
+                               mb_param.out = out;
+                               mb_param.inp = inp;
+                               mb_param.len = len;
+                               EVP_CIPHER_CTX_ctrl(&ctx,
+                                       EVP_CTRL_TLS1_1_MULTIBLOCK_ENCRYPT,
+                                       sizeof(mb_param),&mb_param);
+                               }
+                       else
+                               {
+                               int pad;
+
+                               RAND_bytes(out,16);
+                               len+=16;
+                               aad[11] = len>>8;
+                               aad[12] = len;
+                               pad=EVP_CIPHER_CTX_ctrl(&ctx,
+                                       EVP_CTRL_AEAD_TLS1_AAD,13,aad);
+                               EVP_Cipher(&ctx,out,inp,len+pad);
+                               }
+                       }
+               d=Time_F(STOP);
+               BIO_printf(bio_err,mr ? "+R:%d:%s:%f\n"
+                       : "%d %s's in %.2fs\n",count,"evp",d);
+               results[D_EVP][j]=((double)count)/d*mblengths[j];
+               }
+
+       if (mr)
+               {
+               fprintf(stdout,"+H");
+               for (j=0; j<num; j++)
+                       fprintf(stdout,":%d",mblengths[j]);
+               fprintf(stdout,"\n");
+               fprintf(stdout,"+F:%d:%s",D_EVP,alg_name);
+               for (j=0; j<num; j++)
+                       fprintf(stdout,":%.2f",results[D_EVP][j]);
+               fprintf(stdout,"\n");
+               }
+       else
+               {
+               fprintf(stdout,"The 'numbers' are in 1000s of bytes per second processed.\n"); 
+               fprintf(stdout,"type                    ");
+               for (j=0;  j<num; j++)
+                       fprintf(stdout,"%7d bytes",mblengths[j]);
+               fprintf(stdout,"\n");
+               fprintf(stdout,"%-24s",alg_name);
+
+               for (j=0; j<num; j++)
+                       {
+                       if (results[D_EVP][j] > 10000)
+                               fprintf(stdout," %11.2fk",results[D_EVP][j]/1e3);
+                       else
+                               fprintf(stdout," %11.2f ",results[D_EVP][j]);
+                       }
+               fprintf(stdout,"\n");
+               }
+
+       OPENSSL_free(inp);
+       OPENSSL_free(out);
+       }
 #endif