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