libnm-util/crypto_gnutls.c

   1 /* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
   2 /* NetworkManager Wireless Applet -- Display wireless access points and allow user control
   3  *
   4  * Dan Williams <dcbw@redhat.com>
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the
  18  * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
  19  * Boston, MA 02110-1301 USA.
  20  *
  21  * Copyright 2007 - 2015 Red Hat, Inc.
  22  */
  23
  24 #include "nm-default.h"
  25
  26 #include <gnutls/gnutls.h>
  27 #include <gnutls/crypto.h>
  28 #include <gnutls/x509.h>
  29 #include <gnutls/pkcs12.h>
  30
  31 #include "crypto.h"
  32
  33 #define SALT_LEN 8
  34
  35 static gboolean initialized = FALSE;
  36
  37 gboolean
  38 crypto_init (GError **error)
  39 {
  40         if (initialized)
  41                 return TRUE;
  42
  43         if (gnutls_global_init() != 0) {
  44                 gnutls_global_deinit();
  45                 g_set_error (error, NM_CRYPTO_ERROR,
  46                              NM_CRYPTO_ERR_INIT_FAILED,
  47                              "%s",
  48                              _("Failed to initialize the crypto engine."));
  49                 return FALSE;
  50         }
  51
  52         initialized = TRUE;
  53         return TRUE;
  54 }
  55
  56 gboolean
  57 crypto_md5_hash (const char *salt,
  58                  const gsize salt_len,
  59                  const char *password,
  60                  gsize password_len,
  61                  char *buffer,
  62                  gsize buflen,
  63                  GError **error)
  64 {
  65         gnutls_hash_hd_t ctx;
  66         int err;
  67         int nkey = buflen;
  68         const gsize digest_len = 16;
  69         int count = 0;
  70         char digest[MD5_HASH_LEN];
  71         char *p = buffer;
  72
  73         if (salt)
  74                 g_return_val_if_fail (salt_len >= SALT_LEN, FALSE);
  75
  76         g_return_val_if_fail (password != NULL, FALSE);
  77         g_return_val_if_fail (password_len > 0, FALSE);
  78         g_return_val_if_fail (buffer != NULL, FALSE);
  79         g_return_val_if_fail (buflen > 0, FALSE);
  80
  81         if (gnutls_hash_get_len (GNUTLS_DIG_MD5) > MD5_HASH_LEN) {
  82                 g_set_error (error, NM_CRYPTO_ERROR,
  83                              NM_CRYPTO_ERR_MD5_INIT_FAILED,
  84                              _("Hash length too long (%d > %d)."),
  85                              gnutls_hash_get_len (GNUTLS_DIG_MD5), MD5_HASH_LEN);
  86                 return FALSE;
  87         }
  88
  89         while (nkey > 0) {
  90                 int i = 0;
  91
  92                 err = gnutls_hash_init (&ctx, GNUTLS_DIG_MD5);
  93                 if (err < 0)
  94                         goto error;
  95
  96                 if (count++)
  97                         gnutls_hash (ctx, digest, digest_len);
  98                 gnutls_hash (ctx, password, password_len);
  99                 if (salt)
 100                         gnutls_hash (ctx, salt, SALT_LEN); /* Only use 8 bytes of salt */
 101                 gnutls_hash_deinit (ctx, digest);
 102
 103                 while (nkey && (i < digest_len)) {
 104                         *(p++) = digest[i++];
 105                         nkey--;
 106                 }
 107         }
 108
 109         memset (digest, 0, sizeof (digest));
 110         return TRUE;
 111 error:
 112         memset (digest, 0, sizeof (digest));
 113         g_set_error (error, NM_CRYPTO_ERROR,
 114                      NM_CRYPTO_ERR_MD5_INIT_FAILED,
 115                      _("Failed to initialize the MD5 engine: %s (%s)"),
 116                      gnutls_strerror_name (err), gnutls_strerror (err));
 117         return FALSE;
 118 }
 119
 120 char *
 121 crypto_decrypt (const char *cipher,
 122                 int key_type,
 123                 GByteArray *data,
 124                 const char *iv,
 125                 const gsize iv_len,
 126                 const char *key,
 127                 const gsize key_len,
 128                 gsize *out_len,
 129                 GError **error)
 130 {
 131         gnutls_cipher_hd_t ctx;
 132         gnutls_datum_t key_dt, iv_dt;
 133         int err;
 134         int cipher_mech, i;
 135         char *output = NULL;
 136         gboolean success = FALSE;
 137         gsize pad_len, real_iv_len;
 138
 139         if (!strcmp (cipher, CIPHER_DES_EDE3_CBC)) {
 140                 cipher_mech = GNUTLS_CIPHER_3DES_CBC;
 141                 real_iv_len = SALT_LEN;
 142         } else if (!strcmp (cipher, CIPHER_DES_CBC)) {
 143                 cipher_mech = GNUTLS_CIPHER_DES_CBC;
 144                 real_iv_len = SALT_LEN;
 145         } else if (!strcmp (cipher, CIPHER_AES_CBC)) {
 146                 cipher_mech = GNUTLS_CIPHER_AES_128_CBC;
 147                 real_iv_len = 16;
 148         } else {
 149                 g_set_error (error, NM_CRYPTO_ERROR,
 150                              NM_CRYPTO_ERR_UNKNOWN_CIPHER,
 151                              _("Private key cipher '%s' was unknown."),
 152                              cipher);
 153                 return NULL;
 154         }
 155
 156         if (iv_len < real_iv_len) {
 157                 g_set_error (error, NM_CRYPTO_ERROR,
 158                              NM_CRYPTO_ERR_RAW_IV_INVALID,
 159                              _("Invalid IV length (must be at least %zd)."),
 160                              real_iv_len);
 161                 return NULL;
 162         }
 163
 164         output = g_malloc0 (data->len);
 165
 166         key_dt.data = (unsigned char *) key;
 167         key_dt.size = key_len;
 168         iv_dt.data = (unsigned char *) iv;
 169         iv_dt.size = iv_len;
 170
 171         err = gnutls_cipher_init (&ctx, cipher_mech, &key_dt, &iv_dt);
 172         if (err < 0) {
 173                 g_set_error (error, NM_CRYPTO_ERROR,
 174                              NM_CRYPTO_ERR_CIPHER_INIT_FAILED,
 175                              _("Failed to initialize the decryption cipher context: %s (%s)"),
 176                              gnutls_strerror_name (err), gnutls_strerror (err));
 177                 goto out;
 178         }
 179
 180         err = gnutls_cipher_decrypt2 (ctx, data->data, data->len, output, data->len);
 181         if (err < 0) {
 182                 g_set_error (error, NM_CRYPTO_ERROR,
 183                              NM_CRYPTO_ERR_CIPHER_DECRYPT_FAILED,
 184                              _("Failed to decrypt the private key: %s (%s)"),
 185                              gnutls_strerror_name (err), gnutls_strerror (err));
 186                 goto out;
 187         }
 188         pad_len = output[data->len - 1];
 189
 190         /* Check if the padding at the end of the decrypted data is valid */
 191         if (pad_len == 0 || pad_len > real_iv_len) {
 192                 g_set_error (error, NM_CRYPTO_ERROR,
 193                              NM_CRYPTO_ERR_CIPHER_DECRYPT_FAILED,
 194                              _("Failed to decrypt the private key: unexpected padding length."));
 195                 goto out;
 196         }
 197
 198         /* Validate tail padding; last byte is the padding size, and all pad bytes
 199          * should contain the padding size.
 200          */
 201         for (i = 1; i <= pad_len; ++i) {
 202                 if (output[data->len - i] != pad_len) {
 203                         g_set_error (error, NM_CRYPTO_ERROR,
 204                                      NM_CRYPTO_ERR_CIPHER_DECRYPT_FAILED,
 205                                      _("Failed to decrypt the private key."));
 206                         goto out;
 207                 }
 208         }
 209
 210         *out_len = data->len - pad_len;
 211         success = TRUE;
 212
 213 out:
 214         if (!success) {
 215                 if (output) {
 216                         /* Don't expose key material */
 217                         memset (output, 0, data->len);
 218                         g_free (output);
 219                         output = NULL;
 220                 }
 221         }
 222         gnutls_cipher_deinit (ctx);
 223         return output;
 224 }
 225
 226 char *
 227 crypto_encrypt (const char *cipher,
 228                 const GByteArray *data,
 229                 const char *iv,
 230                 const gsize iv_len,
 231                 const char *key,
 232                 gsize key_len,
 233                 gsize *out_len,
 234                 GError **error)
 235 {
 236         gnutls_cipher_hd_t ctx;
 237         gnutls_datum_t key_dt, iv_dt;
 238         int err;
 239         int cipher_mech;
 240         char *output = NULL;
 241         gboolean success = FALSE;
 242         gsize padded_buf_len, pad_len, output_len;
 243         char *padded_buf = NULL;
 244         guint32 i;
 245         gsize salt_len;
 246
 247         if (!strcmp (cipher, CIPHER_DES_EDE3_CBC)) {
 248                 cipher_mech = GNUTLS_CIPHER_3DES_CBC;
 249                 salt_len = SALT_LEN;
 250         } else if (!strcmp (cipher, CIPHER_AES_CBC)) {
 251                 cipher_mech = GNUTLS_CIPHER_AES_128_CBC;
 252                 salt_len = iv_len;
 253         } else {
 254                 g_set_error (error, NM_CRYPTO_ERROR,
 255                              NM_CRYPTO_ERR_UNKNOWN_CIPHER,
 256                              _("Private key cipher '%s' was unknown."),
 257                              cipher);
 258                 return NULL;
 259         }
 260
 261         /* If data->len % ivlen == 0, then we add another complete block
 262          * onto the end so that the decrypter knows there's padding.
 263          */
 264         pad_len = iv_len - (data->len % iv_len);
 265         output_len = padded_buf_len = data->len + pad_len;
 266         padded_buf = g_malloc0 (padded_buf_len);
 267
 268         memcpy (padded_buf, data->data, data->len);
 269         for (i = 0; i < pad_len; i++)
 270                 padded_buf[data->len + i] = (guint8) (pad_len & 0xFF);
 271
 272         output = g_malloc0 (output_len);
 273
 274         key_dt.data = (unsigned char *) key;
 275         key_dt.size = key_len;
 276         iv_dt.data = (unsigned char *) iv;
 277         iv_dt.size = iv_len;
 278
 279         err = gnutls_cipher_init (&ctx, cipher_mech, &key_dt, &iv_dt);
 280         if (err < 0) {
 281                 g_set_error (error, NM_CRYPTO_ERROR,
 282                              NM_CRYPTO_ERR_CIPHER_INIT_FAILED,
 283                              _("Failed to initialize the encryption cipher context: %s (%s)"),
 284                              gnutls_strerror_name (err), gnutls_strerror (err));
 285                 goto out;
 286         }
 287
 288         err = gnutls_cipher_encrypt2 (ctx, padded_buf, padded_buf_len, output, output_len);
 289         if (err < 0) {
 290                 g_set_error (error, NM_CRYPTO_ERROR,
 291                              NM_CRYPTO_ERR_CIPHER_DECRYPT_FAILED,
 292                              _("Failed to encrypt the data: %s (%s)"),
 293                              gnutls_strerror_name (err), gnutls_strerror (err));
 294                 goto out;
 295         }
 296
 297         *out_len = output_len;
 298         success = TRUE;
 299
 300 out:
 301         if (padded_buf) {
 302                 memset (padded_buf, 0, padded_buf_len);
 303                 g_free (padded_buf);
 304                 padded_buf = NULL;
 305         }
 306
 307         if (!success) {
 308                 if (output) {
 309                         /* Don't expose key material */
 310                         memset (output, 0, output_len);
 311                         g_free (output);
 312                         output = NULL;
 313                 }
 314         }
 315         gnutls_cipher_deinit (ctx);
 316         return output;
 317 }
 318
 319 NMCryptoFileFormat
 320 crypto_verify_cert (const unsigned char *data,
 321                     gsize len,
 322                     GError **error)
 323 {
 324         gnutls_x509_crt_t der;
 325         gnutls_datum_t dt;
 326         int err;
 327
 328         err = gnutls_x509_crt_init (&der);
 329         if (err < 0) {
 330                 g_set_error (error, NM_CRYPTO_ERROR,
 331                              NM_CRYPTO_ERR_CERT_FORMAT_INVALID,
 332                              _("Error initializing certificate data: %s"),
 333                              gnutls_strerror (err));
 334                 return NM_CRYPTO_FILE_FORMAT_UNKNOWN;
 335         }
 336
 337         /* Try DER first */
 338         dt.data = (unsigned char *) data;
 339         dt.size = len;
 340         err = gnutls_x509_crt_import (der, &dt, GNUTLS_X509_FMT_DER);
 341         if (err == GNUTLS_E_SUCCESS) {
 342                 gnutls_x509_crt_deinit (der);
 343                 return NM_CRYPTO_FILE_FORMAT_X509;
 344         }
 345
 346         /* And PEM next */
 347         err = gnutls_x509_crt_import (der, &dt, GNUTLS_X509_FMT_PEM);
 348         gnutls_x509_crt_deinit (der);
 349         if (err == GNUTLS_E_SUCCESS)
 350                 return NM_CRYPTO_FILE_FORMAT_X509;
 351
 352         g_set_error (error, NM_CRYPTO_ERROR,
 353                      NM_CRYPTO_ERR_CERT_FORMAT_INVALID,
 354                      _("Couldn't decode certificate: %s"),
 355                      gnutls_strerror (err));
 356         return NM_CRYPTO_FILE_FORMAT_UNKNOWN;
 357 }
 358
 359 gboolean
 360 crypto_verify_pkcs12 (const GByteArray *data,
 361                       const char *password,
 362                       GError **error)
 363 {
 364         gnutls_pkcs12_t p12;
 365         gnutls_datum_t dt;
 366         gboolean success = FALSE;
 367         int err;
 368
 369         g_return_val_if_fail (data != NULL, FALSE);
 370
 371         dt.data = (unsigned char *) data->data;
 372         dt.size = data->len;
 373
 374         err = gnutls_pkcs12_init (&p12);
 375         if (err < 0) {
 376                 g_set_error (error, NM_CRYPTO_ERROR,
 377                              NM_CRYPTO_ERR_DECODE_FAILED,
 378                              _("Couldn't initialize PKCS#12 decoder: %s"),
 379                              gnutls_strerror (err));
 380                 return FALSE;
 381         }
 382
 383         /* DER first */
 384         err = gnutls_pkcs12_import (p12, &dt, GNUTLS_X509_FMT_DER, 0);
 385         if (err < 0) {
 386                 /* PEM next */
 387                 err = gnutls_pkcs12_import (p12, &dt, GNUTLS_X509_FMT_PEM, 0);
 388                 if (err < 0) {
 389                         g_set_error (error, NM_CRYPTO_ERROR,
 390                                      NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
 391                                      _("Couldn't decode PKCS#12 file: %s"),
 392                                      gnutls_strerror (err));
 393                         goto out;
 394                 }
 395         }
 396
 397         err = gnutls_pkcs12_verify_mac (p12, password);
 398         if (err == GNUTLS_E_SUCCESS)
 399                 success = TRUE;
 400         else {
 401                 g_set_error (error, NM_CRYPTO_ERROR,
 402                              NM_CRYPTO_ERR_CIPHER_DECRYPT_FAILED,
 403                              _("Couldn't verify PKCS#12 file: %s"),
 404                              gnutls_strerror (err));
 405         }
 406
 407 out:
 408         gnutls_pkcs12_deinit (p12);
 409         return success;
 410 }
 411
 412 gboolean
 413 crypto_verify_pkcs8 (const GByteArray *data,
 414                      gboolean is_encrypted,
 415                      const char *password,
 416                      GError **error)
 417 {
 418         gnutls_x509_privkey_t p8;
 419         gnutls_datum_t dt;
 420         int err;
 421
 422         g_return_val_if_fail (data != NULL, FALSE);
 423
 424         dt.data = (unsigned char *) data->data;
 425         dt.size = data->len;
 426
 427         err = gnutls_x509_privkey_init (&p8);
 428         if (err < 0) {
 429                 g_set_error (error, NM_CRYPTO_ERROR,
 430                              NM_CRYPTO_ERR_DECODE_FAILED,
 431                              _("Couldn't initialize PKCS#8 decoder: %s"),
 432                              gnutls_strerror (err));
 433                 return FALSE;
 434         }
 435
 436         err = gnutls_x509_privkey_import_pkcs8 (p8,
 437                                                 &dt,
 438                                                 GNUTLS_X509_FMT_DER,
 439                                                 is_encrypted ? password : NULL,
 440                                                 is_encrypted ? 0 : GNUTLS_PKCS_PLAIN);
 441         gnutls_x509_privkey_deinit (p8);
 442
 443         if (err < 0) {
 444                 if (err == GNUTLS_E_UNKNOWN_CIPHER_TYPE) {
 445                         /* HACK: gnutls doesn't support all the cipher types that openssl
 446                          * can use with PKCS#8, so if we encounter one, we have to assume
 447                          * the given password works.  gnutls needs to unsuckify, apparently.
 448                          * Specifically, by default openssl uses pbeWithMD5AndDES-CBC
 449                          * which gnutls does not support.
 450                          */
 451                 } else {
 452                         g_set_error (error, NM_CRYPTO_ERROR,
 453                                      NM_CRYPTO_ERR_FILE_FORMAT_INVALID,
 454                                      _("Couldn't decode PKCS#8 file: %s"),
 455                                      gnutls_strerror (err));
 456                         return FALSE;
 457                 }
 458         }
 459
 460         return TRUE;
 461 }
 462
 463 gboolean
 464 crypto_randomize (void *buffer, gsize buffer_len, GError **error)
 465 {
 466         gnutls_rnd (GNUTLS_RND_RANDOM, buffer, buffer_len);
 467         return TRUE;
 468 }