mirror of
https://github.com/hanzoai/lastpass-mcp.git
synced 2026-11-14 21:30:44 +00:00
527 lines
14 KiB
C
527 lines
14 KiB
C
/*
|
|
* command to show the contents of a vault entry
|
|
*
|
|
* 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 02110-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 "cmd.h"
|
|
#include "cipher.h"
|
|
#include "util.h"
|
|
#include "config.h"
|
|
#include "terminal.h"
|
|
#include "agent.h"
|
|
#include "kdf.h"
|
|
#include "endpoints.h"
|
|
#include "clipboard.h"
|
|
#include "format.h"
|
|
#include "json-format.h"
|
|
#include <getopt.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <stdbool.h>
|
|
#include <ctype.h>
|
|
|
|
/*
|
|
* If a secure note field contains ascii armor, its newlines will
|
|
* have been replaced by spaces when saving. Undo this for
|
|
* display purposes. The replacement (if applicable) is done
|
|
* in-place.
|
|
*/
|
|
static char *fix_ascii_armor(char *armor_str)
|
|
{
|
|
char *end_header, *start_trailer, *ptr;
|
|
|
|
/* need at least 4 "-----" strings */
|
|
if (strlen(armor_str) < 20)
|
|
return armor_str;
|
|
|
|
/* look for -----BEGIN [xxx]----- and -----END [xxx]----- strings */
|
|
if (strncmp(armor_str, "-----BEGIN", 10))
|
|
return armor_str;
|
|
|
|
end_header = strstr(armor_str + 10, "----- ");
|
|
if (!end_header)
|
|
return armor_str;
|
|
|
|
start_trailer = strstr(end_header, "-----END");
|
|
if (!start_trailer)
|
|
return armor_str;
|
|
|
|
if (strncmp(armor_str + strlen(armor_str) - 5, "-----", 5))
|
|
return armor_str;
|
|
|
|
/* ok, probably ascii armor, go ahead and munge it as such */
|
|
ptr = end_header;
|
|
while ((ptr = strchr(ptr, ' ')) != NULL) {
|
|
if (ptr >= start_trailer)
|
|
break;
|
|
/* don't modify spaces after headers, e.g. encrypted keys */
|
|
if (ptr[-1] == ':') {
|
|
ptr++;
|
|
continue;
|
|
}
|
|
*ptr = '\n';
|
|
}
|
|
return armor_str;
|
|
}
|
|
|
|
static char *attachment_filename(struct account *account,
|
|
struct attach *attach)
|
|
{
|
|
_cleanup_free_ unsigned char *key_bin = NULL;
|
|
|
|
if (!attach->filename ||
|
|
!account->attachkey ||
|
|
strlen(account->attachkey) != KDF_HASH_LEN * 2 ||
|
|
hex_to_bytes(account->attachkey, &key_bin)) {
|
|
return xstrdup("unknown");
|
|
}
|
|
|
|
return cipher_aes_decrypt_base64(attach->filename, key_bin);
|
|
}
|
|
|
|
static bool attachment_is_binary(unsigned char *data, size_t len)
|
|
{
|
|
size_t i;
|
|
for (i = 0; i < min(len, 100); i++) {
|
|
if (!isprint(data[i]))
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
static void show_attachment(const struct session *session,
|
|
struct account *account,
|
|
struct attach *attach,
|
|
bool quiet)
|
|
{
|
|
_cleanup_free_ unsigned char *key_bin = NULL;
|
|
_cleanup_free_ char *result = NULL;
|
|
_cleanup_free_ char *filename = NULL;
|
|
int ret;
|
|
char opt;
|
|
char *ptext;
|
|
size_t len;
|
|
char *shareid = NULL;
|
|
unsigned char *bytes = NULL;
|
|
FILE *fp = stdout;
|
|
|
|
if (!account->attachkey || strlen(account->attachkey) != KDF_HASH_LEN * 2)
|
|
die("Missing attach key for account %s\n", account->name);
|
|
|
|
if (hex_to_bytes(account->attachkey, &key_bin))
|
|
die("Invalid attach key for account %s\n", account->name);
|
|
|
|
if (account->share != NULL)
|
|
shareid = account->share->id;
|
|
|
|
filename = attachment_filename(account, attach);
|
|
|
|
ret = lastpass_load_attachment(session, shareid, attach, &result);
|
|
if (ret)
|
|
die("Could not load attachment %s\n", attach->id);
|
|
|
|
ptext = cipher_aes_decrypt_base64(result, key_bin);
|
|
if (!ptext)
|
|
die("Unable to decrypt attachment %s\n", attach->id);
|
|
|
|
len = unbase64(ptext, &bytes);
|
|
|
|
if (attachment_is_binary(bytes, len) && !quiet) {
|
|
opt = ask_options("yns", 's',
|
|
"\"%s\" is a binary file, print it anyway (or save)? ",
|
|
filename);
|
|
switch (opt) {
|
|
case 'n':
|
|
return;
|
|
case 's':
|
|
fp = fopen(filename, "wb");
|
|
if (!fp)
|
|
die("Unable to open %s\n", filename);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
len = fwrite(bytes, 1, len, fp);
|
|
if (fp != stdout) {
|
|
fprintf(stderr, TERMINAL_FG_GREEN "Wrote %zu bytes to \"%s\"\n" TERMINAL_RESET, len, filename);
|
|
fclose(fp);
|
|
}
|
|
}
|
|
|
|
static char *pretty_field_value(struct field *field)
|
|
{
|
|
char *value;
|
|
if (!strcmp(field->type, "checkbox"))
|
|
value = xstrdup(field->checked ? "Checked" : "Unchecked");
|
|
else if (!strcmp(field->type, "radio"))
|
|
xasprintf(&value, "%s, %s", field->value, field->checked ? "Checked" : "Unchecked");
|
|
else
|
|
value = fix_ascii_armor(xstrdup(field->value));
|
|
return value;
|
|
}
|
|
|
|
static void print_header(char *title_format, struct account *found)
|
|
{
|
|
struct buffer buf;
|
|
|
|
buffer_init(&buf);
|
|
format_account(&buf, title_format, found);
|
|
terminal_printf("%s\n", buf.bytes);
|
|
free(buf.bytes);
|
|
}
|
|
|
|
static void print_field(char *field_format, struct account *account,
|
|
char *name, char *value)
|
|
{
|
|
struct buffer buf;
|
|
|
|
buffer_init(&buf);
|
|
format_field(&buf, field_format, account, name, value);
|
|
terminal_printf("%s\n", buf.bytes);
|
|
free(buf.bytes);
|
|
}
|
|
|
|
static void print_attachment(char *field_format,
|
|
struct account *account,
|
|
struct attach *attach)
|
|
{
|
|
_cleanup_free_ char *attach_id = NULL;
|
|
_cleanup_free_ char *filename = NULL;
|
|
|
|
xasprintf(&attach_id, "att-%s", attach->id);
|
|
filename = attachment_filename(account, attach);
|
|
|
|
print_field(field_format, account, attach_id, filename);
|
|
}
|
|
|
|
static struct attach *find_attachment(struct account *account,
|
|
const char *attach_id)
|
|
{
|
|
struct attach *attach = NULL;
|
|
|
|
/* trim 'att-' off id if someone passed it */
|
|
if (!strncmp(attach_id, "att-", 4))
|
|
attach_id += 4;
|
|
|
|
list_for_each_entry(attach, &account->attach_head, list) {
|
|
if (!strcmp(attach->id, attach_id))
|
|
return attach;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
|
|
int cmd_show(int argc, char **argv)
|
|
{
|
|
unsigned char key[KDF_HASH_LEN];
|
|
struct session *session = NULL;
|
|
struct blob *blob = NULL;
|
|
_cleanup_free_ char *value = NULL;
|
|
static struct option long_options[] = {
|
|
{"sync", required_argument, NULL, 'S'},
|
|
{"all", no_argument, NULL, 'A'},
|
|
{"username", no_argument, NULL, 'u'},
|
|
{"password", no_argument, NULL, 'p'},
|
|
{"url", no_argument, NULL, 'L'},
|
|
{"field", required_argument, NULL, 'f'},
|
|
{"id", no_argument, NULL, 'I'},
|
|
{"name", no_argument, NULL, 'N'},
|
|
{"notes", no_argument, NULL, 'O'},
|
|
{"attach", required_argument, NULL, 'a'},
|
|
{"clip", no_argument, NULL, 'c'},
|
|
{"color", required_argument, NULL, 'C'},
|
|
{"basic-regexp", no_argument, NULL, 'G'},
|
|
{"fixed-strings", no_argument, NULL, 'F'},
|
|
{"expand-multi", no_argument, NULL, 'x'},
|
|
{"title-format", required_argument, NULL, 't'},
|
|
{"format", required_argument, NULL, 'o'},
|
|
{"json", no_argument, NULL, 'j'},
|
|
{"quiet", no_argument, NULL, 'q'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
|
|
int option;
|
|
int option_index;
|
|
enum { ALL, USERNAME, PASSWORD, URL, FIELD, ID, NAME, NOTES, ATTACH } choice = ALL;
|
|
_cleanup_free_ char *field = NULL;
|
|
struct account *notes_expansion = NULL;
|
|
struct field *found_field;
|
|
char *name, *pretty_field;
|
|
struct account *found, *last_found, *account;
|
|
struct app *app;
|
|
enum blobsync sync = BLOB_SYNC_AUTO;
|
|
bool clip = false;
|
|
bool json = false;
|
|
bool expand_multi = false;
|
|
bool quiet = false;
|
|
struct list_head matches, potential_set;
|
|
enum search_type search = SEARCH_EXACT_MATCH;
|
|
int fields = ACCOUNT_NAME | ACCOUNT_ID | ACCOUNT_FULLNAME;
|
|
struct attach *attach;
|
|
|
|
_cleanup_free_ char *title_format = NULL;
|
|
_cleanup_free_ char *field_format = NULL;
|
|
_cleanup_free_ char *attach_id = NULL;
|
|
|
|
while ((option = getopt_long(argc, argv, "cupFGxtoqj", long_options, &option_index)) != -1) {
|
|
switch (option) {
|
|
case 'S':
|
|
sync = parse_sync_string(optarg);
|
|
break;
|
|
case 'A':
|
|
choice = ALL;
|
|
break;
|
|
case 'u':
|
|
choice = USERNAME;
|
|
break;
|
|
case 'p':
|
|
choice = PASSWORD;
|
|
break;
|
|
case 'L':
|
|
choice = URL;
|
|
break;
|
|
case 'f':
|
|
choice = FIELD;
|
|
field = xstrdup(optarg);
|
|
break;
|
|
case 'G':
|
|
search = SEARCH_BASIC_REGEX;
|
|
break;
|
|
case 'F':
|
|
search = SEARCH_FIXED_SUBSTRING;
|
|
break;
|
|
case 'I':
|
|
choice = ID;
|
|
break;
|
|
case 'N':
|
|
choice = NAME;
|
|
break;
|
|
case 'j':
|
|
json = true;
|
|
break;
|
|
case 'a':
|
|
choice = ATTACH;
|
|
attach_id = xstrdup(optarg);
|
|
break;
|
|
case 'O':
|
|
choice = NOTES;
|
|
break;
|
|
case 'c':
|
|
clip = true;
|
|
break;
|
|
case 'C':
|
|
terminal_set_color_mode(
|
|
parse_color_mode_string(optarg));
|
|
break;
|
|
case 'x':
|
|
expand_multi = true;
|
|
break;
|
|
case 'o':
|
|
field_format = xstrdup(optarg);
|
|
break;
|
|
case 't':
|
|
title_format = xstrdup(optarg);
|
|
break;
|
|
case 'q':
|
|
quiet = true;
|
|
break;
|
|
case '?':
|
|
default:
|
|
die_usage(cmd_show_usage);
|
|
}
|
|
}
|
|
|
|
if (argc - optind < 1)
|
|
die_usage(cmd_show_usage);
|
|
|
|
if (argc - optind > 1) {
|
|
/*
|
|
* if multiple search criteria supplied, go ahead
|
|
* and expand all matches
|
|
*/
|
|
expand_multi = true;
|
|
}
|
|
|
|
init_all(sync, key, &session, &blob);
|
|
|
|
INIT_LIST_HEAD(&matches);
|
|
INIT_LIST_HEAD(&potential_set);
|
|
|
|
if (!title_format) {
|
|
title_format = xstrdup(
|
|
TERMINAL_FG_CYAN "%/as" TERMINAL_RESET
|
|
TERMINAL_FG_BLUE "%/ag"
|
|
TERMINAL_BOLD "%an" TERMINAL_RESET
|
|
TERMINAL_FG_GREEN " [id: %ai]" TERMINAL_RESET);
|
|
}
|
|
if (!field_format) {
|
|
field_format = xstrdup(
|
|
TERMINAL_FG_YELLOW "%fn" TERMINAL_RESET ": %fv");
|
|
}
|
|
|
|
list_for_each_entry(account, &blob->account_head, list)
|
|
list_add(&account->match_list, &potential_set);
|
|
|
|
for (; optind < argc; optind++) {
|
|
|
|
name = argv[optind];
|
|
|
|
switch (search) {
|
|
case SEARCH_EXACT_MATCH:
|
|
find_matching_accounts(&potential_set, name, &matches);
|
|
break;
|
|
case SEARCH_BASIC_REGEX:
|
|
find_matching_regex(&potential_set, name, fields, &matches);
|
|
break;
|
|
case SEARCH_FIXED_SUBSTRING:
|
|
find_matching_substr(&potential_set, name, fields, &matches);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (list_empty(&matches))
|
|
die("Could not find specified account(s).");
|
|
|
|
found = list_first_entry(&matches, struct account, match_list);
|
|
last_found = list_last_entry(&matches, struct account, match_list);
|
|
if (found != last_found && !expand_multi) {
|
|
/* Multiple matches; dump the ids and exit */
|
|
terminal_printf(TERMINAL_FG_YELLOW TERMINAL_BOLD "Multiple matches found.\n");
|
|
list_for_each_entry(found, &matches, match_list)
|
|
print_header(title_format, found);
|
|
exit(EXIT_SUCCESS);
|
|
}
|
|
|
|
/* reprompt if necessary for any matched item */
|
|
list_for_each_entry(found, &matches, match_list) {
|
|
if (found->pwprotect) {
|
|
unsigned char pwprotect_key[KDF_HASH_LEN];
|
|
if (!agent_load_key(pwprotect_key))
|
|
die("Could not authenticate for protected entry.");
|
|
if (memcmp(pwprotect_key, key, KDF_HASH_LEN))
|
|
die("Current key is not on-disk key.");
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (clip)
|
|
clipboard_open();
|
|
|
|
if (json) {
|
|
json_format_account_list(&matches);
|
|
goto done;
|
|
}
|
|
|
|
list_for_each_entry(account, &matches, match_list) {
|
|
|
|
found = account;
|
|
lastpass_log_access(sync, session, key, found);
|
|
|
|
notes_expansion = notes_expand(found);
|
|
if (notes_expansion)
|
|
found = notes_expansion;
|
|
|
|
if (choice == FIELD) {
|
|
bool has_field = false;
|
|
list_for_each_entry(found_field, &found->field_head, list) {
|
|
if (!strcmp(found_field->name, field)) {
|
|
has_field = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!has_field)
|
|
die("Could not find specified field '%s'.", field);
|
|
value = pretty_field_value(found_field);
|
|
} else if (choice == USERNAME)
|
|
value = xstrdup(found->username);
|
|
else if (choice == PASSWORD)
|
|
value = xstrdup(found->password);
|
|
else if (choice == URL)
|
|
value = xstrdup(found->url);
|
|
else if (choice == ID)
|
|
value = xstrdup(found->id);
|
|
else if (choice == NAME)
|
|
value = xstrdup(found->name);
|
|
else if (choice == NOTES)
|
|
value = xstrdup(found->note);
|
|
else if (choice == ATTACH) {
|
|
struct attach *attach = find_attachment(found, attach_id);
|
|
if (!attach)
|
|
die("Could not find specified attachment '%s'.", attach_id);
|
|
show_attachment(session, found, attach, quiet);
|
|
}
|
|
|
|
if (choice == ALL) {
|
|
print_header(title_format, found);
|
|
|
|
if (strlen(found->username))
|
|
print_field(field_format, found, "Username", found->username);
|
|
if (strlen(found->password))
|
|
print_field(field_format, found, "Password", found->password);
|
|
if (strlen(found->url) && strcmp(found->url, "http://"))
|
|
print_field(field_format, found, "URL", found->url);
|
|
if (found->is_app) {
|
|
app = account_to_app(found);
|
|
if (strlen(app->appname))
|
|
print_field(field_format, found, "Application", app->appname);
|
|
}
|
|
|
|
list_for_each_entry(found_field, &found->field_head, list) {
|
|
pretty_field = pretty_field_value(found_field);
|
|
print_field(field_format, found, found_field->name, pretty_field);
|
|
free(pretty_field);
|
|
}
|
|
list_for_each_entry(attach, &found->attach_head, list) {
|
|
print_attachment(field_format, found, attach);
|
|
}
|
|
if (found->pwprotect)
|
|
print_field(field_format, found, "Reprompt", "Yes");
|
|
if (strlen(found->note))
|
|
print_field(field_format, found, "Notes", found->note);
|
|
} else if (choice != ATTACH) {
|
|
if (!value)
|
|
die("Programming error.");
|
|
printf("%s", value);
|
|
if (!clip)
|
|
putchar('\n');
|
|
}
|
|
|
|
account_free(notes_expansion);
|
|
}
|
|
done:
|
|
session_free(session);
|
|
blob_free(blob);
|
|
return 0;
|
|
}
|