kex.c

   1 /*
   2  * Copyright (c) 2000 Markus Friedl.  All rights reserved.
   3  *
   4  * Redistribution and use in source and binary forms, with or without
   5  * modification, are permitted provided that the following conditions
   6  * are met:
   7  * 1. Redistributions of source code must retain the above copyright
   8  *    notice, this list of conditions and the following disclaimer.
   9  * 2. Redistributions in binary form must reproduce the above copyright
  10  *    notice, this list of conditions and the following disclaimer in the
  11  *    documentation and/or other materials provided with the distribution.
  12  * 3. All advertising materials mentioning features or use of this software
  13  *    must display the following acknowledgement:
  14  *      This product includes software developed by Markus Friedl.
  15  * 4. The name of the author may not be used to endorse or promote products
  16  *    derived from this software without specific prior written permission.
  17  *
  18  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
  19  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  20  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  21  * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
  22  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  23  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  24  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  25  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  26  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  27  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  28  */
  29
  30 #include "includes.h"
  31 RCSID("$Id$");
  32
  33 #include "ssh.h"
  34 #include "ssh2.h"
  35 #include "xmalloc.h"
  36 #include "buffer.h"
  37 #include "bufaux.h"
  38 #include "cipher.h"
  39 #include "compat.h"
  40
  41 #if HAVE_OPENSSL
  42 # include <openssl/bn.h>
  43 # include <openssl/dh.h>
  44 # include <openssl/crypto.h>
  45 # include <openssl/bio.h>
  46 # include <openssl/bn.h>
  47 # include <openssl/dh.h>
  48 # include <openssl/pem.h>
  49 #endif /* HAVE_OPENSSL */
  50 #if HAVE_SSL
  51 # include <ssl/bn.h>
  52 # include <ssl/dh.h>
  53 # include <ssl/crypto.h>
  54 # include <ssl/bio.h>
  55 # include <ssl/bn.h>
  56 # include <ssl/dh.h>
  57 # include <ssl/pem.h>
  58 #endif /* HAVE_SSL */
  59
  60 #include "entropy.h"
  61 #include "kex.h"
  62
  63 Buffer *
  64 kex_init(char *myproposal[PROPOSAL_MAX])
  65 {
  66         char c = 0;
  67         unsigned char cookie[16];
  68         u_int32_t rand = 0;
  69         int i;
  70         Buffer *ki = xmalloc(sizeof(*ki));
  71         for (i = 0; i < 16; i++) {
  72                 if (i % 4 == 0)
  73                         rand = arc4random();
  74                 cookie[i] = rand & 0xff;
  75                 rand >>= 8;
  76         }
  77         buffer_init(ki);
  78         buffer_append(ki, (char *)cookie, sizeof cookie);
  79         for (i = 0; i < PROPOSAL_MAX; i++)
  80                 buffer_put_cstring(ki, myproposal[i]);
  81         buffer_append(ki, &c, 1); /* boolean   first_kex_packet_follows */
  82         buffer_put_int(ki, 0);    /* uint32    0 (reserved for future extension) */
  83         return ki;
  84 }
  85
  86 /* diffie-hellman-group1-sha1 */
  87
  88 DH *
  89 new_dh_group1()
  90 {
  91         static char *group1 =
  92             "FFFFFFFF" "FFFFFFFF" "C90FDAA2" "2168C234" "C4C6628B" "80DC1CD1"
  93             "29024E08" "8A67CC74" "020BBEA6" "3B139B22" "514A0879" "8E3404DD"
  94             "EF9519B3" "CD3A431B" "302B0A6D" "F25F1437" "4FE1356D" "6D51C245"
  95             "E485B576" "625E7EC6" "F44C42E9" "A637ED6B" "0BFF5CB6" "F406B7ED"
  96             "EE386BFB" "5A899FA5" "AE9F2411" "7C4B1FE6" "49286651" "ECE65381"
  97             "FFFFFFFF" "FFFFFFFF";
  98         DH *dh;
  99         int ret;
 100         dh = DH_new();
 101         if(dh == NULL)
 102                 fatal("DH_new");
 103         ret = BN_hex2bn(&dh->p,group1);
 104         if(ret<0)
 105                 fatal("BN_hex2bn");
 106         dh->g = BN_new();
 107         if(dh->g == NULL)
 108                 fatal("DH_new g");
 109         BN_set_word(dh->g,2);
 110
 111         seed_rng();
 112         if (DH_generate_key(dh) == 0)
 113                 fatal("DH_generate_key");
 114
 115         return dh;
 116 }
 117
 118 void
 119 bignum_print(BIGNUM *b)
 120 {
 121         BN_print_fp(stderr,b);
 122 }
 123
 124 void
 125 dump_digest(unsigned char *digest, int len)
 126 {
 127         int i;
 128         for (i = 0; i< len; i++){
 129                 fprintf(stderr, "%02x", digest[i]);
 130                 if(i%2!=0)
 131                         fprintf(stderr, " ");
 132         }
 133         fprintf(stderr, "\n");
 134 }
 135
 136 unsigned char *
 137 kex_hash(
 138     char *client_version_string,
 139     char *server_version_string,
 140     char *ckexinit, int ckexinitlen,
 141     char *skexinit, int skexinitlen,
 142     char *serverhostkeyblob, int sbloblen,
 143     BIGNUM *client_dh_pub,
 144     BIGNUM *server_dh_pub,
 145     BIGNUM *shared_secret)
 146 {
 147         Buffer b;
 148         static unsigned char digest[EVP_MAX_MD_SIZE];
 149         EVP_MD *evp_md = EVP_sha1();
 150         EVP_MD_CTX md;
 151
 152         buffer_init(&b);
 153         buffer_put_string(&b, client_version_string, strlen(client_version_string));
 154         buffer_put_string(&b, server_version_string, strlen(server_version_string));
 155
 156         /* kexinit messages: fake header: len+SSH2_MSG_KEXINIT */
 157         buffer_put_int(&b, ckexinitlen+1);
 158         buffer_put_char(&b, SSH2_MSG_KEXINIT);
 159         buffer_append(&b, ckexinit, ckexinitlen);
 160         buffer_put_int(&b, skexinitlen+1);
 161         buffer_put_char(&b, SSH2_MSG_KEXINIT);
 162         buffer_append(&b, skexinit, skexinitlen);
 163
 164         buffer_put_string(&b, serverhostkeyblob, sbloblen);
 165         buffer_put_bignum2(&b, client_dh_pub);
 166         buffer_put_bignum2(&b, server_dh_pub);
 167         buffer_put_bignum2(&b, shared_secret);
 168
 169 #ifdef DEBUG_KEX
 170         buffer_dump(&b);
 171 #endif
 172
 173         EVP_DigestInit(&md, evp_md);
 174         EVP_DigestUpdate(&md, buffer_ptr(&b), buffer_len(&b));
 175         EVP_DigestFinal(&md, digest, NULL);
 176
 177         buffer_free(&b);
 178
 179 #ifdef DEBUG_KEX
 180         dump_digest(digest, evp_md->md_size);
 181 #endif
 182         return digest;
 183 }
 184
 185 unsigned char *
 186 derive_key(int id, int need, char unsigned *hash, BIGNUM *shared_secret)
 187 {
 188         Buffer b;
 189         EVP_MD *evp_md = EVP_sha1();
 190         EVP_MD_CTX md;
 191         char c = id;
 192         int have;
 193         int mdsz = evp_md->md_size;
 194         unsigned char *digest = xmalloc(((need+mdsz-1)/mdsz)*mdsz);
 195
 196         buffer_init(&b);
 197         buffer_put_bignum2(&b, shared_secret);
 198
 199         EVP_DigestInit(&md, evp_md);
 200         EVP_DigestUpdate(&md, buffer_ptr(&b), buffer_len(&b));  /* shared_secret K */
 201         EVP_DigestUpdate(&md, hash, mdsz);              /* transport-06 */
 202         EVP_DigestUpdate(&md, &c, 1);                   /* key id */
 203         EVP_DigestUpdate(&md, hash, mdsz);              /* session id */
 204         EVP_DigestFinal(&md, digest, NULL);
 205
 206         /* expand */
 207         for (have = mdsz; need > have; have += mdsz) {
 208                 EVP_DigestInit(&md, evp_md);
 209                 EVP_DigestUpdate(&md, buffer_ptr(&b), buffer_len(&b));
 210                 EVP_DigestUpdate(&md, hash, mdsz);
 211                 EVP_DigestUpdate(&md, digest, have);
 212                 EVP_DigestFinal(&md, digest + have, NULL);
 213         }
 214         buffer_free(&b);
 215 #ifdef DEBUG_KEX
 216         fprintf(stderr, "Digest '%c'== ", c);
 217         dump_digest(digest, need);
 218 #endif
 219         return digest;
 220 }
 221
 222 #define NKEYS   6
 223
 224 #define MAX_PROP        20
 225 #define SEP     ","
 226
 227 char *
 228 get_match(char *client, char *server)
 229 {
 230         char *sproposals[MAX_PROP];
 231         char *p;
 232         int i, j, nproposals;
 233
 234         for ((p = strtok(server, SEP)), i=0; p; (p = strtok(NULL, SEP)), i++) {
 235                 if (i < MAX_PROP)
 236                         sproposals[i] = p;
 237                 else
 238                         break;
 239         }
 240         nproposals = i;
 241
 242         for ((p = strtok(client, SEP)), i=0; p; (p = strtok(NULL, SEP)), i++) {
 243                 for (j = 0; j < nproposals; j++)
 244                         if (strcmp(p, sproposals[j]) == 0)
 245                                 return xstrdup(p);
 246         }
 247         return NULL;
 248 }
 249 void
 250 choose_enc(Enc *enc, char *client, char *server)
 251 {
 252         char *name = get_match(client, server);
 253         if (name == NULL)
 254                 fatal("no matching cipher found: client %s server %s", client, server);
 255         enc->type = cipher_number(name);
 256
 257         switch (enc->type) {
 258         case SSH_CIPHER_3DES_CBC:
 259                 enc->key_len = 24;
 260                 enc->iv_len = 8;
 261                 enc->block_size = 8;
 262                 break;
 263         case SSH_CIPHER_BLOWFISH_CBC:
 264         case SSH_CIPHER_CAST128_CBC:
 265                 enc->key_len = 16;
 266                 enc->iv_len = 8;
 267                 enc->block_size = 8;
 268                 break;
 269         case SSH_CIPHER_ARCFOUR:
 270                 enc->key_len = 16;
 271                 enc->iv_len = 0;
 272                 enc->block_size = 8;
 273                 break;
 274         default:
 275                 fatal("unsupported cipher %s", name);
 276         }
 277         enc->name = name;
 278         enc->enabled = 0;
 279         enc->iv = NULL;
 280         enc->key = NULL;
 281 }
 282 void
 283 choose_mac(Mac *mac, char *client, char *server)
 284 {
 285         char *name = get_match(client, server);
 286         if (name == NULL)
 287                 fatal("no matching mac found: client %s server %s", client, server);
 288         if (strcmp(name, "hmac-md5") == 0) {
 289                 mac->md = EVP_md5();
 290         } else if (strcmp(name, "hmac-sha1") == 0) {
 291                 mac->md = EVP_sha1();
 292         } else if (strcmp(name, "hmac-ripemd160@openssh.com") == 0) {
 293                 mac->md = EVP_ripemd160();
 294         } else {
 295                 fatal("unsupported mac %s", name);
 296         }
 297         mac->name = name;
 298         mac->mac_len = mac->md->md_size;
 299         mac->key_len = datafellows ? 16 : mac->mac_len;
 300         mac->key = NULL;
 301         mac->enabled = 0;
 302 }
 303 void
 304 choose_comp(Comp *comp, char *client, char *server)
 305 {
 306         char *name = get_match(client, server);
 307         if (name == NULL)
 308                 fatal("no matching comp found: client %s server %s", client, server);
 309         if (strcmp(name, "zlib") == 0) {
 310                 comp->type = 1;
 311         } else if (strcmp(name, "none") == 0) {
 312                 comp->type = 0;
 313         } else {
 314                 fatal("unsupported comp %s", name);
 315         }
 316         comp->name = name;
 317 }
 318 void
 319 choose_kex(Kex *k, char *client, char *server)
 320 {
 321         k->name = get_match(client, server);
 322         if (k->name == NULL)
 323                 fatal("no kex alg");
 324         if (strcmp(k->name, KEX_DH1) != 0)
 325                 fatal("bad kex alg %s", k->name);
 326 }
 327 void
 328 choose_hostkeyalg(Kex *k, char *client, char *server)
 329 {
 330         k->hostkeyalg = get_match(client, server);
 331         if (k->hostkeyalg == NULL)
 332                 fatal("no hostkey alg");
 333         if (strcmp(k->hostkeyalg, KEX_DSS) != 0)
 334                 fatal("bad hostkey alg %s", k->hostkeyalg);
 335 }
 336
 337 Kex *
 338 kex_choose_conf(char *cprop[PROPOSAL_MAX], char *sprop[PROPOSAL_MAX], int server)
 339 {
 340         int i;
 341         int mode;
 342         int ctos;                               /* direction: if true client-to-server */
 343         int need;
 344         Kex *k;
 345
 346         k = xmalloc(sizeof(*k));
 347         memset(k, 0, sizeof(*k));
 348         k->server = server;
 349
 350         for (mode = 0; mode < MODE_MAX; mode++) {
 351                 int nenc, nmac, ncomp;
 352                 ctos = (!k->server && mode == MODE_OUT) || (k->server && mode == MODE_IN);
 353                 nenc  = ctos ? PROPOSAL_ENC_ALGS_CTOS  : PROPOSAL_ENC_ALGS_STOC;
 354                 nmac  = ctos ? PROPOSAL_MAC_ALGS_CTOS  : PROPOSAL_MAC_ALGS_STOC;
 355                 ncomp = ctos ? PROPOSAL_COMP_ALGS_CTOS : PROPOSAL_COMP_ALGS_STOC;
 356                 choose_enc (&k->enc [mode], cprop[nenc],  sprop[nenc]);
 357                 choose_mac (&k->mac [mode], cprop[nmac],  sprop[nmac]);
 358                 choose_comp(&k->comp[mode], cprop[ncomp], sprop[ncomp]);
 359                 log("kex: %s %s %s %s",
 360                     ctos ? "client->server" : "server->client",
 361                     k->enc[mode].name,
 362                     k->mac[mode].name,
 363                     k->comp[mode].name);
 364         }
 365         choose_kex(k, cprop[PROPOSAL_KEX_ALGS], sprop[PROPOSAL_KEX_ALGS]);
 366         choose_hostkeyalg(k, cprop[PROPOSAL_SERVER_HOST_KEY_ALGS],
 367             sprop[PROPOSAL_SERVER_HOST_KEY_ALGS]);
 368         for (i = 0; i < PROPOSAL_MAX; i++) {
 369                 xfree(cprop[i]);
 370                 xfree(sprop[i]);
 371         }
 372         need = 0;
 373         for (mode = 0; mode < MODE_MAX; mode++) {
 374             if (need < k->enc[mode].key_len)
 375                     need = k->enc[mode].key_len;
 376             if (need < k->enc[mode].iv_len)
 377                     need = k->enc[mode].iv_len;
 378             if (need < k->mac[mode].key_len)
 379                     need = k->mac[mode].key_len;
 380         }
 381         /* need runden? */
 382 #define WE_NEED 32
 383         k->we_need = WE_NEED;
 384         k->we_need = need;
 385         return k;
 386 }
 387
 388 int
 389 kex_derive_keys(Kex *k, unsigned char *hash, BIGNUM *shared_secret)
 390 {
 391         int i;
 392         int mode;
 393         int ctos;
 394         unsigned char *keys[NKEYS];
 395
 396         for (i = 0; i < NKEYS; i++)
 397                 keys[i] = derive_key('A'+i, k->we_need, hash, shared_secret);
 398
 399         for (mode = 0; mode < MODE_MAX; mode++) {
 400                 ctos = (!k->server && mode == MODE_OUT) || (k->server && mode == MODE_IN);
 401                 k->enc[mode].iv  = keys[ctos ? 0 : 1];
 402                 k->enc[mode].key = keys[ctos ? 2 : 3];
 403                 k->mac[mode].key = keys[ctos ? 4 : 5];
 404         }
 405         return 0;
 406 }