mirror of
https://github.com/hanzoai/lastpass-mcp.git
synced 2026-11-14 21:30:44 +00:00
421 lines
9.7 KiB
C
421 lines
9.7 KiB
C
/*
|
|
* command for importing vault entries from CSV file into the vault
|
|
*
|
|
* Copyright (C) 2014-2024 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 "util.h"
|
|
#include "config.h"
|
|
#include "terminal.h"
|
|
#include "kdf.h"
|
|
#include "blob.h"
|
|
#include "endpoints.h"
|
|
#include "agent.h"
|
|
#include "list.h"
|
|
#include <getopt.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
#include <string.h>
|
|
#include <search.h>
|
|
|
|
struct csv_record {
|
|
struct list_head field_head;
|
|
struct list_head list;
|
|
};
|
|
|
|
struct csv_field {
|
|
char *value;
|
|
struct list_head list;
|
|
};
|
|
|
|
enum csv_token {
|
|
CSV_NONE,
|
|
CSV_FIELD,
|
|
CSV_NL,
|
|
CSV_EOF
|
|
};
|
|
|
|
static enum csv_token csv_next_token(FILE *fp, char **retp)
|
|
{
|
|
int ch, nextch;
|
|
bool readch = false;
|
|
bool in_quote = false;
|
|
bool done = false;
|
|
bool eol = false;
|
|
char *rptr;
|
|
|
|
struct buffer result = {
|
|
.len = 0,
|
|
.max = 80,
|
|
.bytes = NULL,
|
|
};
|
|
result.bytes = xcalloc(result.max, 1);
|
|
|
|
*retp = NULL;
|
|
while (!done) {
|
|
ch = fgetc(fp);
|
|
if (ch == EOF)
|
|
break;
|
|
|
|
readch = true;
|
|
switch(ch)
|
|
{
|
|
case '\n':
|
|
case ',':
|
|
/* non-quoted newline / comma terminate field */
|
|
if (!in_quote) {
|
|
done = true;
|
|
eol = (ch == '\n');
|
|
break;
|
|
}
|
|
|
|
/* otherwise append */
|
|
buffer_append_char(&result, ch);
|
|
break;
|
|
|
|
case '"':
|
|
/*
|
|
* quote immediately after comma starts a
|
|
* double-quoted field
|
|
*/
|
|
if (result.len == 0 && !in_quote) {
|
|
in_quote = true;
|
|
continue;
|
|
}
|
|
|
|
if (in_quote) {
|
|
/*
|
|
* inside a dqfield, two double quotes adds a
|
|
* quote, print one
|
|
*/
|
|
nextch = fgetc(fp);
|
|
if (nextch == '"') {
|
|
buffer_append_char(&result, '"');
|
|
continue;
|
|
}
|
|
|
|
/* otherwise terminate the quote */
|
|
in_quote = false;
|
|
ungetc(nextch, fp);
|
|
continue;
|
|
}
|
|
/* quote not after a comma, treat as unescaped */
|
|
buffer_append_char(&result, ch);
|
|
break;
|
|
default:
|
|
buffer_append_char(&result, ch);
|
|
}
|
|
}
|
|
|
|
if (!readch)
|
|
return CSV_EOF;
|
|
|
|
rptr = result.bytes;
|
|
/* trim cr/nl, but not spaces (they may be significant) */
|
|
while (rptr[strlen(rptr)-1] == '\r' ||
|
|
rptr[strlen(rptr)-1] == '\n') {
|
|
rptr[strlen(rptr)-1] = '\0';
|
|
}
|
|
*retp = rptr;
|
|
|
|
if (eol)
|
|
return CSV_NL;
|
|
|
|
return CSV_FIELD;
|
|
}
|
|
|
|
static struct csv_record *csv_record_new()
|
|
{
|
|
struct csv_record *r;
|
|
|
|
r = new0(struct csv_record, 1);
|
|
INIT_LIST_HEAD(&r->field_head);
|
|
return r;
|
|
}
|
|
|
|
/*
|
|
* Return a list of csv_record items from parsing a CSV file.
|
|
*/
|
|
static void csv_parse(FILE *fp, struct list_head *list)
|
|
{
|
|
char *p;
|
|
enum csv_token token;
|
|
struct csv_record *record;
|
|
|
|
record = csv_record_new();
|
|
while ((token = csv_next_token(fp, &p))) {
|
|
if (p) {
|
|
struct csv_field *field = new0(struct csv_field, 1);
|
|
field->value = p;
|
|
list_add_tail(&field->list, &record->field_head);
|
|
}
|
|
if (token == CSV_NL || token == CSV_EOF) {
|
|
if (!list_empty(&record->field_head)) {
|
|
list_add_tail(&record->list, list);
|
|
record = csv_record_new();
|
|
}
|
|
}
|
|
if (token == CSV_EOF)
|
|
break;
|
|
}
|
|
free(record);
|
|
}
|
|
|
|
static struct account *new_import_account(unsigned char key[KDF_HASH_LEN], const struct feature_flag *feature_flag)
|
|
{
|
|
struct account *account = new_account();
|
|
|
|
account_set_url(account, xstrdup(""), key, feature_flag);
|
|
account_set_username(account, xstrdup(""), key);
|
|
account_set_password(account, xstrdup(""), key);
|
|
account_set_note(account, xstrdup(""), key);
|
|
account_set_name(account, xstrdup(""), key);
|
|
account_set_group(account, xstrdup(""), key);
|
|
|
|
return account;
|
|
}
|
|
|
|
static int csv_parse_accounts(FILE *fp, struct list_head *account_list,
|
|
unsigned char key[KDF_HASH_LEN], const struct feature_flag *feature_flag)
|
|
{
|
|
struct list_head items;
|
|
struct csv_record *record, *tmp_record, *first;
|
|
struct csv_field *field, *tmp_field;
|
|
int i = 0;
|
|
int num_accounts = 0;
|
|
|
|
int url_index = -1,
|
|
username_index = -1,
|
|
password_index = -1,
|
|
extra_index = -1,
|
|
name_index = -1,
|
|
grouping_index = -1,
|
|
fav_index = -1;
|
|
|
|
INIT_LIST_HEAD(&items);
|
|
csv_parse(fp, &items);
|
|
|
|
if (list_empty(&items))
|
|
return 0;
|
|
|
|
#define set_field_index(x) \
|
|
do { \
|
|
if (!strcmp(field->value, #x)) { \
|
|
x ## _index = i; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define set_field(x, fieldname) \
|
|
do { \
|
|
if (i == x ## _index) { \
|
|
account_set_ ## fieldname (account, field->value, key); \
|
|
set = true; \
|
|
} \
|
|
} while (0)
|
|
|
|
#define set_field_ff(x, fieldname, feature_flag) \
|
|
do { \
|
|
if (i == x ## _index) { \
|
|
account_set_ ## fieldname (account, field->value, key, feature_flag); \
|
|
set = true; \
|
|
} \
|
|
} while (0)
|
|
|
|
/*
|
|
* first line should tell us the field matrix; if
|
|
* it doesn't reveal anything useful then we won't
|
|
* import anything
|
|
*/
|
|
record = list_first_entry(&items, struct csv_record, list);
|
|
list_for_each_entry(field, &record->field_head, list) {
|
|
set_field_index(url);
|
|
set_field_index(username);
|
|
set_field_index(password);
|
|
set_field_index(extra);
|
|
set_field_index(name);
|
|
set_field_index(grouping);
|
|
set_field_index(fav);
|
|
i++;
|
|
}
|
|
|
|
if (url_index == -1 && username_index == -1 &&
|
|
password_index == -1 && extra_index == -1 &&
|
|
name_index == -1 && grouping_index == -1 &&
|
|
fav_index == -1) {
|
|
die("Could not read the CSV header at the first line of the input file");
|
|
return 0;
|
|
}
|
|
|
|
first = record;
|
|
list_for_each_entry(record, &items, list) {
|
|
struct account *account;
|
|
if (record == first)
|
|
continue;
|
|
|
|
account = new_import_account(key, feature_flag);
|
|
i = 0;
|
|
list_for_each_entry(field, &record->field_head, list) {
|
|
bool set = false;
|
|
set_field_ff(url, url, feature_flag);
|
|
set_field(username, username);
|
|
set_field(password, password);
|
|
set_field(name, name);
|
|
set_field(grouping, group);
|
|
set_field(extra, note);
|
|
if (i == fav_index) {
|
|
account->fav = field->value[0] == '1';
|
|
set = true;
|
|
}
|
|
|
|
/* free unknown field */
|
|
if (!set)
|
|
free(field->value);
|
|
i++;
|
|
}
|
|
num_accounts++;
|
|
list_add_tail(&account->list, account_list);
|
|
}
|
|
|
|
list_for_each_entry_safe(record, tmp_record, &items, list) {
|
|
list_for_each_entry_safe(field, tmp_field,
|
|
&record->field_head, list) {
|
|
free(field);
|
|
}
|
|
free(record);
|
|
}
|
|
return num_accounts;
|
|
}
|
|
|
|
/* dedupe based on password / url / name / username sets */
|
|
int csv_dedupe_compare(const void *k1, const void *k2)
|
|
{
|
|
const struct account *a1 = k1, *a2 = k2;
|
|
int r;
|
|
|
|
if ((r = strcmp(a1->password, a2->password)))
|
|
return r;
|
|
if ((r = strcmp(a1->username, a2->username)))
|
|
return r;
|
|
if ((r = strcmp(a1->url, a2->url)))
|
|
return r;
|
|
return strcmp(a1->name, a2->name);
|
|
}
|
|
|
|
void csv_dedupe_accounts(struct list_head *blob_accounts,
|
|
struct list_head *new_accounts)
|
|
{
|
|
struct account *account, *tmp;
|
|
void *search_tree = NULL;
|
|
|
|
list_for_each_entry(account, blob_accounts, list) {
|
|
tsearch(account, &search_tree, csv_dedupe_compare);
|
|
}
|
|
|
|
list_for_each_entry_safe(account, tmp, new_accounts, list) {
|
|
if (tfind(account, &search_tree, csv_dedupe_compare)) {
|
|
list_del(&account->list);
|
|
account_free(account);
|
|
}
|
|
}
|
|
}
|
|
|
|
int cmd_import(int argc, char **argv)
|
|
{
|
|
static struct option long_options[] = {
|
|
{"sync", required_argument, NULL, 'S'},
|
|
{"keep-dupes", no_argument, NULL, 'k'},
|
|
{0, 0, 0, 0}
|
|
};
|
|
int option;
|
|
int option_index;
|
|
enum blobsync sync = BLOB_SYNC_AUTO;
|
|
unsigned char key[KDF_HASH_LEN];
|
|
_cleanup_fclose_ FILE *fp;
|
|
struct session *session = NULL;
|
|
struct blob *blob = NULL;
|
|
struct list_head accounts;
|
|
struct account *account;
|
|
int count, new_count;
|
|
bool keep_dupes = false;
|
|
int ret;
|
|
|
|
while ((option = getopt_long(argc, argv, "", long_options, &option_index)) != -1) {
|
|
switch (option) {
|
|
case 'S':
|
|
sync = parse_sync_string(optarg);
|
|
break;
|
|
case 'k':
|
|
keep_dupes = true;
|
|
break;
|
|
case '?':
|
|
default:
|
|
die_usage(cmd_import_usage);
|
|
}
|
|
}
|
|
|
|
if (argc - optind < 1) {
|
|
fp = stdin;
|
|
} else {
|
|
char *filename = argv[optind];
|
|
fp = fopen(filename, "rb");
|
|
if (!fp)
|
|
die("Unable to open %s", filename);
|
|
}
|
|
|
|
init_all(sync, key, &session, &blob);
|
|
|
|
INIT_LIST_HEAD(&accounts);
|
|
count = csv_parse_accounts(fp, &accounts, key, &session->feature_flag);
|
|
|
|
printf("Parsed %d accounts\n", count);
|
|
|
|
new_count = 0;
|
|
if (!keep_dupes)
|
|
csv_dedupe_accounts(&blob->account_head, &accounts);
|
|
|
|
list_for_each_entry(account, &accounts, list) {
|
|
new_count++;
|
|
};
|
|
|
|
if (count - new_count)
|
|
printf("Removed %d duplicate accounts\n", count - new_count);
|
|
|
|
ret = lastpass_upload(session, &accounts);
|
|
if (ret)
|
|
die("Import failed (%d)\n", ret);
|
|
|
|
session_free(session);
|
|
blob_free(blob);
|
|
return 0;
|
|
}
|