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