src/usr.bin/ssh/kexgex.c - diff

Return to kexgex.c CVS log

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

Diff for /src/usr.bin/ssh/kexgex.c between version 1.28 and 1.29

-version 1.28, 2014/01/09 23:20:00
+version 1.29, 2015/01/19 20:16:15
 Line 29
 Line 29
 Line 29
  #include <openssl/evp.h>
  #include <signal.h>
- #include "buffer.h"
+ #include "sshkey.h"
- #include "key.h"
  #include "cipher.h"
  #include "kex.h"
  #include "ssh2.h"
+ #include "ssherr.h"
+ #include "sshbuf.h"
  #include "digest.h"
- #include "log.h"
- void
+ int
  kexgex_hash(
      int hash_alg,
-     char *client_version_string,
+     const char *client_version_string,
-     char *server_version_string,
+     const char *server_version_string,
-     char *ckexinit, int ckexinitlen,
+     const u_char *ckexinit, size_t ckexinitlen,
-     char *skexinit, int skexinitlen,
+     const u_char *skexinit, size_t skexinitlen,
-     u_char *serverhostkeyblob, int sbloblen,
+     const u_char *serverhostkeyblob, size_t sbloblen,
-     int min, int wantbits, int max, BIGNUM *prime, BIGNUM *gen,
+     int min, int wantbits, int max,
-     BIGNUM *client_dh_pub,
+     const BIGNUM *prime,
-     BIGNUM *server_dh_pub,
+     const BIGNUM *gen,
-     BIGNUM *shared_secret,
+     const BIGNUM *client_dh_pub,
-     u_char **hash, u_int *hashlen)
+     const BIGNUM *server_dh_pub,
+     const BIGNUM *shared_secret,
+     u_char *hash, size_t *hashlen)
  {
-         Buffer b;
+         struct sshbuf *b;
-         static u_char digest[SSH_DIGEST_MAX_LENGTH];
+         int r;
-         buffer_init(&b);
+         if (*hashlen < ssh_digest_bytes(SSH_DIGEST_SHA1))
-         buffer_put_cstring(&b, client_version_string);
+                 return SSH_ERR_INVALID_ARGUMENT;
-         buffer_put_cstring(&b, server_version_string);
+         if ((b = sshbuf_new()) == NULL)
+                 return SSH_ERR_ALLOC_FAIL;
-         /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */
+         if ((r = sshbuf_put_cstring(b, client_version_string)) != 0 ||
-         buffer_put_int(&b, ckexinitlen+1);
+             (r = sshbuf_put_cstring(b, server_version_string)) != 0 ||
-         buffer_put_char(&b, SSH2_MSG_KEXINIT);
+             /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */
-         buffer_append(&b, ckexinit, ckexinitlen);
+             (r = sshbuf_put_u32(b, ckexinitlen+1)) != 0 ||
-         buffer_put_int(&b, skexinitlen+1);
+             (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||
-         buffer_put_char(&b, SSH2_MSG_KEXINIT);
+             (r = sshbuf_put(b, ckexinit, ckexinitlen)) != 0 ||
-         buffer_append(&b, skexinit, skexinitlen);
+             (r = sshbuf_put_u32(b, skexinitlen+1)) != 0 ||
+             (r = sshbuf_put_u8(b, SSH2_MSG_KEXINIT)) != 0 ||
-         buffer_put_string(&b, serverhostkeyblob, sbloblen);
+             (r = sshbuf_put(b, skexinit, skexinitlen)) != 0 ||
-         if (min == -1 || max == -1)
+             (r = sshbuf_put_string(b, serverhostkeyblob, sbloblen)) != 0 ||
-                 buffer_put_int(&b, wantbits);
+             (min != -1 && (r = sshbuf_put_u32(b, min)) != 0) ||
-         else {
+             (r = sshbuf_put_u32(b, wantbits)) != 0 ||
-                 buffer_put_int(&b, min);
+             (max != -1 && (r = sshbuf_put_u32(b, max)) != 0) ||
-                 buffer_put_int(&b, wantbits);
+             (r = sshbuf_put_bignum2(b, prime)) != 0 ||
-                 buffer_put_int(&b, max);
+             (r = sshbuf_put_bignum2(b, gen)) != 0 ||
+             (r = sshbuf_put_bignum2(b, client_dh_pub)) != 0 ||
+             (r = sshbuf_put_bignum2(b, server_dh_pub)) != 0 ||
+             (r = sshbuf_put_bignum2(b, shared_secret)) != 0) {
+                 sshbuf_free(b);
+                 return r;
          }
-         buffer_put_bignum2(&b, prime);
-         buffer_put_bignum2(&b, gen);
-         buffer_put_bignum2(&b, client_dh_pub);
-         buffer_put_bignum2(&b, server_dh_pub);
-         buffer_put_bignum2(&b, shared_secret);
  #ifdef DEBUG_KEXDH
-         buffer_dump(&b);
+         sshbuf_dump(b, stderr);
  #endif
-         if (ssh_digest_buffer(hash_alg, &b, digest, sizeof(digest)) != 0)
+         if (ssh_digest_buffer(hash_alg, b, hash, *hashlen) != 0) {
-                 fatal("%s: ssh_digest_buffer failed", __func__);
+                 sshbuf_free(b);
+                 return SSH_ERR_LIBCRYPTO_ERROR;
-         buffer_free(&b);
+         }
+         sshbuf_free(b);
- #ifdef DEBUG_KEX
-         dump_digest("hash", digest, ssh_digest_bytes(hash_alg));
- #endif
-         *hash = digest;
          *hashlen = ssh_digest_bytes(hash_alg);
+ #ifdef DEBUG_KEXDH
+         dump_digest("hash", hash, *hashlen);
+ #endif
+         return 0;
  }