Merge branch 'vendor/OPENSSH'
[dragonfly.git] / crypto / openssh / cipher.c
index 1e91290..aeb55b4 100644 (file)
@@ -1,4 +1,4 @@
-/* $OpenBSD: cipher.c,v 1.82 2009/01/26 09:58:15 markus Exp $ */
+/* $OpenBSD: cipher.c,v 1.99 2014/06/24 01:13:21 djm Exp $ */
 /*
  * Author: Tatu Ylonen <ylo@cs.hut.fi>
  * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
 
 #include <sys/types.h>
 
-#include <openssl/md5.h>
-
 #include <string.h>
 #include <stdarg.h>
+#include <stdio.h>
 
-#include "xmalloc.h"
-#include "log.h"
 #include "cipher.h"
+#include "misc.h"
+#include "sshbuf.h"
+#include "ssherr.h"
+#include "digest.h"
 
-/* compatibility with old or broken OpenSSL versions */
 #include "openbsd-compat/openssl-compat.h"
 
+#ifdef WITH_SSH1
 extern const EVP_CIPHER *evp_ssh1_bf(void);
 extern const EVP_CIPHER *evp_ssh1_3des(void);
-extern void ssh1_3des_iv(EVP_CIPHER_CTX *, int, u_char *, int);
-extern const EVP_CIPHER *evp_aes_128_ctr(void);
-extern void ssh_aes_ctr_iv(EVP_CIPHER_CTX *, int, u_char *, u_int);
+extern int ssh1_3des_iv(EVP_CIPHER_CTX *, int, u_char *, int);
+#endif
 
