Files

248 lines
7.4 KiB
C

/*
* command for changing master password
*
* Copyright (C) 2014-2018 LastPass.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program; if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA.
*
* In addition, as a special exception, the copyright holders give
* permission to link the code of portions of this program with the
* OpenSSL library under certain conditions as described in each
* individual source file, and distribute linked combinations
* including the two.
*
* You must obey the GNU General Public License in all respects
* for all of the code used other than OpenSSL. If you modify
* file(s) with this exception, you may extend this exception to your
* version of the file(s), but you are not obligated to do so. If you
* do not wish to do so, delete this exception statement from your
* version. If you delete this exception statement from all source
* files in the program, then also delete it here.
*
* See LICENSE.OpenSSL for more details regarding this exception.
*/
#include <errno.h>
#include <string.h>
#include "blob.h"
#include "kdf.h"
#include "cmd.h"
#include "endpoints.h"
#include "config.h"
#include "password.h"
#include "cipher.h"
#include "session.h"
static void show_status_bar(const char *operation,
unsigned int cur, unsigned int max)
{
char progress[41] = {0};
size_t len;
if (!max)
max = 1;
if (cur > max)
cur = max;
len = (cur * (sizeof(progress) - 1)) / max;
if (len)
memset(progress, '=', len);
terminal_fprintf(stderr, TERMINAL_FG_CYAN "%s " TERMINAL_RESET
TERMINAL_FG_BLUE "[%-*s] " TERMINAL_RESET
TERMINAL_FG_CYAN "%d/%d \r" TERMINAL_RESET,
operation, (int) sizeof(progress)-1, progress, cur, max);
}
static void reencrypt(struct session *session,
struct pwchange_info *info,
unsigned char key[KDF_HASH_LEN],
unsigned char new_key[KDF_HASH_LEN])
{
struct pwchange_field *field;
struct pwchange_su_key *su_key;
struct private_key tmp;
unsigned int n_fields = 0;
unsigned int i = 0;
unsigned int n_required = 0;
unsigned int errors = 0;
/* count how many things we'll encrypt */
list_for_each_entry(field, &info->fields, list) {
n_fields++;
}
list_for_each_entry(su_key, &info->su_keys, list) {
n_fields++;
}
/* plus sharing key */
n_fields++;
show_status_bar("Re-encrypting", i++, n_fields);
/* decrypt and re-encrypt RSA sharing key */
if (!cipher_decrypt_private_key(info->privkey_encrypted, key, &tmp))
die("Could not decrypt server private key!");
if (tmp.len != session->private_key.len ||
memcmp(session->private_key.key, tmp.key, session->private_key.len)) {
die("Server and session private key don't match! Try lpass sync first.");
}
info->new_privkey_encrypted =
cipher_encrypt_private_key(&tmp, new_key);
secure_clear(tmp.key, tmp.len);
free(tmp.key);
/* reencrypt site info */
list_for_each_entry(field, &info->fields, list) {
show_status_bar("Re-encrypting", i++, n_fields);
if (!field->optional)
n_required++;
char *ptext = cipher_aes_decrypt_base64(field->old_ctext, key);
if (!ptext) {
if (!field->optional)
errors++;
ptext = " ";
}
field->new_ctext = encrypt_and_base64(ptext, new_key);
}
/*
* Fail if > 10% decryption errors. This indicates the blob and key
* are out of sync somehow, or that user has reverted a password
* change but some entries are encrypted with the new key.
*/
if (errors > n_required / 10)
die("Too many decryption failures.");
/* encrypt recovery copy of our key */
list_for_each_entry(su_key, &info->su_keys, list) {
show_status_bar("Re-encrypting", i++, n_fields);
size_t enc_key_len = su_key->sharing_key.len;
unsigned char *enc_key = xmalloc(enc_key_len);
cipher_rsa_encrypt_bytes(new_key, KDF_HASH_LEN,
&su_key->sharing_key,
enc_key, &enc_key_len);
bytes_to_hex(enc_key, &su_key->new_enc_key, enc_key_len);
free(enc_key);
}
show_status_bar("Re-encrypting", n_fields, n_fields);
info->new_privkey_hash = cipher_sha256_hex((unsigned char *)
info->new_privkey_encrypted,
strlen(info->new_privkey_encrypted));
info->new_key_hash = cipher_sha256_hex(new_key, KDF_HASH_LEN);
printf("\n");
}
int cmd_passwd(int argc, char **argv)
{
UNUSED(argc);
UNUSED(argv);
unsigned char key[KDF_HASH_LEN];
unsigned char new_key[KDF_HASH_LEN];
char hex[KDF_HEX_LEN];
char new_hex[KDF_HEX_LEN];
struct session *session = NULL;
struct blob *blob;
int ret;
_cleanup_free_ char *password = NULL;
_cleanup_free_ char *new_password = NULL;
_cleanup_free_ char *pw2 = NULL;
_cleanup_free_ char *username = NULL;
int iterations;
bool match;
struct pwchange_info info;
/* load existing session, if present */
init_all(BLOB_SYNC_YES, key, &session, &blob);
username = config_read_string("username");
iterations = lastpass_iterations(username);
if (!iterations)
die("Unable to fetch iteration count. Check your internet connection and be sure your username is valid.");
/* reprompt for old mpw */
password = password_prompt("Current Master Password", NULL,
"Please enter the current LastPass master password for <%s>.",
username);
if (!password)
die("Failed to enter password.");
kdf_login_key(username, password, iterations, hex);
secure_clear_str(password);
/* prompt for new pw */
new_password = password_prompt("New Master Password", NULL,
"Please enter the new LastPass master password for <%s>.",
username);
pw2 = password_prompt("Confirm New Master Password", NULL,
"Please retype the new LastPass master password for <%s>.",
username);
if (!new_password || !pw2)
die("Failed to enter new password.");
match = strcmp(new_password, pw2) == 0;
secure_clear_str(pw2);
if (!match)
die("Bad password: passwords don't match.");
if (strlen(new_password) < 8)
die("Bad password: too short.");
kdf_decryption_key(username, new_password, iterations, new_key);
kdf_login_key(username, new_password, iterations, new_hex);
secure_clear_str(new_password);
/*
* Fetch the data to reencrypt. We may learn at this point that the
* current password was incorrect, so handle that accordingly.
*/
terminal_printf(TERMINAL_FG_CYAN "Fetching data...\n" TERMINAL_RESET);
ret = lastpass_pwchange_start(session, username, hex, &info);
if (ret) {
if (ret == -EPERM)
die("Incorrect password. Password not changed.");
else
die("Error changing password (error=%d)", ret);
}
/* reencrypt */
reencrypt(session, &info, key, new_key);
terminal_printf(TERMINAL_FG_CYAN "Uploading...\n" TERMINAL_RESET);
_cleanup_free_ char *enc_username = encrypt_and_base64(username, new_key);
ret = lastpass_pwchange_complete(session, username, enc_username,
hex, new_hex, iterations, &info);
if (ret)
die("Password change failed.");
session_kill();
terminal_printf(TERMINAL_FG_GREEN TERMINAL_BOLD "Success" TERMINAL_RESET ": Password changed and logged out.\n");
return 0;
}