gost_md2012.c

   1 /**********************************************************************
   2  *                          gost_md2012.c                             *
   3  *             Copyright (c) 2013 Cryptocom LTD.                      *
   4  *         This file is distributed under the same license as OpenSSL *
   5  *                                                                    *
   6  *          GOST R 34.11-2012 interface to OpenSSL engine.            *
   7  *                                                                    *
   8  * Author: Alexey Degtyarev <alexey@renatasystems.org>                *
   9  *                                                                    *
  10  **********************************************************************/
  11
  12 #include <openssl/evp.h>
  13 #include "gosthash2012.h"
  14
  15 static int gost_digest_init512(EVP_MD_CTX *ctx);
  16 static int gost_digest_init256(EVP_MD_CTX *ctx);
  17 static int gost_digest_update(EVP_MD_CTX *ctx, const void *data,
  18                               size_t count);
  19 static int gost_digest_final(EVP_MD_CTX *ctx, unsigned char *md);
  20 static int gost_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from);
  21 static int gost_digest_cleanup(EVP_MD_CTX *ctx);
  22 static int gost_digest_ctrl_256(EVP_MD_CTX *ctx, int type, int arg,
  23                                 void *ptr);
  24 static int gost_digest_ctrl_512(EVP_MD_CTX *ctx, int type, int arg,
  25                                 void *ptr);
  26
  27 const char micalg_256[] = "gostr3411-2012-256";
  28 const char micalg_512[] = "gostr3411-2012-512";
  29
  30 static EVP_MD *_hidden_GostR3411_2012_256_md = NULL;
  31 static EVP_MD *_hidden_GostR3411_2012_512_md = NULL;
  32
  33 EVP_MD *digest_gost2012_256(void)
  34 {
  35     if (_hidden_GostR3411_2012_256_md == NULL) {
  36         EVP_MD *md;
  37
  38         if ((md =
  39              EVP_MD_meth_new(NID_id_GostR3411_2012_256, NID_undef)) == NULL
  40             || !EVP_MD_meth_set_result_size(md, 32)
  41             || !EVP_MD_meth_set_input_blocksize(md, 64)
  42             || !EVP_MD_meth_set_app_datasize(md, sizeof(gost2012_hash_ctx))
  43             || !EVP_MD_meth_set_init(md, gost_digest_init256)
  44             || !EVP_MD_meth_set_update(md, gost_digest_update)
  45             || !EVP_MD_meth_set_final(md, gost_digest_final)
  46             || !EVP_MD_meth_set_copy(md, gost_digest_copy)
  47             || !EVP_MD_meth_set_ctrl(md, gost_digest_ctrl_256)
  48             || !EVP_MD_meth_set_cleanup(md, gost_digest_cleanup)) {
  49             EVP_MD_meth_free(md);
  50             md = NULL;
  51         }
  52         _hidden_GostR3411_2012_256_md = md;
  53     }
  54     return _hidden_GostR3411_2012_256_md;
  55 }
  56
  57 void digest_gost2012_256_destroy(void)
  58 {
  59     EVP_MD_meth_free(_hidden_GostR3411_2012_256_md);
  60     _hidden_GostR3411_2012_256_md = NULL;
  61 }
  62
  63 EVP_MD *digest_gost2012_512(void)
  64 {
  65     if (_hidden_GostR3411_2012_512_md == NULL) {
  66         EVP_MD *md;
  67
  68         if ((md =
  69              EVP_MD_meth_new(NID_id_GostR3411_2012_512, NID_undef)) == NULL
  70             || !EVP_MD_meth_set_result_size(md, 64)
  71             || !EVP_MD_meth_set_input_blocksize(md, 64)
  72             || !EVP_MD_meth_set_app_datasize(md, sizeof(gost2012_hash_ctx))
  73             || !EVP_MD_meth_set_init(md, gost_digest_init512)
  74             || !EVP_MD_meth_set_update(md, gost_digest_update)
  75             || !EVP_MD_meth_set_final(md, gost_digest_final)
  76             || !EVP_MD_meth_set_copy(md, gost_digest_copy)
  77             || !EVP_MD_meth_set_ctrl(md, gost_digest_ctrl_512)
  78             || !EVP_MD_meth_set_cleanup(md, gost_digest_cleanup)) {
  79             EVP_MD_meth_free(md);
  80             md = NULL;
  81         }
  82         _hidden_GostR3411_2012_512_md = md;
  83     }
  84     return _hidden_GostR3411_2012_512_md;
  85 }
  86
  87 void digest_gost2012_512_destroy(void)
  88 {
  89     EVP_MD_meth_free(_hidden_GostR3411_2012_512_md);
  90     _hidden_GostR3411_2012_512_md = NULL;
  91 }
  92
  93 static int gost_digest_init512(EVP_MD_CTX *ctx)
  94 {
  95     init_gost2012_hash_ctx((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx),
  96                            512);
  97     return 1;
  98 }
  99
 100 static int gost_digest_init256(EVP_MD_CTX *ctx)
 101 {
 102     init_gost2012_hash_ctx((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx),
 103                            256);
 104     return 1;
 105 }
 106
 107 static int gost_digest_update(EVP_MD_CTX *ctx, const void *data, size_t count)
 108 {
 109     gost2012_hash_block((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx), data,
 110                         count);
 111     return 1;
 112 }
 113
 114 static int gost_digest_final(EVP_MD_CTX *ctx, unsigned char *md)
 115 {
 116     gost2012_finish_hash((gost2012_hash_ctx *) EVP_MD_CTX_md_data(ctx), md);
 117     return 1;
 118 }
 119
 120 static int gost_digest_copy(EVP_MD_CTX *to, const EVP_MD_CTX *from)
 121 {
 122     if (EVP_MD_CTX_md_data(to) && EVP_MD_CTX_md_data(from))
 123         memcpy(EVP_MD_CTX_md_data(to), EVP_MD_CTX_md_data(from),
 124                sizeof(gost2012_hash_ctx));
 125
 126     return 1;
 127 }
 128
 129 static int gost_digest_cleanup(EVP_MD_CTX *ctx)
 130 {
 131     if (EVP_MD_CTX_md_data(ctx))
 132         memset(EVP_MD_CTX_md_data(ctx), 0x00, sizeof(gost2012_hash_ctx));
 133
 134     return 1;
 135 }
 136
 137 static int gost_digest_ctrl_256(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
 138 {
 139     switch (type) {
 140     case EVP_MD_CTRL_MICALG:
 141         {
 142             *((char **)ptr) = OPENSSL_malloc(strlen(micalg_256) + 1);
 143             if (*((char **)ptr) != NULL) {
 144                 strcpy(*((char **)ptr), micalg_256);
 145                 return 1;
 146             }
 147             return 0;
 148         }
 149     default:
 150         return 0;
 151     }
 152 }
 153
 154 static int gost_digest_ctrl_512(EVP_MD_CTX *ctx, int type, int arg, void *ptr)
 155 {
 156     switch (type) {
 157     case EVP_MD_CTRL_MICALG:
 158         {
 159             *((char **)ptr) = OPENSSL_malloc(strlen(micalg_512) + 1);
 160             if (*((char **)ptr) != NULL) {
 161                 strcpy(*((char **)ptr), micalg_512);
 162                 return 1;
 163             }
 164             return 0;
 165         }
 166         return 1;
 167     default:
 168         return 0;
 169     }
 170 }