src/password.c

   1 /*
   2  * Claws Mail -- a GTK+ based, lightweight, and fast e-mail client
   3  * Copyright (C) 2016 The Claws Mail Team
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; either version 3 of the License, or
   8  * (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program. If not, see <http://www.gnu.org/licenses/>.
  17  *
  18  */
  19
  20 #ifdef HAVE_CONFIG_H
  21 #include "config.h"
  22 #include "claws-features.h"
  23 #endif
  24
  25 #ifdef PASSWORD_CRYPTO_GNUTLS
  26 # include <gnutls/gnutls.h>
  27 # include <gnutls/crypto.h>
  28 #endif
  29
  30 #include <glib.h>
  31 #include <glib/gi18n.h>
  32
  33 #if defined G_OS_UNIX
  34 #include <fcntl.h>
  35 #include <unistd.h>
  36 #elif defined G_OS_WIN32
  37 #include <windows.h>
  38 #include <wincrypt.h>
  39 #endif
  40
  41 #include "common/passcrypt.h"
  42 #include "common/plugin.h"
  43 #include "common/pkcs5_pbkdf2.h"
  44 #include "common/timing.h"
  45 #include "common/utils.h"
  46 #include "account.h"
  47 #include "alertpanel.h"
  48 #include "inputdialog.h"
  49 #include "password.h"
  50 #include "passwordstore.h"
  51 #include "prefs_common.h"
  52
  53 #ifndef PASSWORD_CRYPTO_OLD
  54 static gchar *_master_passphrase = NULL;
  55
  56 /* Length of stored key derivation, before base64. */
  57 #define KD_LENGTH 64
  58
  59 /* Length of randomly generated and saved salt, used for key derivation.
  60  * Also before base64. */
  61 #define KD_SALT_LENGTH 64
  62
  63 static void _generate_salt()
  64 {
  65 #if defined G_OS_UNIX
  66         int rnd;
  67 #elif defined G_OS_WIN32
  68         HCRYPTPROV rnd;
  69 #endif
  70         gint ret;
  71         guchar salt[KD_SALT_LENGTH];
  72
  73         if (prefs_common_get_prefs()->master_passphrase_salt != NULL) {
  74                 g_free(prefs_common_get_prefs()->master_passphrase_salt);
  75         }
  76
  77         /* Prepare our source of random data. */
  78 #if defined G_OS_UNIX
  79         rnd = open("/dev/urandom", O_RDONLY);
  80         if (rnd == -1) {
  81                 perror("fopen on /dev/urandom");
  82 #elif defined G_OS_WIN32
  83         if (!CryptAcquireContext(&rnd, NULL, NULL, PROV_RSA_FULL, 0) &&
  84                         !CryptAcquireContext(&rnd, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
  85                 debug_print("Could not acquire a CSP handle.\n");
  86 #endif
  87                 return;
  88         }
  89
  90 #if defined G_OS_UNIX
  91         ret = read(rnd, salt, KD_SALT_LENGTH);
  92         if (ret != KD_SALT_LENGTH) {
  93                 perror("read into salt");
  94                 close(rnd);
  95 #elif defined G_OS_WIN32
  96         if (!CryptGenRandom(rnd, KD_SALT_LENGTH, salt)) {
  97                 debug_print("Could not read random data for salt\n");
  98                 CryptReleaseContext(rnd, 0);
  99 #endif
 100                 return;
 101         }
 102
 103 #if defined G_OS_UNIX
 104         close(rnd);
 105 #elif defined G_OS_WIN32
 106         CryptReleaseContext(rnd, 0);
 107 #endif
 108
 109         prefs_common_get_prefs()->master_passphrase_salt =
 110                 g_base64_encode(salt, KD_SALT_LENGTH);
 111 }
 112
 113 #undef KD_SALT_LENGTH
 114
 115 static guchar *_make_key_deriv(const gchar *passphrase, guint rounds)
 116 {
 117         guchar *kd, *salt;
 118         gchar *saltpref = prefs_common_get_prefs()->master_passphrase_salt;
 119         gsize saltlen;
 120         gint ret;
 121
 122         /* Grab our salt, generating and saving a new random one if needed. */
 123         if (saltpref == NULL || strlen(saltpref) == 0) {
 124                 _generate_salt();
 125                 saltpref = prefs_common_get_prefs()->master_passphrase_salt;
 126         }
 127         salt = g_base64_decode(saltpref, &saltlen);
 128         kd = g_malloc0(KD_LENGTH);
 129
 130         START_TIMING("PBKDF2");
 131         ret = pkcs5_pbkdf2(passphrase, strlen(passphrase), salt, saltlen,
 132                         kd, KD_LENGTH, rounds);
 133         END_TIMING();
 134
 135         g_free(salt);
 136
 137         if (ret == 0) {
 138                 return kd;
 139         }
 140
 141         g_free(kd);
 142         return NULL;
 143 }
 144
 145 static const gchar *master_passphrase()
 146 {
 147         gchar *input;
 148         gboolean end = FALSE;
 149
 150         if (!prefs_common_get_prefs()->use_master_passphrase) {
 151                 return PASSCRYPT_KEY;
 152         }
 153
 154         if (_master_passphrase != NULL) {
 155                 debug_print("Master passphrase is in memory, offering it.\n");
 156                 return _master_passphrase;
 157         }
 158
 159         while (!end) {
 160                 input = input_dialog_with_invisible(_("Input master passphrase"),
 161                                 _("Input master passphrase"), NULL);
 162
 163                 if (input == NULL) {
 164                         debug_print("Cancel pressed at master passphrase dialog.\n");
 165                         break;
 166                 }
 167
 168                 if (master_passphrase_is_correct(input)) {
 169                         debug_print("Entered master passphrase seems to be correct, remembering it.\n");
 170                         _master_passphrase = input;
 171                         end = TRUE;
 172                 } else {
 173                         alertpanel_error(_("Incorrect master passphrase."));
 174                 }
 175         }
 176
 177         return _master_passphrase;
 178 }
 179
 180 const gboolean master_passphrase_is_set()
 181 {
 182         if (prefs_common_get_prefs()->master_passphrase == NULL
 183                         || strlen(prefs_common_get_prefs()->master_passphrase) == 0)
 184                 return FALSE;
 185
 186         return TRUE;
 187 }
 188
 189 const gboolean master_passphrase_is_correct(const gchar *input)
 190 {
 191         guchar *kd, *input_kd;
 192         gchar **tokens;
 193         gchar *stored_kd = prefs_common_get_prefs()->master_passphrase;
 194         gsize kd_len;
 195         guint rounds = 0;
 196         gint ret;
 197
 198         g_return_val_if_fail(stored_kd != NULL && strlen(stored_kd) > 0, FALSE);
 199         g_return_val_if_fail(input != NULL, FALSE);
 200
 201         if (stored_kd == NULL)
 202                 return FALSE;
 203
 204         tokens = g_strsplit_set(stored_kd, "{}", 3);
 205         if (tokens[0] == NULL ||
 206                         strlen(tokens[0]) != 0 || /* nothing before { */
 207                         tokens[1] == NULL ||
 208                         strncmp(tokens[1], "PBKDF2-HMAC-SHA1,", 17) || /* correct tag */
 209                         strlen(tokens[1]) <= 17 || /* something after , */
 210                         (rounds = atoi(tokens[1] + 17)) <= 0 || /* valid rounds # */
 211                         tokens[2] == NULL ||
 212                         strlen(tokens[2]) == 0) { /* string continues after } */
 213                 debug_print("Mangled master_passphrase format in config, can not use it.\n");
 214                 g_strfreev(tokens);
 215                 return FALSE;
 216         }
 217
 218         stored_kd = tokens[2];
 219         kd = g_base64_decode(stored_kd, &kd_len); /* should be 64 */
 220         g_strfreev(tokens);
 221
 222         if (kd_len != KD_LENGTH) {
 223                 debug_print("master_passphrase is %ld bytes long, should be %d.\n",
 224                                 kd_len, KD_LENGTH);
 225                 g_free(kd);
 226                 return FALSE;
 227         }
 228
 229         input_kd = _make_key_deriv(input, rounds);
 230         ret = memcmp(kd, input_kd, kd_len);
 231
 232         g_free(input_kd);
 233         g_free(kd);
 234
 235         if (ret == 0)
 236                 return TRUE;
 237
 238         return FALSE;
 239 }
 240
 241 gboolean master_passphrase_is_entered()
 242 {
 243         return (_master_passphrase == NULL) ? FALSE : TRUE;
 244 }
 245
 246 void master_passphrase_forget()
 247 {
 248         /* If master passphrase is currently in memory (entered by user),
 249          * get rid of it. User will have to enter the new one again. */
 250         if (_master_passphrase != NULL) {
 251                 memset(_master_passphrase, 0, strlen(_master_passphrase));
 252                 g_free(_master_passphrase);
 253                 _master_passphrase = NULL;
 254         }
 255 }
 256
 257 void master_passphrase_change(const gchar *oldp, const gchar *newp)
 258 {
 259         guchar *kd;
 260         gchar *base64_kd;
 261         guint rounds = prefs_common_get_prefs()->master_passphrase_pbkdf2_rounds;
 262
 263         g_return_if_fail(rounds > 0);
 264
 265         if (oldp == NULL) {
 266                 /* If oldp is NULL, make sure the user has to enter the
 267                  * current master passphrase before being able to change it. */
 268                 master_passphrase_forget();
 269                 oldp = master_passphrase();
 270         }
 271         g_return_if_fail(oldp != NULL);
 272
 273         /* Update master passphrase hash in prefs */
 274         if (prefs_common_get_prefs()->master_passphrase != NULL)
 275                 g_free(prefs_common_get_prefs()->master_passphrase);
 276
 277         if (newp != NULL) {
 278                 debug_print("Storing key derivation of new master passphrase\n");
 279                 kd = _make_key_deriv(newp, rounds);
 280                 base64_kd = g_base64_encode(kd, 64);
 281                 prefs_common_get_prefs()->master_passphrase =
 282                         g_strdup_printf("{PBKDF2-HMAC-SHA1,%d}%s", rounds, base64_kd);
 283                 g_free(kd);
 284                 g_free(base64_kd);
 285         } else {
 286                 debug_print("Setting master_passphrase to NULL\n");
 287                 prefs_common_get_prefs()->master_passphrase = NULL;
 288         }
 289
 290         /* Now go over all accounts, reencrypting their passwords using
 291          * the new master passphrase. */
 292
 293         if (oldp == NULL)
 294                 oldp = PASSCRYPT_KEY;
 295         if (newp == NULL)
 296                 newp = PASSCRYPT_KEY;
 297
 298         debug_print("Reencrypting all account passwords...\n");
 299         passwd_store_reencrypt_all(oldp, newp);
 300
 301         /* Now reencrypt all plugins passwords fields
 302          * FIXME: Unloaded plugins won't be able to update their stored passwords
 303          */
 304         plugins_master_passphrase_change(oldp, newp);
 305
 306         master_passphrase_forget();
 307 }
 308 #endif
 309
 310 gchar *password_encrypt_old(const gchar *password)
 311 {
 312         if (!password || strlen(password) == 0) {
 313                 return NULL;
 314         }
 315
 316         gchar *encrypted = g_strdup(password);
 317         gchar *encoded, *result;
 318         gsize len = strlen(password);
 319
 320         passcrypt_encrypt(encrypted, len);
 321         encoded = g_base64_encode(encrypted, len);
 322         g_free(encrypted);
 323         result = g_strconcat("!", encoded, NULL);
 324         g_free(encoded);
 325
 326         return result;
 327 }
 328
 329 gchar *password_decrypt_old(const gchar *password)
 330 {
 331         if (!password || strlen(password) == 0) {
 332                 return NULL;
 333         }
 334
 335         if (*password != '!' || strlen(password) < 2) {
 336                 return NULL;
 337         }
 338
 339         gsize len;
 340         gchar *decrypted = g_base64_decode(password + 1, &len);
 341
 342         passcrypt_decrypt(decrypted, len);
 343         return decrypted;
 344 }
 345
 346 #ifdef PASSWORD_CRYPTO_GNUTLS
 347 #define BUFSIZE 128
 348
 349 /* Since we can't count on having GnuTLS new enough to have
 350  * gnutls_cipher_get_iv_size(), we hardcode the IV length for now. */
 351 #define IVLEN 16
 352
 353 gchar *password_encrypt_gnutls(const gchar *password,
 354                 const gchar *encryption_passphrase)
 355 {
 356         /* Another, slightly inferior combination is AES-128-CBC + SHA-256.
 357          * Any block cipher in CBC mode with keysize N and a hash algo with
 358          * digest length 2*N would do. */
 359         gnutls_cipher_algorithm_t algo = GNUTLS_CIPHER_AES_256_CBC;
 360         gnutls_digest_algorithm_t digest = GNUTLS_DIG_SHA512;
 361         gnutls_cipher_hd_t handle;
 362         gnutls_datum_t key, iv;
 363         int keylen, digestlen, blocklen, ret, i;
 364         unsigned char hashbuf[BUFSIZE], *buf, *encbuf, *base, *output;
 365 #if defined G_OS_UNIX
 366         int rnd;
 367 #elif defined G_OS_WIN32
 368         HCRYPTPROV rnd;
 369 #endif
 370
 371         g_return_val_if_fail(password != NULL, NULL);
 372         g_return_val_if_fail(encryption_passphrase != NULL, NULL);
 373
 374 /*      ivlen = gnutls_cipher_get_iv_size(algo);*/
 375         keylen = gnutls_cipher_get_key_size(algo);
 376         blocklen = gnutls_cipher_get_block_size(algo);
 377         digestlen = gnutls_hash_get_len(digest);
 378
 379         /* Prepare key for cipher - first half of hash of passkey XORed with
 380          * the second. */
 381         memset(&hashbuf, 0, BUFSIZE);
 382         if ((ret = gnutls_hash_fast(digest, encryption_passphrase,
 383                                         strlen(encryption_passphrase), &hashbuf)) < 0) {
 384                 debug_print("Hashing passkey failed: %s\n", gnutls_strerror(ret));
 385                 return NULL;
 386         }
 387         for (i = 0; i < digestlen/2; i++) {
 388                 hashbuf[i] = hashbuf[i] ^ hashbuf[i+digestlen/2];
 389         }
 390
 391         key.data = malloc(keylen);
 392         memcpy(key.data, &hashbuf, keylen);
 393         key.size = keylen;
 394
 395         /* Prepare our source of random data. */
 396 #if defined G_OS_UNIX
 397         rnd = open("/dev/urandom", O_RDONLY);
 398         if (rnd == -1) {
 399                 perror("fopen on /dev/urandom");
 400 #elif defined G_OS_WIN32
 401         if (!CryptAcquireContext(&rnd, NULL, NULL, PROV_RSA_FULL, 0) &&
 402                         !CryptAcquireContext(&rnd, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
 403                 debug_print("Could not acquire a CSP handle.\n");
 404 #endif
 405                 g_free(key.data);
 406                 return NULL;
 407         }
 408
 409         /* Prepare random IV for cipher */
 410         iv.data = malloc(IVLEN);
 411         iv.size = IVLEN;
 412 #if defined G_OS_UNIX
 413         ret = read(rnd, iv.data, IVLEN);
 414         if (ret != IVLEN) {
 415                 perror("read into iv");
 416                 close(rnd);
 417 #elif defined G_OS_WIN32
 418         if (!CryptGenRandom(rnd, IVLEN, iv.data)) {
 419                 debug_print("Could not read random data for IV\n");
 420                 CryptReleaseContext(rnd, 0);
 421 #endif
 422                 g_free(key.data);
 423                 g_free(iv.data);
 424                 return NULL;
 425         }
 426
 427         /* Initialize the encryption */
 428         ret = gnutls_cipher_init(&handle, algo, &key, &iv);
 429         if (ret < 0) {
 430                 g_free(key.data);
 431                 g_free(iv.data);
 432 #if defined G_OS_UNIX
 433                 close(rnd);
 434 #elif defined G_OS_WIN32
 435                 CryptReleaseContext(rnd, 0);
 436 #endif
 437                 return NULL;
 438         }
 439
 440         /* Fill buf with one block of random data, our password, pad the
 441          * rest with zero bytes. */
 442         buf = malloc(BUFSIZE + blocklen);
 443         memset(buf, 0, BUFSIZE);
 444 #if defined G_OS_UNIX
 445         ret = read(rnd, buf, blocklen);
 446         if (ret != blocklen) {
 447                 perror("read into buffer");
 448                 close(rnd);
 449 #elif defined G_OS_WIN32
 450         if (!CryptGenRandom(rnd, blocklen, buf)) {
 451                 debug_print("Could not read random data for IV\n");
 452                 CryptReleaseContext(rnd, 0);
 453 #endif
 454                 g_free(buf);
 455                 g_free(key.data);
 456                 g_free(iv.data);
 457                 gnutls_cipher_deinit(handle);
 458                 return NULL;
 459         }
 460
 461         /* We don't need any more random data. */
 462 #if defined G_OS_UNIX
 463         close(rnd);
 464 #elif defined G_OS_WIN32
 465         CryptReleaseContext(rnd, 0);
 466 #endif
 467
 468         memcpy(buf + blocklen, password, strlen(password));
 469
 470         /* Encrypt into encbuf */
 471         encbuf = malloc(BUFSIZE + blocklen);
 472         memset(encbuf, 0, BUFSIZE + blocklen);
 473         ret = gnutls_cipher_encrypt2(handle, buf, BUFSIZE + blocklen,
 474                         encbuf, BUFSIZE + blocklen);
 475         if (ret < 0) {
 476                 g_free(key.data);
 477                 g_free(iv.data);
 478                 g_free(buf);
 479                 g_free(encbuf);
 480                 gnutls_cipher_deinit(handle);
 481                 return NULL;
 482         }
 483
 484         /* Cleanup */
 485         gnutls_cipher_deinit(handle);
 486         g_free(key.data);
 487         g_free(iv.data);
 488         g_free(buf);
 489
 490         /* And finally prepare the resulting string:
 491          * "{algorithm}base64encodedciphertext" */
 492         base = g_base64_encode(encbuf, BUFSIZE);
 493         g_free(encbuf);
 494         output = g_strdup_printf("{%s}%s", gnutls_cipher_get_name(algo), base);
 495         g_free(base);
 496
 497         return output;
 498 }
 499
 500 gchar *password_decrypt_gnutls(const gchar *password,
 501                 const gchar *decryption_passphrase)
 502 {
 503         gchar **tokens, *tmp;
 504         gnutls_cipher_algorithm_t algo;
 505         gnutls_digest_algorithm_t digest = GNUTLS_DIG_UNKNOWN;
 506         gnutls_cipher_hd_t handle;
 507         gnutls_datum_t key, iv;
 508         int keylen, digestlen, blocklen, ret, i;
 509         gsize len;
 510         unsigned char hashbuf[BUFSIZE], *buf;
 511 #if defined G_OS_UNIX
 512         int rnd;
 513 #elif defined G_OS_WIN32
 514         HCRYPTPROV rnd;
 515 #endif
 516
 517         g_return_val_if_fail(password != NULL, NULL);
 518         g_return_val_if_fail(decryption_passphrase != NULL, NULL);
 519
 520         tokens = g_strsplit_set(password, "{}", 3);
 521
 522         /* Parse the string, retrieving algorithm and encrypted data.
 523          * We expect "{algorithm}base64encodedciphertext". */
 524         if (strlen(tokens[0]) != 0 ||
 525                         (algo = gnutls_cipher_get_id(tokens[1])) == GNUTLS_CIPHER_UNKNOWN ||
 526                         strlen(tokens[2]) == 0)
 527                 return NULL;
 528
 529         /* Our hash algo needs to have digest length twice as long as our
 530          * cipher algo's key length. */
 531         if (algo == GNUTLS_CIPHER_AES_256_CBC) {
 532                 debug_print("Using AES-256-CBC + SHA-512 for decryption\n");
 533                 digest = GNUTLS_DIG_SHA512;
 534         } else if (algo == GNUTLS_CIPHER_AES_128_CBC) {
 535                 debug_print("Using AES-128-CBC + SHA-256 for decryption\n");
 536                 digest = GNUTLS_DIG_SHA256;
 537         }
 538         if (digest == GNUTLS_DIG_UNKNOWN) {
 539                 debug_print("Password is encrypted with unsupported cipher, giving up.\n");
 540                 g_strfreev(tokens);
 541                 return NULL;
 542         }
 543
 544 /*      ivlen = gnutls_cipher_get_iv_size(algo); */
 545         keylen = gnutls_cipher_get_key_size(algo);
 546         blocklen = gnutls_cipher_get_block_size(algo);
 547         digestlen = gnutls_hash_get_len(digest);
 548
 549         /* Prepare key for cipher - first half of hash of passkey XORed with
 550          * the second. AES-256 has key length 32 and length of SHA-512 hash
 551          * is exactly twice that, 64. */
 552         memset(&hashbuf, 0, BUFSIZE);
 553         if ((ret = gnutls_hash_fast(digest, decryption_passphrase,
 554                                         strlen(decryption_passphrase), &hashbuf)) < 0) {
 555                 debug_print("Hashing passkey failed: %s\n", gnutls_strerror(ret));
 556                 g_strfreev(tokens);
 557                 return NULL;
 558         }
 559         for (i = 0; i < digestlen/2; i++) {
 560                 hashbuf[i] = hashbuf[i] ^ hashbuf[i+digestlen/2];
 561         }
 562
 563         key.data = malloc(keylen);
 564         memcpy(key.data, &hashbuf, keylen);
 565         key.size = keylen;
 566
 567         /* Prepare our source of random data. */
 568 #if defined G_OS_UNIX
 569         rnd = open("/dev/urandom", O_RDONLY);
 570         if (rnd == -1) {
 571                 perror("fopen on /dev/urandom");
 572 #elif defined G_OS_WIN32
 573         if (!CryptAcquireContext(&rnd, NULL, NULL, PROV_RSA_FULL, 0) &&
 574                         !CryptAcquireContext(&rnd, NULL, NULL, PROV_RSA_FULL, CRYPT_NEWKEYSET)) {
 575                 debug_print("Could not acquire a CSP handle.\n");
 576 #endif
 577                 g_free(key.data);
 578                 g_strfreev(tokens);
 579                 return NULL;
 580         }
 581
 582         /* Prepare random IV for cipher */
 583         iv.data = malloc(IVLEN);
 584         iv.size = IVLEN;
 585 #if defined G_OS_UNIX
 586         ret = read(rnd, iv.data, IVLEN);
 587         if (ret != IVLEN) {
 588                 perror("read into iv");
 589                 close(rnd);
 590 #elif defined G_OS_WIN32
 591         if (!CryptGenRandom(rnd, IVLEN, iv.data)) {
 592                 debug_print("Could not read random data for IV\n");
 593                 CryptReleaseContext(rnd, 0);
 594 #endif
 595                 g_free(key.data);
 596                 g_free(iv.data);
 597                 g_strfreev(tokens);
 598                 return NULL;
 599         }
 600
 601         /* We don't need any more random data. */
 602 #if defined G_OS_UNIX
 603         close(rnd);
 604 #elif defined G_OS_WIN32
 605         CryptReleaseContext(rnd, 0);
 606 #endif
 607
 608         /* Prepare encrypted password string for decryption. */
 609         tmp = g_base64_decode(tokens[2], &len);
 610         g_strfreev(tokens);
 611
 612         /* Initialize the decryption */
 613         ret = gnutls_cipher_init(&handle, algo, &key, &iv);
 614         if (ret < 0) {
 615                 debug_print("Cipher init failed: %s\n", gnutls_strerror(ret));
 616                 g_free(key.data);
 617                 g_free(iv.data);
 618                 return NULL;
 619         }
 620
 621         buf = malloc(BUFSIZE + blocklen);
 622         memset(buf, 0, BUFSIZE + blocklen);
 623         ret = gnutls_cipher_decrypt2(handle, tmp, len,
 624                         buf, BUFSIZE + blocklen);
 625         if (ret < 0) {
 626                 debug_print("Decryption failed: %s\n", gnutls_strerror(ret));
 627                 g_free(key.data);
 628                 g_free(iv.data);
 629                 g_free(buf);
 630                 gnutls_cipher_deinit(handle);
 631                 return NULL;
 632         }
 633
 634         /* Cleanup */
 635         gnutls_cipher_deinit(handle);
 636         g_free(key.data);
 637         g_free(iv.data);
 638
 639         tmp = g_strndup(buf + blocklen, MIN(strlen(buf + blocklen), BUFSIZE));
 640         g_free(buf);
 641         return tmp;
 642 }
 643
 644 #undef BUFSIZE
 645
 646 #endif
 647
 648 gchar *password_encrypt(const gchar *password,
 649                 const gchar *encryption_passphrase)
 650 {
 651         if (password == NULL || strlen(password) == 0) {
 652                 return NULL;
 653         }
 654
 655 #ifndef PASSWORD_CRYPTO_OLD
 656         if (encryption_passphrase == NULL)
 657                 encryption_passphrase = master_passphrase();
 658
 659         return password_encrypt_real(password, encryption_passphrase);
 660 #else
 661         return password_encrypt_old(password);
 662 #endif
 663 }
 664
 665 gchar *password_decrypt(const gchar *password,
 666                 const gchar *decryption_passphrase)
 667 {
 668         if (password == NULL || strlen(password) == 0) {
 669                 return NULL;
 670         }
 671
 672         /* First, check if the password was possibly decrypted using old,
 673          * obsolete method */
 674         if (*password == '!') {
 675                 debug_print("Trying to decrypt password using the old method...\n");
 676                 return password_decrypt_old(password);
 677         }
 678
 679         /* Try available crypto backend */
 680 #ifndef PASSWORD_CRYPTO_OLD
 681         if (decryption_passphrase == NULL)
 682                 decryption_passphrase = master_passphrase();
 683
 684         if (*password == '{') {
 685                 debug_print("Trying to decrypt password...\n");
 686                 return password_decrypt_real(password, decryption_passphrase);
 687         }
 688 #endif
 689
 690         /* Fallback, in case the configuration is really old and
 691          * stored password in plaintext */
 692         debug_print("Assuming password was stored plaintext, returning it unchanged\n");
 693         return g_strdup(password);
 694 }