libnm-core/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 #include "nm-errors.h"
  33
  34 #define SALT_LEN 8
  35
  36 static gboolean initialized = FALSE;
  37
  38 gboolean
  39 crypto_init (GError **error)
  40 {
  41         if (initialized)
  42                 return TRUE;
  43
  44         if (gnutls_global_init() != 0) {
  45                 gnutls_global_deinit();
  46                 g_set_error_literal (error, NM_CRYPTO_ERROR,
  47                                      NM_CRYPTO_ERROR_FAILED,
  48                                      _("Failed to initialize the crypto engine."));
  49                 return FALSE;
  50         }
  51
  52         initialized = TRUE;
  53         return TRUE;
  54 }
  55
  56 char *
  57 crypto_decrypt (const char *cipher,
  58                 int key_type,
  59                 const guint8 *data,
  60                 gsize data_len,
  61                 const char *iv,
  62                 const gsize iv_len,
  63                 const char *key,
  64                 const gsize key_len,
  65                 gsize *out_len,
  66                 GError **error)
  67 {
  68         gnutls_cipher_hd_t ctx;
  69         gnutls_datum_t key_dt, iv_dt;
  70         int err;
  71         int cipher_mech, i;
  72         char *output = NULL;
  73         gboolean success = FALSE;
  74         gsize pad_len, real_iv_len;
  75
  76         if (!crypto_init (error))
  77                 return NULL;
  78
  79         if (!strcmp (cipher, CIPHER_DES_EDE3_CBC)) {
  80                 cipher_mech = GNUTLS_CIPHER_3DES_CBC;
  81                 real_iv_len = SALT_LEN;
  82         } else if (!strcmp (cipher, CIPHER_DES_CBC)) {
  83                 cipher_mech = GNUTLS_CIPHER_DES_CBC;
  84                 real_iv_len = SALT_LEN;
  85         } else if (!strcmp (cipher, CIPHER_AES_CBC)) {
  86                 cipher_mech = GNUTLS_CIPHER_AES_128_CBC;
  87                 real_iv_len = 16;
  88         } else {
  89                 g_set_error (error, NM_CRYPTO_ERROR,
  90                              NM_CRYPTO_ERROR_UNKNOWN_CIPHER,
  91                              _("Private key cipher '%s' was unknown."),
  92                              cipher);
  93                 return NULL;
  94         }
  95
  96         if (iv_len < real_iv_len) {
  97                 g_set_error (error, NM_CRYPTO_ERROR,
  98                              NM_CRYPTO_ERROR_INVALID_DATA,
  99                              _("Invalid IV length (must be at least %zd)."),
 100                              real_iv_len);
 101                 return NULL;
 102         }
 103
 104         output = g_malloc0 (data_len);
 105
 106         key_dt.data = (unsigned char *) key;
 107         key_dt.size = key_len;
 108         iv_dt.data = (unsigned char *) iv;
 109         iv_dt.size = iv_len;
 110
 111         err = gnutls_cipher_init (&ctx, cipher_mech, &key_dt, &iv_dt);
 112         if (err < 0) {
 113                 g_set_error (error, NM_CRYPTO_ERROR,
 114                              NM_CRYPTO_ERROR_DECRYPTION_FAILED,
 115                              _("Failed to initialize the decryption cipher context: %s (%s)"),
 116                              gnutls_strerror_name (err), gnutls_strerror (err));
 117                 goto out;
 118         }
 119
 120         err = gnutls_cipher_decrypt2 (ctx, data, data_len, output, data_len);
 121         if (err < 0) {
 122                 g_set_error (error, NM_CRYPTO_ERROR,
 123                              NM_CRYPTO_ERROR_DECRYPTION_FAILED,
 124                              _("Failed to decrypt the private key: %s (%s)"),
 125                              gnutls_strerror_name (err), gnutls_strerror (err));
 126                 goto out;
 127         }
 128         pad_len = output[data_len - 1];
 129
 130         /* Check if the padding at the end of the decrypted data is valid */
 131         if (pad_len == 0 || pad_len > real_iv_len) {
 132                 g_set_error (error, NM_CRYPTO_ERROR,
 133                              NM_CRYPTO_ERROR_DECRYPTION_FAILED,
 134                              _("Failed to decrypt the private key: unexpected padding length."));
 135                 goto out;
 136         }
 137
 138         /* Validate tail padding; last byte is the padding size, and all pad bytes
 139          * should contain the padding size.
 140          */
 141         for (i = 1; i <= pad_len; ++i) {
 142                 if (output[data_len - i] != pad_len) {
 143                         g_set_error (error, NM_CRYPTO_ERROR,
 144                                      NM_CRYPTO_ERROR_DECRYPTION_FAILED,
 145                                      _("Failed to decrypt the private key."));
 146                         goto out;
 147                 }
 148         }
 149
 150         *out_len = data_len - pad_len;
 151         success = TRUE;
 152
 153 out:
 154         if (!success) {
 155                 if (output) {
 156                         /* Don't expose key material */
 157                         memset (output, 0, data_len);
 158                         g_free (output);
 159                         output = NULL;
 160                 }
 161         }
 162         gnutls_cipher_deinit (ctx);
 163         return output;
 164 }
 165
 166 char *
 167 crypto_encrypt (const char *cipher,
 168                 const guint8 *data,
 169                 gsize data_len,
 170                 const char *iv,
 171                 const gsize iv_len,
 172                 const char *key,
 173                 gsize key_len,
 174                 gsize *out_len,
 175                 GError **error)
 176 {
 177         gnutls_cipher_hd_t ctx;
 178         gnutls_datum_t key_dt, iv_dt;
 179         int err;
 180         int cipher_mech;
 181         char *output = NULL;
 182         gboolean success = FALSE;
 183         gsize padded_buf_len, pad_len, output_len;
 184         char *padded_buf = NULL;
 185         guint32 i;
 186
 187         if (!crypto_init (error))
 188                 return NULL;
 189
 190         if (!strcmp (cipher, CIPHER_DES_EDE3_CBC))
 191                 cipher_mech = GNUTLS_CIPHER_3DES_CBC;
 192         else if (!strcmp (cipher, CIPHER_AES_CBC))
 193                 cipher_mech = GNUTLS_CIPHER_AES_128_CBC;
 194         else {
 195                 g_set_error (error, NM_CRYPTO_ERROR,
 196                              NM_CRYPTO_ERROR_UNKNOWN_CIPHER,
 197                              _("Private key cipher '%s' was unknown."),
 198                              cipher);
 199                 return NULL;
 200         }
 201
 202         /* If data_len % ivlen == 0, then we add another complete block
 203          * onto the end so that the decrypter knows there's padding.
 204          */
 205         pad_len = iv_len - (data_len % iv_len);
 206         output_len = padded_buf_len = data_len + pad_len;
 207         padded_buf = g_malloc0 (padded_buf_len);
 208
 209         memcpy (padded_buf, data, data_len);
 210         for (i = 0; i < pad_len; i++)
 211                 padded_buf[data_len + i] = (guint8) (pad_len & 0xFF);
 212
 213         output = g_malloc0 (output_len);
 214
 215         key_dt.data = (unsigned char *) key;
 216         key_dt.size = key_len;
 217         iv_dt.data = (unsigned char *) iv;
 218         iv_dt.size = iv_len;
 219
 220         err = gnutls_cipher_init (&ctx, cipher_mech, &key_dt, &iv_dt);
 221         if (err < 0) {
 222                 g_set_error (error, NM_CRYPTO_ERROR,
 223                              NM_CRYPTO_ERROR_ENCRYPTION_FAILED,
 224                              _("Failed to initialize the encryption cipher context: %s (%s)"),
 225                              gnutls_strerror_name (err), gnutls_strerror (err));
 226                 goto out;
 227         }
 228
 229         err = gnutls_cipher_encrypt2 (ctx, padded_buf, padded_buf_len, output, output_len);
 230         if (err < 0) {
 231                 g_set_error (error, NM_CRYPTO_ERROR,
 232                              NM_CRYPTO_ERROR_ENCRYPTION_FAILED,
 233                              _("Failed to encrypt the data: %s (%s)"),
 234                              gnutls_strerror_name (err), gnutls_strerror (err));
 235                 goto out;
 236         }
 237
 238         *out_len = output_len;
 239         success = TRUE;
 240
 241 out:
 242         if (padded_buf) {
 243                 memset (padded_buf, 0, padded_buf_len);
 244                 g_free (padded_buf);
 245                 padded_buf = NULL;
 246         }
 247
 248         if (!success) {
 249                 if (output) {
 250                         /* Don't expose key material */
 251                         memset (output, 0, output_len);
 252                         g_free (output);
 253                         output = NULL;
 254                 }
 255         }
 256         gnutls_cipher_deinit (ctx);
 257         return output;
 258 }
 259
 260 NMCryptoFileFormat
 261 crypto_verify_cert (const unsigned char *data,
 262                     gsize len,
 263                     GError **error)
 264 {
 265         gnutls_x509_crt_t der;
 266         gnutls_datum_t dt;
 267         int err;
 268
 269         if (!crypto_init (error))
 270                 return NM_CRYPTO_FILE_FORMAT_UNKNOWN;
 271
 272         err = gnutls_x509_crt_init (&der);
 273         if (err < 0) {
 274                 g_set_error (error, NM_CRYPTO_ERROR,
 275                              NM_CRYPTO_ERROR_INVALID_DATA,
 276                              _("Error initializing certificate data: %s"),
 277                              gnutls_strerror (err));
 278                 return NM_CRYPTO_FILE_FORMAT_UNKNOWN;
 279         }
 280
 281         /* Try DER first */
 282         dt.data = (unsigned char *) data;
 283         dt.size = len;
 284         err = gnutls_x509_crt_import (der, &dt, GNUTLS_X509_FMT_DER);
 285         if (err == GNUTLS_E_SUCCESS) {
 286                 gnutls_x509_crt_deinit (der);
 287                 return NM_CRYPTO_FILE_FORMAT_X509;
 288         }
 289
 290         /* And PEM next */
 291         err = gnutls_x509_crt_import (der, &dt, GNUTLS_X509_FMT_PEM);
 292         gnutls_x509_crt_deinit (der);
 293         if (err == GNUTLS_E_SUCCESS)
 294                 return NM_CRYPTO_FILE_FORMAT_X509;
 295
 296         g_set_error (error, NM_CRYPTO_ERROR,
 297                      NM_CRYPTO_ERROR_INVALID_DATA,
 298                      _("Couldn't decode certificate: %s"),
 299                      gnutls_strerror (err));
 300         return NM_CRYPTO_FILE_FORMAT_UNKNOWN;
 301 }
 302
 303 gboolean
 304 crypto_verify_pkcs12 (const guint8 *data,
 305                       gsize data_len,
 306                       const char *password,
 307                       GError **error)
 308 {
 309         gnutls_pkcs12_t p12;
 310         gnutls_datum_t dt;
 311         gboolean success = FALSE;
 312         int err;
 313
 314         g_return_val_if_fail (data != NULL, FALSE);
 315
 316         if (!crypto_init (error))
 317                 return FALSE;
 318
 319         dt.data = (unsigned char *) data;
 320         dt.size = data_len;
 321
 322         err = gnutls_pkcs12_init (&p12);
 323         if (err < 0) {
 324                 g_set_error (error, NM_CRYPTO_ERROR,
 325                              NM_CRYPTO_ERROR_FAILED,
 326                              _("Couldn't initialize PKCS#12 decoder: %s"),
 327                              gnutls_strerror (err));
 328                 return FALSE;
 329         }
 330
 331         /* DER first */
 332         err = gnutls_pkcs12_import (p12, &dt, GNUTLS_X509_FMT_DER, 0);
 333         if (err < 0) {
 334                 /* PEM next */
 335                 err = gnutls_pkcs12_import (p12, &dt, GNUTLS_X509_FMT_PEM, 0);
 336                 if (err < 0) {
 337                         g_set_error (error, NM_CRYPTO_ERROR,
 338                                      NM_CRYPTO_ERROR_INVALID_DATA,
 339                                      _("Couldn't decode PKCS#12 file: %s"),
 340                                      gnutls_strerror (err));
 341                         goto out;
 342                 }
 343         }
 344
 345         err = gnutls_pkcs12_verify_mac (p12, password);
 346         if (err == GNUTLS_E_SUCCESS)
 347                 success = TRUE;
 348         else {
 349                 g_set_error (error, NM_CRYPTO_ERROR,
 350                              NM_CRYPTO_ERROR_DECRYPTION_FAILED,
 351                              _("Couldn't verify PKCS#12 file: %s"),
 352                              gnutls_strerror (err));
 353         }
 354
 355 out:
 356         gnutls_pkcs12_deinit (p12);
 357         return success;
 358 }
 359
 360 gboolean
 361 crypto_verify_pkcs8 (const guint8 *data,
 362                      gsize data_len,
 363                      gboolean is_encrypted,
 364                      const char *password,
 365                      GError **error)
 366 {
 367         gnutls_x509_privkey_t p8;
 368         gnutls_datum_t dt;
 369         int err;
 370
 371         g_return_val_if_fail (data != NULL, FALSE);
 372
 373         if (!crypto_init (error))
 374                 return FALSE;
 375
 376         dt.data = (unsigned char *) data;
 377         dt.size = data_len;
 378
 379         err = gnutls_x509_privkey_init (&p8);
 380         if (err < 0) {
 381                 g_set_error (error, NM_CRYPTO_ERROR,
 382                              NM_CRYPTO_ERROR_FAILED,
 383                              _("Couldn't initialize PKCS#8 decoder: %s"),
 384                              gnutls_strerror (err));
 385                 return FALSE;
 386         }
 387
 388         err = gnutls_x509_privkey_import_pkcs8 (p8,
 389                                                 &dt,
 390                                                 GNUTLS_X509_FMT_DER,
 391                                                 is_encrypted ? password : NULL,
 392                                                 is_encrypted ? 0 : GNUTLS_PKCS_PLAIN);
 393         gnutls_x509_privkey_deinit (p8);
 394
 395         if (err < 0) {
 396                 if (err == GNUTLS_E_UNKNOWN_CIPHER_TYPE) {
 397                         /* HACK: gnutls doesn't support all the cipher types that openssl
 398                          * can use with PKCS#8, so if we encounter one, we have to assume
 399                          * the given password works.  gnutls needs to unsuckify, apparently.
 400                          * Specifically, by default openssl uses pbeWithMD5AndDES-CBC
 401                          * which gnutls does not support.
 402                          */
 403                 } else {
 404                         g_set_error (error, NM_CRYPTO_ERROR,
 405                                      NM_CRYPTO_ERROR_INVALID_DATA,
 406                                      _("Couldn't decode PKCS#8 file: %s"),
 407                                      gnutls_strerror (err));
 408                         return FALSE;
 409                 }
 410         }
 411
 412         return TRUE;
 413 }
 414
 415 gboolean
 416 crypto_randomize (void *buffer, gsize buffer_len, GError **error)
 417 {
 418         if (!crypto_init (error))
 419                 return FALSE;
 420
 421         gnutls_rnd (GNUTLS_RND_RANDOM, buffer, buffer_len);
 422         return TRUE;
 423 }