mirror of
https://github.com/hanzoai/lastpass-mcp.git
synced 2026-11-14 21:30:44 +00:00
458 lines
12 KiB
C
458 lines
12 KiB
C
/*
|
|
* configuration file handling
|
|
*
|
|
* 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 "config.h"
|
|
#include "util.h"
|
|
#include <stdlib.h>
|
|
#include <sys/types.h>
|
|
#include <sys/stat.h>
|
|
#include <errno.h>
|
|
#include <unistd.h>
|
|
#include <utime.h>
|
|
#include <string.h>
|
|
#include <openssl/evp.h>
|
|
#include <openssl/aes.h>
|
|
#include <openssl/err.h>
|
|
#include <openssl/rand.h>
|
|
#include <openssl/hmac.h>
|
|
|
|
/*
|
|
* Map well-known pathnames to their configuration type.
|
|
*/
|
|
struct pathname_type_tuple {
|
|
char *name;
|
|
enum config_type type;
|
|
};
|
|
|
|
struct pathname_type_tuple pathname_type_lookup[] = {
|
|
{ "env", CONFIG_CONFIG },
|
|
{ "blob", CONFIG_DATA },
|
|
{ "iterations", CONFIG_DATA },
|
|
{ "username", CONFIG_DATA },
|
|
{ "verify", CONFIG_DATA },
|
|
{ "plaintext_key", CONFIG_DATA },
|
|
{ "trusted_id", CONFIG_DATA },
|
|
{ "session_uid", CONFIG_DATA },
|
|
{ "session_sessionid", CONFIG_DATA },
|
|
{ "session_token", CONFIG_DATA },
|
|
{ "session_privatekey", CONFIG_DATA },
|
|
{ "session_server", CONFIG_DATA },
|
|
{ "lpass.log", CONFIG_DATA },
|
|
{ "agent.sock", CONFIG_RUNTIME },
|
|
{ "uploader.pid", CONFIG_RUNTIME },
|
|
};
|
|
|
|
char *config_type_to_xdg[] = {
|
|
[CONFIG_DATA] = "XDG_DATA_HOME",
|
|
[CONFIG_CONFIG] = "XDG_CONFIG_HOME",
|
|
[CONFIG_RUNTIME] = "XDG_RUNTIME_DIR",
|
|
};
|
|
|
|
static
|
|
char *get_xdg_dir(const char *xdg_var)
|
|
{
|
|
char *home;
|
|
char *retstr = NULL;
|
|
|
|
if (getenv(xdg_var))
|
|
return xstrdup(getenv(xdg_var));
|
|
|
|
/*
|
|
* $XDG var not set in environment; decide whether
|
|
* to use backups locations based on existence of
|
|
* $XDG_RUNTIME_DIR.
|
|
*/
|
|
if (!getenv("XDG_RUNTIME_DIR"))
|
|
return NULL;
|
|
|
|
home = getenv("HOME");
|
|
if (!home)
|
|
return NULL;
|
|
|
|
if (!strcmp(xdg_var, "XDG_DATA_HOME"))
|
|
xasprintf(&retstr, "%s/.local/share", home);
|
|
else if (!strcmp(xdg_var, "XDG_CONFIG_HOME"))
|
|
xasprintf(&retstr, "%s/.config", home);
|
|
|
|
return retstr;
|
|
}
|
|
|
|
/*
|
|
* Get the path to a config file given its name and the type of file.
|
|
*
|
|
* lpass looks for files in the following directories:
|
|
*
|
|
* First, if $LPASS_HOME is set, everything goes there.
|
|
*
|
|
* After that, if it is a persistent, user-specific data file,
|
|
* it goes in $XDG_DATA_HOME/lpass.
|
|
*
|
|
* If a configuration item, it goes in $XDG_CONFIG_HOME.
|
|
*
|
|
* If a purely runtime item (socket, pidfile, etc) it goes in
|
|
* $XDG_RUNTIME_HOME.
|
|
*
|
|
* If none of the $XDG environment variables are set, fall-back
|
|
* to ~/.lpass.
|
|
*/
|
|
static
|
|
char *config_path_for_type(enum config_type type, const char *name)
|
|
{
|
|
char *home, *path, *xdg_env;
|
|
_cleanup_free_ char *config = NULL;
|
|
_cleanup_free_ char *xdg_dir = NULL;
|
|
struct stat sbuf;
|
|
int ret;
|
|
|
|
xdg_env = config_type_to_xdg[type];
|
|
|
|
home = getenv("LPASS_HOME");
|
|
if (home)
|
|
config = xstrdup(home);
|
|
else if ((xdg_dir = get_xdg_dir(xdg_env))) {
|
|
xasprintf(&config, "%s/lpass", xdg_dir);
|
|
} else {
|
|
home = getenv("HOME");
|
|
if (!home)
|
|
die("HOME is not set");
|
|
|
|
xasprintf(&config, "%s/.lpass", home);
|
|
}
|
|
|
|
ret = stat(config, &sbuf);
|
|
if ((ret == -1 && errno == ENOENT) || !S_ISDIR(sbuf.st_mode)) {
|
|
unlink(config);
|
|
if (mkdir(config, 0700) < 0)
|
|
die_errno("mkdir(%s)", config);
|
|
} else if (ret == -1)
|
|
die_errno("stat(%s)", config);
|
|
|
|
_cleanup_free_ char *buffer = xstrdup(name);
|
|
_cleanup_free_ char *dir_path = xstrdup(config);
|
|
char *saveptr = NULL;
|
|
for (char *token = strtok_r(buffer, "/", &saveptr); token && saveptr && strlen(saveptr) > 0; token = strtok_r(NULL, "/", &saveptr)) {
|
|
xstrappendf(&dir_path, "/%s", token);
|
|
|
|
ret = stat(dir_path, &sbuf);
|
|
if ((ret == -1 && errno == ENOENT) || !S_ISDIR(sbuf.st_mode)) {
|
|
unlink(dir_path);
|
|
if (mkdir(dir_path, 0700) < 0)
|
|
die_errno("mkdir(%s)", dir_path);
|
|
} else if (ret == -1)
|
|
die_errno("stat(%s)", dir_path);
|
|
}
|
|
|
|
xasprintf(&path, "%s/%s", config, name);
|
|
|
|
return path;
|
|
}
|
|
|
|
|
|
enum config_type config_path_type(const char *name)
|
|
{
|
|
unsigned int i;
|
|
|
|
/* aliases are config files */
|
|
if (!strncmp(name, "alias", 5)) {
|
|
return CONFIG_CONFIG;
|
|
}
|
|
|
|
/* lock files are runtime */
|
|
if (strlen(name) >= 5 && !strcmp(name + strlen(name) - 5, ".lock")) {
|
|
return CONFIG_RUNTIME;
|
|
}
|
|
|
|
/* categorized this configuration file by name? */
|
|
for (i=0; i < ARRAY_SIZE(pathname_type_lookup); i++) {
|
|
if (!strcmp(name, pathname_type_lookup[i].name)) {
|
|
return pathname_type_lookup[i].type;
|
|
}
|
|
}
|
|
|
|
/* everything else is config_data */
|
|
return CONFIG_DATA;
|
|
}
|
|
|
|
char *config_path(const char *name)
|
|
{
|
|
return config_path_for_type(config_path_type(name), name);
|
|
}
|
|
|
|
|
|
FILE *config_fopen(const char *name, const char *mode)
|
|
{
|
|
_cleanup_free_ char *path = config_path(name);
|
|
return fopen(path, mode);
|
|
}
|
|
|
|
void config_touch(const char *name)
|
|
{
|
|
_cleanup_free_ char *path = NULL;
|
|
path = config_path(name);
|
|
if (utime(path, NULL) < 0)
|
|
die_errno("utime");
|
|
}
|
|
|
|
bool config_exists(const char *name)
|
|
{
|
|
_cleanup_free_ char *path = NULL;
|
|
struct stat sbuf;
|
|
|
|
path = config_path(name);
|
|
return stat(path, &sbuf) != -1;
|
|
}
|
|
|
|
time_t config_mtime(const char *name)
|
|
{
|
|
_cleanup_free_ char *path = NULL;
|
|
struct stat sbuf;
|
|
|
|
path = config_path(name);
|
|
if (stat(path, &sbuf) < 0)
|
|
return 0;
|
|
|
|
return sbuf.st_mtime;
|
|
}
|
|
|
|
bool config_unlink(const char *name)
|
|
{
|
|
_cleanup_free_ char *path = config_path(name);
|
|
return unlink(path) == 0;
|
|
}
|
|
|
|
void config_write_string(const char *name, const char *string)
|
|
{
|
|
config_write_buffer(name, string, strlen(string));
|
|
}
|
|
|
|
void config_write_buffer(const char *name, const char *buffer, size_t len)
|
|
{
|
|
_cleanup_free_ char *tempname = NULL;
|
|
_cleanup_free_ char *finalpath = config_path(name);
|
|
int tempfd;
|
|
FILE *tempfile = NULL;
|
|
|
|
xasprintf(&tempname, "%s.XXXXXX", finalpath);
|
|
tempfd = mkstemp(tempname);
|
|
if (tempfd < 0)
|
|
die_errno("mkstemp(%s)", tempname);
|
|
tempfile = fdopen(tempfd, "w");
|
|
if (!tempfile)
|
|
goto error;
|
|
if (fwrite(buffer, 1, len, tempfile) != len)
|
|
goto error;
|
|
fclose(tempfile);
|
|
tempfile = NULL;
|
|
if (rename(tempname, finalpath) < 0)
|
|
goto error;
|
|
return;
|
|
|
|
error:
|
|
tempfd = errno;
|
|
if (tempfile)
|
|
fclose(tempfile);
|
|
unlink(tempname);
|
|
errno = tempfd;
|
|
die_errno("config-%s", name);
|
|
}
|
|
|
|
char *config_read_string(const char *name)
|
|
{
|
|
_cleanup_free_ char *buffer = NULL;
|
|
size_t len = config_read_buffer(name, (unsigned char **) &buffer);
|
|
|
|
if (!buffer)
|
|
return NULL;
|
|
|
|
return xstrndup(buffer, len);
|
|
}
|
|
|
|
size_t config_read_buffer(const char *name, unsigned char **out)
|
|
{
|
|
_cleanup_fclose_ FILE *file = NULL;
|
|
unsigned char *buffer;
|
|
size_t len, read;
|
|
|
|
file = config_fopen(name, "r");
|
|
if (!file) {
|
|
*out = NULL;
|
|
return 0;
|
|
}
|
|
|
|
for (len = 0, buffer = xmalloc(8192); ; buffer = xrealloc(buffer, len + 8192)) {
|
|
read = fread(buffer + len, 1, 8192, file);
|
|
len += read;
|
|
if (read != 8192) {
|
|
if (ferror(file))
|
|
die_errno("fread(config-%s)", name);
|
|
break;
|
|
}
|
|
}
|
|
|
|
*out = buffer;
|
|
return len;
|
|
}
|
|
|
|
/*
|
|
* ciphertext = IV | aes-256-cbc(plaintext, key)
|
|
* authenticated-ciphertext = HMAC-SHA256(ciphertext, key) | ciphertext
|
|
*
|
|
* These two functions work with `authenticated-ciphertext`.
|
|
*/
|
|
|
|
static size_t encrypt_buffer(const char *buffer, size_t in_len, unsigned const char key[KDF_HASH_LEN], char **out)
|
|
{
|
|
EVP_CIPHER_CTX *ctx;
|
|
char *ciphertext;
|
|
unsigned char iv[AES_BLOCK_SIZE];
|
|
int out_len;
|
|
unsigned int hmac_len;
|
|
size_t len;
|
|
|
|
if (!RAND_bytes(iv, AES_BLOCK_SIZE))
|
|
die("Could not generate random bytes for CBC IV.");
|
|
|
|
ciphertext = xcalloc(in_len + AES_BLOCK_SIZE * 2 + SHA256_DIGEST_LENGTH, 1);
|
|
|
|
ctx = EVP_CIPHER_CTX_new();
|
|
if (!ctx)
|
|
goto error;
|
|
|
|
len = SHA256_DIGEST_LENGTH;
|
|
memcpy(ciphertext + len, iv, AES_BLOCK_SIZE);
|
|
len += AES_BLOCK_SIZE;
|
|
|
|
if (!EVP_EncryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, iv))
|
|
goto error;
|
|
if (!EVP_EncryptUpdate(ctx, (unsigned char *)(ciphertext + len), &out_len, (unsigned char *)buffer, in_len))
|
|
goto error;
|
|
len += out_len;
|
|
if (!EVP_EncryptFinal_ex(ctx, (unsigned char *)(ciphertext + len), &out_len))
|
|
goto error;
|
|
len += out_len;
|
|
|
|
if (!HMAC(EVP_sha256(), key, KDF_HASH_LEN, (unsigned char *)(ciphertext + SHA256_DIGEST_LENGTH), len - SHA256_DIGEST_LENGTH, (unsigned char *)ciphertext, &hmac_len))
|
|
goto error;
|
|
|
|
EVP_CIPHER_CTX_free(ctx);
|
|
*out = ciphertext;
|
|
return len;
|
|
|
|
error:
|
|
EVP_CIPHER_CTX_free(ctx);
|
|
free(ciphertext);
|
|
die("Failed to encrypt data.");
|
|
|
|
}
|
|
|
|
static size_t decrypt_buffer(const unsigned char *buffer, size_t in_len, unsigned const char key[KDF_HASH_LEN], unsigned char **out)
|
|
{
|
|
EVP_CIPHER_CTX *ctx;
|
|
unsigned char *plaintext = NULL;
|
|
int out_len;
|
|
unsigned int hmac_len;
|
|
size_t len;
|
|
unsigned char hmac[SHA256_DIGEST_LENGTH];
|
|
|
|
ctx = EVP_CIPHER_CTX_new();
|
|
if (!ctx)
|
|
goto error;
|
|
|
|
if (in_len < (SHA256_DIGEST_LENGTH + AES_BLOCK_SIZE * 2))
|
|
goto error;
|
|
|
|
if (!HMAC(EVP_sha256(), key, KDF_HASH_LEN, (unsigned char *)(buffer + SHA256_DIGEST_LENGTH), in_len - SHA256_DIGEST_LENGTH, hmac, &hmac_len))
|
|
goto error;
|
|
if (CRYPTO_memcmp(hmac, buffer, SHA256_DIGEST_LENGTH))
|
|
goto error;
|
|
|
|
plaintext = xcalloc(in_len + AES_BLOCK_SIZE, 1);
|
|
if (!EVP_DecryptInit_ex(ctx, EVP_aes_256_cbc(), NULL, key, (unsigned char *)(buffer + SHA256_DIGEST_LENGTH)))
|
|
goto error;
|
|
if (!EVP_DecryptUpdate(ctx, (unsigned char *)plaintext, &out_len, (unsigned char *)(buffer + SHA256_DIGEST_LENGTH + AES_BLOCK_SIZE), in_len - SHA256_DIGEST_LENGTH - AES_BLOCK_SIZE))
|
|
goto error;
|
|
len = out_len;
|
|
if (!EVP_DecryptFinal_ex(ctx, (unsigned char *)(plaintext + out_len), &out_len))
|
|
goto error;
|
|
len += out_len;
|
|
EVP_CIPHER_CTX_free(ctx);
|
|
*out = plaintext;
|
|
return len;
|
|
|
|
error:
|
|
EVP_CIPHER_CTX_free(ctx);
|
|
free(plaintext);
|
|
*out = NULL;
|
|
return 0;
|
|
}
|
|
|
|
void config_write_encrypted_string(const char *name, const char *string, unsigned const char key[KDF_HASH_LEN])
|
|
{
|
|
config_write_encrypted_buffer(name, string, strlen(string), key);
|
|
}
|
|
|
|
void config_write_encrypted_buffer(const char *name, const char *buffer, size_t len, unsigned const char key[KDF_HASH_LEN])
|
|
{
|
|
_cleanup_free_ char *encrypted_buffer = NULL;
|
|
|
|
len = encrypt_buffer(buffer, len, key, &encrypted_buffer);
|
|
config_write_buffer(name, encrypted_buffer, len);
|
|
}
|
|
|
|
char *config_read_encrypted_string(const char *name, unsigned const char key[KDF_HASH_LEN])
|
|
{
|
|
_cleanup_free_ char *buffer = NULL;
|
|
size_t len = config_read_encrypted_buffer(name, (unsigned char **) &buffer, key);
|
|
|
|
if (!buffer)
|
|
return NULL;
|
|
|
|
return xstrndup(buffer, len);
|
|
}
|
|
|
|
size_t config_read_encrypted_buffer(const char *name, unsigned char **buffer, unsigned const char key[KDF_HASH_LEN])
|
|
{
|
|
_cleanup_free_ unsigned char *encrypted_buffer = NULL;
|
|
size_t len;
|
|
|
|
len = config_read_buffer(name, &encrypted_buffer);
|
|
if (!encrypted_buffer) {
|
|
*buffer = NULL;
|
|
return 0;
|
|
}
|
|
|
|
return decrypt_buffer(encrypted_buffer, len, key, buffer);
|
|
}
|