mirror of
https://github.com/hanzoai/lastpass-mcp.git
synced 2026-11-14 21:30:44 +00:00
517 lines
12 KiB
C
517 lines
12 KiB
C
/*
|
|
* utility functions
|
|
*
|
|
* 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.
|
|
*
|
|
* reallocarray is:
|
|
* Copyright (c) 2008 Otto Moerbeek <[email protected]>.
|
|
* strlcpy and strlcat are:
|
|
* Copyright (c) 1998 Todd C. Miller <[email protected]>.
|
|
* For reallocarray, strlcpy, and strlcat:
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
#include "util.h"
|
|
#include "process.h"
|
|
#include "terminal.h"
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdint.h>
|
|
#include <stdarg.h>
|
|
#include <stdio.h>
|
|
#include <ctype.h>
|
|
#include <errno.h>
|
|
#include <limits.h>
|
|
#include <openssl/rand.h>
|
|
|
|
void warn(const char *err, ...)
|
|
{
|
|
char message[4096];
|
|
va_list params;
|
|
|
|
va_start(params, err);
|
|
vsnprintf(message, sizeof(message), err, params);
|
|
va_end(params);
|
|
|
|
terminal_fprintf(stderr, TERMINAL_FG_YELLOW TERMINAL_BOLD "Warning" TERMINAL_RESET ": %s\n", message);
|
|
}
|
|
|
|
void warn_errno(const char *err, ...)
|
|
{
|
|
char message[4096], *error_message;
|
|
va_list params;
|
|
|
|
error_message = strerror(errno);
|
|
|
|
va_start(params, err);
|
|
vsnprintf(message, sizeof(message), err, params);
|
|
va_end(params);
|
|
|
|
terminal_fprintf(stderr, TERMINAL_FG_YELLOW TERMINAL_BOLD "WARNING" TERMINAL_RESET ": " TERMINAL_FG_YELLOW "%s" TERMINAL_RESET ": %s\n", error_message, message);
|
|
}
|
|
|
|
_noreturn_ void die(const char *err, ...)
|
|
{
|
|
char message[4096];
|
|
va_list params;
|
|
|
|
va_start(params, err);
|
|
vsnprintf(message, sizeof(message), err, params);
|
|
va_end(params);
|
|
|
|
terminal_fprintf(stderr, TERMINAL_FG_RED TERMINAL_BOLD "Error" TERMINAL_RESET ": %s\n", message);
|
|
exit(1);
|
|
}
|
|
_noreturn_ void die_errno(const char *err, ...)
|
|
{
|
|
char message[4096], *error_message;
|
|
va_list params;
|
|
|
|
error_message = strerror(errno);
|
|
|
|
va_start(params, err);
|
|
vsnprintf(message, sizeof(message), err, params);
|
|
va_end(params);
|
|
|
|
terminal_fprintf(stderr, TERMINAL_FG_RED TERMINAL_BOLD "Error" TERMINAL_RESET ": " TERMINAL_FG_RED "%s" TERMINAL_RESET ": %s\n", error_message, message);
|
|
exit(1);
|
|
}
|
|
|
|
void die_usage(const char *usage)
|
|
{
|
|
terminal_fprintf(stderr, "Usage: %s %s\n", ARGV[0], usage);
|
|
exit(1);
|
|
}
|
|
|
|
char ask_options(char *options, char def, const char *prompt, ...)
|
|
{
|
|
va_list params;
|
|
_cleanup_free_ char *response = NULL;
|
|
size_t len = 0;
|
|
unsigned int i;
|
|
|
|
for (;;) {
|
|
va_start(params, prompt);
|
|
terminal_fprintf(stderr, TERMINAL_FG_YELLOW);
|
|
vfprintf(stderr, prompt, params);
|
|
terminal_fprintf(stderr, TERMINAL_RESET);
|
|
va_end(params);
|
|
terminal_fprintf(stderr, " [");
|
|
for (i = 0; i < strlen(options); i++) {
|
|
if (options[i] == def) {
|
|
terminal_fprintf(stderr,TERMINAL_BOLD "%c" TERMINAL_RESET, toupper(options[i]));
|
|
} else {
|
|
terminal_fprintf(stderr, "%c", options[i]);
|
|
}
|
|
if (i < strlen(options)-1)
|
|
terminal_fprintf(stderr, "/");
|
|
else
|
|
terminal_fprintf(stderr, "] ");
|
|
}
|
|
if (getline(&response, &len, stdin) < 0)
|
|
die("aborted response.");
|
|
strlower(response);
|
|
|
|
if (!strcmp("\n", response))
|
|
return def;
|
|
|
|
if (strlen(response) && strchr(options, response[0]))
|
|
return response[0];
|
|
|
|
terminal_fprintf(stderr, TERMINAL_FG_RED TERMINAL_BOLD "Error" TERMINAL_RESET ": Response not understood.\n");
|
|
free(response);
|
|
response = NULL;
|
|
len = 0;
|
|
}
|
|
}
|
|
|
|
bool ask_yes_no(bool default_yes, const char *prompt, ...)
|
|
{
|
|
va_list params;
|
|
char message[4096];
|
|
|
|
va_start(params, prompt);
|
|
vsnprintf(message, sizeof(message), prompt, params);
|
|
va_end(params);
|
|
|
|
return ask_options("yn", (default_yes) ? 'y' : 'n', message) == 'y';
|
|
}
|
|
|
|
void *xmalloc(size_t size)
|
|
{
|
|
void *ret = malloc(size);
|
|
if (likely(ret))
|
|
return ret;
|
|
die_errno("malloc(%zu)", size);
|
|
}
|
|
void *xcalloc(size_t nmemb, size_t size)
|
|
{
|
|
void *ret = calloc(nmemb, size);
|
|
if (likely(ret))
|
|
return ret;
|
|
die_errno("calloc(%zu, %zu)", nmemb, size);
|
|
}
|
|
void *xrealloc(void *ptr, size_t size)
|
|
{
|
|
void *ret = realloc(ptr, size);
|
|
if (likely(ret))
|
|
return ret;
|
|
die_errno("realloc(%p, %zu)", ptr, size);
|
|
}
|
|
void *reallocarray(void *optr, size_t nmemb, size_t size)
|
|
{
|
|
if (!size || !nmemb) {
|
|
errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) &&
|
|
nmemb > 0 && SIZE_MAX / nmemb < size) {
|
|
errno = ENOMEM;
|
|
return NULL;
|
|
}
|
|
return realloc(optr, size * nmemb);
|
|
}
|
|
void *xreallocarray(void *ptr, size_t nmemb, size_t size)
|
|
{
|
|
void *ret = reallocarray(ptr, nmemb, size);
|
|
if (likely(ret))
|
|
return ret;
|
|
die_errno("reallocarray(%p, %zu, %zu)", ptr, nmemb, size);
|
|
}
|
|
|
|
void *xstrdup(const char *str)
|
|
{
|
|
void *ret = strdup(str);
|
|
if (likely(ret))
|
|
return ret;
|
|
die_errno("strdup(%p)", (void *) str);
|
|
}
|
|
void *xstrndup(const char *str, size_t maxlen)
|
|
{
|
|
void *ret = strndup(str, maxlen);
|
|
if (likely(ret))
|
|
return ret;
|
|
die_errno("strndup(%p, %zu)", (void *) str, maxlen);
|
|
}
|
|
int xasprintf(char **strp, const char *fmt, ...)
|
|
{
|
|
va_list params;
|
|
int ret;
|
|
|
|
va_start(params, fmt);
|
|
ret = xvasprintf(strp, fmt, params);
|
|
va_end(params);
|
|
|
|
return ret;
|
|
}
|
|
int xvasprintf(char **strp, const char *fmt, va_list ap)
|
|
{
|
|
int ret;
|
|
|
|
ret = vasprintf(strp, fmt, ap);
|
|
if (ret == -1)
|
|
die_errno("asprintf(%p, %s, ...)", (void *)strp, fmt);
|
|
|
|
return ret;
|
|
}
|
|
|
|
#ifdef __GLIBC__
|
|
size_t strlcpy(char *dst, const char *src, size_t siz)
|
|
{
|
|
char *d = dst;
|
|
const char *s = src;
|
|
size_t n = siz;
|
|
|
|
/* Copy as many bytes as will fit */
|
|
if (n != 0) {
|
|
while (--n != 0) {
|
|
if ((*d++ = *s++) == '\0')
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* Not enough room in dst, add NUL and traverse rest of src */
|
|
if (n == 0) {
|
|
if (siz != 0)
|
|
*d = '\0'; /* NUL-terminate dst */
|
|
while (*s++)
|
|
;
|
|
}
|
|
|
|
return (s - src - 1); /* count does not include NUL */
|
|
}
|
|
size_t strlcat(char *dst, const char *src, size_t siz)
|
|
{
|
|
char *d = dst;
|
|
const char *s = src;
|
|
size_t n = siz;
|
|
size_t dlen;
|
|
|
|
/* Find the end of dst and adjust bytes left but don't go past end */
|
|
while (n-- != 0 && *d != '\0')
|
|
d++;
|
|
dlen = d - dst;
|
|
n = siz - dlen;
|
|
|
|
if (n == 0)
|
|
return (dlen + strlen(s));
|
|
while (*s != '\0') {
|
|
if (n != 1) {
|
|
*d++ = *s;
|
|
n--;
|
|
}
|
|
s++;
|
|
}
|
|
*d = '\0';
|
|
|
|
return (dlen + (s - src)); /* count does not include NUL */
|
|
}
|
|
#else
|
|
char *strchrnul(const char *s, int c)
|
|
{
|
|
char *p = strchr(s, c);
|
|
if (!p)
|
|
p = (char *)s + strlen(s);
|
|
return p;
|
|
}
|
|
#endif
|
|
|
|
void strlower(char *str)
|
|
{
|
|
for (; *str; ++str)
|
|
*str = tolower(*str);
|
|
}
|
|
void strupper(char *str)
|
|
{
|
|
for (; *str; ++str)
|
|
*str = toupper(*str);
|
|
}
|
|
char *xstrlower(const char *str)
|
|
{
|
|
char *copy = xstrdup(str);
|
|
strlower(copy);
|
|
return copy;
|
|
}
|
|
char *xstrupper(const char *str)
|
|
{
|
|
char *copy = xstrdup(str);
|
|
strupper(copy);
|
|
return copy;
|
|
}
|
|
char *xultostr(unsigned long num)
|
|
{
|
|
char *str;
|
|
xasprintf(&str, "%ld", num);
|
|
return str;
|
|
}
|
|
|
|
bool starts_with(const char *str, const char *start)
|
|
{
|
|
for (; ; ++str, ++start) {
|
|
if (!*start)
|
|
return true;
|
|
else if (*str != *start)
|
|
return false;
|
|
}
|
|
}
|
|
bool ends_with(const char *str, const char *end)
|
|
{
|
|
int str_len = strlen(str);
|
|
int end_len = strlen(end);
|
|
if (str_len < end_len)
|
|
return false;
|
|
else
|
|
return !strcmp(str + str_len - end_len, end);
|
|
}
|
|
char *trim(char *str)
|
|
{
|
|
int start, i;
|
|
|
|
for (start = 0; isspace(str[start]) && str[start]; ++start);
|
|
|
|
for (i = 0; str[i + start]; ++i)
|
|
str[i] = str[i + start];
|
|
str[i] = '\0';
|
|
|
|
for (--i; i >= 0 && isspace(str[i]); --i)
|
|
str[i] = '\0';
|
|
|
|
return str;
|
|
}
|
|
|
|
void xstrappend(char **str, const char *suffix)
|
|
{
|
|
if (!*str) {
|
|
*str = xstrdup(suffix);
|
|
return;
|
|
}
|
|
size_t len = strlen(*str) + strlen(suffix) + 1;
|
|
*str = xrealloc(*str, len);
|
|
strlcat(*str, suffix, len);
|
|
}
|
|
void xstrappendf(char **str, const char *suffixfmt, ...)
|
|
{
|
|
_cleanup_free_ char *fmt = NULL;
|
|
va_list args;
|
|
|
|
va_start(args, suffixfmt);
|
|
xvasprintf(&fmt, suffixfmt, args);
|
|
va_end(args);
|
|
|
|
xstrappend(str, fmt);
|
|
}
|
|
void xstrprepend(char **str, const char *prefix)
|
|
{
|
|
if (!*str) {
|
|
*str = xstrdup(prefix);
|
|
return;
|
|
}
|
|
size_t len = strlen(*str) + strlen(prefix) + 1;
|
|
char *new = xmalloc(len);
|
|
strlcpy(new, prefix, len);
|
|
strlcat(new, *str, len);
|
|
free(*str);
|
|
*str = new;
|
|
}
|
|
void xstrprependf(char **str, const char *suffixfmt, ...)
|
|
{
|
|
_cleanup_free_ char *fmt = NULL;
|
|
va_list args;
|
|
|
|
va_start(args, suffixfmt);
|
|
xvasprintf(&fmt, suffixfmt, args);
|
|
va_end(args);
|
|
|
|
xstrprepend(str, fmt);
|
|
}
|
|
|
|
void secure_clear(void *ptr, size_t len)
|
|
{
|
|
if (!ptr)
|
|
return;
|
|
|
|
memset(ptr, 0, len);
|
|
/* prevent GCC / LLVM from optimizing out memset */
|
|
asm volatile("" : : "r"(ptr) : "memory");
|
|
}
|
|
|
|
void secure_clear_str(char *str)
|
|
{
|
|
if (!str)
|
|
return;
|
|
|
|
secure_clear(str, strlen(str));
|
|
}
|
|
|
|
void *secure_resize(void *ptr, size_t oldlen, size_t newlen)
|
|
{
|
|
/* open-coded realloc, with a secure memset in the middle */
|
|
void *newptr = xmalloc(newlen);
|
|
if (ptr) {
|
|
memcpy(newptr, ptr, min(oldlen, newlen));
|
|
secure_clear(ptr, oldlen);
|
|
free(ptr);
|
|
}
|
|
return newptr;
|
|
}
|
|
|
|
static char hex_digits[] = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f' };
|
|
_unroll_ void bytes_to_hex(const unsigned char *bytes, char **hex, size_t len)
|
|
{
|
|
if (!*hex)
|
|
*hex = xmalloc(len * 2 + 1);
|
|
for (size_t i = 0; i < len; ++i) {
|
|
(*hex)[i * 2] = hex_digits[(bytes[i] >> 4) & 0xF];
|
|
(*hex)[i * 2 + 1] = hex_digits[bytes[i] & 0xF];
|
|
}
|
|
(*hex)[len * 2] = '\0';
|
|
}
|
|
|
|
int hex_to_bytes(const char *hex, unsigned char **bytes)
|
|
{
|
|
size_t len = strlen(hex);
|
|
if (len % 2 != 0) {
|
|
if (!*bytes)
|
|
*bytes = xcalloc(1, 1);
|
|
**bytes = '\0';
|
|
return -EINVAL;
|
|
}
|
|
if (!*bytes)
|
|
*bytes = xmalloc(len / 2 + 1);
|
|
for (size_t i = 0; i < len / 2; ++i) {
|
|
if (sscanf(&hex[i * 2], "%2hhx", (unsigned char *)(*bytes + i)) != 1) {
|
|
fprintf(stderr, "%s\n", hex);
|
|
**bytes = '\0';
|
|
return -EINVAL;
|
|
}
|
|
}
|
|
(*bytes)[len / 2] = '\0';
|
|
return 0;
|
|
}
|
|
|
|
/* [min, max) */
|
|
unsigned long range_rand(unsigned long min, unsigned long max)
|
|
{
|
|
unsigned long base_random, range, remainder, bucket;
|
|
|
|
if (!RAND_bytes((unsigned char *)&base_random, sizeof(base_random)))
|
|
die("Could not generate random bytes.");
|
|
if (ULONG_MAX == base_random)
|
|
return range_rand(min, max);
|
|
range = max - min;
|
|
remainder = ULONG_MAX % range;
|
|
bucket = ULONG_MAX / range;
|
|
if (base_random < ULONG_MAX - remainder)
|
|
return min + base_random / bucket;
|
|
return range_rand(min, max);
|
|
}
|
|
|
|
void get_random_bytes(unsigned char *buf, size_t len)
|
|
{
|
|
if (!RAND_bytes(buf, len))
|
|
die("Could not generate random bytes.");
|
|
}
|
|
|
|
const char *bool_str(bool val)
|
|
{
|
|
return val ? "1" : "0";
|
|
}
|