-struct Cipher {
+struct sshcipher {
        char    *name;
        int     number;         /* for ssh1 only */
        u_int   block_size;
        u_int   key_len;
+       u_int   iv_len;         /* defaults to block_size */
+       u_int   auth_len;
        u_int   discard_len;
-       u_int   cbc_mode;
+       u_int   flags;
+#define CFLAG_CBC              (1<<0)
+#define CFLAG_CHACHAPOLY       (1<<1)
+#define CFLAG_AESCTR           (1<<2)
+#define CFLAG_NONE             (1<<3)
+#ifdef WITH_OPENSSL
        const EVP_CIPHER        *(*evptype)(void);
-} ciphers[] = {
-       { "none",               SSH_CIPHER_NONE, 8, 0, 0, 0, EVP_enc_null },
-       { "des",                SSH_CIPHER_DES, 8, 8, 0, 1, EVP_des_cbc },
-       { "3des",               SSH_CIPHER_3DES, 8, 16, 0, 1, evp_ssh1_3des },
-       { "blowfish",           SSH_CIPHER_BLOWFISH, 8, 32, 0, 1, evp_ssh1_bf },
-
-       { "3des-cbc",           SSH_CIPHER_SSH2, 8, 24, 0, 1, EVP_des_ede3_cbc },
-       { "blowfish-cbc",       SSH_CIPHER_SSH2, 8, 16, 0, 1, EVP_bf_cbc },
-       { "cast128-cbc",        SSH_CIPHER_SSH2, 8, 16, 0, 1, EVP_cast5_cbc },
-       { "arcfour",            SSH_CIPHER_SSH2, 8, 16, 0, 0, EVP_rc4 },
-       { "arcfour128",         SSH_CIPHER_SSH2, 8, 16, 1536, 0, EVP_rc4 },
-       { "arcfour256",         SSH_CIPHER_SSH2, 8, 32, 1536, 0, EVP_rc4 },
-       { "aes128-cbc",         SSH_CIPHER_SSH2, 16, 16, 0, 1, EVP_aes_128_cbc },
-       { "aes192-cbc",         SSH_CIPHER_SSH2, 16, 24, 0, 1, EVP_aes_192_cbc },
-       { "aes256-cbc",         SSH_CIPHER_SSH2, 16, 32, 0, 1, EVP_aes_256_cbc },
-       { "rijndael-cbc@lysator.liu.se",
-                               SSH_CIPHER_SSH2, 16, 32, 0, 1, EVP_aes_256_cbc },
-       { "aes128-ctr",         SSH_CIPHER_SSH2, 16, 16, 0, 0, evp_aes_128_ctr },
-       { "aes192-ctr",         SSH_CIPHER_SSH2, 16, 24, 0, 0, evp_aes_128_ctr },
-       { "aes256-ctr",         SSH_CIPHER_SSH2, 16, 32, 0, 0, evp_aes_128_ctr },
-#ifdef USE_CIPHER_ACSS
-       { "acss@openssh.org",   SSH_CIPHER_SSH2, 16, 5, 0, 0, EVP_acss },
+#else
+       void    *ignored;
 #endif
-       { NULL,                 SSH_CIPHER_INVALID, 0, 0, 0, 0, NULL }
+};
+
+static const struct sshcipher ciphers[] = {
+#ifdef WITH_SSH1
+       { "des",        SSH_CIPHER_DES, 8, 8, 0, 0, 0, 1, EVP_des_cbc },
+       { "3des",       SSH_CIPHER_3DES, 8, 16, 0, 0, 0, 1, evp_ssh1_3des },
+       { "blowfish",   SSH_CIPHER_BLOWFISH, 8, 32, 0, 0, 0, 1, evp_ssh1_bf },
+#endif /* WITH_SSH1 */
+#ifdef WITH_OPENSSL
+       { "none",       SSH_CIPHER_NONE, 8, 0, 0, 0, 0, 0, EVP_enc_null },
+       { "3des-cbc",   SSH_CIPHER_SSH2, 8, 24, 0, 0, 0, 1, EVP_des_ede3_cbc },
+       { "blowfish-cbc",
+                       SSH_CIPHER_SSH2, 8, 16, 0, 0, 0, 1, EVP_bf_cbc },
+       { "cast128-cbc",
+                       SSH_CIPHER_SSH2, 8, 16, 0, 0, 0, 1, EVP_cast5_cbc },
+       { "arcfour",    SSH_CIPHER_SSH2, 8, 16, 0, 0, 0, 0, EVP_rc4 },
+       { "arcfour128", SSH_CIPHER_SSH2, 8, 16, 0, 0, 1536, 0, EVP_rc4 },
+       { "arcfour256", SSH_CIPHER_SSH2, 8, 32, 0, 0, 1536, 0, EVP_rc4 },
+       { "aes128-cbc", SSH_CIPHER_SSH2, 16, 16, 0, 0, 0, 1, EVP_aes_128_cbc },
+       { "aes192-cbc", SSH_CIPHER_SSH2, 16, 24, 0, 0, 0, 1, EVP_aes_192_cbc },
+       { "aes256-cbc", SSH_CIPHER_SSH2, 16, 32, 0, 0, 0, 1, EVP_aes_256_cbc },
+       { "rijndael-cbc@lysator.liu.se",
+                       SSH_CIPHER_SSH2, 16, 32, 0, 0, 0, 1, EVP_aes_256_cbc },
+       { "aes128-ctr", SSH_CIPHER_SSH2, 16, 16, 0, 0, 0, 0, EVP_aes_128_ctr },
+       { "aes192-ctr", SSH_CIPHER_SSH2, 16, 24, 0, 0, 0, 0, EVP_aes_192_ctr },
+       { "aes256-ctr", SSH_CIPHER_SSH2, 16, 32, 0, 0, 0, 0, EVP_aes_256_ctr },
+# ifdef OPENSSL_HAVE_EVPGCM
+       { "aes128-gcm@openssh.com",
+                       SSH_CIPHER_SSH2, 16, 16, 12, 16, 0, 0, EVP_aes_128_gcm },
+       { "aes256-gcm@openssh.com",
+                       SSH_CIPHER_SSH2, 16, 32, 12, 16, 0, 0, EVP_aes_256_gcm },
+# endif /* OPENSSL_HAVE_EVPGCM */
+#else /* WITH_OPENSSL */
+       { "aes128-ctr", SSH_CIPHER_SSH2, 16, 16, 0, 0, 0, CFLAG_AESCTR, NULL },
+       { "aes192-ctr", SSH_CIPHER_SSH2, 16, 24, 0, 0, 0, CFLAG_AESCTR, NULL },
+       { "aes256-ctr", SSH_CIPHER_SSH2, 16, 32, 0, 0, 0, CFLAG_AESCTR, NULL },
+       { "none",       SSH_CIPHER_NONE, 8, 0, 0, 0, 0, CFLAG_NONE, NULL },
+#endif /* WITH_OPENSSL */
+       { "chacha20-poly1305@openssh.com",
+                       SSH_CIPHER_SSH2, 8, 64, 0, 16, 0, CFLAG_CHACHAPOLY, NULL },
+
+       { NULL,         SSH_CIPHER_INVALID, 0, 0, 0, 0, 0, 0, NULL }
 };
 
 /*--*/
 
+/* Returns a comma-separated list of supported ciphers. */
+char *
+cipher_alg_list(char sep, int auth_only)
+{
+       char *tmp, *ret = NULL;
+       size_t nlen, rlen = 0;
+       const struct sshcipher *c;
+
+       for (c = ciphers; c->name != NULL; c++) {
+               if (c->number != SSH_CIPHER_SSH2)
+                       continue;
+               if (auth_only && c->auth_len == 0)
+                       continue;
+               if (ret != NULL)
+                       ret[rlen++] = sep;
+               nlen = strlen(c->name);
+               if ((tmp = realloc(ret, rlen + nlen + 2)) == NULL) {
+                       free(ret);
+                       return NULL;
+               }
+               ret = tmp;
+               memcpy(ret + rlen, c->name, nlen + 1);
+               rlen += nlen;
+       }
+       return ret;
+}
+
 u_int
-cipher_blocksize(const Cipher *c)
+cipher_blocksize(const struct sshcipher *c)
 {
        return (c->block_size);
 }
 
 u_int
-cipher_keylen(const Cipher *c)
+cipher_keylen(const struct sshcipher *c)
 {
        return (c->key_len);
 }
 
 u_int
-cipher_get_number(const Cipher *c)
+cipher_seclen(const struct sshcipher *c)
+{
+       if (strcmp("3des-cbc", c->name) == 0)
+               return 14;
+       return cipher_keylen(c);
+}
+
+u_int
+cipher_authlen(const struct sshcipher *c)
+{
+       return (c->auth_len);
+}
+
+u_int
+cipher_ivlen(const struct sshcipher *c)
+{
+       /*
+        * Default is cipher block size, except for chacha20+poly1305 that
+        * needs no IV. XXX make iv_len == -1 default?
+        */
+       return (c->iv_len != 0 || (c->flags & CFLAG_CHACHAPOLY) != 0) ?
+           c->iv_len : c->block_size;
+}
+
+u_int
+cipher_get_number(const struct sshcipher *c)
 {
        return (c->number);
 }
 
 u_int
-cipher_is_cbc(const Cipher *c)
+cipher_is_cbc(const struct sshcipher *c)
 {
-       return (c->cbc_mode);
+       return (c->flags & CFLAG_CBC) != 0;
 }
 
 u_int
@@ -129,20 +209,20 @@ cipher_mask_ssh1(int client)
        return mask;
 }
 
