gost_omac_acpkm.c

   1 /*
   2  * Copyright (C) 2018,2020 Vitaly Chikunov <vt@altlinux.org>. All Rights Reserved.
   3  * Copyright (c) 2010 The OpenSSL Project.  All rights reserved.
   4  *
   5  * Contents licensed under the terms of the OpenSSL license
   6  * See https://www.openssl.org/source/license.html for details
   7  */
   8 #include <string.h>
   9 #include <openssl/cmac.h>
  10 #include <openssl/conf.h>
  11 #include <openssl/err.h>
  12 #include <openssl/evp.h>
  13
  14 #include "e_gost_err.h"
  15 #include "gost_lcl.h"
  16 #include "gost_grasshopper_defines.h"
  17 #include "gost_grasshopper_cipher.h"
  18
  19 #define ACPKM_T_MAX (GRASSHOPPER_KEY_SIZE + GRASSHOPPER_BLOCK_SIZE)
  20 /*
  21  * CMAC code from crypto/cmac/cmac.c with ACPKM tweaks
  22  */
  23 struct CMAC_ACPKM_CTX_st {
  24     /* Cipher context to use */
  25     EVP_CIPHER_CTX *cctx;
  26     /* CTR-ACPKM cipher */
  27     EVP_CIPHER_CTX *actx;
  28     unsigned char km[ACPKM_T_MAX]; /* Key material */
  29     /* Temporary block */
  30     unsigned char tbl[EVP_MAX_BLOCK_LENGTH];
  31     /* Last (possibly partial) block */
  32     unsigned char last_block[EVP_MAX_BLOCK_LENGTH];
  33     /* Number of bytes in last block: -1 means context not initialised */
  34     int nlast_block;
  35     unsigned int section_size; /* N */
  36     unsigned int num; /* processed bytes until section_size */
  37 };
  38 typedef struct CMAC_ACPKM_CTX_st CMAC_ACPKM_CTX;
  39
  40 static unsigned char zero_iv[ACPKM_T_MAX];
  41
  42 /* Make temporary keys K1 and K2 */
  43
  44 static void make_kn(unsigned char *k1, unsigned char *l, int bl)
  45 {
  46     int i;
  47     /* Shift block to left, including carry */
  48     for (i = 0; i < bl; i++) {
  49         k1[i] = l[i] << 1;
  50         if (i < bl - 1 && l[i + 1] & 0x80)
  51             k1[i] |= 1;
  52     }
  53     /* If MSB set fixup with R */
  54     if (l[0] & 0x80)
  55         k1[bl - 1] ^= bl == 16 ? 0x87 : 0x1b;
  56 }
  57
  58 static CMAC_ACPKM_CTX *CMAC_ACPKM_CTX_new(void)
  59 {
  60     CMAC_ACPKM_CTX *ctx;
  61     ctx = OPENSSL_zalloc(sizeof(CMAC_ACPKM_CTX));
  62     if (!ctx)
  63         return NULL;
  64     ctx->cctx = EVP_CIPHER_CTX_new();
  65     if (ctx->cctx == NULL) {
  66         OPENSSL_free(ctx);
  67         return NULL;
  68     }
  69     ctx->actx = EVP_CIPHER_CTX_new();
  70     if (ctx->actx == NULL) {
  71         EVP_CIPHER_CTX_free(ctx->cctx);
  72         OPENSSL_free(ctx);
  73         return NULL;
  74     }
  75     ctx->nlast_block = -1;
  76     ctx->num = 0;
  77     ctx->section_size = 4096; /* recommended value for Kuznyechik */
  78     return ctx;
  79 }
  80
  81 static void CMAC_ACPKM_CTX_cleanup(CMAC_ACPKM_CTX *ctx)
  82 {
  83     EVP_CIPHER_CTX_cleanup(ctx->cctx);
  84     EVP_CIPHER_CTX_cleanup(ctx->actx);
  85     OPENSSL_cleanse(ctx->tbl, EVP_MAX_BLOCK_LENGTH);
  86     OPENSSL_cleanse(ctx->km, ACPKM_T_MAX);
  87     OPENSSL_cleanse(ctx->last_block, EVP_MAX_BLOCK_LENGTH);
  88     ctx->nlast_block = -1;
  89 }
  90
  91 static void CMAC_ACPKM_CTX_free(CMAC_ACPKM_CTX *ctx)
  92 {
  93     if (!ctx)
  94         return;
  95     CMAC_ACPKM_CTX_cleanup(ctx);
  96     EVP_CIPHER_CTX_free(ctx->cctx);
  97     EVP_CIPHER_CTX_free(ctx->actx);
  98     OPENSSL_free(ctx);
  99 }
 100
 101 static int CMAC_ACPKM_CTX_copy(CMAC_ACPKM_CTX *out, const CMAC_ACPKM_CTX *in)
 102 {
 103     int bl;
 104     if (in->nlast_block == -1)
 105         return 0;
 106     if (!EVP_CIPHER_CTX_copy(out->cctx, in->cctx))
 107         return 0;
 108     if (!EVP_CIPHER_CTX_copy(out->actx, in->actx))
 109         return 0;
 110     bl = EVP_CIPHER_CTX_block_size(in->cctx);
 111     memcpy(out->km, in->km, ACPKM_T_MAX);
 112     memcpy(out->tbl, in->tbl, bl);
 113     memcpy(out->last_block, in->last_block, bl);
 114     out->nlast_block = in->nlast_block;
 115     out->section_size = in->section_size;
 116     out->num = in->num;
 117     return 1;
 118 }
 119
 120 static int CMAC_ACPKM_Init(CMAC_ACPKM_CTX *ctx, const void *key, size_t keylen,
 121                            const EVP_CIPHER *cipher, ENGINE *impl)
 122 {
 123     /* All zeros means restart */
 124     if (!key && !cipher && !impl && keylen == 0) {
 125         /* Not initialised */
 126         if (ctx->nlast_block == -1)
 127             return 0;
 128         if (!EVP_EncryptInit_ex(ctx->cctx, NULL, NULL, NULL, zero_iv))
 129             return 0;
 130         memset(ctx->tbl, 0, EVP_CIPHER_CTX_block_size(ctx->cctx));
 131         ctx->nlast_block = 0;
 132         /* No restart for ACPKM */
 133         return 1;
 134     }
 135     /* Initialise context */
 136     if (cipher) {
 137         const EVP_CIPHER *acpkm;
 138
 139         if (!EVP_EncryptInit_ex(ctx->cctx, cipher, impl, NULL, NULL))
 140             return 0;
 141         if (!EVP_CIPHER_is_a(cipher, SN_grasshopper_cbc))
 142             return 0;
 143         acpkm = cipher_gost_grasshopper_ctracpkm();
 144         if (!EVP_EncryptInit_ex(ctx->actx, acpkm, impl, NULL, NULL))
 145             return 0;
 146     }
 147     /* Non-NULL key means initialisation is complete */
 148     if (key) {
 149         unsigned char acpkm_iv[EVP_MAX_BLOCK_LENGTH];
 150         int block_size, key_len;
 151
 152         /* Initialize CTR for ACPKM-Master */
 153         if (!EVP_CIPHER_CTX_cipher(ctx->actx))
 154             return 0;
 155         /* block size of ACPKM cipher could be 1, but,
 156          * cbc cipher is same with correct block_size */
 157         block_size = EVP_CIPHER_CTX_block_size(ctx->cctx);
 158         /* Wide IV = 1^{n/2} || 0,
 159          * where a^r denotes the string that consists of r 'a' bits */
 160         memset(acpkm_iv, 0xff, block_size / 2);
 161         memset(acpkm_iv + block_size / 2, 0, block_size / 2);
 162         if (!EVP_EncryptInit_ex(ctx->actx, NULL, NULL, key, acpkm_iv))
 163             return 0;
 164         /* EVP_CIPHER key_len may be different from EVP_CIPHER_CTX key_len */
 165         key_len = EVP_CIPHER_key_length(EVP_CIPHER_CTX_cipher(ctx->actx));
 166
 167         /* Generate first key material (K^1 || K^1_1) */
 168         if (!EVP_Cipher(ctx->actx, ctx->km, zero_iv, key_len + block_size))
 169             return 0;
 170
 171         /* Initialize cbc for CMAC */
 172         if (!EVP_CIPHER_CTX_cipher(ctx->cctx) ||
 173             !EVP_CIPHER_CTX_set_key_length(ctx->cctx, key_len))
 174             return 0;
 175         /* set CBC key to K^1 */
 176         if (!EVP_EncryptInit_ex(ctx->cctx, NULL, NULL, ctx->km, zero_iv))
 177             return 0;
 178         ctx->nlast_block = 0;
 179     }
 180     return 1;
 181 }
 182
 183 /* Encrypt zeros with master key
 184  * to generate T*-sized key material */
 185 static int CMAC_ACPKM_Master(CMAC_ACPKM_CTX *ctx)
 186 {
 187     return EVP_Cipher(ctx->actx, ctx->km, zero_iv,
 188         EVP_CIPHER_key_length(EVP_CIPHER_CTX_cipher(ctx->actx)) +
 189         EVP_CIPHER_CTX_block_size(ctx->cctx));
 190 }
 191
 192 static int CMAC_ACPKM_Mesh(CMAC_ACPKM_CTX *ctx)
 193 {
 194     if (ctx->num < ctx->section_size)
 195         return 1;
 196     ctx->num = 0;
 197     if (!CMAC_ACPKM_Master(ctx))
 198         return 0;
 199     /* Restart cbc with new key */
 200     if (!EVP_EncryptInit_ex(ctx->cctx, NULL, NULL, ctx->km,
 201             EVP_CIPHER_CTX_iv(ctx->cctx)))
 202         return 0;
 203     return 1;
 204 }
 205
 206 static int CMAC_ACPKM_Update(CMAC_ACPKM_CTX *ctx, const void *in, size_t dlen)
 207 {
 208     const unsigned char *data = in;
 209     size_t bl;
 210     if (ctx->nlast_block == -1)
 211         return 0;
 212     if (dlen == 0)
 213         return 1;
 214     bl = EVP_CIPHER_CTX_block_size(ctx->cctx);
 215     /* Copy into partial block if we need to */
 216     if (ctx->nlast_block > 0) {
 217         size_t nleft;
 218         nleft = bl - ctx->nlast_block;
 219         if (dlen < nleft)
 220             nleft = dlen;
 221         memcpy(ctx->last_block + ctx->nlast_block, data, nleft);
 222         dlen -= nleft;
 223         ctx->nlast_block += nleft;
 224         /* If no more to process return */
 225         if (dlen == 0)
 226             return 1;
 227         data += nleft;
 228         /* Else not final block so encrypt it */
 229         if (!CMAC_ACPKM_Mesh(ctx))
 230             return 0;
 231         if (!EVP_Cipher(ctx->cctx, ctx->tbl, ctx->last_block, bl))
 232             return 0;
 233         ctx->num += bl;
 234     }
 235     /* Encrypt all but one of the complete blocks left */
 236     while (dlen > bl) {
 237         if (!CMAC_ACPKM_Mesh(ctx))
 238             return 0;
 239         if (!EVP_Cipher(ctx->cctx, ctx->tbl, data, bl))
 240             return 0;
 241         dlen -= bl;
 242         data += bl;
 243         ctx->num += bl;
 244     }
 245     /* Copy any data left to last block buffer */
 246     memcpy(ctx->last_block, data, dlen);
 247     ctx->nlast_block = dlen;
 248     return 1;
 249
 250 }
 251
 252 /* Return value is propagated to EVP_DigestFinal_ex */
 253 static int CMAC_ACPKM_Final(CMAC_ACPKM_CTX *ctx, unsigned char *out,
 254                             size_t *poutlen)
 255 {
 256     int i, bl, lb, key_len;
 257     unsigned char *k1, k2[EVP_MAX_BLOCK_LENGTH];
 258     if (ctx->nlast_block == -1)
 259         return 0;
 260     bl = EVP_CIPHER_CTX_block_size(ctx->cctx);
 261     if (bl != 8 && bl != 16) {
 262         GOSTerr(GOST_F_OMAC_ACPKM_IMIT_FINAL, GOST_R_INVALID_MAC_PARAMS);
 263         return 0;
 264     }
 265     *poutlen = (size_t) bl;
 266     if (!out)
 267         return 1;
 268     lb = ctx->nlast_block;
 269
 270     if (!CMAC_ACPKM_Mesh(ctx))
 271         return 0;
 272     key_len = EVP_CIPHER_key_length(EVP_CIPHER_CTX_cipher(ctx->actx));
 273     /* Keys k1 and k2 */
 274     k1 = ctx->km + key_len;
 275     make_kn(k2, ctx->km + key_len, bl);
 276
 277     /* Is last block complete? */
 278     if (lb == bl) {
 279         for (i = 0; i < bl; i++)
 280             out[i] = ctx->last_block[i] ^ k1[i];
 281     } else {
 282         ctx->last_block[lb] = 0x80;
 283         if (bl - lb > 1)
 284             memset(ctx->last_block + lb + 1, 0, bl - lb - 1);
 285         for (i = 0; i < bl; i++)
 286             out[i] = ctx->last_block[i] ^ k2[i];
 287     }
 288     OPENSSL_cleanse(k1, bl);
 289     OPENSSL_cleanse(k2, bl);
 290     OPENSSL_cleanse(ctx->km, ACPKM_T_MAX);
 291     if (!EVP_Cipher(ctx->cctx, out, out, bl)) {
 292         OPENSSL_cleanse(out, bl);
 293         return 0;
 294     }
 295     return 1;
 296 }
 297
 298 /*
 299  * End of CMAC code from crypto/cmac/cmac.c with ACPKM tweaks
 300  */
 301
 302 typedef struct omac_acpkm_ctx {
 303     CMAC_ACPKM_CTX *cmac_ctx;
 304     size_t dgst_size;
 305     const char *cipher_name;
 306     int key_set;
 307 } OMAC_ACPKM_CTX;
 308
 309 #define MAX_GOST_OMAC_ACPKM_SIZE 16
 310
 311 static int omac_acpkm_init(EVP_MD_CTX *ctx, const char *cipher_name)
 312 {
 313     OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 314     memset(c, 0, sizeof(OMAC_ACPKM_CTX));
 315     c->cipher_name = cipher_name;
 316     c->key_set = 0;
 317
 318     switch (OBJ_txt2nid(cipher_name)) {
 319     case NID_grasshopper_cbc:
 320         c->dgst_size = 16;
 321         break;
 322     }
 323
 324     return 1;
 325 }
 326
 327 static int grasshopper_omac_acpkm_init(EVP_MD_CTX *ctx)
 328 {
 329     return omac_acpkm_init(ctx, SN_grasshopper_cbc);
 330 }
 331
 332 static int omac_acpkm_imit_update(EVP_MD_CTX *ctx, const void *data,
 333                                   size_t count)
 334 {
 335     OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 336     if (!c->key_set) {
 337         GOSTerr(GOST_F_OMAC_ACPKM_IMIT_UPDATE, GOST_R_MAC_KEY_NOT_SET);
 338         return 0;
 339     }
 340
 341     return CMAC_ACPKM_Update(c->cmac_ctx, data, count);
 342 }
 343
 344 int omac_acpkm_imit_final(EVP_MD_CTX *ctx, unsigned char *md)
 345 {
 346     OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 347     unsigned char mac[MAX_GOST_OMAC_ACPKM_SIZE];
 348     size_t mac_size = sizeof(mac);
 349     int ret;
 350
 351     if (!c->key_set) {
 352         GOSTerr(GOST_F_OMAC_ACPKM_IMIT_FINAL, GOST_R_MAC_KEY_NOT_SET);
 353         return 0;
 354     }
 355
 356     ret = CMAC_ACPKM_Final(c->cmac_ctx, mac, &mac_size);
 357
 358     memcpy(md, mac, c->dgst_size);
 359     return ret;
 360 }
 361
 362 static int omac_acpkm_imit_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
 363 {
 364     OMAC_ACPKM_CTX *c_to = EVP_MD_CTX_md_data(to);
 365     const OMAC_ACPKM_CTX *c_from = EVP_MD_CTX_md_data(from);
 366
 367     if (c_from && c_to) {
 368         c_to->dgst_size = c_from->dgst_size;
 369         c_to->cipher_name = c_from->cipher_name;
 370         c_to->key_set = c_from->key_set;
 371     } else {
 372         return 0;
 373     }
 374     if (!c_from->cmac_ctx) {
 375         if (c_to->cmac_ctx) {
 376             CMAC_ACPKM_CTX_free(c_to->cmac_ctx);
 377             c_to->cmac_ctx = NULL;
 378         }
 379         return 1;
 380     }
 381     if ((c_to->cmac_ctx == c_from->cmac_ctx) || (c_to->cmac_ctx == NULL))  {
 382         c_to->cmac_ctx = CMAC_ACPKM_CTX_new();
 383     }
 384
 385     return (c_to->cmac_ctx) ? CMAC_ACPKM_CTX_copy(c_to->cmac_ctx, c_from->cmac_ctx) : 0;
 386 }
 387
 388 /* Clean up imit ctx */
 389 static int omac_acpkm_imit_cleanup(EVP_MD_CTX *ctx)
 390 {
 391     OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 392
 393     if (c) {
 394         CMAC_ACPKM_CTX_free(c->cmac_ctx);
 395         memset(EVP_MD_CTX_md_data(ctx), 0, sizeof(OMAC_ACPKM_CTX));
 396     }
 397     return 1;
 398 }
 399
 400 static int omac_acpkm_key(OMAC_ACPKM_CTX *c, const EVP_CIPHER *cipher,
 401                           const unsigned char *key, size_t key_size)
 402 {
 403     int ret = 0;
 404
 405     c->cmac_ctx = CMAC_ACPKM_CTX_new();
 406     if (c->cmac_ctx == NULL) {
 407         GOSTerr(GOST_F_OMAC_ACPKM_KEY, ERR_R_MALLOC_FAILURE);
 408         return 0;
 409     }
 410
 411     ret = CMAC_ACPKM_Init(c->cmac_ctx, key, key_size, cipher, NULL);
 412     if (ret > 0) {
 413         c->key_set = 1;
 414     }
 415     return 1;
 416 }
 417
 418 int omac_acpkm_imit_ctrl(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
 419 {
 420     switch (type) {
 421     case EVP_MD_CTRL_KEY_LEN:
 422         *((unsigned int *)(ptr)) = 32;
 423         return 1;
 424     case EVP_MD_CTRL_SET_KEY:
 425         {
 426             OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 427             const EVP_MD *md = EVP_MD_CTX_md(ctx);
 428             EVP_CIPHER *cipher = NULL;
 429             int ret = 0;
 430
 431             if (c->cipher_name == NULL) {
 432                 if (EVP_MD_is_a(md, SN_grasshopper_mac)
 433                     || EVP_MD_is_a(md, SN_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac))
 434                     c->cipher_name = SN_grasshopper_cbc;
 435             }
 436             if ((cipher =
 437                  (EVP_CIPHER *)EVP_get_cipherbyname(c->cipher_name)) == NULL
 438                 && (cipher =
 439                     EVP_CIPHER_fetch(NULL, c->cipher_name, NULL)) == NULL) {
 440                 GOSTerr(GOST_F_OMAC_ACPKM_IMIT_CTRL, GOST_R_CIPHER_NOT_FOUND);
 441             }
 442             if (EVP_MD_meth_get_init(EVP_MD_CTX_md(ctx)) (ctx) <= 0) {
 443                 GOSTerr(GOST_F_OMAC_ACPKM_IMIT_CTRL, GOST_R_MAC_KEY_NOT_SET);
 444                 goto set_key_end;
 445             }
 446             EVP_MD_CTX_set_flags(ctx, EVP_MD_CTX_FLAG_NO_INIT);
 447             if (c->key_set) {
 448                 GOSTerr(GOST_F_OMAC_ACPKM_IMIT_CTRL, GOST_R_BAD_ORDER);
 449                 goto set_key_end;
 450             }
 451             if (arg == 0) {
 452                 struct gost_mac_key *key = (struct gost_mac_key *)ptr;
 453                 ret = omac_acpkm_key(c, cipher, key->key, 32);
 454                 goto set_key_end;
 455             } else if (arg == 32) {
 456                 ret = omac_acpkm_key(c, cipher, ptr, 32);
 457                 goto set_key_end;
 458             }
 459             GOSTerr(GOST_F_OMAC_ACPKM_IMIT_CTRL, GOST_R_INVALID_MAC_KEY_SIZE);
 460           set_key_end:
 461             EVP_CIPHER_free(cipher);
 462             return ret;
 463         }
 464     case EVP_CTRL_KEY_MESH:
 465         {
 466             OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 467             if (!arg || (arg % EVP_MD_block_size(EVP_MD_CTX_md(ctx))))
 468                 return -1;
 469             c->cmac_ctx->section_size = arg;
 470             if (ptr && *(int *)ptr) {
 471                 /* Set parameter T */
 472                 if (EVP_CIPHER_get0_provider(EVP_CIPHER_CTX_cipher(c->cmac_ctx->actx))
 473                     == NULL) {
 474                     if (!EVP_CIPHER_CTX_ctrl(c->cmac_ctx->actx, EVP_CTRL_KEY_MESH,
 475                                              *(int *)ptr, NULL))
 476                         return 0;
 477                 } else {
 478                     size_t cipher_key_mesh = (size_t)*(int *)ptr;
 479                     OSSL_PARAM params[] = { OSSL_PARAM_END, OSSL_PARAM_END };
 480                     params[0] = OSSL_PARAM_construct_size_t("key-mesh",
 481                                                             &cipher_key_mesh);
 482                     if (!EVP_CIPHER_CTX_set_params(c->cmac_ctx->actx, params))
 483                         return 0;
 484                 }
 485             }
 486             return 1;
 487         }
 488     case EVP_MD_CTRL_XOF_LEN:   /* Supported in OpenSSL */
 489         {
 490             OMAC_ACPKM_CTX *c = EVP_MD_CTX_md_data(ctx);
 491             switch (OBJ_txt2nid(c->cipher_name)) {
 492             case NID_grasshopper_cbc:
 493                 if (arg < 1 || arg > 16) {
 494                     GOSTerr(GOST_F_OMAC_ACPKM_IMIT_CTRL, GOST_R_INVALID_MAC_SIZE);
 495                     return 0;
 496                 }
 497                 c->dgst_size = arg;
 498                 break;
 499             case NID_magma_cbc:
 500                 if (arg < 1 || arg > 8) {
 501                     GOSTerr(GOST_F_OMAC_ACPKM_IMIT_CTRL, GOST_R_INVALID_MAC_SIZE);
 502                     return 0;
 503                 }
 504                 c->dgst_size = arg;
 505                 break;
 506             default:
 507                 return 0;
 508             }
 509             return 1;
 510         }
 511
 512     default:
 513         return 0;
 514     }
 515 }
 516
 517 GOST_digest kuznyechik_ctracpkm_omac_digest = {
 518     .nid = NID_id_tc26_cipher_gostr3412_2015_kuznyechik_ctracpkm_omac,
 519     .result_size = MAX_GOST_OMAC_ACPKM_SIZE,
 520     .input_blocksize = GRASSHOPPER_BLOCK_SIZE,
 521     .app_datasize = sizeof(OMAC_ACPKM_CTX),
 522     .flags = EVP_MD_FLAG_XOF,
 523     .init = grasshopper_omac_acpkm_init,
 524     .update = omac_acpkm_imit_update,
 525     .final = omac_acpkm_imit_final,
 526     .copy = omac_acpkm_imit_copy,
 527     .cleanup = omac_acpkm_imit_cleanup,
 528     .ctrl = omac_acpkm_imit_ctrl,
 529 };