crypto/evp/e_camellia.c

   1 /*
   2  * Copyright 2006-2018 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the Apache License 2.0 (the "License").  You may not use
   5  * this file except in compliance with the License.  You can obtain a copy
   6  * in the file LICENSE in the source distribution or at
   7  * https://www.openssl.org/source/license.html
   8  */
   9
  10 #include <openssl/opensslconf.h>
  11 #ifdef OPENSSL_NO_CAMELLIA
  12 NON_EMPTY_TRANSLATION_UNIT
  13 #else
  14
  15 # include <openssl/evp.h>
  16 # include <openssl/err.h>
  17 # include <string.h>
  18 # include <assert.h>
  19 # include <openssl/camellia.h>
  20 # include "internal/evp_int.h"
  21 # include "internal/modes_int.h"
  22
  23 static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  24                              const unsigned char *iv, int enc);
  25
  26 /* Camellia subkey Structure */
  27 typedef struct {
  28     CAMELLIA_KEY ks;
  29     block128_f block;
  30     union {
  31         cbc128_f cbc;
  32         ctr128_f ctr;
  33     } stream;
  34 } EVP_CAMELLIA_KEY;
  35
  36 # define MAXBITCHUNK     ((size_t)1<<(sizeof(size_t)*8-4))
  37
  38 /* Attribute operation for Camellia */
  39 # define data(ctx)       EVP_C_DATA(EVP_CAMELLIA_KEY,ctx)
  40
  41 # if defined(AES_ASM) && (defined(__sparc) || defined(__sparc__))
  42 /* ---------^^^ this is not a typo, just a way to detect that
  43  * assembler support was in general requested... */
  44 #  include "sparc_arch.h"
  45
  46 extern unsigned int OPENSSL_sparcv9cap_P[];
  47
  48 #  define SPARC_CMLL_CAPABLE      (OPENSSL_sparcv9cap_P[1] & CFR_CAMELLIA)
  49
  50 void cmll_t4_set_key(const unsigned char *key, int bits, CAMELLIA_KEY *ks);
  51 void cmll_t4_encrypt(const unsigned char *in, unsigned char *out,
  52                      const CAMELLIA_KEY *key);
  53 void cmll_t4_decrypt(const unsigned char *in, unsigned char *out,
  54                      const CAMELLIA_KEY *key);
  55
  56 void cmll128_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
  57                             size_t len, const CAMELLIA_KEY *key,
  58                             unsigned char *ivec);
  59 void cmll128_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
  60                             size_t len, const CAMELLIA_KEY *key,
  61                             unsigned char *ivec);
  62 void cmll256_t4_cbc_encrypt(const unsigned char *in, unsigned char *out,
  63                             size_t len, const CAMELLIA_KEY *key,
  64                             unsigned char *ivec);
  65 void cmll256_t4_cbc_decrypt(const unsigned char *in, unsigned char *out,
  66                             size_t len, const CAMELLIA_KEY *key,
  67                             unsigned char *ivec);
  68 void cmll128_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
  69                               size_t blocks, const CAMELLIA_KEY *key,
  70                               unsigned char *ivec);
  71 void cmll256_t4_ctr32_encrypt(const unsigned char *in, unsigned char *out,
  72                               size_t blocks, const CAMELLIA_KEY *key,
  73                               unsigned char *ivec);
  74
  75 static int cmll_t4_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  76                             const unsigned char *iv, int enc)
  77 {
  78     int ret, mode, bits;
  79     EVP_CAMELLIA_KEY *dat =
  80         (EVP_CAMELLIA_KEY *)EVP_CIPHER_CTX_get_cipher_data(ctx);
  81
  82     mode = EVP_CIPHER_CTX_mode(ctx);
  83     bits = EVP_CIPHER_CTX_key_length(ctx) * 8;
  84
  85     cmll_t4_set_key(key, bits, &dat->ks);
  86
  87     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
  88         && !enc) {
  89         ret = 0;
  90         dat->block = (block128_f) cmll_t4_decrypt;
  91         switch (bits) {
  92         case 128:
  93             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
  94                 (cbc128_f) cmll128_t4_cbc_decrypt : NULL;
  95             break;
  96         case 192:
  97         case 256:
  98             dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
  99                 (cbc128_f) cmll256_t4_cbc_decrypt : NULL;
 100             break;
 101         default:
 102             ret = -1;
 103         }
 104     } else {
 105         ret = 0;
 106         dat->block = (block128_f) cmll_t4_encrypt;
 107         switch (bits) {
 108         case 128:
 109             if (mode == EVP_CIPH_CBC_MODE)
 110                 dat->stream.cbc = (cbc128_f) cmll128_t4_cbc_encrypt;
 111             else if (mode == EVP_CIPH_CTR_MODE)
 112                 dat->stream.ctr = (ctr128_f) cmll128_t4_ctr32_encrypt;
 113             else
 114                 dat->stream.cbc = NULL;
 115             break;
 116         case 192:
 117         case 256:
 118             if (mode == EVP_CIPH_CBC_MODE)
 119                 dat->stream.cbc = (cbc128_f) cmll256_t4_cbc_encrypt;
 120             else if (mode == EVP_CIPH_CTR_MODE)
 121                 dat->stream.ctr = (ctr128_f) cmll256_t4_ctr32_encrypt;
 122             else
 123                 dat->stream.cbc = NULL;
 124             break;
 125         default:
 126             ret = -1;
 127         }
 128     }
 129
 130     if (ret < 0) {
 131         EVPerr(EVP_F_CMLL_T4_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED);
 132         return 0;
 133     }
 134
 135     return 1;
 136 }
 137
 138 #  define cmll_t4_cbc_cipher camellia_cbc_cipher
 139 static int cmll_t4_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 140                               const unsigned char *in, size_t len);
 141
 142 #  define cmll_t4_ecb_cipher camellia_ecb_cipher
 143 static int cmll_t4_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 144                               const unsigned char *in, size_t len);
 145
 146 #  define cmll_t4_ofb_cipher camellia_ofb_cipher
 147 static int cmll_t4_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 148                               const unsigned char *in, size_t len);
 149
 150 #  define cmll_t4_cfb_cipher camellia_cfb_cipher
 151 static int cmll_t4_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 152                               const unsigned char *in, size_t len);
 153
 154 #  define cmll_t4_cfb8_cipher camellia_cfb8_cipher
 155 static int cmll_t4_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 156                                const unsigned char *in, size_t len);
 157
 158 #  define cmll_t4_cfb1_cipher camellia_cfb1_cipher
 159 static int cmll_t4_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 160                                const unsigned char *in, size_t len);
 161
 162 #  define cmll_t4_ctr_cipher camellia_ctr_cipher
 163 static int cmll_t4_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 164                               const unsigned char *in, size_t len);
 165
 166 #  define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 167 static const EVP_CIPHER cmll_t4_##keylen##_##mode = { \
 168         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 169         flags|EVP_CIPH_##MODE##_MODE,   \
 170         cmll_t4_init_key,               \
 171         cmll_t4_##mode##_cipher,        \
 172         NULL,                           \
 173         sizeof(EVP_CAMELLIA_KEY),       \
 174         NULL,NULL,NULL,NULL }; \
 175 static const EVP_CIPHER camellia_##keylen##_##mode = { \
 176         nid##_##keylen##_##nmode,blocksize,     \
 177         keylen/8,ivlen, \
 178         flags|EVP_CIPH_##MODE##_MODE,   \
 179         camellia_init_key,              \
 180         camellia_##mode##_cipher,       \
 181         NULL,                           \
 182         sizeof(EVP_CAMELLIA_KEY),       \
 183         NULL,NULL,NULL,NULL }; \
 184 const EVP_CIPHER *EVP_camellia_##keylen##_##mode(void) \
 185 { return SPARC_CMLL_CAPABLE?&cmll_t4_##keylen##_##mode:&camellia_##keylen##_##mode; }
 186
 187 # else
 188
 189 #  define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 190 static const EVP_CIPHER camellia_##keylen##_##mode = { \
 191         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 192         flags|EVP_CIPH_##MODE##_MODE,   \
 193         camellia_init_key,              \
 194         camellia_##mode##_cipher,       \
 195         NULL,                           \
 196         sizeof(EVP_CAMELLIA_KEY),       \
 197         NULL,NULL,NULL,NULL }; \
 198 const EVP_CIPHER *EVP_camellia_##keylen##_##mode(void) \
 199 { return &camellia_##keylen##_##mode; }
 200
 201 # endif
 202
 203 # define BLOCK_CIPHER_generic_pack(nid,keylen,flags)             \
 204         BLOCK_CIPHER_generic(nid,keylen,16,16,cbc,cbc,CBC,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)     \
 205         BLOCK_CIPHER_generic(nid,keylen,16,0,ecb,ecb,ECB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)      \
 206         BLOCK_CIPHER_generic(nid,keylen,1,16,ofb128,ofb,OFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
 207         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb128,cfb,CFB,flags|EVP_CIPH_FLAG_DEFAULT_ASN1)   \
 208         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb1,cfb1,CFB,flags)       \
 209         BLOCK_CIPHER_generic(nid,keylen,1,16,cfb8,cfb8,CFB,flags)       \
 210         BLOCK_CIPHER_generic(nid, keylen, 1, 16, ctr, ctr, CTR, flags)
 211
 212 /* The subkey for Camellia is generated. */
 213 static int camellia_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
 214                              const unsigned char *iv, int enc)
 215 {
 216     int ret, mode;
 217     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 218
 219     ret = Camellia_set_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8, &dat->ks);
 220     if (ret < 0) {
 221         EVPerr(EVP_F_CAMELLIA_INIT_KEY, EVP_R_CAMELLIA_KEY_SETUP_FAILED);
 222         return 0;
 223     }
 224
 225     mode = EVP_CIPHER_CTX_mode(ctx);
 226     if ((mode == EVP_CIPH_ECB_MODE || mode == EVP_CIPH_CBC_MODE)
 227         && !enc) {
 228         dat->block = (block128_f) Camellia_decrypt;
 229         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 230             (cbc128_f) Camellia_cbc_encrypt : NULL;
 231     } else {
 232         dat->block = (block128_f) Camellia_encrypt;
 233         dat->stream.cbc = mode == EVP_CIPH_CBC_MODE ?
 234             (cbc128_f) Camellia_cbc_encrypt : NULL;
 235     }
 236
 237     return 1;
 238 }
 239
 240 static int camellia_cbc_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 241                                const unsigned char *in, size_t len)
 242 {
 243     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 244
 245     if (dat->stream.cbc)
 246         (*dat->stream.cbc) (in, out, len, &dat->ks,
 247                             EVP_CIPHER_CTX_iv_noconst(ctx),
 248                             EVP_CIPHER_CTX_encrypting(ctx));
 249     else if (EVP_CIPHER_CTX_encrypting(ctx))
 250         CRYPTO_cbc128_encrypt(in, out, len, &dat->ks,
 251                               EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);
 252     else
 253         CRYPTO_cbc128_decrypt(in, out, len, &dat->ks,
 254                               EVP_CIPHER_CTX_iv_noconst(ctx), dat->block);
 255
 256     return 1;
 257 }
 258
 259 static int camellia_ecb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 260                                const unsigned char *in, size_t len)
 261 {
 262     size_t bl = EVP_CIPHER_CTX_block_size(ctx);
 263     size_t i;
 264     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 265
 266     if (len < bl)
 267         return 1;
 268
 269     for (i = 0, len -= bl; i <= len; i += bl)
 270         (*dat->block) (in + i, out + i, &dat->ks);
 271
 272     return 1;
 273 }
 274
 275 static int camellia_ofb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 276                                const unsigned char *in, size_t len)
 277 {
 278     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 279
 280     int num = EVP_CIPHER_CTX_num(ctx);
 281     CRYPTO_ofb128_encrypt(in, out, len, &dat->ks,
 282                           EVP_CIPHER_CTX_iv_noconst(ctx), &num, dat->block);
 283     EVP_CIPHER_CTX_set_num(ctx, num);
 284     return 1;
 285 }
 286
 287 static int camellia_cfb_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 288                                const unsigned char *in, size_t len)
 289 {
 290     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 291
 292     int num = EVP_CIPHER_CTX_num(ctx);
 293     CRYPTO_cfb128_encrypt(in, out, len, &dat->ks,
 294                           EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);
 295     EVP_CIPHER_CTX_set_num(ctx, num);
 296     return 1;
 297 }
 298
 299 static int camellia_cfb8_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 300                                 const unsigned char *in, size_t len)
 301 {
 302     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 303
 304     int num = EVP_CIPHER_CTX_num(ctx);
 305     CRYPTO_cfb128_8_encrypt(in, out, len, &dat->ks,
 306                             EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);
 307     EVP_CIPHER_CTX_set_num(ctx, num);
 308     return 1;
 309 }
 310
 311 static int camellia_cfb1_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 312                                 const unsigned char *in, size_t len)
 313 {
 314     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 315
 316     if (EVP_CIPHER_CTX_test_flags(ctx, EVP_CIPH_FLAG_LENGTH_BITS)) {
 317         int num = EVP_CIPHER_CTX_num(ctx);
 318         CRYPTO_cfb128_1_encrypt(in, out, len, &dat->ks,
 319                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);
 320         EVP_CIPHER_CTX_set_num(ctx, num);
 321         return 1;
 322     }
 323
 324     while (len >= MAXBITCHUNK) {
 325         int num = EVP_CIPHER_CTX_num(ctx);
 326         CRYPTO_cfb128_1_encrypt(in, out, MAXBITCHUNK * 8, &dat->ks,
 327                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);
 328         EVP_CIPHER_CTX_set_num(ctx, num);
 329         len -= MAXBITCHUNK;
 330         out += MAXBITCHUNK;
 331         in  += MAXBITCHUNK;
 332     }
 333     if (len) {
 334         int num = EVP_CIPHER_CTX_num(ctx);
 335         CRYPTO_cfb128_1_encrypt(in, out, len * 8, &dat->ks,
 336                                 EVP_CIPHER_CTX_iv_noconst(ctx), &num, EVP_CIPHER_CTX_encrypting(ctx), dat->block);
 337         EVP_CIPHER_CTX_set_num(ctx, num);
 338     }
 339
 340     return 1;
 341 }
 342
 343 static int camellia_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 344                                const unsigned char *in, size_t len)
 345 {
 346     unsigned int num = EVP_CIPHER_CTX_num(ctx);
 347     EVP_CAMELLIA_KEY *dat = EVP_C_DATA(EVP_CAMELLIA_KEY,ctx);
 348
 349     if (dat->stream.ctr)
 350         CRYPTO_ctr128_encrypt_ctr32(in, out, len, &dat->ks,
 351                                     EVP_CIPHER_CTX_iv_noconst(ctx),
 352                                     EVP_CIPHER_CTX_buf_noconst(ctx), &num,
 353                                     dat->stream.ctr);
 354     else
 355         CRYPTO_ctr128_encrypt(in, out, len, &dat->ks,
 356                               EVP_CIPHER_CTX_iv_noconst(ctx),
 357                               EVP_CIPHER_CTX_buf_noconst(ctx), &num,
 358                               dat->block);
 359     EVP_CIPHER_CTX_set_num(ctx, num);
 360     return 1;
 361 }
 362
 363 BLOCK_CIPHER_generic_pack(NID_camellia, 128, 0)
 364     BLOCK_CIPHER_generic_pack(NID_camellia, 192, 0)
 365     BLOCK_CIPHER_generic_pack(NID_camellia, 256, 0)
 366 #endif