-Cipher *
+const struct sshcipher *
 cipher_by_name(const char *name)
 {
-       Cipher *c;
+       const struct sshcipher *c;
        for (c = ciphers; c->name != NULL; c++)
                if (strcmp(c->name, name) == 0)
                        return c;
        return NULL;
 }
 
-Cipher *
+const struct sshcipher *
 cipher_by_number(int id)
 {
-       Cipher *c;
+       const struct sshcipher *c;
        for (c = ciphers; c->name != NULL; c++)
                if (c->number == id)
                        return c;
@@ -153,27 +233,24 @@ cipher_by_number(int id)
 int
 ciphers_valid(const char *names)
 {
-       Cipher *c;
+       const struct sshcipher *c;
        char *cipher_list, *cp;
        char *p;
 
        if (names == NULL || strcmp(names, "") == 0)
                return 0;
-       cipher_list = cp = xstrdup(names);
+       if ((cipher_list = cp = strdup(names)) == NULL)
+               return 0;
        for ((p = strsep(&cp, CIPHER_SEP)); p && *p != '\0';
            (p = strsep(&cp, CIPHER_SEP))) {
                c = cipher_by_name(p);
                if (c == NULL || (c->number != SSH_CIPHER_SSH2 &&
 c->number != SSH_CIPHER_NONE)) {
-                       debug("bad cipher %s [%s]", p, names);
-                       xfree(cipher_list);
+                       free(cipher_list);
                        return 0;
-               } else {
-                       debug3("cipher ok: %s [%s]", p, names);
                }
        }
-       debug3("ciphers ok: [%s]", names);
-       xfree(cipher_list);
+       free(cipher_list);
        return 1;
 }
 
@@ -185,7 +262,7 @@ c->number != SSH_CIPHER_NONE)) {
 int
 cipher_number(const char *name)
 {
-       Cipher *c;
+       const struct sshcipher *c;
        if (name == NULL)
                return -1;
        for (c = ciphers; c->name != NULL; c++)
@@ -197,238 +274,379 @@ cipher_number(const char *name)
 char *
 cipher_name(int id)
 {
-       Cipher *c = cipher_by_number(id);
+       const struct sshcipher *c = cipher_by_number(id);
        return (c==NULL) ? "<unknown>" : c->name;
 }
 
-void
-cipher_init(CipherContext *cc, Cipher *cipher,
+const char *
+cipher_warning_message(const struct sshcipher_ctx *cc)
+{
+       if (cc == NULL || cc->cipher == NULL)
+               return NULL;
+       if (cc->cipher->number == SSH_CIPHER_DES)
+               return "use of DES is strongly discouraged due to "
+                   "cryptographic weaknesses";
+       return NULL;
+}
+
+int
+cipher_init(struct sshcipher_ctx *cc, const struct sshcipher *cipher,
     const u_char *key, u_int keylen, const u_char *iv, u_int ivlen,
     int do_encrypt)
 {
-       static int dowarn = 1;
-#ifdef SSH_OLD_EVP
-       EVP_CIPHER *type;
-#else
+#ifdef WITH_OPENSSL
+       int ret = SSH_ERR_INTERNAL_ERROR;
        const EVP_CIPHER *type;
        int klen;
-#endif
        u_char *junk, *discard;
 
        if (cipher->number == SSH_CIPHER_DES) {
-               if (dowarn) {
-                       error("Warning: use of DES is strongly discouraged "
-                           "due to cryptographic weaknesses");
-                       dowarn = 0;
-               }
                if (keylen > 8)
                        keylen = 8;
        }
+#endif
        cc->plaintext = (cipher->number == SSH_CIPHER_NONE);
+       cc->encrypt = do_encrypt;
 
-       if (keylen < cipher->key_len)
-               fatal("cipher_init: key length %d is insufficient for %s.",
-                   keylen, cipher->name);
-       if (iv != NULL && ivlen < cipher->block_size)
-               fatal("cipher_init: iv length %d is insufficient for %s.",
-                   ivlen, cipher->name);
-       cc->cipher = cipher;
+       if (keylen < cipher->key_len ||
+           (iv != NULL && ivlen < cipher_ivlen(cipher)))
+               return SSH_ERR_INVALID_ARGUMENT;
 
-       type = (*cipher->evptype)();
-
-       EVP_CIPHER_CTX_init(&cc->evp);
-#ifdef SSH_OLD_EVP
-       if (type->key_len > 0 && type->key_len != keylen) {
-               debug("cipher_init: set keylen (%d -> %d)",
-                   type->key_len, keylen);
-               type->key_len = keylen;
+       cc->cipher = cipher;
+       if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0) {
+               return chachapoly_init(&cc->cp_ctx, key, keylen);
        }
-       EVP_CipherInit(&cc->evp, type, (u_char *)key, (u_char *)iv,
-           (do_encrypt == CIPHER_ENCRYPT));
+#ifndef WITH_OPENSSL
+       if ((cc->cipher->flags & CFLAG_AESCTR) != 0) {
+               aesctr_keysetup(&cc->ac_ctx, key, 8 * keylen, 8 * ivlen);
+               aesctr_ivsetup(&cc->ac_ctx, iv);
+               return 0;
+       }
+       if ((cc->cipher->flags & CFLAG_NONE) != 0)
+               return 0;
+       return SSH_ERR_INVALID_ARGUMENT;
 #else
+       type = (*cipher->evptype)();
+       EVP_CIPHER_CTX_init(&cc->evp);
        if (EVP_CipherInit(&cc->evp, type, NULL, (u_char *)iv,
-           (do_encrypt == CIPHER_ENCRYPT)) == 0)
-               fatal("cipher_init: EVP_CipherInit failed for %s",
-                   cipher->name);
+           (do_encrypt == CIPHER_ENCRYPT)) == 0) {
+               ret = SSH_ERR_LIBCRYPTO_ERROR;
+               goto bad;
+       }
+       if (cipher_authlen(cipher) &&
+           !EVP_CIPHER_CTX_ctrl(&cc->evp, EVP_CTRL_GCM_SET_IV_FIXED,
+           -1, (u_char *)iv)) {
+               ret = SSH_ERR_LIBCRYPTO_ERROR;
+               goto bad;
+       }
        klen = EVP_CIPHER_CTX_key_length(&cc->evp);
        if (klen > 0 && keylen != (u_int)klen) {
-               debug2("cipher_init: set keylen (%d -> %d)", klen, keylen);
-               if (EVP_CIPHER_CTX_set_key_length(&cc->evp, keylen) == 0)
-                       fatal("cipher_init: set keylen failed (%d -> %d)",
-                           klen, keylen);
+               if (EVP_CIPHER_CTX_set_key_length(&cc->evp, keylen) == 0) {
+                       ret = SSH_ERR_LIBCRYPTO_ERROR;
+                       goto bad;
+               }
+       }
+       if (EVP_CipherInit(&cc->evp, NULL, (u_char *)key, NULL, -1) == 0) {
+               ret = SSH_ERR_LIBCRYPTO_ERROR;
+               goto bad;
        }
-       if (EVP_CipherInit(&cc->evp, NULL, (u_char *)key, NULL, -1) == 0)
-               fatal("cipher_init: EVP_CipherInit: set key failed for %s",
-                   cipher->name);
-#endif
 
        if (cipher->discard_len > 0) {
-               junk = xmalloc(cipher->discard_len);
-               discard = xmalloc(cipher->discard_len);
-               if (EVP_Cipher(&cc->evp, discard, junk,
-                   cipher->discard_len) == 0)
-                       fatal("evp_crypt: EVP_Cipher failed during discard");
-               memset(discard, 0, cipher->discard_len);
-               xfree(junk);
-               xfree(discard);
+               if ((junk = malloc(cipher->discard_len)) == NULL ||
+                   (discard = malloc(cipher->discard_len)) == NULL) {
+                       if (junk != NULL)
+                               free(junk);
+                       ret = SSH_ERR_ALLOC_FAIL;
+                       goto bad;
+               }
+               ret = EVP_Cipher(&cc->evp, discard, junk, cipher->discard_len);
+               explicit_bzero(discard, cipher->discard_len);
+               free(junk);
+               free(discard);
+               if (ret != 1) {
+                       ret = SSH_ERR_LIBCRYPTO_ERROR;
+ bad:
+                       EVP_CIPHER_CTX_cleanup(&cc->evp);
+                       return ret;
+               }
        }
+#endif
+       return 0;
 }
 
-void
-cipher_crypt(CipherContext *cc, u_char *dest, const u_char *src, u_int len)
+/*
+ * cipher_crypt() operates as following:
+ * Copy 'aadlen' bytes (without en/decryption) from 'src' to 'dest'.
+ * Theses bytes are treated as additional authenticated data for
+ * authenticated encryption modes.
+ * En/Decrypt 'len' bytes at offset 'aadlen' from 'src' to 'dest'.
+ * Use 'authlen' bytes at offset 'len'+'aadlen' as the authentication tag.
+ * This tag is written on encryption and verified on decryption.
+ * Both 'aadlen' and 'authlen' can be set to 0.
+ */
+int
+cipher_crypt(struct sshcipher_ctx *cc, u_int seqnr, u_char *dest,
+   const u_char *src, u_int len, u_int aadlen, u_int authlen)
 {
+       if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0) {
+               return chachapoly_crypt(&cc->cp_ctx, seqnr, dest, src,
+                   len, aadlen, authlen, cc->encrypt);
+       }
+#ifndef WITH_OPENSSL
+       if ((cc->cipher->flags & CFLAG_AESCTR) != 0) {
+               if (aadlen)
+                       memcpy(dest, src, aadlen);
+               aesctr_encrypt_bytes(&cc->ac_ctx, src + aadlen,
+                   dest + aadlen, len);
+               return 0;
+       }
+       if ((cc->cipher->flags & CFLAG_NONE) != 0) {
+               memcpy(dest, src, aadlen + len);
+               return 0;
+       }
+       return SSH_ERR_INVALID_ARGUMENT;
+#else
+       if (authlen) {
+               u_char lastiv[1];
+
+               if (authlen != cipher_authlen(cc->cipher))
+                       return SSH_ERR_INVALID_ARGUMENT;
+               /* increment IV */
+               if (!EVP_CIPHER_CTX_ctrl(&cc->evp, EVP_CTRL_GCM_IV_GEN,
+                   1, lastiv))
+                       return SSH_ERR_LIBCRYPTO_ERROR;
+               /* set tag on decyption */
+               if (!cc->encrypt &&
+                   !EVP_CIPHER_CTX_ctrl(&cc->evp, EVP_CTRL_GCM_SET_TAG,
+                   authlen, (u_char *)src + aadlen + len))
+                       return SSH_ERR_LIBCRYPTO_ERROR;
+       }
+       if (aadlen) {
+               if (authlen &&
+                   EVP_Cipher(&cc->evp, NULL, (u_char *)src, aadlen) < 0)
+                       return SSH_ERR_LIBCRYPTO_ERROR;
+               memcpy(dest, src, aadlen);
+       }
        if (len % cc->cipher->block_size)
-               fatal("cipher_encrypt: bad plaintext length %d", len);
-       if (EVP_Cipher(&cc->evp, dest, (u_char *)src, len) == 0)
-               fatal("evp_crypt: EVP_Cipher failed");
+               return SSH_ERR_INVALID_ARGUMENT;
+       if (EVP_Cipher(&cc->evp, dest + aadlen, (u_char *)src + aadlen,
+           len) < 0)
+               return SSH_ERR_LIBCRYPTO_ERROR;
+       if (authlen) {
+               /* compute tag (on encrypt) or verify tag (on decrypt) */
+               if (EVP_Cipher(&cc->evp, NULL, NULL, 0) < 0)
+                       return cc->encrypt ?
+                           SSH_ERR_LIBCRYPTO_ERROR : SSH_ERR_MAC_INVALID;
+               if (cc->encrypt &&
+                   !EVP_CIPHER_CTX_ctrl(&cc->evp, EVP_CTRL_GCM_GET_TAG,
+                   authlen, dest + aadlen + len))
+                       return SSH_ERR_LIBCRYPTO_ERROR;
+       }
+       return 0;
+#endif
 }
 
