lib/crypto-api.c

   1 /*
   2  * Copyright (C) 2000, 2004, 2005, 2008, 2010, 2011 Free Software Foundation,
   3  * Inc.
   4  *
   5  * Author: Nikos Mavrogiannopoulos
   6  *
   7  * This file is part of GnuTLS.
   8  *
   9  * The GnuTLS is free software; you can redistribute it and/or
  10  * modify it under the terms of the GNU Lesser General Public License
  11  * as published by the Free Software Foundation; either version 3 of
  12  * the License, or (at your option) any later version.
  13  *
  14  * This library is distributed in the hope that it will be useful, but
  15  * WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17  * Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program.  If not, see <http://www.gnu.org/licenses/>
  21  *
  22  */
  23
  24 #include <gnutls_int.h>
  25 #include <gnutls_errors.h>
  26 #include <gnutls_cipher_int.h>
  27 #include <gnutls_datum.h>
  28 #include <gnutls/crypto.h>
  29 #include <random.h>
  30 #include <crypto.h>
  31
  32 typedef struct api_cipher_hd_st
  33 {
  34   cipher_hd_st ctx_enc;
  35   cipher_hd_st ctx_dec;
  36 } api_cipher_hd_st;
  37
  38 /**
  39  * gnutls_cipher_init:
  40  * @handle: is a #gnutls_cipher_hd_t structure.
  41  * @cipher: the encryption algorithm to use
  42  * @key: The key to be used for encryption
  43  * @iv: The IV to use (if not applicable set NULL)
  44  *
  45  * This function will initialize an context that can be used for
  46  * encryption/decryption of data. This will effectively use the
  47  * current crypto backend in use by gnutls or the cryptographic
  48  * accelerator in use.
  49  *
  50  * Returns: Zero or a negative error code on error.
  51  *
  52  * Since: 2.10.0
  53  **/
  54 int
  55 gnutls_cipher_init (gnutls_cipher_hd_t * handle,
  56                     gnutls_cipher_algorithm_t cipher,
  57                     const gnutls_datum_t * key, const gnutls_datum_t * iv)
  58 {
  59 api_cipher_hd_st * h;
  60 int ret;
  61
  62   *handle = gnutls_calloc (1, sizeof (api_cipher_hd_st));
  63   if (*handle == NULL)
  64     {
  65       gnutls_assert ();
  66       return GNUTLS_E_MEMORY_ERROR;
  67     }
  68
  69   h = *handle;
  70   ret = _gnutls_cipher_init (&h->ctx_enc, cipher, key, iv, 1);
  71
  72   if (ret >= 0 && _gnutls_cipher_is_aead( &h->ctx_enc) == 0) /* AEAD ciphers are stream - so far */
  73     ret = _gnutls_cipher_init (&h->ctx_dec, cipher, key, iv, 0);
  74
  75   return ret;
  76 }
  77
  78 /**
  79  * gnutls_cipher_tag:
  80  * @handle: is a #gnutls_cipher_hd_t structure.
  81  * @tag: will hold the tag
  82  * @tag_size: The length of the tag to return
  83  *
  84  * This function operates on authenticated encryption with
  85  * associated data (AEAD) ciphers and will return the
  86  * output tag.
  87  *
  88  * Returns: Zero or a negative error code on error.
  89  *
  90  * Since: 3.0.0
  91  **/
  92 int
  93 gnutls_cipher_tag (gnutls_cipher_hd_t handle, void *tag, size_t tag_size)
  94 {
  95 api_cipher_hd_st * h = handle;
  96
  97   if (_gnutls_cipher_is_aead( &h->ctx_enc)==0)
  98     return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
  99
 100   _gnutls_cipher_tag( &h->ctx_enc, tag, tag_size);
 101
 102   return 0;
 103 }
 104
 105 /**
 106  * gnutls_cipher_add_auth:
 107  * @handle: is a #gnutls_cipher_hd_t structure.
 108  * @text: the data to be authenticated
 109  * @text_size: The length of the data
 110  *
 111  * This function operates on authenticated encryption with
 112  * associated data (AEAD) ciphers and authenticate the
 113  * input data. This function can only be called once
 114  * and before any encryption operations.
 115  *
 116  * Returns: Zero or a negative error code on error.
 117  *
 118  * Since: 3.0.0
 119  **/
 120 int
 121 gnutls_cipher_add_auth (gnutls_cipher_hd_t handle, const void *text, size_t text_size)
 122 {
 123 api_cipher_hd_st * h = handle;
 124
 125   if (_gnutls_cipher_is_aead( &h->ctx_enc)==0)
 126     return gnutls_assert_val(GNUTLS_E_INVALID_REQUEST);
 127
 128   _gnutls_cipher_auth( &h->ctx_enc, text, text_size);
 129
 130   return 0;
 131 }
 132
 133 /**
 134  * gnutls_cipher_set_iv:
 135  * @handle: is a #gnutls_cipher_hd_t structure.
 136  * @iv: the IV to set
 137  * @ivlen: The length of the IV
 138  *
 139  * This function will set the IV to be used for the next
 140  * encryption block.
 141  *
 142  * Since: 3.0.0
 143  **/
 144 void
 145 gnutls_cipher_set_iv (gnutls_cipher_hd_t handle, void *iv, size_t ivlen)
 146 {
 147 api_cipher_hd_st * h = handle;
 148
 149   _gnutls_cipher_setiv( &h->ctx_enc, iv, ivlen);
 150
 151   if (_gnutls_cipher_is_aead( &h->ctx_enc)==0)
 152     _gnutls_cipher_setiv( &h->ctx_dec, iv, ivlen);
 153 }
 154
 155 /**
 156  * gnutls_cipher_encrypt:
 157  * @handle: is a #gnutls_cipher_hd_t structure.
 158  * @text: the data to encrypt
 159  * @textlen: The length of data to encrypt
 160  *
 161  * This function will encrypt the given data using the algorithm
 162  * specified by the context.
 163  *
 164  * Returns: Zero or a negative error code on error.
 165  *
 166  * Since: 2.10.0
 167  **/
 168 int
 169 gnutls_cipher_encrypt (gnutls_cipher_hd_t handle, void *text, size_t textlen)
 170 {
 171 api_cipher_hd_st * h = handle;
 172
 173   return _gnutls_cipher_encrypt (&h->ctx_enc, text, textlen);
 174 }
 175
 176 /**
 177  * gnutls_cipher_decrypt:
 178  * @handle: is a #gnutls_cipher_hd_t structure.
 179  * @ciphertext: the data to encrypt
 180  * @ciphertextlen: The length of data to encrypt
 181  *
 182  * This function will decrypt the given data using the algorithm
 183  * specified by the context.
 184  *
 185  * Returns: Zero or a negative error code on error.
 186  *
 187  * Since: 2.10.0
 188  **/
 189 int
 190 gnutls_cipher_decrypt (gnutls_cipher_hd_t handle, void *ciphertext,
 191                        size_t ciphertextlen)
 192 {
 193 api_cipher_hd_st * h = handle;
 194
 195   if (_gnutls_cipher_is_aead( &h->ctx_enc)!=0)
 196     return _gnutls_cipher_decrypt (&h->ctx_enc, ciphertext, ciphertextlen);
 197   else
 198     return _gnutls_cipher_decrypt (&h->ctx_dec, ciphertext, ciphertextlen);
 199 }
 200
 201 /**
 202  * gnutls_cipher_encrypt2:
 203  * @handle: is a #gnutls_cipher_hd_t structure.
 204  * @text: the data to encrypt
 205  * @textlen: The length of data to encrypt
 206  * @ciphertext: the encrypted data
 207  * @ciphertextlen: The available length for encrypted data
 208  *
 209  * This function will encrypt the given data using the algorithm
 210  * specified by the context.
 211  *
 212  * Returns: Zero or a negative error code on error.
 213  *
 214  * Since: 2.12.0
 215  **/
 216 int
 217 gnutls_cipher_encrypt2 (gnutls_cipher_hd_t handle, const void *text, size_t textlen,
 218                         void *ciphertext, size_t ciphertextlen)
 219 {
 220 api_cipher_hd_st * h = handle;
 221
 222   return _gnutls_cipher_encrypt2 (&h->ctx_enc, text, textlen,
 223                                   ciphertext, ciphertextlen);
 224 }
 225
 226 /**
 227  * gnutls_cipher_decrypt2:
 228  * @handle: is a #gnutls_cipher_hd_t structure.
 229  * @ciphertext: the data to encrypt
 230  * @ciphertextlen: The length of data to encrypt
 231  * @text: the decrypted data
 232  * @textlen: The available length for decrypted data
 233  *
 234  * This function will decrypt the given data using the algorithm
 235  * specified by the context.
 236  *
 237  * Returns: Zero or a negative error code on error.
 238  *
 239  * Since: 2.12.0
 240  **/
 241 int
 242 gnutls_cipher_decrypt2 (gnutls_cipher_hd_t handle, const void *ciphertext,
 243                         size_t ciphertextlen, void *text, size_t textlen)
 244 {
 245 api_cipher_hd_st * h = handle;
 246
 247   return _gnutls_cipher_decrypt2 (&h->ctx_dec, ciphertext,
 248                                   ciphertextlen, text, textlen);
 249 }
 250
 251 /**
 252  * gnutls_cipher_deinit:
 253  * @handle: is a #gnutls_cipher_hd_t structure.
 254  *
 255  * This function will deinitialize all resources occupied by the given
 256  * encryption context.
 257  *
 258  * Since: 2.10.0
 259  **/
 260 void
 261 gnutls_cipher_deinit (gnutls_cipher_hd_t handle)
 262 {
 263 api_cipher_hd_st * h = handle;
 264
 265   _gnutls_cipher_deinit (&h->ctx_enc);
 266   if (_gnutls_cipher_is_aead( &h->ctx_enc)==0)
 267     _gnutls_cipher_deinit (&h->ctx_dec);
 268   gnutls_free (handle);
 269 }
 270
 271
 272 /* HMAC */
 273
 274 /**
 275  * gnutls_hmac_init:
 276  * @dig: is a #gnutls_hmac_hd_t structure.
 277  * @algorithm: the HMAC algorithm to use
 278  * @key: The key to be used for encryption
 279  * @keylen: The length of the key
 280  *
 281  * This function will initialize an context that can be used to
 282  * produce a Message Authentication Code (MAC) of data.  This will
 283  * effectively use the current crypto backend in use by gnutls or the
 284  * cryptographic accelerator in use.
 285  *
 286  * Returns: Zero or a negative error code on error.
 287  *
 288  * Since: 2.10.0
 289  **/
 290 int
 291 gnutls_hmac_init (gnutls_hmac_hd_t * dig,
 292                   gnutls_digest_algorithm_t algorithm,
 293                   const void *key, size_t keylen)
 294 {
 295   *dig = gnutls_malloc (sizeof (digest_hd_st));
 296   if (*dig == NULL)
 297     {
 298       gnutls_assert ();
 299       return GNUTLS_E_MEMORY_ERROR;
 300     }
 301
 302   return _gnutls_hmac_init (((digest_hd_st *) * dig), algorithm, key, keylen);
 303 }
 304
 305 /**
 306  * gnutls_hmac:
 307  * @handle: is a #gnutls_cipher_hd_t structure.
 308  * @text: the data to hash
 309  * @textlen: The length of data to hash
 310  *
 311  * This function will hash the given data using the algorithm
 312  * specified by the context.
 313  *
 314  * Returns: Zero or a negative error code on error.
 315  *
 316  * Since: 2.10.0
 317  **/
 318 int
 319 gnutls_hmac (gnutls_hmac_hd_t handle, const void *text, size_t textlen)
 320 {
 321   return _gnutls_hmac ((digest_hd_st *) handle, text, textlen);
 322 }
 323
 324 /**
 325  * gnutls_hmac_output:
 326  * @handle: is a #gnutls_hmac_hd_t structure.
 327  * @digest: is the output value of the MAC
 328  *
 329  * This function will output the current MAC value.
 330  *
 331  * Since: 2.10.0
 332  **/
 333 void
 334 gnutls_hmac_output (gnutls_hmac_hd_t handle, void *digest)
 335 {
 336   _gnutls_hmac_output ((digest_hd_st *) handle, digest);
 337 }
 338
 339 /**
 340  * gnutls_hmac_deinit:
 341  * @handle: is a #gnutls_hmac_hd_t structure.
 342  * @digest: is the output value of the MAC
 343  *
 344  * This function will deinitialize all resources occupied by
 345  * the given hmac context.
 346  *
 347  * Since: 2.10.0
 348  **/
 349 void
 350 gnutls_hmac_deinit (gnutls_hmac_hd_t handle, void *digest)
 351 {
 352   _gnutls_hmac_deinit ((digest_hd_st *) handle, digest);
 353   gnutls_free (handle);
 354 }
 355
 356 /**
 357  * gnutls_hmac_get_len:
 358  * @algorithm: the hmac algorithm to use
 359  *
 360  * This function will return the length of the output data
 361  * of the given hmac algorithm.
 362  *
 363  * Returns: The length or zero on error.
 364  *
 365  * Since: 2.10.0
 366  **/
 367 int
 368 gnutls_hmac_get_len (gnutls_mac_algorithm_t algorithm)
 369 {
 370   return _gnutls_hmac_get_algo_len (algorithm);
 371 }
 372
 373 /**
 374  * gnutls_hmac_fast:
 375  * @algorithm: the hash algorithm to use
 376  * @key: the key to use
 377  * @keylen: The length of the key
 378  * @text: the data to hash
 379  * @textlen: The length of data to hash
 380  * @digest: is the output value of the hash
 381  *
 382  * This convenience function will hash the given data and return output
 383  * on a single call.
 384  *
 385  * Returns: Zero or a negative error code on error.
 386  *
 387  * Since: 2.10.0
 388  **/
 389 int
 390 gnutls_hmac_fast (gnutls_mac_algorithm_t algorithm,
 391                   const void *key, size_t keylen,
 392                   const void *text, size_t textlen, void *digest)
 393 {
 394   return _gnutls_hmac_fast (algorithm, key, keylen, text, textlen, digest);
 395 }
 396
 397 /* HASH */
 398
 399 /**
 400  * gnutls_hash_init:
 401  * @dig: is a #gnutls_hash_hd_t structure.
 402  * @algorithm: the hash algorithm to use
 403  *
 404  * This function will initialize an context that can be used to
 405  * produce a Message Digest of data.  This will effectively use the
 406  * current crypto backend in use by gnutls or the cryptographic
 407  * accelerator in use.
 408  *
 409  * Returns: Zero or a negative error code on error.
 410  *
 411  * Since: 2.10.0
 412  **/
 413 int
 414 gnutls_hash_init (gnutls_hash_hd_t * dig, gnutls_digest_algorithm_t algorithm)
 415 {
 416   *dig = gnutls_malloc (sizeof (digest_hd_st));
 417   if (*dig == NULL)
 418     {
 419       gnutls_assert ();
 420       return GNUTLS_E_MEMORY_ERROR;
 421     }
 422
 423   return _gnutls_hash_init (((digest_hd_st *) * dig), algorithm);
 424 }
 425
 426 /**
 427  * gnutls_hash:
 428  * @handle: is a #gnutls_cipher_hd_t structure.
 429  * @text: the data to hash
 430  * @textlen: The length of data to hash
 431  *
 432  * This function will hash the given data using the algorithm
 433  * specified by the context.
 434  *
 435  * Returns: Zero or a negative error code on error.
 436  *
 437  * Since: 2.10.0
 438  **/
 439 int
 440 gnutls_hash (gnutls_hash_hd_t handle, const void *text, size_t textlen)
 441 {
 442   return _gnutls_hash ((digest_hd_st *) handle, text, textlen);
 443 }
 444
 445 /**
 446  * gnutls_hash_output:
 447  * @handle: is a #gnutls_hash_hd_t structure.
 448  * @digest: is the output value of the hash
 449  *
 450  * This function will output the current hash value.
 451  *
 452  * Since: 2.10.0
 453  **/
 454 void
 455 gnutls_hash_output (gnutls_hash_hd_t handle, void *digest)
 456 {
 457   _gnutls_hash_output ((digest_hd_st *) handle, digest);
 458 }
 459
 460 /**
 461  * gnutls_hash_deinit:
 462  * @handle: is a #gnutls_hash_hd_t structure.
 463  * @digest: is the output value of the hash
 464  *
 465  * This function will deinitialize all resources occupied by
 466  * the given hash context.
 467  *
 468  * Since: 2.10.0
 469  **/
 470 void
 471 gnutls_hash_deinit (gnutls_hash_hd_t handle, void *digest)
 472 {
 473   _gnutls_hash_deinit ((digest_hd_st *) handle, digest);
 474   gnutls_free (handle);
 475 }
 476
 477 /**
 478  * gnutls_hash_get_len:
 479  * @algorithm: the hash algorithm to use
 480  *
 481  * This function will return the length of the output data
 482  * of the given hash algorithm.
 483  *
 484  * Returns: The length or zero on error.
 485  *
 486  * Since: 2.10.0
 487  **/
 488 int
 489 gnutls_hash_get_len (gnutls_digest_algorithm_t algorithm)
 490 {
 491   return _gnutls_hash_get_algo_len (algorithm);
 492 }
 493
 494 /**
 495  * gnutls_hash_fast:
 496  * @algorithm: the hash algorithm to use
 497  * @text: the data to hash
 498  * @textlen: The length of data to hash
 499  * @digest: is the output value of the hash
 500  *
 501  * This convenience function will hash the given data and return output
 502  * on a single call.
 503  *
 504  * Returns: Zero or a negative error code on error.
 505  *
 506  * Since: 2.10.0
 507  **/
 508 int
 509 gnutls_hash_fast (gnutls_digest_algorithm_t algorithm,
 510                   const void *text, size_t textlen, void *digest)
 511 {
 512   return _gnutls_hash_fast (algorithm, text, textlen, digest);
 513 }
 514
 515 /**
 516  * gnutls_key_generate:
 517  * @key: is a pointer to a #gnutls_datum_t which will contain a newly
 518  * created key.
 519  * @key_size: The number of bytes of the key.
 520  *
 521  * Generates a random key of @key_bytes size.
 522  *
 523  * Returns: On success, %GNUTLS_E_SUCCESS (0) is returned, or an
 524  * error code.
 525  *
 526  * Since: 3.0.0
 527  **/
 528 int
 529 gnutls_key_generate (gnutls_datum_t * key, unsigned int key_size)
 530 {
 531   int ret;
 532
 533   key->size = key_size;
 534   key->data = gnutls_malloc (key->size);
 535   if (!key->data)
 536     {
 537       gnutls_assert ();
 538       return GNUTLS_E_MEMORY_ERROR;
 539     }
 540
 541   ret = gnutls_rnd (GNUTLS_RND_RANDOM, key->data, key->size);
 542   if (ret < 0)
 543     {
 544       gnutls_assert ();
 545       _gnutls_free_datum (key);
 546       return ret;
 547     }
 548
 549   return 0;
 550 }