mirror of
https://github.com/hanzoai/lastpass-mcp.git
synced 2026-11-14 21:30:44 +00:00
285 lines
7.9 KiB
C
285 lines
7.9 KiB
C
/*
|
|
* http posting routines
|
|
*
|
|
* 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 "http.h"
|
|
#include "log.h"
|
|
#include "util.h"
|
|
#include "version.h"
|
|
#include <stdarg.h>
|
|
#include <stdint.h>
|
|
#include <errno.h>
|
|
#include <string.h>
|
|
#include <signal.h>
|
|
#include <curl/curl.h>
|
|
|
|
struct mem_chunk {
|
|
char *ptr;
|
|
size_t len;
|
|
};
|
|
|
|
#ifndef TEST_BUILD
|
|
static bool interrupted = false;
|
|
static sig_t previous_handler = SIG_DFL;
|
|
static void interruption_detected(int signal)
|
|
{
|
|
UNUSED(signal);
|
|
interrupted = true;
|
|
}
|
|
static void set_interrupt_detect(void)
|
|
{
|
|
interrupted = false;
|
|
previous_handler = signal(SIGINT, interruption_detected);
|
|
}
|
|
static void unset_interrupt_detect(void)
|
|
{
|
|
interrupted = false;
|
|
signal(SIGINT, previous_handler);
|
|
}
|
|
static int check_interruption(void *p, double dltotal, double dlnow, double ultotal, double ulnow)
|
|
{
|
|
UNUSED(p);
|
|
UNUSED(dltotal);
|
|
UNUSED(dlnow);
|
|
UNUSED(ultotal);
|
|
UNUSED(ulnow);
|
|
return interrupted;
|
|
}
|
|
|
|
static size_t write_data(char *ptr, size_t size, size_t nmemb, void *data)
|
|
{
|
|
size_t len, new_len;
|
|
struct mem_chunk *mem = (struct mem_chunk *)data;
|
|
if ((nmemb >= MUL_NO_OVERFLOW || size >= MUL_NO_OVERFLOW) && nmemb > 0 && SIZE_MAX / nmemb < size) {
|
|
errno = ENOMEM;
|
|
return 0;
|
|
}
|
|
len = size * nmemb;
|
|
new_len = len + mem->len + 1;
|
|
if (new_len <= mem->len || new_len <= len || new_len < 1) {
|
|
errno = ENOMEM;
|
|
return 0;
|
|
}
|
|
|
|
mem->ptr = xrealloc(mem->ptr, new_len);
|
|
memcpy(mem->ptr + mem->len, ptr, len);
|
|
mem->len += len;
|
|
mem->ptr[mem->len] = '\0';
|
|
|
|
return len;
|
|
}
|
|
#endif
|
|
|
|
static
|
|
void vhttp_post_add_params(struct http_param_set *param_set, va_list args)
|
|
{
|
|
char **argv_ptr;
|
|
char *arg;
|
|
size_t count = 0;
|
|
|
|
if (!param_set->argv) {
|
|
param_set->n_alloced = 2;
|
|
param_set->argv = xcalloc(param_set->n_alloced, sizeof(char *));
|
|
}
|
|
argv_ptr = param_set->argv;
|
|
while (*argv_ptr) {
|
|
argv_ptr++;
|
|
count++;
|
|
}
|
|
|
|
while ((arg = va_arg(args, char *))) {
|
|
if (count == param_set->n_alloced - 1) {
|
|
param_set->n_alloced += 2;
|
|
param_set->argv = xreallocarray(param_set->argv,
|
|
param_set->n_alloced, sizeof(char *));
|
|
argv_ptr = ¶m_set->argv[count];
|
|
}
|
|
*argv_ptr++ = arg;
|
|
count++;
|
|
}
|
|
*argv_ptr = 0;
|
|
}
|
|
|
|
int http_init()
|
|
{
|
|
curl_global_cleanup();
|
|
return curl_global_init(CURL_GLOBAL_DEFAULT);
|
|
}
|
|
|
|
void http_post_add_params(struct http_param_set *param_set, ...)
|
|
{
|
|
va_list args;
|
|
va_start(args, param_set);
|
|
vhttp_post_add_params(param_set, args);
|
|
va_end(args);
|
|
}
|
|
|
|
char *http_post_lastpass(const char *page, const struct session *session, size_t *final_len, ...)
|
|
{
|
|
va_list args;
|
|
struct http_param_set params = {
|
|
.argv = NULL,
|
|
.n_alloced = 0
|
|
};
|
|
|
|
va_start(args, final_len);
|
|
vhttp_post_add_params(¶ms, args);
|
|
char *result = http_post_lastpass_param_set(page, session, final_len, ¶ms);
|
|
free(params.argv);
|
|
return result;
|
|
}
|
|
|
|
#ifndef TEST_BUILD
|
|
char *http_post_lastpass_v_noexit(const char *server, const char *page, const struct session *session, size_t *final_len, char **argv, int *curl_ret, long *http_code)
|
|
{
|
|
_cleanup_free_ char *url = NULL;
|
|
_cleanup_free_ char *postdata = NULL;
|
|
_cleanup_free_ char *cookie = NULL;
|
|
_cleanup_fclose_ FILE *logstream = NULL;
|
|
char *param, *encoded_param;
|
|
CURL *curl = NULL;
|
|
char separator;
|
|
size_t len, new_len;
|
|
int ret;
|
|
struct mem_chunk result;
|
|
const char *login_server;
|
|
|
|
/* if we have a session, use that server, otherwise use whatever was passed */
|
|
login_server = session ? session->server : server;
|
|
|
|
/* if nothing passed, use lastpass */
|
|
if (!login_server)
|
|
login_server = LASTPASS_SERVER;
|
|
|
|
xasprintf(&url, "https://%s/%s", login_server, page);
|
|
|
|
lpass_log(LOG_DEBUG, "Making request to %s\n", url);
|
|
|
|
curl = curl_easy_init();
|
|
if (!curl)
|
|
die("Could not init curl");
|
|
|
|
len = 0;
|
|
for (separator = '=', param = *argv;
|
|
param;
|
|
separator = (separator == '=') ? '&' : '=', param = *(++argv)) {
|
|
encoded_param = curl_easy_escape(curl, param, 0);
|
|
if (!encoded_param)
|
|
die("Could not escape %s with curl", param);
|
|
new_len = strlen(encoded_param) + 1 /* separator */;
|
|
postdata = xrealloc(postdata, len + new_len + 1 /* null */);
|
|
snprintf(postdata + len, new_len + 1, "%s%c", encoded_param, separator);
|
|
len += new_len;
|
|
curl_free(encoded_param);
|
|
}
|
|
if (len && postdata)
|
|
postdata[len - 1] = '\0';
|
|
|
|
memset(&result, 0, sizeof(result));
|
|
curl_easy_setopt(curl, CURLOPT_URL, url);
|
|
curl_easy_setopt(curl, CURLOPT_USERAGENT, LASTPASS_CLI_USERAGENT);
|
|
|
|
/* TODO: Make this optional via either env vars and/or an option for
|
|
* lpass -4 or lpass -6
|
|
*/
|
|
curl_easy_setopt(curl, CURLOPT_IPRESOLVE, CURL_IPRESOLVE_V4);
|
|
|
|
if (lpass_log_level() >= LOG_VERBOSE) {
|
|
logstream = lpass_log_open();
|
|
if (logstream) {
|
|
curl_easy_setopt(curl, CURLOPT_STDERR, logstream);
|
|
curl_easy_setopt(curl, CURLOPT_VERBOSE, 1);
|
|
}
|
|
}
|
|
#if defined(DO_NOT_ENABLE_ME_MITM_PROXY_FOR_DEBUGGING_ONLY)
|
|
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 0);
|
|
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 0);
|
|
curl_easy_setopt(curl, CURLOPT_PROXY, "http://localhost:8080");
|
|
#else
|
|
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYHOST, 2);
|
|
curl_easy_setopt(curl, CURLOPT_SSL_VERIFYPEER, 1);
|
|
#endif
|
|
curl_easy_setopt(curl, CURLOPT_WRITEFUNCTION, write_data);
|
|
curl_easy_setopt(curl, CURLOPT_WRITEDATA, &result);
|
|
curl_easy_setopt(curl, CURLOPT_FAILONERROR, 1);
|
|
curl_easy_setopt(curl, CURLOPT_PROGRESSFUNCTION, check_interruption);
|
|
curl_easy_setopt(curl, CURLOPT_NOPROGRESS, 0);
|
|
if (postdata)
|
|
curl_easy_setopt(curl, CURLOPT_POSTFIELDS, postdata);
|
|
if (session) {
|
|
xasprintf(&cookie, "PHPSESSID=%s", session->sessionid);
|
|
curl_easy_setopt(curl, CURLOPT_COOKIE, cookie);
|
|
}
|
|
|
|
set_interrupt_detect();
|
|
ret = curl_easy_perform(curl);
|
|
unset_interrupt_detect();
|
|
|
|
curl_easy_getinfo(curl, CURLINFO_RESPONSE_CODE, http_code);
|
|
curl_easy_cleanup(curl);
|
|
*curl_ret = ret;
|
|
|
|
if (ret != CURLE_OK) {
|
|
result.len = 0;
|
|
free(result.ptr);
|
|
result.ptr = NULL;
|
|
} else if (!result.ptr)
|
|
result.ptr = xstrdup("");
|
|
if (final_len)
|
|
*final_len = result.len;
|
|
|
|
return result.ptr;
|
|
}
|
|
#endif
|
|
|
|
char *http_post_lastpass_v(const char *server, const char *page, const struct session *session, size_t *final_len, char **argv)
|
|
{
|
|
char *result;
|
|
int ret;
|
|
long http_code;
|
|
|
|
result = http_post_lastpass_v_noexit(server, page, session, final_len,
|
|
argv, &ret, &http_code);
|
|
|
|
if (ret != CURLE_OK && ret != CURLE_ABORTED_BY_CALLBACK)
|
|
die("%s.", curl_easy_strerror(ret));
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
char *http_post_lastpass_param_set(const char *page, const struct session *session, size_t *final_len, struct http_param_set *param_set) {
|
|
return http_post_lastpass_v(NULL, page, session, final_len, param_set->argv);
|
|
}
|