crypto/evp/e_aria.c

   1 /*
   2  * Copyright 2006-2017 The OpenSSL Project Authors. All Rights Reserved.
   3  *
   4  * Licensed under the OpenSSL license (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 /* ====================================================================
  11  * Copyright (c) 2017 Oracle and/or its affiliates.  All rights reserved.
  12  */
  13
  14 #include "internal/cryptlib.h"
  15 #ifndef OPENSSL_NO_ARIA
  16 # include <openssl/evp.h>
  17 # include <openssl/modes.h>
  18 # include"internal/aria.h"
  19 # include "internal/evp_int.h"
  20
  21 /* ARIA subkey Structure */
  22 typedef struct {
  23     ARIA_KEY ks;
  24 } EVP_ARIA_KEY;
  25
  26 /* The subkey for ARIA is generated. */
  27 static int aria_init_key(EVP_CIPHER_CTX *ctx, const unsigned char *key,
  28                             const unsigned char *iv, int enc)
  29 {
  30     int ret;
  31     int mode = EVP_CIPHER_CTX_mode(ctx);
  32
  33     if (enc || (mode != EVP_CIPH_ECB_MODE && mode != EVP_CIPH_CBC_MODE))
  34         ret = aria_set_encrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
  35                                         EVP_CIPHER_CTX_get_cipher_data(ctx));
  36     else
  37         ret = aria_set_decrypt_key(key, EVP_CIPHER_CTX_key_length(ctx) * 8,
  38                                         EVP_CIPHER_CTX_get_cipher_data(ctx));
  39     if (ret < 0) {
  40         EVPerr(EVP_F_ARIA_INIT_KEY,EVP_R_ARIA_KEY_SETUP_FAILED);
  41         return 0;
  42     }
  43     return 1;
  44 }
  45
  46 static void aria_cbc_encrypt(const unsigned char *in, unsigned char *out,
  47                              size_t len, const ARIA_KEY *key,
  48                              unsigned char *ivec, const int enc)
  49 {
  50
  51     if (enc)
  52         CRYPTO_cbc128_encrypt(in, out, len, key, ivec,
  53                               (block128_f) aria_encrypt);
  54     else
  55         CRYPTO_cbc128_decrypt(in, out, len, key, ivec,
  56                               (block128_f) aria_encrypt);
  57 }
  58
  59 static void aria_cfb128_encrypt(const unsigned char *in, unsigned char *out,
  60                                 size_t length, const ARIA_KEY *key,
  61                                 unsigned char *ivec, int *num, const int enc)
  62 {
  63
  64     CRYPTO_cfb128_encrypt(in, out, length, key, ivec, num, enc,
  65                           (block128_f) aria_encrypt);
  66 }
  67
  68 static void aria_cfb1_encrypt(const unsigned char *in, unsigned char *out,
  69                               size_t length, const ARIA_KEY *key,
  70                               unsigned char *ivec, int *num, const int enc)
  71 {
  72     CRYPTO_cfb128_1_encrypt(in, out, length, key, ivec, num, enc,
  73                             (block128_f) aria_encrypt);
  74 }
  75
  76 static void aria_cfb8_encrypt(const unsigned char *in, unsigned char *out,
  77                               size_t length, const ARIA_KEY *key,
  78                               unsigned char *ivec, int *num, const int enc)
  79 {
  80     CRYPTO_cfb128_8_encrypt(in, out, length, key, ivec, num, enc,
  81                             (block128_f) aria_encrypt);
  82 }
  83
  84 static void aria_ecb_encrypt(const unsigned char *in, unsigned char *out,
  85                              const ARIA_KEY *key, const int enc)
  86 {
  87     aria_encrypt(in, out, key);
  88 }
  89
  90 static void aria_ofb128_encrypt(const unsigned char *in, unsigned char *out,
  91                              size_t length, const ARIA_KEY *key,
  92                              unsigned char *ivec, int *num)
  93 {
  94     CRYPTO_ofb128_encrypt(in, out, length, key, ivec, num,
  95                          (block128_f) aria_encrypt);
  96 }
  97
  98 IMPLEMENT_BLOCK_CIPHER(aria_128, ks, aria, EVP_ARIA_KEY,
  99                         NID_aria_128, 16, 16, 16, 128,
 100                         0, aria_init_key, NULL,
 101                         EVP_CIPHER_set_asn1_iv,
 102                         EVP_CIPHER_get_asn1_iv,
 103                         NULL)
 104 IMPLEMENT_BLOCK_CIPHER(aria_192, ks, aria, EVP_ARIA_KEY,
 105                         NID_aria_192, 16, 24, 16, 128,
 106                         0, aria_init_key, NULL,
 107                         EVP_CIPHER_set_asn1_iv,
 108                         EVP_CIPHER_get_asn1_iv,
 109                         NULL)
 110 IMPLEMENT_BLOCK_CIPHER(aria_256, ks, aria, EVP_ARIA_KEY,
 111                         NID_aria_256, 16, 32, 16, 128,
 112                         0, aria_init_key, NULL,
 113                         EVP_CIPHER_set_asn1_iv,
 114                         EVP_CIPHER_get_asn1_iv,
 115                         NULL)
 116
 117 # define IMPLEMENT_ARIA_CFBR(ksize,cbits) \
 118                 IMPLEMENT_CFBR(aria,aria,EVP_ARIA_KEY,ks,ksize,cbits,16,0)
 119 IMPLEMENT_ARIA_CFBR(128,1)
 120 IMPLEMENT_ARIA_CFBR(192,1)
 121 IMPLEMENT_ARIA_CFBR(256,1)
 122 IMPLEMENT_ARIA_CFBR(128,8)
 123 IMPLEMENT_ARIA_CFBR(192,8)
 124 IMPLEMENT_ARIA_CFBR(256,8)
 125
 126 # define BLOCK_CIPHER_generic(nid,keylen,blocksize,ivlen,nmode,mode,MODE,flags) \
 127 static const EVP_CIPHER aria_##keylen##_##mode = { \
 128         nid##_##keylen##_##nmode,blocksize,keylen/8,ivlen, \
 129         flags|EVP_CIPH_##MODE##_MODE,   \
 130         aria_init_key,                  \
 131         aria_##mode##_cipher,           \
 132         NULL,                           \
 133         sizeof(EVP_ARIA_KEY),           \
 134         NULL,NULL,NULL,NULL };          \
 135 const EVP_CIPHER *EVP_aria_##keylen##_##mode(void) \
 136 { return &aria_##keylen##_##mode; }
 137
 138 static int aria_ctr_cipher(EVP_CIPHER_CTX *ctx, unsigned char *out,
 139                                const unsigned char *in, size_t len)
 140 {
 141     unsigned int num = EVP_CIPHER_CTX_num(ctx);
 142     EVP_ARIA_KEY *dat = EVP_C_DATA(EVP_ARIA_KEY,ctx);
 143
 144     CRYPTO_ctr128_encrypt(in, out, len, &dat->ks,
 145                           EVP_CIPHER_CTX_iv_noconst(ctx),
 146                           EVP_CIPHER_CTX_buf_noconst(ctx), &num,
 147                           (block128_f) aria_encrypt);
 148     EVP_CIPHER_CTX_set_num(ctx, num);
 149     return 1;
 150 }
 151
 152 BLOCK_CIPHER_generic(NID_aria, 128, 1, 16, ctr, ctr, CTR, 0)
 153 BLOCK_CIPHER_generic(NID_aria, 192, 1, 16, ctr, ctr, CTR, 0)
 154 BLOCK_CIPHER_generic(NID_aria, 256, 1, 16, ctr, ctr, CTR, 0)
 155
 156 #endif