-void
-cipher_cleanup(CipherContext *cc)
+/* Extract the packet length, including any decryption necessary beforehand */
+int
+cipher_get_length(struct sshcipher_ctx *cc, u_int *plenp, u_int seqnr,
+    const u_char *cp, u_int len)
 {
-       if (EVP_CIPHER_CTX_cleanup(&cc->evp) == 0)
-               error("cipher_cleanup: EVP_CIPHER_CTX_cleanup failed");
+       if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0)
+               return chachapoly_get_length(&cc->cp_ctx, plenp, seqnr,
+                   cp, len);
+       if (len < 4)
+               return SSH_ERR_MESSAGE_INCOMPLETE;
+       *plenp = get_u32(cp);
+       return 0;
+}
+
+int
+cipher_cleanup(struct sshcipher_ctx *cc)
+{
+       if (cc == NULL || cc->cipher == NULL)
+               return 0;
+       if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0)
+               explicit_bzero(&cc->cp_ctx, sizeof(cc->cp_ctx));
+       else if ((cc->cipher->flags & CFLAG_AESCTR) != 0)
+               explicit_bzero(&cc->ac_ctx, sizeof(cc->ac_ctx));
+#ifdef WITH_OPENSSL
+       else if (EVP_CIPHER_CTX_cleanup(&cc->evp) == 0)
+               return SSH_ERR_LIBCRYPTO_ERROR;
+#endif
+       return 0;
 }
 
 /*
  * Selects the cipher, and keys if by computing the MD5 checksum of the
  * passphrase and using the resulting 16 bytes as the key.
  */
