/* $OpenBSD: authfile.c,v 1.145 2024/09/22 12:56:21 jsg Exp $ */
/*
 * Copyright (c) 2000, 2013 Markus Friedl.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include "includes.h"

#include <sys/types.h>
#include <sys/stat.h>
#include <sys/uio.h>

#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdarg.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <limits.h>

#include "cipher.h"
#include "ssh.h"
#include "log.h"
#include "authfile.h"
#include "misc.h"
#include "atomicio.h"
#include "sshkey.h"
#include "sshbuf.h"
#include "ssherr.h"
#include "krl.h"

/* Save a key blob to a file */
static int
sshkey_save_private_blob(struct sshbuf *keybuf, const char *filename)
{
        int r;
        mode_t omask;

        omask = umask(077);
        r = sshbuf_write_file(filename, keybuf);
        umask(omask);
        return r;
}

int
sshkey_save_private(struct sshkey *key, const char *filename,
    const char *passphrase, const char *comment,
    int format, const char *openssh_format_cipher, int openssh_format_rounds)
{
        struct sshbuf *keyblob = NULL;
        int r;

        if ((keyblob = sshbuf_new()) == NULL)
                return SSH_ERR_ALLOC_FAIL;
        if ((r = sshkey_private_to_fileblob(key, keyblob, passphrase, comment,
            format, openssh_format_cipher, openssh_format_rounds)) != 0)
                goto out;
        if ((r = sshkey_save_private_blob(keyblob, filename)) != 0)
                goto out;
        r = 0;
 out:
        sshbuf_free(keyblob);
        return r;
}

/* XXX remove error() calls from here? */
int
sshkey_perm_ok(int fd, const char *filename)
{
        struct stat st;

        if (fstat(fd, &st) == -1)
                return SSH_ERR_SYSTEM_ERROR;
        /*
         * if a key owned by the user is accessed, then we check the
         * permissions of the file. if the key owned by a different user,
         * then we don't care.
         */
#ifdef HAVE_CYGWIN
        if (check_ntsec(filename))
#endif
        if ((st.st_uid == getuid()) && (st.st_mode & 077) != 0) {
                error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
                error("@         WARNING: UNPROTECTED PRIVATE KEY FILE!          @");
                error("@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@@");
                error("Permissions 0%3.3o for '%s' are too open.",
                    (u_int)st.st_mode & 0777, filename);
                error("It is required that your private key files are NOT accessible by others.");
                error("This private key will be ignored.");
                return SSH_ERR_KEY_BAD_PERMISSIONS;
        }
        return 0;
}

int
sshkey_load_private_type(int type, const char *filename, const char *passphrase,
    struct sshkey **keyp, char **commentp)
{
        int fd, r;

        if (keyp != NULL)
                *keyp = NULL;
        if (commentp != NULL)
                *commentp = NULL;

        if ((fd = open(filename, O_RDONLY)) == -1)
                return SSH_ERR_SYSTEM_ERROR;

        r = sshkey_perm_ok(fd, filename);
        if (r != 0)
                goto out;

        r = sshkey_load_private_type_fd(fd, type, passphrase, keyp, commentp);
        if (r == 0 && keyp && *keyp)
                r = sshkey_set_filename(*keyp, filename);
 out:
        close(fd);
        return r;
}

int
sshkey_load_private(const char *filename, const char *passphrase,
    struct sshkey **keyp, char **commentp)
{
        return sshkey_load_private_type(KEY_UNSPEC, filename, passphrase,
            keyp, commentp);
}

int
sshkey_load_private_type_fd(int fd, int type, const char *passphrase,
    struct sshkey **keyp, char **commentp)
{
        struct sshbuf *buffer = NULL;
        int r;

        if (keyp != NULL)
                *keyp = NULL;
        if ((r = sshbuf_load_fd(fd, &buffer)) != 0 ||
            (r = sshkey_parse_private_fileblob_type(buffer, type,
            passphrase, keyp, commentp)) != 0)
                goto out;

        /* success */
        r = 0;
 out:
        sshbuf_free(buffer);
        return r;
}

/* Load a pubkey from the unencrypted envelope of a new-format private key */
static int
sshkey_load_pubkey_from_private(const char *filename, struct sshkey **pubkeyp)
{
        struct sshbuf *buffer = NULL;
        struct sshkey *pubkey = NULL;
        int r, fd;

        if (pubkeyp != NULL)
                *pubkeyp = NULL;

        if ((fd = open(filename, O_RDONLY)) == -1)
                return SSH_ERR_SYSTEM_ERROR;
        if ((r = sshbuf_load_fd(fd, &buffer)) != 0 ||
            (r = sshkey_parse_pubkey_from_private_fileblob_type(buffer,
            KEY_UNSPEC, &pubkey)) != 0)
                goto out;
        if ((r = sshkey_set_filename(pubkey, filename)) != 0)
                goto out;
        /* success */
        if (pubkeyp != NULL) {
                *pubkeyp = pubkey;
                pubkey = NULL;
        }
        r = 0;
 out:
        close(fd);
        sshbuf_free(buffer);
        sshkey_free(pubkey);
        return r;
}

