Return to digest.c CVS log

Up to [local] / src / usr.bin / ssh

Annotation of src/usr.bin/ssh/digest.c, Revision 1.3

1.3     ! djm         1: /* $OpenBSD: digest.c,v 1.2 2014/01/17 05:26:41 dtucker Exp $ */
1.1       djm         2: /*
                      3:  * Copyright (c) 2013 Damien Miller <djm@mindrot.org>
                      4:  *
                      5:  * Permission to use, copy, modify, and distribute this software for any
                      6:  * purpose with or without fee is hereby granted, provided that the above
                      7:  * copyright notice and this permission notice appear in all copies.
                      8:  *
                      9:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     10:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     11:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     12:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     13:  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
                     14:  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
                     15:  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     16:  */
                     17:
                     18: #include <sys/types.h>
                     19: #include <limits.h>
                     20: #include <stdlib.h>
                     21: #include <string.h>
                     22:
                     23: #include <openssl/evp.h>
                     24:
                     25: #include "buffer.h"
                     26: #include "digest.h"
                     27:
                     28: struct ssh_digest_ctx {
                     29:        int alg;
                     30:        EVP_MD_CTX mdctx;
                     31: };
                     32:
                     33: struct ssh_digest {
                     34:        int id;
                     35:        const char *name;
                     36:        size_t digest_len;
                     37:        const EVP_MD *(*mdfunc)(void);
                     38: };
                     39:
                     40: /* NB. Indexed directly by algorithm number */
                     41: const struct ssh_digest digests[] = {
                     42:        { SSH_DIGEST_MD5,       "MD5",          16,     EVP_md5 },
                     43:        { SSH_DIGEST_RIPEMD160, "RIPEMD160",    20,     EVP_ripemd160 },
                     44:        { SSH_DIGEST_SHA1,      "SHA1",         20,     EVP_sha1 },
                     45:        { SSH_DIGEST_SHA256,    "SHA256",       32,     EVP_sha256 },
                     46:        { SSH_DIGEST_SHA384,    "SHA384",       48,     EVP_sha384 },
                     47:        { SSH_DIGEST_SHA512,    "SHA512",       64,     EVP_sha512 },
                     48:        { -1,                   NULL,           0,      NULL },
                     49: };
                     50:
                     51: static const struct ssh_digest *
                     52: ssh_digest_by_alg(int alg)
                     53: {
                     54:        if (alg < 0 || alg >= SSH_DIGEST_MAX)
                     55:                return NULL;
                     56:        if (digests[alg].id != alg) /* sanity */
                     57:                return NULL;
                     58:        return &(digests[alg]);
                     59: }
                     60:
                     61: size_t
                     62: ssh_digest_bytes(int alg)
                     63: {
                     64:        const struct ssh_digest *digest = ssh_digest_by_alg(alg);
                     65:
                     66:        return digest == NULL ? 0 : digest->digest_len;
                     67: }
                     68:
                     69: struct ssh_digest_ctx *
                     70: ssh_digest_start(int alg)
                     71: {
                     72:        const struct ssh_digest *digest = ssh_digest_by_alg(alg);
                     73:        struct ssh_digest_ctx *ret;
                     74:
                     75:        if (digest == NULL || ((ret = calloc(1, sizeof(*ret))) == NULL))
                     76:                return NULL;
                     77:        ret->alg = alg;
                     78:        EVP_MD_CTX_init(&ret->mdctx);
                     79:        if (EVP_DigestInit_ex(&ret->mdctx, digest->mdfunc(), NULL) != 1) {
                     80:                free(ret);
                     81:                return NULL;
                     82:        }
                     83:        return ret;
                     84: }
                     85:
                     86: int
                     87: ssh_digest_update(struct ssh_digest_ctx *ctx, const void *m, size_t mlen)
                     88: {
                     89:        if (EVP_DigestUpdate(&ctx->mdctx, m, mlen) != 1)
                     90:                return -1;
                     91:        return 0;
                     92: }
                     93:
                     94: int
                     95: ssh_digest_update_buffer(struct ssh_digest_ctx *ctx, const Buffer *b)
                     96: {
                     97:        return ssh_digest_update(ctx, buffer_ptr(b), buffer_len(b));
                     98: }
                     99:
                    100: int
                    101: ssh_digest_final(struct ssh_digest_ctx *ctx, u_char *d, size_t dlen)
                    102: {
                    103:        const struct ssh_digest *digest = ssh_digest_by_alg(ctx->alg);
                    104:        u_int l = dlen;
                    105:
                    106:        if (dlen > UINT_MAX)
                    107:                return -1;
                    108:        if (dlen < digest->digest_len) /* No truncation allowed */
                    109:                return -1;
                    110:        if (EVP_DigestFinal_ex(&ctx->mdctx, d, &l) != 1)
                    111:                return -1;
                    112:        if (l != digest->digest_len) /* sanity */
                    113:                return -1;
                    114:        return 0;
                    115: }
                    116:
                    117: void
                    118: ssh_digest_free(struct ssh_digest_ctx *ctx)
                    119: {
                    120:        EVP_MD_CTX_cleanup(&ctx->mdctx);
                    121:        memset(ctx, 0, sizeof(*ctx));
1.3     ! djm       122:        free(ctx);
1.1       djm       123: }
                    124:
                    125: int
                    126: ssh_digest_memory(int alg, const void *m, size_t mlen, u_char *d, size_t dlen)
                    127: {
                    128:        struct ssh_digest_ctx *ctx = ssh_digest_start(alg);
                    129:
                    130:        if (ctx == NULL)
                    131:                return -1;
                    132:        if (ssh_digest_update(ctx, m, mlen) != 0 ||
                    133:            ssh_digest_final(ctx, d, dlen) != 0)
                    134:                return -1;
                    135:        ssh_digest_free(ctx);
                    136:        return 0;
                    137: }
                    138:
                    139: int
                    140: ssh_digest_buffer(int alg, const Buffer *b, u_char *d, size_t dlen)
                    141: {
                    142:        return ssh_digest_memory(alg, buffer_ptr(b), buffer_len(b), d, dlen);
                    143: }