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