static int
sshkey_try_load_public(struct sshkey **kp, const char *filename,
    char **commentp)
{
        FILE *f;
        char *line = NULL, *cp;
        size_t linesize = 0;
        int r;
        struct sshkey *k = NULL;

        if (kp == NULL)
                return SSH_ERR_INVALID_ARGUMENT;
        *kp = NULL;
        if (commentp != NULL)
                *commentp = NULL;
        if ((f = fopen(filename, "r")) == NULL)
                return SSH_ERR_SYSTEM_ERROR;
        if ((k = sshkey_new(KEY_UNSPEC)) == NULL) {
                fclose(f);
                return SSH_ERR_ALLOC_FAIL;
        }
        while (getline(&line, &linesize, f) != -1) {
                cp = line;
                switch (*cp) {
                case '#':
                case '\n':
                case '\0':
                        continue;
                }
                /* Abort loading if this looks like a private key */
                if (strncmp(cp, "-----BEGIN", 10) == 0 ||
                    strcmp(cp, "SSH PRIVATE KEY FILE") == 0)
                        break;
                /* Skip leading whitespace. */
                for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
                        ;
                if (*cp) {
                        if ((r = sshkey_read(k, &cp)) == 0) {
                                cp[strcspn(cp, "\r\n")] = '\0';
                                if (commentp) {
                                        *commentp = strdup(*cp ?
                                            cp : filename);
                                        if (*commentp == NULL)
                                                r = SSH_ERR_ALLOC_FAIL;
                                }
                                /* success */
                                *kp = k;
                                free(line);
                                fclose(f);
                                return r;
                        }
                }
        }
        free(k);
        free(line);
        fclose(f);
        return SSH_ERR_INVALID_FORMAT;
}

/* load public key from any pubkey file */
int
sshkey_load_public(const char *filename, struct sshkey **keyp, char **commentp)
{
        char *pubfile = NULL;
        int r, oerrno;

        if (keyp != NULL)
                *keyp = NULL;
        if (commentp != NULL)
                *commentp = NULL;

        if ((r = sshkey_try_load_public(keyp, filename, commentp)) == 0)
                goto out;

        /* try .pub suffix */
        if (asprintf(&pubfile, "%s.pub", filename) == -1)
                return SSH_ERR_ALLOC_FAIL;
        if ((r = sshkey_try_load_public(keyp, pubfile, commentp)) == 0)
                goto out;

        /* finally, try to extract public key from private key file */
        if ((r = sshkey_load_pubkey_from_private(filename, keyp)) == 0)
                goto out;

        /* Pretend we couldn't find the key */
        r = SSH_ERR_SYSTEM_ERROR;
        errno = ENOENT;

 out:
        oerrno = errno;
        free(pubfile);
        errno = oerrno;
        return r;
}

/* Load the certificate associated with the named private key */
int
sshkey_load_cert(const char *filename, struct sshkey **keyp)
{
        struct sshkey *pub = NULL;
        char *file = NULL;
        int r = SSH_ERR_INTERNAL_ERROR;

        if (keyp != NULL)
                *keyp = NULL;

        if (asprintf(&file, "%s-cert.pub", filename) == -1)
                return SSH_ERR_ALLOC_FAIL;

        r = sshkey_try_load_public(keyp, file, NULL);
        free(file);
        sshkey_free(pub);
        return r;
}

/* Load private key and certificate */
int
sshkey_load_private_cert(int type, const char *filename, const char *passphrase,
    struct sshkey **keyp)
{
        struct sshkey *key = NULL, *cert = NULL;
        int r;

        if (keyp != NULL)
                *keyp = NULL;

        switch (type) {
#ifdef WITH_OPENSSL
        case KEY_RSA:
        case KEY_DSA:
        case KEY_ECDSA:
#endif /* WITH_OPENSSL */
        case KEY_ED25519:
        case KEY_XMSS:
        case KEY_UNSPEC:
                break;
        default:
                return SSH_ERR_KEY_TYPE_UNKNOWN;
        }

        if ((r = sshkey_load_private_type(type, filename,
            passphrase, &key, NULL)) != 0 ||
            (r = sshkey_load_cert(filename, &cert)) != 0)
                goto out;

        /* Make sure the private key matches the certificate */
        if (sshkey_equal_public(key, cert) == 0) {
                r = SSH_ERR_KEY_CERT_MISMATCH;
                goto out;
        }

        if ((r = sshkey_to_certified(key)) != 0 ||
            (r = sshkey_cert_copy(cert, key)) != 0)
                goto out;
        r = 0;
        if (keyp != NULL) {
                *keyp = key;
                key = NULL;
        }
 out:
        sshkey_free(key);
        sshkey_free(cert);
        return r;
}