-
-void
-cipher_set_key_string(CipherContext *cc, Cipher *cipher,
+int
+cipher_set_key_string(struct sshcipher_ctx *cc, const struct sshcipher *cipher,
     const char *passphrase, int do_encrypt)
 {
-       MD5_CTX md;
        u_char digest[16];
+       int r = SSH_ERR_INTERNAL_ERROR;
 
-       MD5_Init(&md);
-       MD5_Update(&md, (const u_char *)passphrase, strlen(passphrase));
-       MD5_Final(digest, &md);
-
-       cipher_init(cc, cipher, digest, 16, NULL, 0, do_encrypt);
+       if ((r = ssh_digest_memory(SSH_DIGEST_MD5,
+           passphrase, strlen(passphrase),
+           digest, sizeof(digest))) != 0)
+               goto out;
 
-       memset(digest, 0, sizeof(digest));
-       memset(&md, 0, sizeof(md));
+       r = cipher_init(cc, cipher, digest, 16, NULL, 0, do_encrypt);
+ out:
+       explicit_bzero(digest, sizeof(digest));
+       return r;
 }
 
 /*
- * Exports an IV from the CipherContext required to export the key
+ * Exports an IV from the sshcipher_ctx required to export the key
  * state back from the unprivileged child to the privileged parent
  * process.
  */
-
 int
-cipher_get_keyiv_len(const CipherContext *cc)
+cipher_get_keyiv_len(const struct sshcipher_ctx *cc)
 {
-       Cipher *c = cc->cipher;
-       int ivlen;
+       const struct sshcipher *c = cc->cipher;
+       int ivlen = 0;
 
        if (c->number == SSH_CIPHER_3DES)
                ivlen = 24;
+       else if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0)
+               ivlen = 0;
+#ifdef WITH_OPENSSL
        else
                ivlen = EVP_CIPHER_CTX_iv_length(&cc->evp);
+#endif /* WITH_OPENSSL */
        return (ivlen);
 }
 
