lib/gnutls_mpi.c

   1 /*
   2  * Copyright (C) 2001, 2002, 2003, 2004, 2005, 2008 Free Software Foundation
   3  *
   4  * Author: Nikos Mavrogiannopoulos
   5  *
   6  * This file is part of GNUTLS.
   7  *
   8  * The GNUTLS library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public License
  10  * as published by the Free Software Foundation; either version 2.1 of
  11  * the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful, but
  14  * WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301,
  21  * USA
  22  *
  23  */
  24
  25 /* Here lie everything that has to do with large numbers, libgcrypt and
  26  * other stuff that didn't fit anywhere else.
  27  */
  28
  29 #include <gnutls_int.h>
  30 #include <libtasn1.h>
  31 #include <gnutls_errors.h>
  32 #include <gnutls_num.h>
  33 #include <gnutls_mpi.h>
  34 #include <random.h>
  35
  36 /* Functions that refer to the mpi library.
  37  */
  38
  39 #define clearbit(v,n)    ((unsigned char)(v) & ~( (unsigned char)(1) << (unsigned)(n)))
  40
  41 bigint_t
  42 _gnutls_mpi_randomize (bigint_t r, unsigned int bits,
  43                        gnutls_rnd_level_t level)
  44 {
  45   size_t size = 1 + (bits / 8);
  46   int ret;
  47   int rem, i;
  48   bigint_t tmp;
  49   char tmpbuf[512];
  50   opaque *buf;
  51   int buf_release = 0;
  52
  53   if (size < sizeof (tmpbuf))
  54     {
  55       buf = tmpbuf;
  56     }
  57   else
  58     {
  59       buf = gnutls_malloc (size);
  60       if (buf == NULL)
  61         {
  62           gnutls_assert ();
  63           goto cleanup;
  64         }
  65       buf_release = 1;
  66     }
  67
  68
  69   ret = _gnutls_rnd (level, buf, size);
  70   if (ret < 0)
  71     {
  72       gnutls_assert ();
  73       goto cleanup;
  74     }
  75
  76   /* mask the bits that weren't requested */
  77   rem = bits % 8;
  78
  79   if (rem == 0)
  80     {
  81       buf[0] = 0;
  82     }
  83   else
  84     {
  85       for (i = 8; i >= rem; i--)
  86         buf[0] = clearbit (buf[0], i);
  87     }
  88
  89   ret = _gnutls_mpi_scan (&tmp, buf, size);
  90   if (ret < 0)
  91     {
  92       gnutls_assert ();
  93       goto cleanup;
  94     }
  95
  96   if (buf_release != 0)
  97     {
  98       gnutls_free (buf);
  99       buf = NULL;
 100     }
 101
 102   if (r != NULL)
 103     {
 104       _gnutls_mpi_set (r, tmp);
 105       _gnutls_mpi_release (&tmp);
 106       return r;
 107     }
 108
 109   return tmp;
 110
 111 cleanup:
 112   if (buf_release != 0)
 113     gnutls_free (buf);
 114   return NULL;
 115 }
 116
 117 void
 118 _gnutls_mpi_release (bigint_t * x)
 119 {
 120   if (*x == NULL)
 121     return;
 122
 123   _gnutls_mpi_ops.bigint_release (*x);
 124   *x = NULL;
 125 }
 126
 127 /* returns zero on success
 128  */
 129 int
 130 _gnutls_mpi_scan (bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 131 {
 132   *ret_mpi =
 133     _gnutls_mpi_ops.bigint_scan (buffer, nbytes, GNUTLS_MPI_FORMAT_USG);
 134   if (*ret_mpi == NULL)
 135     {
 136       gnutls_assert ();
 137       return GNUTLS_E_MPI_SCAN_FAILED;
 138     }
 139
 140   return 0;
 141 }
 142
 143 /* returns zero on success. Fails if the number is zero.
 144  */
 145 int
 146 _gnutls_mpi_scan_nz (bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 147 {
 148   int ret;
 149
 150   ret = _gnutls_mpi_scan (ret_mpi, buffer, nbytes);
 151   if (ret < 0)
 152     return ret;
 153
 154   /* MPIs with 0 bits are illegal
 155    */
 156   if (_gnutls_mpi_get_nbits (*ret_mpi) == 0)
 157     {
 158       _gnutls_mpi_release (ret_mpi);
 159       return GNUTLS_E_MPI_SCAN_FAILED;
 160     }
 161
 162   return 0;
 163 }
 164
 165 int
 166 _gnutls_mpi_scan_pgp (bigint_t * ret_mpi, const void *buffer, size_t nbytes)
 167 {
 168   *ret_mpi =
 169     _gnutls_mpi_ops.bigint_scan (buffer, nbytes, GNUTLS_MPI_FORMAT_PGP);
 170   if (*ret_mpi == NULL)
 171     {
 172       gnutls_assert ();
 173       return GNUTLS_E_MPI_SCAN_FAILED;
 174     }
 175
 176   return 0;
 177 }
 178
 179 /* Always has the first bit zero */
 180 int
 181 _gnutls_mpi_dprint_lz (const bigint_t a, gnutls_datum_t * dest)
 182 {
 183   int ret;
 184   opaque *buf = NULL;
 185   size_t bytes = 0;
 186
 187   if (dest == NULL || a == NULL)
 188     return GNUTLS_E_INVALID_REQUEST;
 189
 190   _gnutls_mpi_print_lz (a, NULL, &bytes);
 191
 192   if (bytes != 0)
 193     buf = gnutls_malloc (bytes);
 194   if (buf == NULL)
 195     return GNUTLS_E_MEMORY_ERROR;
 196
 197   ret = _gnutls_mpi_print_lz (a, buf, &bytes);
 198   if (ret < 0)
 199     {
 200       gnutls_free (buf);
 201       return ret;
 202     }
 203
 204   dest->data = buf;
 205   dest->size = bytes;
 206   return 0;
 207 }
 208
 209 int
 210 _gnutls_mpi_dprint (const bigint_t a, gnutls_datum_t * dest)
 211 {
 212   int ret;
 213   opaque *buf = NULL;
 214   size_t bytes = 0;
 215
 216   if (dest == NULL || a == NULL)
 217     return GNUTLS_E_INVALID_REQUEST;
 218
 219   _gnutls_mpi_print (a, NULL, &bytes);
 220   if (bytes != 0)
 221     buf = gnutls_malloc (bytes);
 222   if (buf == NULL)
 223     return GNUTLS_E_MEMORY_ERROR;
 224
 225   ret = _gnutls_mpi_print (a, buf, &bytes);
 226   if (ret < 0)
 227     {
 228       gnutls_free (buf);
 229       return ret;
 230     }
 231
 232   dest->data = buf;
 233   dest->size = bytes;
 234   return 0;
 235 }
 236
 237 /* This function will copy the mpi data into a datum,
 238  * but will set minimum size to 'size'. That means that
 239  * the output value is left padded with zeros.
 240  */
 241 int
 242 _gnutls_mpi_dprint_size (const bigint_t a, gnutls_datum_t * dest, size_t size)
 243 {
 244   int ret;
 245   opaque *buf = NULL;
 246   size_t bytes = 0;
 247   unsigned int i;
 248
 249   if (dest == NULL || a == NULL)
 250     return GNUTLS_E_INVALID_REQUEST;
 251
 252   _gnutls_mpi_print (a, NULL, &bytes);
 253   if (bytes != 0)
 254     buf = gnutls_malloc (MAX (size, bytes));
 255   if (buf == NULL)
 256     return GNUTLS_E_MEMORY_ERROR;
 257
 258   dest->size = MAX (size, bytes);
 259
 260   if (bytes <= size)
 261     {
 262       size_t diff = size - bytes;
 263       for (i = 0; i < diff; i++)
 264         buf[i] = 0;
 265       ret = _gnutls_mpi_print (a, &buf[diff], &bytes);
 266     }
 267   else
 268     {
 269       ret = _gnutls_mpi_print (a, buf, &bytes);
 270     }
 271
 272   if (ret < 0)
 273     {
 274       gnutls_free (buf);
 275       return ret;
 276     }
 277
 278   dest->data = buf;
 279   dest->size = MAX (size, bytes);
 280   return 0;
 281 }
 282
 283 /* this function reads an integer
 284  * from asn1 structs. Combines the read and mpi_scan
 285  * steps.
 286  */
 287 int
 288 _gnutls_x509_read_int (ASN1_TYPE node, const char *value, bigint_t * ret_mpi)
 289 {
 290   int result;
 291   opaque *tmpstr = NULL;
 292   int tmpstr_size;
 293
 294   tmpstr_size = 0;
 295   result = asn1_read_value (node, value, NULL, &tmpstr_size);
 296   if (result != ASN1_MEM_ERROR)
 297     {
 298       gnutls_assert ();
 299       return _gnutls_asn2err (result);
 300     }
 301
 302   tmpstr = gnutls_malloc (tmpstr_size);
 303   if (tmpstr == NULL)
 304     {
 305       gnutls_assert ();
 306       return GNUTLS_E_MEMORY_ERROR;
 307     }
 308
 309   result = asn1_read_value (node, value, tmpstr, &tmpstr_size);
 310   if (result != ASN1_SUCCESS)
 311     {
 312       gnutls_assert ();
 313       gnutls_free (tmpstr);
 314       return _gnutls_asn2err (result);
 315     }
 316
 317   result = _gnutls_mpi_scan (ret_mpi, tmpstr, tmpstr_size);
 318   gnutls_free (tmpstr);
 319
 320   if (result < 0)
 321     {
 322       gnutls_assert ();
 323       return result;
 324     }
 325
 326   return 0;
 327 }
 328
 329 /* Writes the specified integer into the specified node.
 330  */
 331 int
 332 _gnutls_x509_write_int (ASN1_TYPE node, const char *value, bigint_t mpi,
 333                         int lz)
 334 {
 335   opaque *tmpstr;
 336   size_t s_len;
 337   int result;
 338
 339   s_len = 0;
 340   if (lz)
 341     result = _gnutls_mpi_print_lz (mpi, NULL, &s_len);
 342   else
 343     result = _gnutls_mpi_print (mpi, NULL, &s_len);
 344
 345   if (result != 0)
 346     {
 347       gnutls_assert ();
 348       return result;
 349     }
 350
 351   tmpstr = gnutls_malloc (s_len);
 352   if (tmpstr == NULL)
 353     {
 354       gnutls_assert ();
 355       return GNUTLS_E_MEMORY_ERROR;
 356     }
 357
 358   if (lz)
 359     result = _gnutls_mpi_print_lz (mpi, tmpstr, &s_len);
 360   else
 361     result = _gnutls_mpi_print (mpi, tmpstr, &s_len);
 362
 363   if (result != 0)
 364     {
 365       gnutls_assert ();
 366       gnutls_free (tmpstr);
 367       return GNUTLS_E_MPI_PRINT_FAILED;
 368     }
 369
 370   result = asn1_write_value (node, value, tmpstr, s_len);
 371
 372   gnutls_free (tmpstr);
 373
 374   if (result != ASN1_SUCCESS)
 375     {
 376       gnutls_assert ();
 377       return _gnutls_asn2err (result);
 378     }
 379
 380   return 0;
 381 }