* New upstream release (closes: #536182). Yes, I know 5.3p1 has been out

  for a while, but there's no GSSAPI patch available for it yet.
  - Change the default cipher order to prefer the AES CTR modes and the
    revised "arcfour256" mode to CBC mode ciphers that are susceptible to
    CPNI-957037 "Plaintext Recovery Attack Against SSH".
  - Add countermeasures to mitigate CPNI-957037-style attacks against the
    SSH protocol's use of CBC-mode ciphers. Upon detection of an invalid
    packet length or Message Authentication Code, ssh/sshd will continue
    reading up to the maximum supported packet length rather than
    immediately terminating the connection. This eliminates most of the
    known differences in behaviour that leaked information about the
    plaintext of injected data which formed the basis of this attack
    (closes: #506115, LP: #379329).
  - ForceCommand directive now accepts commandline arguments for the
    internal-sftp server (closes: #524423, LP: #362511).
  - Add AllowAgentForwarding to available Match keywords list (closes:
    #540623).
  - Make ssh(1) send the correct channel number for
    SSH2_MSG_CHANNEL_SUCCESS and SSH2_MSG_CHANNEL_FAILURE messages to
    avoid triggering 'Non-public channel' error messages on sshd(8) in
    openssh-5.1.
  - Avoid printing 'Non-public channel' warnings in sshd(8), since the
    ssh(1) has sent incorrect channel numbers since ~2004 (this reverts a
    behaviour introduced in openssh-5.1; closes: #496017).
* Update to GSSAPI patch from
  http://www.sxw.org.uk/computing/patches/openssh-5.2p1-gsskex-all-20090726.patch,
  including cascading credentials support (LP: #416958).

1 files changed, 188 insertions, 3 deletions

diff --git a/monitor_wrap.c b/monitor_wrap.c
index 125f879c5..92e04901d 100644
--- a/monitor_wrap.c
+++ b/monitor_wrap.c
@@ -1,4 +1,4 @@
-/* $OpenBSD: monitor_wrap.c,v 1.63 2008/07/10 18:08:11 markus Exp $ */
+/* $OpenBSD: monitor_wrap.c,v 1.64 2008/11/04 08:22:13 djm Exp $ */
 /*
  * Copyright 2002 Niels Provos <provos@citi.umich.edu>
  * Copyright 2002 Markus Friedl <markus@openbsd.org>
@@ -40,6 +40,7 @@
 
 #include <openssl/bn.h>
 #include <openssl/dh.h>
+#include <openssl/evp.h>
 
 #include "openbsd-compat/sys-queue.h"
 #include "xmalloc.h"
@@ -70,7 +71,7 @@
 #include "atomicio.h"
 #include "monitor_fdpass.h"
 #include "misc.h"
-#include "servconf.h"
+#include "jpake.h"
 
 #include "channels.h"
 #include "session.h"
@@ -1256,7 +1257,7 @@ mm_ssh_gssapi_checkmic(Gssctxt *ctx, gss_buffer_t gssbuf, gss_buffer_t gssmic)
 }
 
 int
-mm_ssh_gssapi_userok(char *user)
+mm_ssh_gssapi_userok(char *user, struct passwd *pw)
 {
         Buffer m;
         int authenticated = 0;
@@ -1296,4 +1297,188 @@ mm_ssh_gssapi_sign(Gssctxt *ctx, gss_buffer_desc *data, gss_buffer_desc *hash)
         return(major);
 }
 
+int
+mm_ssh_gssapi_update_creds(ssh_gssapi_ccache *store)
+{
+        Buffer m;
+        int ok;
+
+        buffer_init(&m);
+
+        buffer_put_cstring(&m, store->filename ? store->filename : "");
+        buffer_put_cstring(&m, store->envvar ? store->envvar : "");
+        buffer_put_cstring(&m, store->envval ? store->envval : "");
+        
+        mm_request_send(pmonitor->m_recvfd, MONITOR_REQ_GSSUPCREDS, &m);
+        mm_request_receive_expect(pmonitor->m_recvfd, MONITOR_ANS_GSSUPCREDS, &m);
+
+        ok = buffer_get_int(&m);
+
+        buffer_free(&m);
+        
+        return (ok);
+}
+
 #endif /* GSSAPI */
+
+#ifdef JPAKE
+void
+mm_auth2_jpake_get_pwdata(Authctxt *authctxt, BIGNUM **s,
+    char **hash_scheme, char **salt)
+{
+        Buffer m;
+
+        debug3("%s entering", __func__);
+
+        buffer_init(&m);
+        mm_request_send(pmonitor->m_recvfd,
+            MONITOR_REQ_JPAKE_GET_PWDATA, &m);
+
+        debug3("%s: waiting for MONITOR_ANS_JPAKE_GET_PWDATA", __func__);
+        mm_request_receive_expect(pmonitor->m_recvfd,
+            MONITOR_ANS_JPAKE_GET_PWDATA, &m);
+
+        *hash_scheme = buffer_get_string(&m, NULL);
+        *salt = buffer_get_string(&m, NULL);
+
+        buffer_free(&m);
+}
+
+void
+mm_jpake_step1(struct jpake_group *grp,
+    u_char **id, u_int *id_len,
+    BIGNUM **priv1, BIGNUM **priv2, BIGNUM **g_priv1, BIGNUM **g_priv2,
+    u_char **priv1_proof, u_int *priv1_proof_len,
+    u_char **priv2_proof, u_int *priv2_proof_len)
+{
+        Buffer m;
+
+        debug3("%s entering", __func__);
+
+        buffer_init(&m);
+        mm_request_send(pmonitor->m_recvfd,
+            MONITOR_REQ_JPAKE_STEP1, &m);
+
+        debug3("%s: waiting for MONITOR_ANS_JPAKE_STEP1", __func__);
+        mm_request_receive_expect(pmonitor->m_recvfd,
+            MONITOR_ANS_JPAKE_STEP1, &m);
+
+        if ((*priv1 = BN_new()) == NULL ||
+            (*priv2 = BN_new()) == NULL ||
+            (*g_priv1 = BN_new()) == NULL ||
+            (*g_priv2 = BN_new()) == NULL)
+                fatal("%s: BN_new", __func__);
+
+        *id = buffer_get_string(&m, id_len);
+        /* priv1 and priv2 are, well, private */
+        buffer_get_bignum2(&m, *g_priv1);
+        buffer_get_bignum2(&m, *g_priv2);
+        *priv1_proof = buffer_get_string(&m, priv1_proof_len);
+        *priv2_proof = buffer_get_string(&m, priv2_proof_len);
+
+        buffer_free(&m);
+}
+
+void
+mm_jpake_step2(struct jpake_group *grp, BIGNUM *s,
+    BIGNUM *mypub1, BIGNUM *theirpub1, BIGNUM *theirpub2, BIGNUM *mypriv2,
+    const u_char *theirid, u_int theirid_len,
+    const u_char *myid, u_int myid_len,
+    const u_char *theirpub1_proof, u_int theirpub1_proof_len,
+    const u_char *theirpub2_proof, u_int theirpub2_proof_len,
+    BIGNUM **newpub,
+    u_char **newpub_exponent_proof, u_int *newpub_exponent_proof_len)
+{
+        Buffer m;
+
+        debug3("%s entering", __func__);
+
+        buffer_init(&m);
+        /* monitor already has all bignums except theirpub1, theirpub2 */
+        buffer_put_bignum2(&m, theirpub1);
+        buffer_put_bignum2(&m, theirpub2);
+        /* monitor already knows our id */
+        buffer_put_string(&m, theirid, theirid_len);
+        buffer_put_string(&m, theirpub1_proof, theirpub1_proof_len);
+        buffer_put_string(&m, theirpub2_proof, theirpub2_proof_len);
+
+        mm_request_send(pmonitor->m_recvfd,
+            MONITOR_REQ_JPAKE_STEP2, &m);
+
+        debug3("%s: waiting for MONITOR_ANS_JPAKE_STEP2", __func__);
+        mm_request_receive_expect(pmonitor->m_recvfd,
+            MONITOR_ANS_JPAKE_STEP2, &m);
+
+        if ((*newpub = BN_new()) == NULL)
+                fatal("%s: BN_new", __func__);
+
+        buffer_get_bignum2(&m, *newpub);
+        *newpub_exponent_proof = buffer_get_string(&m,
+            newpub_exponent_proof_len);
+
+        buffer_free(&m);
+}
+
+void
+mm_jpake_key_confirm(struct jpake_group *grp, BIGNUM *s, BIGNUM *step2_val,
+    BIGNUM *mypriv2, BIGNUM *mypub1, BIGNUM *mypub2,
+    BIGNUM *theirpub1, BIGNUM *theirpub2,
+    const u_char *my_id, u_int my_id_len,
+    const u_char *their_id, u_int their_id_len,
+    const u_char *sess_id, u_int sess_id_len,
+    const u_char *theirpriv2_s_proof, u_int theirpriv2_s_proof_len,
+    BIGNUM **k,
+    u_char **confirm_hash, u_int *confirm_hash_len)
+{
+        Buffer m;
+
+        debug3("%s entering", __func__);
+
+        buffer_init(&m);
+        /* monitor already has all bignums except step2_val */
+        buffer_put_bignum2(&m, step2_val);
+        /* monitor already knows all the ids */
+        buffer_put_string(&m, theirpriv2_s_proof, theirpriv2_s_proof_len);
+
+        mm_request_send(pmonitor->m_recvfd,
+            MONITOR_REQ_JPAKE_KEY_CONFIRM, &m);
+
+        debug3("%s: waiting for MONITOR_ANS_JPAKE_KEY_CONFIRM", __func__);
+        mm_request_receive_expect(pmonitor->m_recvfd,
+            MONITOR_ANS_JPAKE_KEY_CONFIRM, &m);
+
+        /* 'k' is sensitive and stays in the monitor */
+        *confirm_hash = buffer_get_string(&m, confirm_hash_len);
+
+        buffer_free(&m);
+}
+
+int
+mm_jpake_check_confirm(const BIGNUM *k,
+    const u_char *peer_id, u_int peer_id_len,
+    const u_char *sess_id, u_int sess_id_len,
+    const u_char *peer_confirm_hash, u_int peer_confirm_hash_len)
+{
+        Buffer m;
+        int success = 0;
+
+        debug3("%s entering", __func__);
+
+        buffer_init(&m);
+        /* k is dummy in slave, ignored */
+        /* monitor knows all the ids */
+        buffer_put_string(&m, peer_confirm_hash, peer_confirm_hash_len);
+        mm_request_send(pmonitor->m_recvfd,
+            MONITOR_REQ_JPAKE_CHECK_CONFIRM, &m);
+
+        debug3("%s: waiting for MONITOR_ANS_JPAKE_CHECK_CONFIRM", __func__);
+        mm_request_receive_expect(pmonitor->m_recvfd,
+            MONITOR_ANS_JPAKE_CHECK_CONFIRM, &m);
+
+        success = buffer_get_int(&m);
+        buffer_free(&m);
+
+        debug3("%s: success = %d", __func__, success);
+        return success;
+}
+#endif /* JPAKE */