-void
-cipher_get_keyiv(CipherContext *cc, u_char *iv, u_int len)
+int
+cipher_get_keyiv(struct sshcipher_ctx *cc, u_char *iv, u_int len)
 {
-       Cipher *c = cc->cipher;
-       int evplen;
+       const struct sshcipher *c = cc->cipher;
+#ifdef WITH_OPENSSL
+       int evplen;
+#endif
+
+       if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0) {
+               if (len != 0)
+                       return SSH_ERR_INVALID_ARGUMENT;
+               return 0;
+       }
+       if ((cc->cipher->flags & CFLAG_NONE) != 0)
+               return 0;
 
        switch (c->number) {
+#ifdef WITH_OPENSSL
        case SSH_CIPHER_NONE:
        case SSH_CIPHER_SSH2:
        case SSH_CIPHER_DES:
        case SSH_CIPHER_BLOWFISH:
                evplen = EVP_CIPHER_CTX_iv_length(&cc->evp);
-               if (evplen <= 0)
-                       return;
+               if (evplen == 0)
+                       return 0;
+               else if (evplen < 0)
+                       return SSH_ERR_LIBCRYPTO_ERROR;
                if ((u_int)evplen != len)
-                       fatal("%s: wrong iv length %d != %d", __func__,
-                           evplen, len);
-#ifdef USE_BUILTIN_RIJNDAEL
-               if (c->evptype == evp_rijndael)
-                       ssh_rijndael_iv(&cc->evp, 0, iv, len);
-               else
-#endif
+                       return SSH_ERR_INVALID_ARGUMENT;
+#ifndef OPENSSL_HAVE_EVPCTR
                if (c->evptype == evp_aes_128_ctr)
                        ssh_aes_ctr_iv(&cc->evp, 0, iv, len);
                else
+#endif
+               if (cipher_authlen(c)) {
+                       if (!EVP_CIPHER_CTX_ctrl(&cc->evp, EVP_CTRL_GCM_IV_GEN,
+                          len, iv))
+                              return SSH_ERR_LIBCRYPTO_ERROR;
+               } else
                        memcpy(iv, cc->evp.iv, len);
                break;
+#endif
+#ifdef WITH_SSH1
        case SSH_CIPHER_3DES:
-               ssh1_3des_iv(&cc->evp, 0, iv, 24);
-               break;
+               return ssh1_3des_iv(&cc->evp, 0, iv, 24);
+#endif
        default:
-               fatal("%s: bad cipher %d", __func__, c->number);
+               return SSH_ERR_INVALID_ARGUMENT;
        }
