gost_omac.c

   1 #include <string.h>
   2 #include <openssl/cmac.h>
   3 #include <openssl/conf.h>
   4 #include <openssl/err.h>
   5 #include <openssl/evp.h>
   6
   7 #include "e_gost_err.h"
   8 #include "gost_lcl.h"
   9
  10 #define min(a,b) (((a) < (b)) ? (a) : (b))
  11
  12 typedef struct omac_ctx {
  13     CMAC_CTX *cmac_ctx;
  14     size_t dgst_size;
  15     int cipher_nid;
  16     int key_set;
  17 } OMAC_CTX;
  18
  19 #define MAX_GOST_OMAC_SIZE 16
  20
  21 static int omac_init(EVP_MD_CTX *ctx, int cipher_nid)
  22 {
  23     OMAC_CTX *c = EVP_MD_CTX_md_data(ctx);
  24     memset(c, 0, sizeof(OMAC_CTX));
  25     c->cipher_nid = cipher_nid;
  26     c->key_set = 0;
  27
  28     switch (cipher_nid) {
  29     case NID_magma_cbc:
  30         c->dgst_size = 4;
  31         break;
  32
  33     case NID_grasshopper_cbc:
  34         c->dgst_size = 8;
  35         break;
  36     }
  37
  38     return 1;
  39 }
  40
  41 static int magma_imit_init(EVP_MD_CTX *ctx)
  42 {
  43     return omac_init(ctx, NID_magma_cbc);
  44 }
  45
  46 static int grasshopper_imit_init(EVP_MD_CTX *ctx)
  47 {
  48     return omac_init(ctx, NID_grasshopper_cbc);
  49 }
  50
  51 static int omac_imit_update(EVP_MD_CTX *ctx, const void *data, size_t count)
  52 {
  53     OMAC_CTX *c = EVP_MD_CTX_md_data(ctx);
  54     if (!c->key_set) {
  55         GOSTerr(GOST_F_OMAC_IMIT_UPDATE, GOST_R_MAC_KEY_NOT_SET);
  56         return 0;
  57     }
  58
  59     return CMAC_Update(c->cmac_ctx, data, count);
  60 }
  61
  62 int omac_imit_final(EVP_MD_CTX *ctx, unsigned char *md)
  63 {
  64     OMAC_CTX *c = EVP_MD_CTX_md_data(ctx);
  65     unsigned char mac[MAX_GOST_OMAC_SIZE];
  66     size_t mac_size = sizeof(mac);
  67
  68     if (!c->key_set) {
  69         GOSTerr(GOST_F_OMAC_IMIT_FINAL, GOST_R_MAC_KEY_NOT_SET);
  70         return 0;
  71     }
  72
  73     CMAC_Final(c->cmac_ctx, mac, &mac_size);
  74
  75     memcpy(md, mac, c->dgst_size);
  76     return 1;
  77 }
  78
  79 int omac_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
  80 {
  81     OMAC_CTX *c_to = EVP_MD_CTX_md_data(to);
  82     const OMAC_CTX *c_from = EVP_MD_CTX_md_data(from);
  83
  84     if (c_from && c_to) {
  85         c_to->dgst_size = c_from->dgst_size;
  86         c_to->cipher_nid = c_from->cipher_nid;
  87         c_to->key_set = c_from->key_set;
  88     } else {
  89         return 0;
  90     }
  91     if (!c_from->cmac_ctx) {
  92         if (c_to->cmac_ctx) {
  93             CMAC_CTX_free(c_to->cmac_ctx);
  94             c_to->cmac_ctx = NULL;
  95         }
  96         return 1;
  97     }
  98     if (c_to->cmac_ctx == c_from->cmac_ctx) {
  99         c_to->cmac_ctx = CMAC_CTX_new();
 100     }
 101     return CMAC_CTX_copy(c_to->cmac_ctx, c_from->cmac_ctx);
 102 }
 103
 104 /* Clean up imit ctx */
 105 int omac_imit_cleanup(EVP_MD_CTX *ctx)
 106 {
 107     OMAC_CTX *c = EVP_MD_CTX_md_data(ctx);
 108
 109     if (c) {
 110         CMAC_CTX_free(c->cmac_ctx);
 111         memset(EVP_MD_CTX_md_data(ctx), 0, sizeof(OMAC_CTX));
 112     }
 113     return 1;
 114 }
 115
 116 static int omac_key(OMAC_CTX * c, const EVP_CIPHER *cipher,
 117                     const unsigned char *key, size_t key_size)
 118 {
 119     int ret = 0;
 120
 121     c->cmac_ctx = CMAC_CTX_new();
 122     if (c->cmac_ctx == NULL) {
 123         GOSTerr(GOST_F_OMAC_KEY, ERR_R_MALLOC_FAILURE);
 124         return 0;
 125     }
 126
 127     ret = CMAC_Init(c->cmac_ctx, key, key_size, cipher, NULL);
 128     if (ret > 0) {
 129         c->key_set = 1;
 130     }
 131     return 1;
 132 }
 133
 134 int omac_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
 135 {
 136     switch (type) {
 137     case EVP_MD_CTRL_KEY_LEN:
 138         *((unsigned int *)(ptr)) = 32;
 139         return 1;
 140     case EVP_MD_CTRL_SET_KEY:
 141         {
 142             OMAC_CTX *c = EVP_MD_CTX_md_data(ctx);
 143             const EVP_MD *md = EVP_MD_CTX_md(ctx);
 144             const EVP_CIPHER *cipher = NULL;
 145
 146             if (c->cipher_nid == NID_undef) {
 147                 switch (EVP_MD_nid(md)) {
 148                 case NID_magma_mac:
 149                     c->cipher_nid = NID_magma_cbc;
 150                     break;
 151
 152                 case NID_grasshopper_mac:
 153                     c->cipher_nid = NID_grasshopper_cbc;
 154                     break;
 155                 }
 156             }
 157             cipher = EVP_get_cipherbynid(c->cipher_nid);
 158
 159             if (cipher == NULL) {
 160                 GOSTerr(GOST_F_OMAC_IMIT_CTRL, GOST_R_CIPHER_NOT_FOUND);
 161             }
 162
 163             if (EVP_MD_meth_get_init(EVP_MD_CTX_md(ctx)) (ctx) <= 0) {
 164                 GOSTerr(GOST_F_OMAC_IMIT_CTRL, GOST_R_MAC_KEY_NOT_SET);
 165                 return 0;
 166             }
 167             EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_NO_INIT);
 168
 169             if (c->key_set) {
 170                 GOSTerr(GOST_F_OMAC_IMIT_CTRL, GOST_R_BAD_ORDER);
 171                 return 0;
 172             }
 173
 174             if (arg == 0) {
 175                 struct gost_mac_key *key = (struct gost_mac_key *)ptr;
 176                 return omac_key(c, cipher, key->key, 32);
 177
 178             } else if (arg == 32) {
 179                 return omac_key(c, cipher, ptr, 32);
 180             }
 181             GOSTerr(GOST_F_OMAC_IMIT_CTRL, GOST_R_INVALID_MAC_KEY_SIZE);
 182             return 0;
 183         }
 184     case EVP_MD_CTRL_MAC_LEN:
 185         {
 186             OMAC_CTX *c = EVP_MD_CTX_md_data(ctx);
 187             switch (c->cipher_nid) {
 188             case NID_magma_cbc:
 189                 if (arg < 1 || arg > 8) {
 190                     GOSTerr(GOST_F_OMAC_IMIT_CTRL, GOST_R_INVALID_MAC_SIZE);
 191                     return 0;
 192                 }
 193                 c->dgst_size = arg;
 194                 break;
 195             case NID_grasshopper_cbc:
 196                 if (arg < 1 || arg > 16) {
 197                     GOSTerr(GOST_F_OMAC_IMIT_CTRL, GOST_R_INVALID_MAC_SIZE);
 198                     return 0;
 199                 }
 200                 c->dgst_size = arg;
 201                 break;
 202             default:
 203                 return 0;
 204             }
 205             return 1;
 206         }
 207
 208     default:
 209         return 0;
 210     }
 211 }
 212
 213 static EVP_MD *_hidden_magma_mac_md = NULL;
 214
 215 EVP_MD *magma_omac(void)
 216 {
 217     if (_hidden_magma_mac_md == NULL) {
 218         EVP_MD *md;
 219
 220         if ((md = EVP_MD_meth_new(NID_magma_mac, NID_undef)) == NULL
 221             || !EVP_MD_meth_set_result_size(md, 4)
 222             || !EVP_MD_meth_set_input_blocksize(md, 8)
 223             || !EVP_MD_meth_set_app_datasize(md, sizeof(OMAC_CTX))
 224             || !EVP_MD_meth_set_flags(md, 0)
 225             || !EVP_MD_meth_set_init(md, magma_imit_init)
 226             || !EVP_MD_meth_set_update(md, omac_imit_update)
 227             || !EVP_MD_meth_set_final(md, omac_imit_final)
 228             || !EVP_MD_meth_set_copy(md, omac_imit_copy)
 229             || !EVP_MD_meth_set_cleanup(md, omac_imit_cleanup)
 230             || !EVP_MD_meth_set_ctrl(md, omac_imit_ctrl)) {
 231             EVP_MD_meth_free(md);
 232             md = NULL;
 233         }
 234         _hidden_magma_mac_md = md;
 235     }
 236     return _hidden_magma_mac_md;
 237 }
 238
 239 void magma_omac_destroy(void)
 240 {
 241     EVP_MD_meth_free(_hidden_magma_mac_md);
 242     _hidden_magma_mac_md = NULL;
 243 }
 244
 245 static EVP_MD *_hidden_grasshopper_mac_md = NULL;
 246
 247 EVP_MD *grasshopper_omac(void)
 248 {
 249     if (_hidden_grasshopper_mac_md == NULL) {
 250         EVP_MD *md;
 251
 252         if ((md = EVP_MD_meth_new(NID_grasshopper_mac, NID_undef)) == NULL
 253             || !EVP_MD_meth_set_result_size(md, 8)
 254             || !EVP_MD_meth_set_input_blocksize(md, 8)
 255             || !EVP_MD_meth_set_app_datasize(md, sizeof(OMAC_CTX))
 256             || !EVP_MD_meth_set_flags(md, 0)
 257             || !EVP_MD_meth_set_init(md, grasshopper_imit_init)
 258             || !EVP_MD_meth_set_update(md, omac_imit_update)
 259             || !EVP_MD_meth_set_final(md, omac_imit_final)
 260             || !EVP_MD_meth_set_copy(md, omac_imit_copy)
 261             || !EVP_MD_meth_set_cleanup(md, omac_imit_cleanup)
 262             || !EVP_MD_meth_set_ctrl(md, omac_imit_ctrl)) {
 263             EVP_MD_meth_free(md);
 264             md = NULL;
 265         }
 266         _hidden_grasshopper_mac_md = md;
 267     }
 268     return _hidden_grasshopper_mac_md;
 269 }
 270
 271 void grasshopper_omac_destroy(void)
 272 {
 273     EVP_MD_meth_free(_hidden_grasshopper_mac_md);
 274     _hidden_grasshopper_mac_md = NULL;
 275 }