Home | History | Annotate | Download | only in digest
      1 /* Copyright (C) 1995-1998 Eric Young (eay (at) cryptsoft.com)
      2  * All rights reserved.
      3  *
      4  * This package is an SSL implementation written
      5  * by Eric Young (eay (at) cryptsoft.com).
      6  * The implementation was written so as to conform with Netscapes SSL.
      7  *
      8  * This library is free for commercial and non-commercial use as long as
      9  * the following conditions are aheared to.  The following conditions
     10  * apply to all code found in this distribution, be it the RC4, RSA,
     11  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
     12  * included with this distribution is covered by the same copyright terms
     13  * except that the holder is Tim Hudson (tjh (at) cryptsoft.com).
     14  *
     15  * Copyright remains Eric Young's, and as such any Copyright notices in
     16  * the code are not to be removed.
     17  * If this package is used in a product, Eric Young should be given attribution
     18  * as the author of the parts of the library used.
     19  * This can be in the form of a textual message at program startup or
     20  * in documentation (online or textual) provided with the package.
     21  *
     22  * Redistribution and use in source and binary forms, with or without
     23  * modification, are permitted provided that the following conditions
     24  * are met:
     25  * 1. Redistributions of source code must retain the copyright
     26  *    notice, this list of conditions and the following disclaimer.
     27  * 2. Redistributions in binary form must reproduce the above copyright
     28  *    notice, this list of conditions and the following disclaimer in the
     29  *    documentation and/or other materials provided with the distribution.
     30  * 3. All advertising materials mentioning features or use of this software
     31  *    must display the following acknowledgement:
     32  *    "This product includes cryptographic software written by
     33  *     Eric Young (eay (at) cryptsoft.com)"
     34  *    The word 'cryptographic' can be left out if the rouines from the library
     35  *    being used are not cryptographic related :-).
     36  * 4. If you include any Windows specific code (or a derivative thereof) from
     37  *    the apps directory (application code) you must include an acknowledgement:
     38  *    "This product includes software written by Tim Hudson (tjh (at) cryptsoft.com)"
     39  *
     40  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
     41  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
     42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     43  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
     44  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     45  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
     46  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
     47  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
     48  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
     49  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
     50  * SUCH DAMAGE.
     51  *
     52  * The licence and distribution terms for any publically available version or
     53  * derivative of this code cannot be changed.  i.e. this code cannot simply be
     54  * copied and put under another distribution licence
     55  * [including the GNU Public Licence.] */
     56 
     57 #include <openssl/digest.h>
     58 
     59 #include <assert.h>
     60 #include <string.h>
     61 
     62 #include <openssl/md4.h>
     63 #include <openssl/md5.h>
     64 #include <openssl/obj.h>
     65 #include <openssl/sha.h>
     66 
     67 #include "internal.h"
     68 
     69 #if defined(NDEBUG)
     70 #define CHECK(x) x
     71 #else
     72 #define CHECK(x) assert(x)
     73 #endif
     74 
     75 
     76 static void md4_init(EVP_MD_CTX *ctx) {
     77   CHECK(MD4_Init(ctx->md_data));
     78 }
     79 
     80 static void md4_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
     81   CHECK(MD4_Update(ctx->md_data, data, count));
     82 }
     83 
     84 static void md4_final(EVP_MD_CTX *ctx, uint8_t *out) {
     85   CHECK(MD4_Final(out, ctx->md_data));
     86 }
     87 
     88 static const EVP_MD md4_md = {
     89     NID_md4,    MD4_DIGEST_LENGTH, 0 /* flags */,       md4_init,
     90     md4_update, md4_final,         64 /* block size */, sizeof(MD4_CTX),
     91 };
     92 
     93 const EVP_MD *EVP_md4(void) { return &md4_md; }
     94 
     95 
     96 static void md5_init(EVP_MD_CTX *ctx) {
     97   CHECK(MD5_Init(ctx->md_data));
     98 }
     99 
    100 static void md5_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
    101   CHECK(MD5_Update(ctx->md_data, data, count));
    102 }
    103 
    104 static void md5_final(EVP_MD_CTX *ctx, uint8_t *out) {
    105   CHECK(MD5_Final(out, ctx->md_data));
    106 }
    107 
    108 static const EVP_MD md5_md = {
    109     NID_md5,    MD5_DIGEST_LENGTH, 0 /* flags */,       md5_init,
    110     md5_update, md5_final,         64 /* block size */, sizeof(MD5_CTX),
    111 };
    112 
    113 const EVP_MD *EVP_md5(void) { return &md5_md; }
    114 
    115 
    116 static void sha1_init(EVP_MD_CTX *ctx) {
    117   CHECK(SHA1_Init(ctx->md_data));
    118 }
    119 
    120 static void sha1_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
    121   CHECK(SHA1_Update(ctx->md_data, data, count));
    122 }
    123 
    124 static void sha1_final(EVP_MD_CTX *ctx, uint8_t *md) {
    125   CHECK(SHA1_Final(md, ctx->md_data));
    126 }
    127 
    128 static const EVP_MD sha1_md = {
    129     NID_sha1,    SHA_DIGEST_LENGTH, 0 /* flags */,       sha1_init,
    130     sha1_update, sha1_final,        64 /* block size */, sizeof(SHA_CTX),
    131 };
    132 
    133 const EVP_MD *EVP_sha1(void) { return &sha1_md; }
    134 
    135 
    136 static void sha224_init(EVP_MD_CTX *ctx) {
    137   CHECK(SHA224_Init(ctx->md_data));
    138 }
    139 
    140 static void sha224_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
    141   CHECK(SHA224_Update(ctx->md_data, data, count));
    142 }
    143 
    144 static void sha224_final(EVP_MD_CTX *ctx, uint8_t *md) {
    145   CHECK(SHA224_Final(md, ctx->md_data));
    146 }
    147 
    148 static const EVP_MD sha224_md = {
    149     NID_sha224,          SHA224_DIGEST_LENGTH, 0 /* flags */,
    150     sha224_init,         sha224_update,        sha224_final,
    151     64 /* block size */, sizeof(SHA256_CTX),
    152 };
    153 
    154 const EVP_MD *EVP_sha224(void) { return &sha224_md; }
    155 
    156 
    157 static void sha256_init(EVP_MD_CTX *ctx) {
    158   CHECK(SHA256_Init(ctx->md_data));
    159 }
    160 
    161 static void sha256_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
    162   CHECK(SHA256_Update(ctx->md_data, data, count));
    163 }
    164 
    165 static void sha256_final(EVP_MD_CTX *ctx, uint8_t *md) {
    166   CHECK(SHA256_Final(md, ctx->md_data));
    167 }
    168 
    169 static const EVP_MD sha256_md = {
    170     NID_sha256,          SHA256_DIGEST_LENGTH, 0 /* flags */,
    171     sha256_init,         sha256_update,        sha256_final,
    172     64 /* block size */, sizeof(SHA256_CTX),
    173 };
    174 
    175 const EVP_MD *EVP_sha256(void) { return &sha256_md; }
    176 
    177 
    178 static void sha384_init(EVP_MD_CTX *ctx) {
    179   CHECK(SHA384_Init(ctx->md_data));
    180 }
    181 
    182 static void sha384_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
    183   CHECK(SHA384_Update(ctx->md_data, data, count));
    184 }
    185 
    186 static void sha384_final(EVP_MD_CTX *ctx, uint8_t *md) {
    187   CHECK(SHA384_Final(md, ctx->md_data));
    188 }
    189 
    190 static const EVP_MD sha384_md = {
    191     NID_sha384,           SHA384_DIGEST_LENGTH, 0 /* flags */,
    192     sha384_init,          sha384_update,        sha384_final,
    193     128 /* block size */, sizeof(SHA512_CTX),
    194 };
    195 
    196 const EVP_MD *EVP_sha384(void) { return &sha384_md; }
    197 
    198 
    199 static void sha512_init(EVP_MD_CTX *ctx) {
    200   CHECK(SHA512_Init(ctx->md_data));
    201 }
    202 
    203 static void sha512_update(EVP_MD_CTX *ctx, const void *data, size_t count) {
    204   CHECK(SHA512_Update(ctx->md_data, data, count));
    205 }
    206 
    207 static void sha512_final(EVP_MD_CTX *ctx, uint8_t *md) {
    208   CHECK(SHA512_Final(md, ctx->md_data));
    209 }
    210 
    211 static const EVP_MD sha512_md = {
    212     NID_sha512,           SHA512_DIGEST_LENGTH, 0 /* flags */,
    213     sha512_init,          sha512_update,        sha512_final,
    214     128 /* block size */, sizeof(SHA512_CTX),
    215 };
    216 
    217 const EVP_MD *EVP_sha512(void) { return &sha512_md; }
    218 
    219 
    220 typedef struct {
    221   MD5_CTX md5;
    222   SHA_CTX sha1;
    223 } MD5_SHA1_CTX;
    224 
    225 static void md5_sha1_init(EVP_MD_CTX *md_ctx) {
    226   MD5_SHA1_CTX *ctx = md_ctx->md_data;
    227   CHECK(MD5_Init(&ctx->md5) && SHA1_Init(&ctx->sha1));
    228 }
    229 
    230 static void md5_sha1_update(EVP_MD_CTX *md_ctx, const void *data,
    231                             size_t count) {
    232   MD5_SHA1_CTX *ctx = md_ctx->md_data;
    233   CHECK(MD5_Update(&ctx->md5, data, count) &&
    234         SHA1_Update(&ctx->sha1, data, count));
    235 }
    236 
    237 static void md5_sha1_final(EVP_MD_CTX *md_ctx, uint8_t *out) {
    238   MD5_SHA1_CTX *ctx = md_ctx->md_data;
    239   CHECK(MD5_Final(out, &ctx->md5) &&
    240         SHA1_Final(out + MD5_DIGEST_LENGTH, &ctx->sha1));
    241 }
    242 
    243 static const EVP_MD md5_sha1_md = {
    244     NID_md5_sha1,
    245     MD5_DIGEST_LENGTH + SHA_DIGEST_LENGTH,
    246     0 /* flags */,
    247     md5_sha1_init,
    248     md5_sha1_update,
    249     md5_sha1_final,
    250     64 /* block size */,
    251     sizeof(MD5_SHA1_CTX),
    252 };
    253 
    254 const EVP_MD *EVP_md5_sha1(void) { return &md5_sha1_md; }
    255 
    256 
    257 struct nid_to_digest {
    258   int nid;
    259   const EVP_MD* (*md_func)(void);
    260   const char *short_name;
    261   const char *long_name;
    262 };
    263 
    264 static const struct nid_to_digest nid_to_digest_mapping[] = {
    265   { NID_md5, EVP_md5, SN_md5, LN_md5 },
    266   { NID_sha1, EVP_sha1, SN_sha1, LN_sha1 },
    267   { NID_sha224, EVP_sha224, SN_sha224, LN_sha224 },
    268   { NID_sha256, EVP_sha256, SN_sha256, LN_sha256 },
    269   { NID_sha384, EVP_sha384, SN_sha384, LN_sha384 },
    270   { NID_sha512, EVP_sha512, SN_sha512, LN_sha512 },
    271   { NID_md5_sha1, EVP_md5_sha1, SN_md5_sha1, LN_md5_sha1 },
    272   { NID_dsaWithSHA, EVP_sha1, SN_dsaWithSHA, LN_dsaWithSHA },
    273   { NID_dsaWithSHA1, EVP_sha1, SN_dsaWithSHA1, LN_dsaWithSHA1 },
    274   { NID_ecdsa_with_SHA1, EVP_sha1, SN_ecdsa_with_SHA1, NULL },
    275   { NID_md5WithRSAEncryption, EVP_md5, SN_md5WithRSAEncryption,
    276     LN_md5WithRSAEncryption },
    277   { NID_sha1WithRSAEncryption, EVP_sha1, SN_sha1WithRSAEncryption,
    278     LN_sha1WithRSAEncryption },
    279   { NID_sha224WithRSAEncryption, EVP_sha224, SN_sha224WithRSAEncryption,
    280     LN_sha224WithRSAEncryption },
    281   { NID_sha256WithRSAEncryption, EVP_sha256, SN_sha256WithRSAEncryption,
    282     LN_sha256WithRSAEncryption },
    283   { NID_sha384WithRSAEncryption, EVP_sha384, SN_sha384WithRSAEncryption,
    284     LN_sha384WithRSAEncryption },
    285   { NID_sha512WithRSAEncryption, EVP_sha512, SN_sha512WithRSAEncryption,
    286     LN_sha512WithRSAEncryption },
    287 };
    288 
    289 const EVP_MD* EVP_get_digestbynid(int nid) {
    290   unsigned i;
    291 
    292   for (i = 0; i < sizeof(nid_to_digest_mapping) / sizeof(struct nid_to_digest);
    293        i++) {
    294     if (nid_to_digest_mapping[i].nid == nid) {
    295       return nid_to_digest_mapping[i].md_func();
    296     }
    297   }
    298 
    299   return NULL;
    300 }
    301 
    302 const EVP_MD* EVP_get_digestbyobj(const ASN1_OBJECT *obj) {
    303   return EVP_get_digestbynid(OBJ_obj2nid(obj));
    304 }
    305 
    306 const EVP_MD *EVP_get_digestbyname(const char *name) {
    307   unsigned i;
    308 
    309   for (i = 0; i < sizeof(nid_to_digest_mapping) / sizeof(struct nid_to_digest);
    310        i++) {
    311     const char *short_name = nid_to_digest_mapping[i].short_name;
    312     const char *long_name = nid_to_digest_mapping[i].long_name;
    313     if ((short_name && strcmp(short_name, name) == 0) ||
    314         (long_name && strcmp(long_name, name) == 0)) {
    315       return nid_to_digest_mapping[i].md_func();
    316     }
    317   }
    318 
    319   return NULL;
    320 }
    321