source4/heimdal/lib/hcrypto/dh-ltm.c

   1 /*
   2  * Copyright (c) 2006 Kungliga Tekniska Högskolan
   3  * (Royal Institute of Technology, Stockholm, Sweden).
   4  * All rights reserved.
   5  *
   6  * Redistribution and use in source and binary forms, with or without
   7  * modification, are permitted provided that the following conditions
   8  * are met:
   9  *
  10  * 1. Redistributions of source code must retain the above copyright
  11  *    notice, this list of conditions and the following disclaimer.
  12  *
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  *
  17  * 3. Neither the name of the Institute nor the names of its contributors
  18  *    may be used to endorse or promote products derived from this software
  19  *    without specific prior written permission.
  20  *
  21  * THIS SOFTWARE IS PROVIDED BY THE INSTITUTE AND CONTRIBUTORS ``AS IS'' AND
  22  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  23  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  24  * ARE DISCLAIMED.  IN NO EVENT SHALL THE INSTITUTE OR CONTRIBUTORS BE LIABLE
  25  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  26  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  27  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  28  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  29  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  30  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  31  * SUCH DAMAGE.
  32  */
  33
  34 #ifdef HAVE_CONFIG_H
  35 #include <config.h>
  36 #endif
  37
  38 #include <stdio.h>
  39 #include <stdlib.h>
  40 #include <dh.h>
  41
  42 #include <roken.h>
  43
  44 #include "tommath.h"
  45
  46 static void
  47 BN2mpz(mp_int *s, const BIGNUM *bn)
  48 {
  49     size_t len;
  50     void *p;
  51
  52     len = BN_num_bytes(bn);
  53     p = malloc(len);
  54     BN_bn2bin(bn, p);
  55     mp_read_unsigned_bin(s, p, len);
  56     free(p);
  57 }
  58
  59
  60 static BIGNUM *
  61 mpz2BN(mp_int *s)
  62 {
  63     size_t size;
  64     BIGNUM *bn;
  65     void *p;
  66
  67     size = mp_unsigned_bin_size(s);
  68     p = malloc(size);
  69     if (p == NULL && size != 0)
  70         return NULL;
  71     mp_to_unsigned_bin(s, p);
  72
  73     bn = BN_bin2bn(p, size, NULL);
  74     free(p);
  75     return bn;
  76 }
  77
  78 /*
  79  *
  80  */
  81
  82 #define DH_NUM_TRIES 10
  83
  84 static int
  85 ltm_dh_generate_key(DH *dh)
  86 {
  87     mp_int pub, priv_key, g, p;
  88     int have_private_key = (dh->priv_key != NULL);
  89     int codes, times = 0;
  90     int res;
  91
  92     if (dh->p == NULL || dh->g == NULL)
  93         return 0;
  94
  95     while (times++ < DH_NUM_TRIES) {
  96         if (!have_private_key) {
  97             size_t bits = BN_num_bits(dh->p);
  98
  99             if (dh->priv_key)
 100                 BN_free(dh->priv_key);
 101
 102             dh->priv_key = BN_new();
 103             if (dh->priv_key == NULL)
 104                 return 0;
 105             if (!BN_rand(dh->priv_key, bits - 1, 0, 0)) {
 106                 BN_clear_free(dh->priv_key);
 107                 dh->priv_key = NULL;
 108                 return 0;
 109             }
 110         }
 111         if (dh->pub_key)
 112             BN_free(dh->pub_key);
 113
 114         mp_init_multi(&pub, &priv_key, &g, &p, NULL);
 115
 116         BN2mpz(&priv_key, dh->priv_key);
 117         BN2mpz(&g, dh->g);
 118         BN2mpz(&p, dh->p);
 119
 120         res = mp_exptmod(&g, &priv_key, &p, &pub);
 121
 122         mp_clear_multi(&priv_key, &g, &p, NULL);
 123         if (res != 0)
 124             continue;
 125
 126         dh->pub_key = mpz2BN(&pub);
 127         mp_clear(&pub);
 128         if (dh->pub_key == NULL)
 129             return 0;
 130
 131         if (DH_check_pubkey(dh, dh->pub_key, &codes) && codes == 0)
 132             break;
 133         if (have_private_key)
 134             return 0;
 135     }
 136
 137     if (times >= DH_NUM_TRIES) {
 138         if (!have_private_key && dh->priv_key) {
 139             BN_free(dh->priv_key);
 140             dh->priv_key = NULL;
 141         }
 142         if (dh->pub_key) {
 143             BN_free(dh->pub_key);
 144             dh->pub_key = NULL;
 145         }
 146         return 0;
 147     }
 148
 149     return 1;
 150 }
 151
 152 static int
 153 ltm_dh_compute_key(unsigned char *shared, const BIGNUM * pub, DH *dh)
 154 {
 155     mp_int s, priv_key, p, peer_pub;
 156     int ret;
 157
 158     if (dh->pub_key == NULL || dh->g == NULL || dh->priv_key == NULL)
 159         return -1;
 160
 161     mp_init_multi(&s, &priv_key, &p, &peer_pub, NULL);
 162     BN2mpz(&p, dh->p);
 163     BN2mpz(&peer_pub, pub);
 164
 165     /* check if peers pubkey is reasonable */
 166     if (mp_isneg(&peer_pub)
 167         || mp_cmp(&peer_pub, &p) >= 0
 168         || mp_cmp_d(&peer_pub, 1) <= 0)
 169     {
 170         ret = -1;
 171         goto out;
 172     }
 173
 174     BN2mpz(&priv_key, dh->priv_key);
 175
 176     ret = mp_exptmod(&peer_pub, &priv_key, &p, &s);
 177
 178     if (ret != 0) {
 179         ret = -1;
 180         goto out;
 181     }
 182
 183     ret = mp_unsigned_bin_size(&s);
 184     mp_to_unsigned_bin(&s, shared);
 185
 186  out:
 187     mp_clear_multi(&s, &priv_key, &p, &peer_pub, NULL);
 188
 189     return ret;
 190 }
 191
 192 static int
 193 ltm_dh_generate_params(DH *dh, int a, int b, BN_GENCB *callback)
 194 {
 195     /* groups should already be known, we don't care about this */
 196     return 0;
 197 }
 198
 199 static int
 200 ltm_dh_init(DH *dh)
 201 {
 202     return 1;
 203 }
 204
 205 static int
 206 ltm_dh_finish(DH *dh)
 207 {
 208     return 1;
 209 }
 210
 211
 212 /*
 213  *
 214  */
 215
 216 const DH_METHOD _hc_dh_ltm_method = {
 217     "hcrypto ltm DH",
 218     ltm_dh_generate_key,
 219     ltm_dh_compute_key,
 220     NULL,
 221     ltm_dh_init,
 222     ltm_dh_finish,
 223     0,
 224     NULL,
 225     ltm_dh_generate_params
 226 };
 227
 228 /**
 229  * DH implementation using libtommath.
 230  *
 231  * @return the DH_METHOD for the DH implementation using libtommath.
 232  *
 233  * @ingroup hcrypto_dh
 234  */
 235
 236 const DH_METHOD *
 237 DH_ltm_method(void)
 238 {
 239     return &_hc_dh_ltm_method;
 240 }