+       return 0;
 }
 
-void
-cipher_set_keyiv(CipherContext *cc, u_char *iv)
+int
+cipher_set_keyiv(struct sshcipher_ctx *cc, const u_char *iv)
 {
-       Cipher *c = cc->cipher;
-       int evplen = 0;
+       const struct sshcipher *c = cc->cipher;
+#ifdef WITH_OPENSSL
+       int evplen = 0;
+#endif
+
+       if ((cc->cipher->flags & CFLAG_CHACHAPOLY) != 0)
+               return 0;
+       if ((cc->cipher->flags & CFLAG_NONE) != 0)
+               return 0;
 
        switch (c->number) {
+#ifdef WITH_OPENSSL
        case SSH_CIPHER_NONE:
        case SSH_CIPHER_SSH2:
        case SSH_CIPHER_DES:
        case SSH_CIPHER_BLOWFISH:
                evplen = EVP_CIPHER_CTX_iv_length(&cc->evp);
-               if (evplen == 0)
-                       return;
-#ifdef USE_BUILTIN_RIJNDAEL
-               if (c->evptype == evp_rijndael)
-                       ssh_rijndael_iv(&cc->evp, 1, iv, evplen);
-               else
-#endif
-               if (c->evptype == evp_aes_128_ctr)
-                       ssh_aes_ctr_iv(&cc->evp, 1, iv, evplen);
-               else
+               if (evplen <= 0)
+                       return SSH_ERR_LIBCRYPTO_ERROR;
+               if (cipher_authlen(c)) {
+                       /* XXX iv arg is const, but EVP_CIPHER_CTX_ctrl isn't */
+                       if (!EVP_CIPHER_CTX_ctrl(&cc->evp,
+                           EVP_CTRL_GCM_SET_IV_FIXED, -1, (void *)iv))
+                               return SSH_ERR_LIBCRYPTO_ERROR;
+               } else
                        memcpy(cc->evp.iv, iv, evplen);
                break;
+#endif
+#ifdef WITH_SSH1
        case SSH_CIPHER_3DES:
-               ssh1_3des_iv(&cc->evp, 1, iv, 24);
-               break;
+               return ssh1_3des_iv(&cc->evp, 1, (u_char *)iv, 24);
+#endif
        default:
-               fatal("%s: bad cipher %d", __func__, c->number);
+               return SSH_ERR_INVALID_ARGUMENT;
        }
+       return 0;
 }
 
