[BACK]Return to ssh-ed25519.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / ssh

Annotation of src/usr.bin/ssh/ssh-ed25519.c, Revision 1.11

1.11    ! djm         1: /* $OpenBSD: ssh-ed25519.c,v 1.10 2022/08/26 08:12:56 djm Exp $ */
1.1       markus      2: /*
                      3:  * Copyright (c) 2013 Markus Friedl <markus@openbsd.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:  */
1.4       djm        17: #define SSHKEY_INTERNAL
1.1       markus     18: #include <sys/types.h>
1.4       djm        19: #include <limits.h>
1.1       markus     20:
                     21: #include "crypto_api.h"
                     22:
                     23: #include <string.h>
                     24: #include <stdarg.h>
                     25:
                     26: #include "log.h"
1.6       markus     27: #include "sshbuf.h"
1.4       djm        28: #include "sshkey.h"
                     29: #include "ssherr.h"
1.1       markus     30: #include "ssh.h"
                     31:
1.11    ! djm        32: static void
        !            33: ssh_ed25519_cleanup(struct sshkey *k)
        !            34: {
        !            35:        freezero(k->ed25519_pk, ED25519_PK_SZ);
        !            36:        freezero(k->ed25519_sk, ED25519_SK_SZ);
        !            37:        k->ed25519_pk = NULL;
        !            38:        k->ed25519_sk = NULL;
        !            39: }
        !            40:
1.1       markus     41: int
1.4       djm        42: ssh_ed25519_sign(const struct sshkey *key, u_char **sigp, size_t *lenp,
                     43:     const u_char *data, size_t datalen, u_int compat)
1.1       markus     44: {
1.4       djm        45:        u_char *sig = NULL;
                     46:        size_t slen = 0, len;
1.1       markus     47:        unsigned long long smlen;
1.4       djm        48:        int r, ret;
                     49:        struct sshbuf *b = NULL;
1.1       markus     50:
1.4       djm        51:        if (lenp != NULL)
                     52:                *lenp = 0;
                     53:        if (sigp != NULL)
                     54:                *sigp = NULL;
                     55:
                     56:        if (key == NULL ||
                     57:            sshkey_type_plain(key->type) != KEY_ED25519 ||
                     58:            key->ed25519_sk == NULL ||
                     59:            datalen >= INT_MAX - crypto_sign_ed25519_BYTES)
                     60:                return SSH_ERR_INVALID_ARGUMENT;
1.1       markus     61:        smlen = slen = datalen + crypto_sign_ed25519_BYTES;
1.4       djm        62:        if ((sig = malloc(slen)) == NULL)
                     63:                return SSH_ERR_ALLOC_FAIL;
1.1       markus     64:
                     65:        if ((ret = crypto_sign_ed25519(sig, &smlen, data, datalen,
                     66:            key->ed25519_sk)) != 0 || smlen <= datalen) {
1.4       djm        67:                r = SSH_ERR_INVALID_ARGUMENT; /* XXX better error? */
                     68:                goto out;
1.1       markus     69:        }
                     70:        /* encode signature */
1.4       djm        71:        if ((b = sshbuf_new()) == NULL) {
                     72:                r = SSH_ERR_ALLOC_FAIL;
                     73:                goto out;
                     74:        }
                     75:        if ((r = sshbuf_put_cstring(b, "ssh-ed25519")) != 0 ||
                     76:            (r = sshbuf_put_string(b, sig, smlen - datalen)) != 0)
                     77:                goto out;
                     78:        len = sshbuf_len(b);
                     79:        if (sigp != NULL) {
                     80:                if ((*sigp = malloc(len)) == NULL) {
                     81:                        r = SSH_ERR_ALLOC_FAIL;
                     82:                        goto out;
                     83:                }
                     84:                memcpy(*sigp, sshbuf_ptr(b), len);
                     85:        }
1.1       markus     86:        if (lenp != NULL)
                     87:                *lenp = len;
1.4       djm        88:        /* success */
                     89:        r = 0;
                     90:  out:
                     91:        sshbuf_free(b);
1.10      djm        92:        if (sig != NULL)
1.8       jsg        93:                freezero(sig, slen);
1.1       markus     94:
1.4       djm        95:        return r;
1.1       markus     96: }
                     97:
                     98: int
1.4       djm        99: ssh_ed25519_verify(const struct sshkey *key,
                    100:     const u_char *signature, size_t signaturelen,
                    101:     const u_char *data, size_t datalen, u_int compat)