/*
 * Returns success if the specified "key" is listed in the file "filename",
 * SSH_ERR_KEY_NOT_FOUND: if the key is not listed or another error.
 * If "strict_type" is set then the key type must match exactly,
 * otherwise a comparison that ignores certificate data is performed.
 * If "check_ca" is set and "key" is a certificate, then its CA key is
 * also checked and sshkey_in_file() will return success if either is found.
 */
int
sshkey_in_file(struct sshkey *key, const char *filename, int strict_type,
    int check_ca)
{
        FILE *f;
        char *line = NULL, *cp;
        size_t linesize = 0;
        int r = 0;
        struct sshkey *pub = NULL;

        int (*sshkey_compare)(const struct sshkey *, const struct sshkey *) =
            strict_type ?  sshkey_equal : sshkey_equal_public;

        if ((f = fopen(filename, "r")) == NULL)
                return SSH_ERR_SYSTEM_ERROR;

        while (getline(&line, &linesize, f) != -1) {
                sshkey_free(pub);
                pub = NULL;
                cp = line;

                /* Skip leading whitespace. */
                for (; *cp && (*cp == ' ' || *cp == '\t'); cp++)
                        ;

                /* Skip comments and empty lines */
                switch (*cp) {
                case '#':
                case '\n':
                case '\0':
                        continue;
                }

                if ((pub = sshkey_new(KEY_UNSPEC)) == NULL) {
                        r = SSH_ERR_ALLOC_FAIL;
                        goto out;
                }
                switch (r = sshkey_read(pub, &cp)) {
                case 0:
                        break;
                case SSH_ERR_KEY_LENGTH:
                        continue;
                default:
                        goto out;
                }
                if (sshkey_compare(key, pub) ||
                    (check_ca && sshkey_is_cert(key) &&
                    sshkey_compare(key->cert->signature_key, pub))) {
                        r = 0;
                        goto out;
                }
        }
        r = SSH_ERR_KEY_NOT_FOUND;
 out:
        free(line);
        sshkey_free(pub);
        fclose(f);
        return r;
}

/*
 * Checks whether the specified key is revoked, returning 0 if not,
 * SSH_ERR_KEY_REVOKED if it is or another error code if something
 * unexpected happened.
 * This will check both the key and, if it is a certificate, its CA key too.
 * "revoked_keys_file" may be a KRL or a one-per-line list of public keys.
 */
int
sshkey_check_revoked(struct sshkey *key, const char *revoked_keys_file)
{
        int r;

        r = ssh_krl_file_contains_key(revoked_keys_file, key);
        /* If this was not a KRL to begin with then continue below */
        if (r != SSH_ERR_KRL_BAD_MAGIC)
                return r;

        /*
         * If the file is not a KRL or we can't handle KRLs then attempt to
         * parse the file as a flat list of keys.
         */
        switch ((r = sshkey_in_file(key, revoked_keys_file, 0, 1))) {
        case 0:
                /* Key found => revoked */
                return SSH_ERR_KEY_REVOKED;
        case SSH_ERR_KEY_NOT_FOUND:
                /* Key not found => not revoked */
                return 0;
        default:
                /* Some other error occurred */
                return r;
        }
}

/*
 * Advanced *cpp past the end of key options, defined as the first unquoted
 * whitespace character. Returns 0 on success or -1 on failure (e.g.
 * unterminated quotes).
 */
int
sshkey_advance_past_options(char **cpp)
{
        char *cp = *cpp;
        int quoted = 0;

        for (; *cp && (quoted || (*cp != ' ' && *cp != '\t')); cp++) {
                if (*cp == '\\' && cp[1] == '"')
                        cp++;   /* Skip both */
                else if (*cp == '"')
                        quoted = !quoted;
        }
        *cpp = cp;
        /* return failure for unterminated quotes */
        return (*cp == '\0' && quoted) ? -1 : 0;
}

/* Save a public key */
int
sshkey_save_public(const struct sshkey *key, const char *path,
    const char *comment)
{
        int fd, oerrno;
        FILE *f = NULL;
        int r = SSH_ERR_INTERNAL_ERROR;

        if ((fd = open(path, O_WRONLY|O_CREAT|O_TRUNC, 0644)) == -1)
                return SSH_ERR_SYSTEM_ERROR;
        if ((f = fdopen(fd, "w")) == NULL) {
                r = SSH_ERR_SYSTEM_ERROR;
                close(fd);
                goto fail;
        }
        if ((r = sshkey_write(key, f)) != 0)
                goto fail;
        fprintf(f, " %s\n", comment);
        if (ferror(f)) {
                r = SSH_ERR_SYSTEM_ERROR;
                goto fail;
        }
        if (fclose(f) != 0) {
                r = SSH_ERR_SYSTEM_ERROR;
                f = NULL;
 fail:
                if (f != NULL) {
                        oerrno = errno;
                        fclose(f);
                        errno = oerrno;
                }
                return r;
        }
        return 0;
}