sha3/sph_simd.h

   1 /* $Id: sph_simd.h 154 2010-04-26 17:00:24Z tp $ */
   2 /**
   3  * SIMD interface. SIMD is a family of functions which differ by
   4  * their output size; this implementation defines SIMD for output
   5  * sizes 224, 256, 384 and 512 bits.
   6  *
   7  * ==========================(LICENSE BEGIN)============================
   8  *
   9  * Copyright (c) 2007-2010  Projet RNRT SAPHIR
  10  *
  11  * Permission is hereby granted, free of charge, to any person obtaining
  12  * a copy of this software and associated documentation files (the
  13  * "Software"), to deal in the Software without restriction, including
  14  * without limitation the rights to use, copy, modify, merge, publish,
  15  * distribute, sublicense, and/or sell copies of the Software, and to
  16  * permit persons to whom the Software is furnished to do so, subject to
  17  * the following conditions:
  18  *
  19  * The above copyright notice and this permission notice shall be
  20  * included in all copies or substantial portions of the Software.
  21  *
  22  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  23  * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  24  * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
  25  * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
  26  * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
  27  * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
  28  * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  29  *
  30  * ===========================(LICENSE END)=============================
  31  *
  32  * @file     sph_simd.h
  33  * @author   Thomas Pornin <[email protected]>
  34  */
  35
  36 #ifndef SPH_SIMD_H__
  37 #define SPH_SIMD_H__
  38
  39 #ifdef __cplusplus
  40 extern "C"{
  41 #endif
  42
  43 #include <stddef.h>
  44 #include "sph_types.h"
  45
  46 /**
  47  * Output size (in bits) for SIMD-224.
  48  */
  49 #define SPH_SIZE_simd224   224
  50
  51 /**
  52  * Output size (in bits) for SIMD-256.
  53  */
  54 #define SPH_SIZE_simd256   256
  55
  56 /**
  57  * Output size (in bits) for SIMD-384.
  58  */
  59 #define SPH_SIZE_simd384   384
  60
  61 /**
  62  * Output size (in bits) for SIMD-512.
  63  */
  64 #define SPH_SIZE_simd512   512
  65
  66 /**
  67  * This structure is a context for SIMD computations: it contains the
  68  * intermediate values and some data from the last entered block. Once
  69  * an SIMD computation has been performed, the context can be reused for
  70  * another computation. This specific structure is used for SIMD-224
  71  * and SIMD-256.
  72  *
  73  * The contents of this structure are private. A running SIMD computation
  74  * can be cloned by copying the context (e.g. with a simple
  75  * <code>memcpy()</code>).
  76  */
  77 typedef struct {
  78 #ifndef DOXYGEN_IGNORE
  79         unsigned char buf[64];    /* first field, for alignment */
  80         size_t ptr;
  81         sph_u32 state[16];
  82         sph_u32 count_low, count_high;
  83 #endif
  84 } sph_simd_small_context;
  85
  86 /**
  87  * This structure is a context for SIMD computations: it contains the
  88  * intermediate values and some data from the last entered block. Once
  89  * an SIMD computation has been performed, the context can be reused for
  90  * another computation. This specific structure is used for SIMD-384
  91  * and SIMD-512.
  92  *
  93  * The contents of this structure are private. A running SIMD computation
  94  * can be cloned by copying the context (e.g. with a simple
  95  * <code>memcpy()</code>).
  96  */
  97 typedef struct {
  98 #ifndef DOXYGEN_IGNORE
  99         unsigned char buf[128];    /* first field, for alignment */
 100         size_t ptr;
 101         sph_u32 state[32];
 102         sph_u32 count_low, count_high;
 103 #endif
 104 } sph_simd_big_context;
 105
 106 /**
 107  * Type for a SIMD-224 context (identical to the common "small" context).
 108  */
 109 typedef sph_simd_small_context sph_simd224_context;
 110
 111 /**
 112  * Type for a SIMD-256 context (identical to the common "small" context).
 113  */
 114 typedef sph_simd_small_context sph_simd256_context;
 115
 116 /**
 117  * Type for a SIMD-384 context (identical to the common "big" context).
 118  */
 119 typedef sph_simd_big_context sph_simd384_context;
 120
 121 /**
 122  * Type for a SIMD-512 context (identical to the common "big" context).
 123  */
 124 typedef sph_simd_big_context sph_simd512_context;
 125
 126 /**
 127  * Initialize an SIMD-224 context. This process performs no memory allocation.
 128  *
 129  * @param cc   the SIMD-224 context (pointer to a
 130  *             <code>sph_simd224_context</code>)
 131  */
 132 void sph_simd224_init(void *cc);
 133
 134 /**
 135  * Process some data bytes. It is acceptable that <code>len</code> is zero
 136  * (in which case this function does nothing).
 137  *
 138  * @param cc     the SIMD-224 context
 139  * @param data   the input data
 140  * @param len    the input data length (in bytes)
 141  */
 142 void sph_simd224(void *cc, const void *data, size_t len);
 143
 144 /**
 145  * Terminate the current SIMD-224 computation and output the result into
 146  * the provided buffer. The destination buffer must be wide enough to
 147  * accomodate the result (28 bytes). The context is automatically
 148  * reinitialized.
 149  *
 150  * @param cc    the SIMD-224 context
 151  * @param dst   the destination buffer
 152  */
 153 void sph_simd224_close(void *cc, void *dst);
 154
 155 /**
 156  * Add a few additional bits (0 to 7) to the current computation, then
 157  * terminate it and output the result in the provided buffer, which must
 158  * be wide enough to accomodate the result (28 bytes). If bit number i
 159  * in <code>ub</code> has value 2^i, then the extra bits are those
 160  * numbered 7 downto 8-n (this is the big-endian convention at the byte
 161  * level). The context is automatically reinitialized.
 162  *
 163  * @param cc    the SIMD-224 context
 164  * @param ub    the extra bits
 165  * @param n     the number of extra bits (0 to 7)
 166  * @param dst   the destination buffer
 167  */
 168 void sph_simd224_addbits_and_close(
 169         void *cc, unsigned ub, unsigned n, void *dst);
 170
 171 /**
 172  * Initialize an SIMD-256 context. This process performs no memory allocation.
 173  *
 174  * @param cc   the SIMD-256 context (pointer to a
 175  *             <code>sph_simd256_context</code>)
 176  */
 177 void sph_simd256_init(void *cc);
 178
 179 /**
 180  * Process some data bytes. It is acceptable that <code>len</code> is zero
 181  * (in which case this function does nothing).
 182  *
 183  * @param cc     the SIMD-256 context
 184  * @param data   the input data
 185  * @param len    the input data length (in bytes)
 186  */
 187 void sph_simd256(void *cc, const void *data, size_t len);
 188
 189 /**
 190  * Terminate the current SIMD-256 computation and output the result into
 191  * the provided buffer. The destination buffer must be wide enough to
 192  * accomodate the result (32 bytes). The context is automatically
 193  * reinitialized.
 194  *
 195  * @param cc    the SIMD-256 context
 196  * @param dst   the destination buffer
 197  */
 198 void sph_simd256_close(void *cc, void *dst);
 199
 200 /**
 201  * Add a few additional bits (0 to 7) to the current computation, then
 202  * terminate it and output the result in the provided buffer, which must
 203  * be wide enough to accomodate the result (32 bytes). If bit number i
 204  * in <code>ub</code> has value 2^i, then the extra bits are those
 205  * numbered 7 downto 8-n (this is the big-endian convention at the byte
 206  * level). The context is automatically reinitialized.
 207  *
 208  * @param cc    the SIMD-256 context
 209  * @param ub    the extra bits
 210  * @param n     the number of extra bits (0 to 7)
 211  * @param dst   the destination buffer
 212  */
 213 void sph_simd256_addbits_and_close(
 214         void *cc, unsigned ub, unsigned n, void *dst);
 215
 216 /**
 217  * Initialize an SIMD-384 context. This process performs no memory allocation.
 218  *
 219  * @param cc   the SIMD-384 context (pointer to a
 220  *             <code>sph_simd384_context</code>)
 221  */
 222 void sph_simd384_init(void *cc);
 223
 224 /**
 225  * Process some data bytes. It is acceptable that <code>len</code> is zero
 226  * (in which case this function does nothing).
 227  *
 228  * @param cc     the SIMD-384 context
 229  * @param data   the input data
 230  * @param len    the input data length (in bytes)
 231  */
 232 void sph_simd384(void *cc, const void *data, size_t len);
 233
 234 /**
 235  * Terminate the current SIMD-384 computation and output the result into
 236  * the provided buffer. The destination buffer must be wide enough to
 237  * accomodate the result (48 bytes). The context is automatically
 238  * reinitialized.
 239  *
 240  * @param cc    the SIMD-384 context
 241  * @param dst   the destination buffer
 242  */
 243 void sph_simd384_close(void *cc, void *dst);
 244
 245 /**
 246  * Add a few additional bits (0 to 7) to the current computation, then
 247  * terminate it and output the result in the provided buffer, which must
 248  * be wide enough to accomodate the result (48 bytes). If bit number i
 249  * in <code>ub</code> has value 2^i, then the extra bits are those
 250  * numbered 7 downto 8-n (this is the big-endian convention at the byte
 251  * level). The context is automatically reinitialized.
 252  *
 253  * @param cc    the SIMD-384 context
 254  * @param ub    the extra bits
 255  * @param n     the number of extra bits (0 to 7)
 256  * @param dst   the destination buffer
 257  */
 258 void sph_simd384_addbits_and_close(
 259         void *cc, unsigned ub, unsigned n, void *dst);
 260
 261 /**
 262  * Initialize an SIMD-512 context. This process performs no memory allocation.
 263  *
 264  * @param cc   the SIMD-512 context (pointer to a
 265  *             <code>sph_simd512_context</code>)
 266  */
 267 void sph_simd512_init(void *cc);
 268
 269 /**
 270  * Process some data bytes. It is acceptable that <code>len</code> is zero
 271  * (in which case this function does nothing).
 272  *
 273  * @param cc     the SIMD-512 context
 274  * @param data   the input data
 275  * @param len    the input data length (in bytes)
 276  */
 277 void sph_simd512(void *cc, const void *data, size_t len);
 278
 279 /**
 280  * Terminate the current SIMD-512 computation and output the result into
 281  * the provided buffer. The destination buffer must be wide enough to
 282  * accomodate the result (64 bytes). The context is automatically
 283  * reinitialized.
 284  *
 285  * @param cc    the SIMD-512 context
 286  * @param dst   the destination buffer
 287  */
 288 void sph_simd512_close(void *cc, void *dst);
 289
 290 /**
 291  * Add a few additional bits (0 to 7) to the current computation, then
 292  * terminate it and output the result in the provided buffer, which must
 293  * be wide enough to accomodate the result (64 bytes). If bit number i
 294  * in <code>ub</code> has value 2^i, then the extra bits are those
 295  * numbered 7 downto 8-n (this is the big-endian convention at the byte
 296  * level). The context is automatically reinitialized.
 297  *
 298  * @param cc    the SIMD-512 context
 299  * @param ub    the extra bits
 300  * @param n     the number of extra bits (0 to 7)
 301  * @param dst   the destination buffer
 302  */
 303 void sph_simd512_addbits_and_close(
 304         void *cc, unsigned ub, unsigned n, void *dst);
 305 #ifdef __cplusplus
 306 }
 307 #endif
 308
 309 #endif