1.1       markus    102: {
1.4       djm       103:        struct sshbuf *b = NULL;
                    104:        char *ktype = NULL;
                    105:        const u_char *sigblob;
                    106:        u_char *sm = NULL, *m = NULL;
                    107:        size_t len;
                    108:        unsigned long long smlen = 0, mlen = 0;
                    109:        int r, ret;
                    110:
                    111:        if (key == NULL ||
                    112:            sshkey_type_plain(key->type) != KEY_ED25519 ||
                    113:            key->ed25519_pk == NULL ||
1.7       djm       114:            datalen >= INT_MAX - crypto_sign_ed25519_BYTES ||
                    115:            signature == NULL || signaturelen == 0)
1.4       djm       116:                return SSH_ERR_INVALID_ARGUMENT;
                    117:
                    118:        if ((b = sshbuf_from(signature, signaturelen)) == NULL)
                    119:                return SSH_ERR_ALLOC_FAIL;
                    120:        if ((r = sshbuf_get_cstring(b, &ktype, NULL)) != 0 ||
                    121:            (r = sshbuf_get_string_direct(b, &sigblob, &len)) != 0)
                    122:                goto out;
1.1       markus    123:        if (strcmp("ssh-ed25519", ktype) != 0) {
1.4       djm       124:                r = SSH_ERR_KEY_TYPE_MISMATCH;
                    125:                goto out;
1.1       markus    126:        }
1.4       djm       127:        if (sshbuf_len(b) != 0) {
                    128:                r = SSH_ERR_UNEXPECTED_TRAILING_DATA;
                    129:                goto out;
1.1       markus    130:        }
                    131:        if (len > crypto_sign_ed25519_BYTES) {
1.4       djm       132:                r = SSH_ERR_INVALID_FORMAT;
                    133:                goto out;
1.1       markus    134:        }
1.5       daniel    135:        if (datalen >= SIZE_MAX - len) {
                    136:                r = SSH_ERR_INVALID_ARGUMENT;
                    137:                goto out;
                    138:        }
1.1       markus    139:        smlen = len + datalen;
1.4       djm       140:        mlen = smlen;
1.6       markus    141:        if ((sm = malloc(smlen)) == NULL || (m = malloc(mlen)) == NULL) {
1.4       djm       142:                r = SSH_ERR_ALLOC_FAIL;
                    143:                goto out;
                    144:        }
1.1       markus    145:        memcpy(sm, sigblob, len);
                    146:        memcpy(sm+len, data, datalen);
                    147:        if ((ret = crypto_sign_ed25519_open(m, &mlen, sm, smlen,
                    148:            key->ed25519_pk)) != 0) {
1.9       djm       149:                debug2_f("crypto_sign_ed25519_open failed: %d", ret);
1.1       markus    150:        }
1.4       djm       151:        if (ret != 0 || mlen != datalen) {
                    152:                r = SSH_ERR_SIGNATURE_INVALID;
                    153:                goto out;
1.1       markus    154:        }
                    155:        /* XXX compare 'm' and 'data' ? */
1.4       djm       156:        /* success */
                    157:        r = 0;
                    158:  out:
1.10      djm       159:        if (sm != NULL)
1.8       jsg       160:                freezero(sm, smlen);
1.10      djm       161:        if (m != NULL)
1.8       jsg       162:                freezero(m, smlen); /* NB mlen may be invalid if r != 0 */
1.4       djm       163:        sshbuf_free(b);
                    164:        free(ktype);
                    165:        return r;
                    166: }
1.11    ! djm       167:
        !           168: static const struct sshkey_impl_funcs sshkey_ed25519_funcs = {
        !           169:        /* .size = */           NULL,
        !           170:        /* .alloc = */          NULL,
        !           171:        /* .cleanup = */        ssh_ed25519_cleanup,
        !           172: };
        !           173:
        !           174: const struct sshkey_impl sshkey_ed25519_impl = {
        !           175:        /* .name = */           "ssh-ed25519",
        !           176:        /* .shortname = */      "ED25519",
        !           177:        /* .sigalg = */         NULL,
        !           178:        /* .type = */           KEY_ED25519,
        !           179:        /* .nid = */            0,
        !           180:        /* .cert = */           0,
        !           181:        /* .sigonly = */        0,
        !           182:        /* .keybits = */        256,
        !           183:        /* .funcs = */          &sshkey_ed25519_funcs,
        !           184: };
        !           185:
        !           186: const struct sshkey_impl sshkey_ed25519_cert_impl = {
        !           187:        /* .name = */           "ssh-ed25519-cert-v01@openssh.com",
        !           188:        /* .shortname = */      "ED25519-CERT",
        !           189:        /* .sigalg = */         NULL,
        !           190:        /* .type = */           KEY_ED25519_CERT,
        !           191:        /* .nid = */            0,
        !           192:        /* .cert = */           1,
        !           193:        /* .sigonly = */        0,
        !           194:        /* .keybits = */        256,
        !           195:        /* .funcs = */          &sshkey_ed25519_funcs,
        !           196: };