src/third_party/boringssl/src/include/openssl/modes.h

   1 /* ====================================================================
   2  * Copyright (c) 2008 The OpenSSL Project.  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  *
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  *
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in
  13  *    the documentation and/or other materials provided with the
  14  *    distribution.
  15  *
  16  * 3. All advertising materials mentioning features or use of this
  17  *    software must display the following acknowledgment:
  18  *    "This product includes software developed by the OpenSSL Project
  19  *    for use in the OpenSSL Toolkit. (http://www.openssl.org/)"
  20  *
  21  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
  22  *    endorse or promote products derived from this software without
  23  *    prior written permission. For written permission, please contact
  24  *    openssl-core@openssl.org.
  25  *
  26  * 5. Products derived from this software may not be called "OpenSSL"
  27  *    nor may "OpenSSL" appear in their names without prior written
  28  *    permission of the OpenSSL Project.
  29  *
  30  * 6. Redistributions of any form whatsoever must retain the following
  31  *    acknowledgment:
  32  *    "This product includes software developed by the OpenSSL Project
  33  *    for use in the OpenSSL Toolkit (http://www.openssl.org/)"
  34  *
  35  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
  36  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  37  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  38  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
  39  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  40  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  41  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
  42  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  43  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
  44  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  45  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
  46  * OF THE POSSIBILITY OF SUCH DAMAGE.
  47  * ==================================================================== */
  48
  49 #ifndef OPENSSL_HEADER_MODES_H
  50 #define OPENSSL_HEADER_MODES_H
  51
  52 #include <openssl/base.h>
  53
  54 #if defined(__cplusplus)
  55 extern "C" {
  56 #endif
  57
  58
  59 /* modes.h contains functions that implement various block-cipher modes. */
  60
  61
  62 /* block128_f is the type of a 128-bit, block cipher. */
  63 typedef void (*block128_f)(const uint8_t in[16], uint8_t out[16],
  64                            const void *key);
  65
  66
  67 /* CTR. */
  68
  69 /* ctr128_f is the type of a function that performs CTR-mode encryption. */
  70 typedef void (*ctr128_f)(const uint8_t *in, uint8_t *out, size_t blocks,
  71                          const void *key, const uint8_t ivec[16]);
  72
  73 /* CRYPTO_ctr128_encrypt encrypts (or decrypts, it's the same in CTR mode)
  74  * |len| bytes from |in| to |out| using |block| in counter mode. There's no
  75  * requirement that |len| be a multiple of any value and any partial blocks are
  76  * stored in |ecount_buf| and |*num|, which must be zeroed before the initial
  77  * call. The counter is a 128-bit, big-endian value in |ivec| and is
  78  * incremented by this function. */
  79 OPENSSL_EXPORT void CRYPTO_ctr128_encrypt(const uint8_t *in, uint8_t *out,
  80                                           size_t len, const void *key,
  81                                           uint8_t ivec[16],
  82                                           uint8_t ecount_buf[16],
  83                                           unsigned int *num, block128_f block);
  84
  85 /* CRYPTO_ctr128_encrypt_ctr32 acts like |CRYPTO_ctr128_encrypt| but takes
  86  * |ctr|, a function that performs CTR mode but only deals with the lower 32
  87  * bits of the counter. This is useful when |ctr| can be an optimised
  88  * function. */
  89 OPENSSL_EXPORT void CRYPTO_ctr128_encrypt_ctr32(
  90     const uint8_t *in, uint8_t *out, size_t len, const void *key,
  91     uint8_t ivec[16], uint8_t ecount_buf[16], unsigned int *num, ctr128_f ctr);
  92
  93
  94 /* GCM. */
  95
  96 typedef struct gcm128_context GCM128_CONTEXT;
  97
  98 /* CRYPTO_gcm128_new allocates a fresh |GCM128_CONTEXT| and calls
  99  * |CRYPTO_gcm128_init|. It returns the new context, or NULL on error. */
 100 OPENSSL_EXPORT GCM128_CONTEXT *CRYPTO_gcm128_new(void *key, block128_f block);
 101
 102 /* CRYPTO_gcm128_init initialises |ctx| to use |block| (typically AES) with the
 103  * given key. */
 104 OPENSSL_EXPORT void CRYPTO_gcm128_init(GCM128_CONTEXT *ctx, void *key,
 105                                        block128_f block);
 106
 107 /* CRYPTO_gcm128_setiv sets the IV (nonce) for |ctx|. */
 108 OPENSSL_EXPORT void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const uint8_t *iv,
 109                                         size_t len);
 110
 111 /* CRYPTO_gcm128_aad sets the authenticated data for an instance of GCM. This
 112  * must be called before and data is encrypted. It returns one on success and
 113  * zero otherwise. */
 114 OPENSSL_EXPORT int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const uint8_t *aad,
 115                                      size_t len);
 116
 117 /* CRYPTO_gcm128_encrypt encrypts |len| bytes from |in| to |out|. It returns
 118  * one on success and zero otherwise. */
 119 OPENSSL_EXPORT int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const uint8_t *in,
 120                                          uint8_t *out, size_t len);
 121
 122 /* CRYPTO_gcm128_decrypt decrypts |len| bytes from |in| to |out|. It returns
 123  * one on success and zero otherwise. */
 124 OPENSSL_EXPORT int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const uint8_t *in,
 125                                          uint8_t *out, size_t len);
 126
 127 /* CRYPTO_gcm128_encrypt_ctr32 encrypts |len| bytes from |in| to |out| using a
 128  * CTR function that only handles the bottom 32 bits of the nonce, like
 129  * |CRYPTO_ctr128_encrypt_ctr32|. It returns one on success and zero
 130  * otherwise. */
 131 OPENSSL_EXPORT int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx,
 132                                                const uint8_t *in, uint8_t *out,
 133                                                size_t len, ctr128_f stream);
 134
 135 /* CRYPTO_gcm128_decrypt_ctr32 decrypts |len| bytes from |in| to |out| using a
 136  * CTR function that only handles the bottom 32 bits of the nonce, like
 137  * |CRYPTO_ctr128_encrypt_ctr32|. It returns one on success and zero
 138  * otherwise. */
 139 OPENSSL_EXPORT int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx,
 140                                                const uint8_t *in, uint8_t *out,
 141                                                size_t len, ctr128_f stream);
 142
 143 /* CRYPTO_gcm128_finish calculates the authenticator and compares it against
 144  * |len| bytes of |tag|. It returns one on success and zero otherwise. */
 145 OPENSSL_EXPORT int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const uint8_t *tag,
 146                                         size_t len);
 147
 148 /* CRYPTO_gcm128_tag calculates the authenticator and copies it into |tag|. The
 149  * minimum of |len| and 16 bytes are copied into |tag|. */
 150 OPENSSL_EXPORT void CRYPTO_gcm128_tag(GCM128_CONTEXT *ctx, uint8_t *tag,
 151                                       size_t len);
 152
 153 /* CRYPTO_gcm128_release clears and frees |ctx|. */
 154 OPENSSL_EXPORT void CRYPTO_gcm128_release(GCM128_CONTEXT *ctx);
 155
 156
 157 /* CBC. */
 158
 159 /* cbc128_f is the type of a function that performs CBC-mode encryption. */
 160 typedef void (*cbc128_f)(const uint8_t *in, uint8_t *out, size_t len,
 161                          const void *key, uint8_t ivec[16], int enc);
 162
 163 /* CRYPTO_cbc128_encrypt encrypts |len| bytes from |in| to |out| using the
 164  * given IV and block cipher in CBC mode. The input need not be a multiple of
 165  * 128 bits long, but the output will round up to the nearest 128 bit multiple,
 166  * zero padding the input if needed. The IV will be updated on return. */
 167 void CRYPTO_cbc128_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 168                            const void *key, uint8_t ivec[16], block128_f block);
 169
 170 /* CRYPTO_cbc128_decrypt decrypts |len| bytes from |in| to |out| using the
 171  * given IV and block cipher in CBC mode. If |len| is not a multiple of 128
 172  * bits then only that many bytes will be written, but a multiple of 128 bits
 173  * is always read from |in|. The IV will be updated on return. */
 174 void CRYPTO_cbc128_decrypt(const uint8_t *in, uint8_t *out, size_t len,
 175                            const void *key, uint8_t ivec[16], block128_f block);
 176
 177
 178 /* OFB. */
 179
 180 /* CRYPTO_ofb128_encrypt encrypts (or decrypts, it's the same with OFB mode)
 181  * |len| bytes from |in| to |out| using |block| in OFB mode. There's no
 182  * requirement that |len| be a multiple of any value and any partial blocks are
 183  * stored in |ivec| and |*num|, the latter must be zero before the initial
 184  * call. */
 185 void CRYPTO_ofb128_encrypt(const uint8_t *in, uint8_t *out,
 186                            size_t len, const void *key, uint8_t ivec[16],
 187                            int *num, block128_f block);
 188
 189
 190 /* CFB. */
 191
 192 /* CRYPTO_cfb128_encrypt encrypts (or decrypts, if |enc| is zero) |len| bytes
 193  * from |in| to |out| using |block| in CFB mode. There's no requirement that
 194  * |len| be a multiple of any value and any partial blocks are stored in |ivec|
 195  * and |*num|, the latter must be zero before the initial call. */
 196 void CRYPTO_cfb128_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 197                            const void *key, uint8_t ivec[16], int *num, int enc,
 198                            block128_f block);
 199
 200 /* CRYPTO_cfb128_8_encrypt encrypts (or decrypts, if |enc| is zero) |len| bytes
 201  * from |in| to |out| using |block| in CFB-8 mode. Prior to the first call
 202  * |num| should be set to zero. */
 203 void CRYPTO_cfb128_8_encrypt(const uint8_t *in, uint8_t *out, size_t len,
 204                              const void *key, uint8_t ivec[16], int *num,
 205                              int enc, block128_f block);
 206
 207 /* CRYPTO_cfb128_1_encrypt encrypts (or decrypts, if |enc| is zero) |len| bytes
 208  * from |in| to |out| using |block| in CFB-1 mode. Prior to the first call
 209  * |num| should be set to zero. */
 210 void CRYPTO_cfb128_1_encrypt(const uint8_t *in, uint8_t *out, size_t bits,
 211                              const void *key, uint8_t ivec[16], int *num,
 212                              int enc, block128_f block);
 213
 214 size_t CRYPTO_cts128_encrypt_block(const uint8_t *in, uint8_t *out, size_t len,
 215                                    const void *key, uint8_t ivec[16],
 216                                    block128_f block);
 217
 218
 219 #if defined(__cplusplus)
 220 }  /* extern C */
 221 #endif
 222
 223 #endif  /* OPENSSL_HEADER_MODES_H */