ceph/src/spdk/intel-ipsec-mb/md5_one_block.c

   1 /*******************************************************************************
   2   Copyright (c) 2012-2018, Intel Corporation
   3
   4   Redistribution and use in source and binary forms, with or without
   5   modification, are permitted provided that the following conditions are met:
   6
   7       * Redistributions of source code must retain the above copyright notice,
   8         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 the
  11         documentation and/or other materials provided with the distribution.
  12       * Neither the name of Intel Corporation nor the names of its contributors
  13         may be used to endorse or promote products derived from this software
  14         without specific prior written permission.
  15
  16   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  17   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  18   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
  19   DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
  20   FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  21   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
  22   SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
  23   CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
  24   OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  25   OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  26 *******************************************************************************/
  27
  28 #include <stdio.h>
  29 #include <stdint.h>
  30 #include "intel-ipsec-mb.h"
  31
  32 #ifdef LINUX
  33 #define ROTATE(a, n) (((a) << (n)) ^ ((a) >> (32 - (n))))
  34 #else
  35 #include <intrin.h>
  36 #define ROTATE(a, n) _rotl(a, n)
  37 #endif
  38
  39 #define H0 0x67452301
  40 #define H1 0xefcdab89
  41 #define H2 0x98badcfe
  42 #define H3 0x10325476
  43
  44 #define F1(b, c, d)     ((((c) ^ (d)) & (b)) ^ (d))
  45 #define F2(b, c, d)     ((((b) ^ (c)) & (d)) ^ (c))
  46 #define F3(b, c, d)     ((b) ^ (c) ^ (d))
  47 #define F4(b, c, d)     (((~(d)) | (b)) ^ (c))
  48
  49 #define STEP1(a, b, c, d, k, w, r) {            \
  50                 a += w + k + F1(b, c, d);       \
  51                 a = ROTATE(a, r);               \
  52                 a += b;                         \
  53         }
  54 #define STEP2(a, b, c, d, k, w, r) {            \
  55                 a += w + k + F2(b, c, d);       \
  56                 a = ROTATE(a, r);               \
  57                 a += b;                         \
  58         }
  59 #define STEP3(a, b, c, d, k, w, r) {            \
  60                 a += w + k + F3(b, c, d);       \
  61                 a = ROTATE(a, r);               \
  62                 a += b;                         \
  63         }
  64 #define STEP4(a, b, c, d, k, w, r) {            \
  65                 a += w + k + F4(b, c, d);       \
  66                 a = ROTATE(a, r);               \
  67                 a += b;                         \
  68         }
  69
  70 __forceinline
  71 void
  72 md5_one_block_common(const uint8_t *data, uint32_t digest[4])
  73 {
  74         uint32_t a, b, c, d;
  75         uint32_t w00, w01, w02, w03, w04, w05, w06, w07,
  76                 w08, w09, w10, w11, w12, w13, w14, w15;
  77         const uint32_t *data32 = (const uint32_t *)data;
  78
  79         a = H0;
  80         b = H1;
  81         c = H2;
  82         d = H3;
  83
  84         w00 = data32[0];
  85         w01 = data32[1];
  86
  87         STEP1(a, b, c, d, 0xd76aa478, w00, 7);
  88         w02 = data32[2];
  89         STEP1(d, a, b, c, 0xe8c7b756, w01, 12);
  90         w03 = data32[3];
  91         STEP1(c, d, a, b, 0x242070db, w02, 17);
  92         w04 = data32[4];
  93         STEP1(b, c, d, a, 0xc1bdceee, w03, 22);
  94         w05 = data32[5];
  95         STEP1(a, b, c, d, 0xf57c0faf, w04, 7);
  96         w06 = data32[6];
  97         STEP1(d, a, b, c, 0x4787c62a, w05, 12);
  98         w07 = data32[7];
  99         STEP1(c, d, a, b, 0xa8304613, w06, 17);
 100         w08 = data32[8];
 101         STEP1(b, c, d, a, 0xfd469501, w07, 22);
 102         w09 = data32[9];
 103         STEP1(a, b, c, d, 0x698098d8, w08, 7);
 104         w10 = data32[10];
 105         STEP1(d, a, b, c, 0x8b44f7af, w09, 12);
 106         w11 = data32[11];
 107         STEP1(c, d, a, b, 0xffff5bb1, w10, 17);
 108         w12 = data32[12];
 109         STEP1(b, c, d, a, 0x895cd7be, w11, 22);
 110         w13 = data32[13];
 111         STEP1(a, b, c, d, 0x6b901122, w12, 7);
 112         w14 = data32[14];
 113         STEP1(d, a, b, c, 0xfd987193, w13, 12);
 114         w15 = data32[15];
 115         STEP1(c, d, a, b, 0xa679438e, w14, 17);
 116         STEP1(b, c, d, a, 0x49b40821, w15, 22);
 117         STEP2(a, b, c, d, 0xf61e2562, w01, 5);
 118         STEP2(d, a, b, c, 0xc040b340, w06, 9);
 119         STEP2(c, d, a, b, 0x265e5a51, w11, 14);
 120         STEP2(b, c, d, a, 0xe9b6c7aa, w00, 20);
 121         STEP2(a, b, c, d, 0xd62f105d, w05, 5);
 122         STEP2(d, a, b, c, 0x02441453, w10, 9);
 123         STEP2(c, d, a, b, 0xd8a1e681, w15, 14);
 124         STEP2(b, c, d, a, 0xe7d3fbc8, w04, 20);
 125         STEP2(a, b, c, d, 0x21e1cde6, w09, 5);
 126         STEP2(d, a, b, c, 0xc33707d6, w14, 9);
 127         STEP2(c, d, a, b, 0xf4d50d87, w03, 14);
 128         STEP2(b, c, d, a, 0x455a14ed, w08, 20);
 129         STEP2(a, b, c, d, 0xa9e3e905, w13, 5);
 130         STEP2(d, a, b, c, 0xfcefa3f8, w02, 9);
 131         STEP2(c, d, a, b, 0x676f02d9, w07, 14);
 132         STEP2(b, c, d, a, 0x8d2a4c8a, w12, 20);
 133         STEP3(a, b, c, d, 0xfffa3942, w05, 4);
 134         STEP3(d, a, b, c, 0x8771f681, w08, 11);
 135         STEP3(c, d, a, b, 0x6d9d6122, w11, 16);
 136         STEP3(b, c, d, a, 0xfde5380c, w14, 23);
 137         STEP3(a, b, c, d, 0xa4beea44, w01, 4);
 138         STEP3(d, a, b, c, 0x4bdecfa9, w04, 11);
 139         STEP3(c, d, a, b, 0xf6bb4b60, w07, 16);
 140         STEP3(b, c, d, a, 0xbebfbc70, w10, 23);
 141         STEP3(a, b, c, d, 0x289b7ec6, w13, 4);
 142         STEP3(d, a, b, c, 0xeaa127fa, w00, 11);
 143         STEP3(c, d, a, b, 0xd4ef3085, w03, 16);
 144         STEP3(b, c, d, a, 0x04881d05, w06, 23);
 145         STEP3(a, b, c, d, 0xd9d4d039, w09, 4);
 146         STEP3(d, a, b, c, 0xe6db99e5, w12, 11);
 147         STEP3(c, d, a, b, 0x1fa27cf8, w15, 16);
 148         STEP3(b, c, d, a, 0xc4ac5665, w02, 23);
 149         STEP4(a, b, c, d, 0xf4292244, w00, 6);
 150         STEP4(d, a, b, c, 0x432aff97, w07, 10);
 151         STEP4(c, d, a, b, 0xab9423a7, w14, 15);
 152         STEP4(b, c, d, a, 0xfc93a039, w05, 21);
 153         STEP4(a, b, c, d, 0x655b59c3, w12, 6);
 154         STEP4(d, a, b, c, 0x8f0ccc92, w03, 10);
 155         STEP4(c, d, a, b, 0xffeff47d, w10, 15);
 156         STEP4(b, c, d, a, 0x85845dd1, w01, 21);
 157         STEP4(a, b, c, d, 0x6fa87e4f, w08, 6);
 158         STEP4(d, a, b, c, 0xfe2ce6e0, w15, 10);
 159         STEP4(c, d, a, b, 0xa3014314, w06, 15);
 160         STEP4(b, c, d, a, 0x4e0811a1, w13, 21);
 161         STEP4(a, b, c, d, 0xf7537e82, w04, 6);
 162         STEP4(d, a, b, c, 0xbd3af235, w11, 10);
 163         STEP4(c, d, a, b, 0x2ad7d2bb, w02, 15);
 164         STEP4(b, c, d, a, 0xeb86d391, w09, 21);
 165
 166         digest[0] = a + H0;
 167         digest[1] = b + H1;
 168         digest[2] = c + H2;
 169         digest[3] = d + H3;
 170 }
 171
 172 void
 173 md5_one_block_sse(const void *data, void *digest)
 174 {
 175         md5_one_block_common(data, digest);
 176 }
 177
 178 void
 179 md5_one_block_avx(const void *data, void *digest)
 180 {
 181         md5_one_block_common(data, digest);
 182 }
 183
 184 void
 185 md5_one_block_avx2(const void *data, void *digest)
 186 {
 187         md5_one_block_common(data, digest);
 188 }
 189
 190 void
 191 md5_one_block_avx512(const void *data, void *digest)
 192 {
 193         md5_one_block_common(data, digest);
 194 }