mirror of
https://github.com/hanzoai/lastpass-mcp.git
synced 2026-11-14 21:30:44 +00:00
248 lines
7.4 KiB
C
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;
|
|
}
|