-#if OPENSSL_VERSION_NUMBER < 0x00907000L
-#define EVP_X_STATE(evp)       &(evp).c
-#define EVP_X_STATE_LEN(evp)   sizeof((evp).c)
-#else
+#ifdef WITH_OPENSSL
 #define EVP_X_STATE(evp)       (evp).cipher_data
 #define EVP_X_STATE_LEN(evp)   (evp).cipher->ctx_size
 #endif
 
 int
-cipher_get_keycontext(const CipherContext *cc, u_char *dat)
+cipher_get_keycontext(const struct sshcipher_ctx *cc, u_char *dat)
 {
-       Cipher *c = cc->cipher;
+#ifdef WITH_OPENSSL
+       const struct sshcipher *c = cc->cipher;
        int plen = 0;
 
-       if (c->evptype == EVP_rc4 || c->evptype == EVP_acss) {
+       if (c->evptype == EVP_rc4) {
                plen = EVP_X_STATE_LEN(cc->evp);
                if (dat == NULL)
                        return (plen);
                memcpy(dat, EVP_X_STATE(cc->evp), plen);
        }
        return (plen);
+#else
+       return 0;
+#endif
 }
 
 void
-cipher_set_keycontext(CipherContext *cc, u_char *dat)
+cipher_set_keycontext(struct sshcipher_ctx *cc, const u_char *dat)
 {
-       Cipher *c = cc->cipher;
+#ifdef WITH_OPENSSL
+       const struct sshcipher *c = cc->cipher;
        int plen;
 
-       if (c->evptype == EVP_rc4 || c->evptype == EVP_acss) {
+       if (c->evptype == EVP_rc4) {
                plen = EVP_X_STATE_LEN(cc->evp);
                memcpy(EVP_X_STATE(cc->evp), dat, plen);
        }
+#endif
 }