5 files changed, 161 insertions, 11 deletions

diff --git a/libsylph/account.c b/libsylph/account.c
index 95d19fc..e4cb5cc 100644
--- a/libsylph/account.c
+++ b/libsylph/account.c
@@ -37,6 +37,8 @@
 #include "utils.h"
 #include "sylmain.h"
 #include "prefs_common.h"
+#include "ssl.h"
+
 
 PrefsAccount *cur_account;
 
@@ -53,9 +55,52 @@ void account_read_config_all(void)
         gchar buf[PREFSBUFSIZE];
         PrefsAccount *ac_prefs;
 #if USE_SSL
-        gchar *master_password;
+        guint cnt;
+        gchar *master_password, *master_password_confirm;
         if (prefs_common.use_master_password) {
-                master_password = input_query_password("Sylpheed", "Master password");
+                if (prefs_common.master_password_hash != NULL) {
+                        for (cnt = 0; cnt < 3; ++cnt) {
+                                /* allow 3 attempts to enter the master password */
+                                master_password = input_query_password(_("Sylpheed"),
+                                                                                                           _("Master password"));
+                                if (check_password(
+                                                master_password,
+                                                prefs_common.master_password_hash) == RC_OK) {
+                                        break;
+                                }
+                                debug_print(_("Wrong master password entered (%d)\n"), cnt);
+                                g_free(master_password);
+                                master_password = NULL;
+                        }
+                } else {
+                        /* No master password set (no master_password_hash) */
+                        for (cnt = 0; cnt < 3; ++cnt) {
+                                master_password = input_query_password(_("Sylpheed"),
+                                                                                                           _("Master password"));
+                                master_password_confirm = input_query_password(
+                                        _("Sylpheed"),
+                                        _("Master password confirmation"));
+                                if (strcmp(master_password, master_password_confirm) == 0) {
+                                        /* The passwords match */
+                                        g_free(master_password_confirm);
+                                        if (generate_password_hash(
+                                                        &prefs_common.master_password_hash,
+                                                        master_password,
+                                                        NULL) != RC_OK) {
+                                                debug_print(
+                                                        _("Could not generate master password hash"));
+                                                g_free(master_password);
+                                                continue;
+                                        }
+                                        prefs_common_write_config();
+                                        break;
+                                }
+                                g_free(master_password);
+                                g_free(master_password_confirm);
+                                master_password = NULL;
+                        }
+                }
+                /* TODO: Warning if password is NULL */
         } else {
                 master_password = NULL;
         }
diff --git a/libsylph/prefs_common.c b/libsylph/prefs_common.c
index 1f1d3e2..6c20319 100644
--- a/libsylph/prefs_common.c
+++ b/libsylph/prefs_common.c
@@ -421,6 +421,8 @@ static PrefParam param[] = {
         /* Master password */
         {"use_master_password", "FALSE", &prefs_common.use_master_password,
         P_BOOL},
+        {"master_password_hash", NULL, &prefs_common.master_password_hash,
+         P_STRING},
 
         /* Interface */
         {"separate_folder", "FALSE", &prefs_common.sep_folder, P_BOOL},
diff --git a/libsylph/prefs_common.h b/libsylph/prefs_common.h
index ef5bb9b..bc1d2f3 100644
--- a/libsylph/prefs_common.h
+++ b/libsylph/prefs_common.h
@@ -251,6 +251,7 @@ struct _PrefsCommon
 
         /* Master password */
         gboolean use_master_password;
+        gchar *master_password_hash;
 
         /* Interface */
         gboolean sep_folder;
diff --git a/libsylph/ssl.c b/libsylph/ssl.c
index 82b77b4..5042f74 100644
--- a/libsylph/ssl.c
+++ b/libsylph/ssl.c
@@ -36,6 +36,8 @@
 #define CIPHER EVP_aes_256_cfb()
 #define KEY_HASH EVP_sha256()
 #define DIGEST_HASH EVP_sha256()
+#define PBKDF2_DIGEST_SIZE 64
+#define PBKDF2_ITERATIONS 100000
 
 static SSL_CTX *ssl_ctx_SSLv23 = NULL;
 static SSL_CTX *ssl_ctx_TLSv1 = NULL;
@@ -779,4 +781,98 @@ cleanup:
 
 }
 
+gint generate_password_hash(gchar **password_hash,
+                            const gchar *password,
+                            const guchar *salt) {
+    /*
+     * Hashes 'password' using PKCS5_PBKDF2_HMAC with SHA512 and 'salt',
+     * and assigns a string to 'password_hash' with the following format:
+     * pbkdf2_sha512$iterations$base64(salt)$base64(password_hash)
+     */
+    guchar lsalt[SALT_SIZE];
+    gchar *PBKDF2_digest, *salt_b64, *digest_b64;
+
+    if (salt == NULL) {
+        if (RAND_bytes(lsalt, SALT_SIZE) != 1) {
+            debug_print("Random problems...\n");
+            return RC_ERROR;
+        }
+    } else {
+        memcpy(lsalt, salt, SALT_SIZE);
+    }
+
+    PBKDF2_digest = OPENSSL_malloc(PBKDF2_DIGEST_SIZE);
+    OPENSSL_cleanse(PBKDF2_digest, PBKDF2_DIGEST_SIZE);
+
+    PKCS5_PBKDF2_HMAC(password,
+                      strlen(password),
+                      lsalt,
+                      SALT_SIZE,
+                      PBKDF2_ITERATIONS,
+                      EVP_sha512(),
+                      PBKDF2_DIGEST_SIZE,
+                      (guchar *) PBKDF2_digest);
+    digest_b64 = g_base64_encode((guchar *) PBKDF2_digest, PBKDF2_DIGEST_SIZE);
+    OPENSSL_cleanse(PBKDF2_digest, PBKDF2_DIGEST_SIZE);
+    OPENSSL_free(PBKDF2_digest);
+
+    salt_b64 = g_base64_encode(lsalt, SALT_SIZE);
+
+    *password_hash = g_strdup_printf("pbkdf2_sha512$%d$%s$%s",
+                                     PBKDF2_ITERATIONS,
+                                     salt_b64,
+                                     digest_b64);
+
+    OPENSSL_cleanse(digest_b64, strlen(digest_b64));
+    OPENSSL_free(digest_b64);
+
+    OPENSSL_cleanse(salt_b64, strlen(salt_b64));
+    OPENSSL_free(salt_b64);
+
+    return RC_OK;
+
+}
+
+gint check_password(const gchar *password, const gchar *password_hash) {
+
+    gint token_counter, rc;
+    guchar *salt;
+    gchar **tokens, *new_hash;
+    gsize salt_length;
+
+    rc = RC_ERROR;
+    tokens = g_strsplit(password_hash,
+                        "$",
+                        -1);
+    token_counter = 0;
+    while (*(tokens + token_counter) != NULL) {
+        ++token_counter;
+    }
+
+    if (token_counter != 4) {
+        debug_print("Invalid password hash...\n");
+        goto cleanup;
+    }
+
+    salt = g_base64_decode(*(tokens + 2), &salt_length);
+    if (salt_length != SALT_SIZE) {
+        debug_print("Salt size does not match\n");
+        goto cleanup;
+    }
+
+    if (generate_password_hash(&new_hash, password, salt) != RC_OK) {
+        debug_print("Password hash generation failed\n");
+        goto cleanup;
+    }
+
+    rc = g_strcmp0(password_hash, new_hash);
+
+cleanup:
+    g_free(salt);
+    g_free(new_hash);
+    g_strfreev(tokens);
+    return rc;
+
+}
+
 #endif /* USE_SSL */
diff --git a/libsylph/ssl.h b/libsylph/ssl.h
index 94ab4b7..6338911 100644
--- a/libsylph/ssl.h
+++ b/libsylph/ssl.h
@@ -68,17 +68,23 @@ void ssl_set_verify_func		(SSLVerifyFunc	 func);
 
 /* master password related code */
 gint encrypt_data(gchar **encrypted,
-                  gint *length_encrypted,
-                  const gchar *data,
-                  const gchar *passphrase,
-                  gint length_data,
-                  guint min_data_length,
-                  gboolean rnd_salt);
+                                  gint *length_encrypted,
+                                  const gchar *data,
+                                  const gchar *passphrase,
+                                  gint length_data,
+                                  guint min_data_length,
+                                  gboolean rnd_salt);
 
 gint decrypt_data(gchar **decrypted,
-                  const gchar *data,
-                  const gchar *passphrase,
-                  gint length_data);
+                                  const gchar *data,
+                                  const gchar *passphrase,
+                                  gint length_data);
+
+gint generate_password_hash(gchar **password_hash,
+                                                        const gchar *password,
+                                                        const guchar *salt);
+
+gint check_password(const gchar *password, const gchar *password_hash);
 /* ---------------------------- */
 #endif /* USE_SSL */