mirror of
git://git.gnupg.org/gnupg.git
synced 2024-09-07 12:56:21 +02:00
![Jakub Jelen](/assets/img/avatar_default.png)
* kbx/kbx-client-util.c (datastream_thread): Initialize pointer * kbx/keybox-dump.c (_keybox_dump_cut_records): free blob * kbx/kbxserver.c (kbxd_start_command_handler): do not free passed ctrl * kbx/keyboxd.c (check_own_socket): free sockname -- Signed-off-by: Jakub Jelen <jjelen@redhat.com> GnuPG-bug-id: 5393
468 lines
12 KiB
C
468 lines
12 KiB
C
/* kbx-client-util.c - Utility functions to implement a keyboxd client
|
||
* Copyright (C) 2020 g10 Code GmbH
|
||
*
|
||
* This file is part of GnuPG.
|
||
*
|
||
* GnuPG 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 3 of the License, or
|
||
* (at your option) any later version.
|
||
*
|
||
* GnuPG 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, see <https://www.gnu.org/licenses/>.
|
||
* SPDX-License-Identifier: GPL-3.0+
|
||
*/
|
||
|
||
#include <config.h>
|
||
#include <stdio.h>
|
||
#include <stdlib.h>
|
||
#include <stddef.h>
|
||
#include <string.h>
|
||
#include <npth.h>
|
||
#include <assuan.h>
|
||
|
||
#include "../common/util.h"
|
||
#include "../common/membuf.h"
|
||
#include "../common/i18n.h"
|
||
#include "../common/asshelp.h"
|
||
#include "../common/exechelp.h"
|
||
#include "../common/sysutils.h"
|
||
#include "../common/host2net.h"
|
||
#include "kbx-client-util.h"
|
||
|
||
|
||
#define MAX_DATABLOB_SIZE (16*1024*1024)
|
||
|
||
|
||
|
||
/* This object is used to implement a client to the keyboxd. */
|
||
struct kbx_client_data_s
|
||
{
|
||
/* The used assuan context. */
|
||
assuan_context_t ctx;
|
||
|
||
/* A stream used to receive data. If this is NULL D-lines are used
|
||
* to receive the data. */
|
||
estream_t fp;
|
||
|
||
/* Condition variable to sync the datastream with the command. */
|
||
npth_mutex_t mutex;
|
||
npth_cond_t cond;
|
||
|
||
/* The data received from the keyboxd and an error code if there was
|
||
* a problem (in which case DATA is also set to NULL. This is only
|
||
* used if FP is not NULL. */
|
||
char *data;
|
||
size_t datalen;
|
||
gpg_error_t dataerr;
|
||
|
||
/* Helper variables in case D-lines are used (FP is NULL) */
|
||
char *dlinedata;
|
||
size_t dlinedatalen;
|
||
gpg_error_t dlineerr;
|
||
};
|
||
|
||
|
||
|
||
static void *datastream_thread (void *arg);
|
||
|
||
|
||
|
||
static void
|
||
lock_datastream (kbx_client_data_t kcd)
|
||
{
|
||
int rc = npth_mutex_lock (&kcd->mutex);
|
||
if (rc)
|
||
log_fatal ("%s: failed to acquire mutex: %s\n", __func__,
|
||
gpg_strerror (gpg_error_from_errno (rc)));
|
||
}
|
||
|
||
|
||
static void
|
||
unlock_datastream (kbx_client_data_t kcd)
|
||
{
|
||
int rc = npth_mutex_unlock (&kcd->mutex);
|
||
if (rc)
|
||
log_fatal ("%s: failed to release mutex: %s\n", __func__,
|
||
gpg_strerror (gpg_error_from_errno (rc)));
|
||
}
|
||
|
||
|
||
|
||
/* Setup the pipe used for receiving data from the keyboxd. Store the
|
||
* info on KCD. */
|
||
static gpg_error_t
|
||
prepare_data_pipe (kbx_client_data_t kcd)
|
||
{
|
||
gpg_error_t err;
|
||
int rc;
|
||
int inpipe[2];
|
||
estream_t infp;
|
||
npth_t thread;
|
||
npth_attr_t tattr;
|
||
|
||
kcd->fp = NULL;
|
||
kcd->data = NULL;
|
||
kcd->datalen = 0;
|
||
kcd->dataerr = 0;
|
||
|
||
err = gnupg_create_inbound_pipe (inpipe, &infp, 0);
|
||
if (err)
|
||
{
|
||
log_error ("error creating inbound pipe: %s\n", gpg_strerror (err));
|
||
return err; /* That should not happen. */
|
||
}
|
||
|
||
err = assuan_sendfd (kcd->ctx, INT2FD (inpipe[1]));
|
||
if (err)
|
||
{
|
||
log_error ("sending sending fd %d to keyboxd: %s <%s>\n",
|
||
inpipe[1], gpg_strerror (err), gpg_strsource (err));
|
||
es_fclose (infp);
|
||
gnupg_close_pipe (inpipe[1]);
|
||
return 0; /* Server may not support fd-passing. */
|
||
}
|
||
|
||
err = assuan_transact (kcd->ctx, "OUTPUT FD",
|
||
NULL, NULL, NULL, NULL, NULL, NULL);
|
||
if (err)
|
||
{
|
||
log_info ("keyboxd does not accept our fd: %s <%s>\n",
|
||
gpg_strerror (err), gpg_strsource (err));
|
||
es_fclose (infp);
|
||
return 0;
|
||
}
|
||
|
||
kcd->fp = infp;
|
||
|
||
|
||
rc = npth_attr_init (&tattr);
|
||
if (rc)
|
||
{
|
||
err = gpg_error_from_errno (rc);
|
||
log_error ("error preparing thread for keyboxd: %s\n",gpg_strerror (err));
|
||
es_fclose (infp);
|
||
kcd->fp = NULL;
|
||
return err;
|
||
}
|
||
npth_attr_setdetachstate (&tattr, NPTH_CREATE_DETACHED);
|
||
rc = npth_create (&thread, &tattr, datastream_thread, kcd);
|
||
if (rc)
|
||
{
|
||
err = gpg_error_from_errno (rc);
|
||
log_error ("error spawning thread for keyboxd: %s\n", gpg_strerror (err));
|
||
npth_attr_destroy (&tattr);
|
||
es_fclose (infp);
|
||
kcd->fp = NULL;
|
||
return err;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
/* The thread used to read from the data stream. This is running as
|
||
* long as the connection and its datastream exists. */
|
||
static void *
|
||
datastream_thread (void *arg)
|
||
{
|
||
kbx_client_data_t kcd = arg;
|
||
gpg_error_t err;
|
||
int rc;
|
||
unsigned char lenbuf[4];
|
||
size_t nread, datalen;
|
||
char *data = NULL;
|
||
char *tmpdata;
|
||
|
||
/* log_debug ("%s: started\n", __func__); */
|
||
while (kcd->fp)
|
||
{
|
||
/* log_debug ("%s: waiting ...\n", __func__); */
|
||
if (es_read (kcd->fp, lenbuf, 4, &nread))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
if (gpg_err_code (err) == GPG_ERR_EAGAIN)
|
||
continue;
|
||
log_error ("error reading data length from keyboxd: %s\n",
|
||
gpg_strerror (err));
|
||
gnupg_sleep (1);
|
||
continue;
|
||
}
|
||
if (nread != 4)
|
||
{
|
||
err = gpg_error (GPG_ERR_EIO);
|
||
log_error ("error reading data length from keyboxd: %s\n",
|
||
"short read");
|
||
continue;
|
||
}
|
||
|
||
datalen = buf32_to_size_t (lenbuf);
|
||
/* log_debug ("keyboxd announced %zu bytes\n", datalen); */
|
||
if (!datalen)
|
||
{
|
||
log_info ("ignoring empty blob received from keyboxd\n");
|
||
continue;
|
||
}
|
||
|
||
if (datalen > MAX_DATABLOB_SIZE)
|
||
{
|
||
err = gpg_error (GPG_ERR_TOO_LARGE);
|
||
/* Drop connection or what shall we do? */
|
||
}
|
||
else if (!(data = xtrymalloc (datalen+1)))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (es_read (kcd->fp, data, datalen, &nread))
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
}
|
||
else if (datalen != nread)
|
||
{
|
||
err = gpg_error (GPG_ERR_TOO_SHORT);
|
||
}
|
||
else
|
||
err = 0;
|
||
|
||
if (err)
|
||
{
|
||
log_error ("error reading data from keyboxd: %s <%s>\n",
|
||
gpg_strerror (err), gpg_strsource (err));
|
||
xfree (data);
|
||
data = NULL;
|
||
datalen = 0;
|
||
}
|
||
else
|
||
{
|
||
/* log_debug ("parsing datastream succeeded\n"); */
|
||
}
|
||
|
||
/* Thread-safe assignment to the result var: */
|
||
tmpdata = kcd->data;
|
||
kcd->data = data;
|
||
kcd->datalen = datalen;
|
||
kcd->dataerr = err;
|
||
xfree (tmpdata);
|
||
data = NULL;
|
||
|
||
/* Tell the main thread. */
|
||
lock_datastream (kcd);
|
||
rc = npth_cond_signal (&kcd->cond);
|
||
if (rc)
|
||
{
|
||
err = gpg_error_from_errno (rc);
|
||
log_error ("%s: signaling condition failed: %s\n",
|
||
__func__, gpg_strerror (err));
|
||
}
|
||
unlock_datastream (kcd);
|
||
}
|
||
/* log_debug ("%s: finished\n", __func__); */
|
||
|
||
return NULL;
|
||
}
|
||
|
||
|
||
|
||
/* Create a new keyboxd client data object and return it at R_KCD.
|
||
* CTX is the assuan context to be used for connecting the keyboxd.
|
||
* If dlines is set, communication is done without fd passing via
|
||
* D-lines. */
|
||
gpg_error_t
|
||
kbx_client_data_new (kbx_client_data_t *r_kcd, assuan_context_t ctx,
|
||
int dlines)
|
||
{
|
||
kbx_client_data_t kcd;
|
||
int rc;
|
||
gpg_error_t err;
|
||
|
||
kcd = xtrycalloc (1, sizeof *kcd);
|
||
if (!kcd)
|
||
return gpg_error_from_syserror ();
|
||
|
||
kcd->ctx = ctx;
|
||
|
||
if (dlines)
|
||
goto leave;
|
||
|
||
rc = npth_mutex_init (&kcd->mutex, NULL);
|
||
if (rc)
|
||
{
|
||
err = gpg_error_from_errno (rc);
|
||
log_error ("error initializing mutex: %s\n", gpg_strerror (err));
|
||
xfree (kcd);
|
||
return err;
|
||
}
|
||
rc = npth_cond_init (&kcd->cond, NULL);
|
||
if (rc)
|
||
{
|
||
err = gpg_error_from_errno (rc);
|
||
log_error ("error initializing condition: %s\n", gpg_strerror (err));
|
||
npth_mutex_destroy (&kcd->mutex);
|
||
xfree (kcd);
|
||
return err;
|
||
}
|
||
|
||
err = prepare_data_pipe (kcd);
|
||
if (err)
|
||
{
|
||
npth_cond_destroy (&kcd->cond);
|
||
npth_mutex_destroy (&kcd->mutex);
|
||
xfree (kcd);
|
||
return err;
|
||
}
|
||
|
||
leave:
|
||
*r_kcd = kcd;
|
||
return 0;
|
||
}
|
||
|
||
|
||
void
|
||
kbx_client_data_release (kbx_client_data_t kcd)
|
||
{
|
||
estream_t fp;
|
||
|
||
if (!kcd)
|
||
return;
|
||
fp = kcd->fp;
|
||
kcd->fp = NULL;
|
||
es_fclose (fp); /* That close should let the thread run into an error. */
|
||
/* FIXME: Make thread killing explicit. Otherwise we run in a
|
||
* log_fatal due to the destroyed mutex. */
|
||
npth_cond_destroy (&kcd->cond);
|
||
npth_mutex_destroy (&kcd->mutex);
|
||
xfree (kcd);
|
||
}
|
||
|
||
|
||
/* Send a simple Assuan command to the server. */
|
||
gpg_error_t
|
||
kbx_client_data_simple (kbx_client_data_t kcd, const char *command)
|
||
{
|
||
/* log_debug ("%s: sending command '%s'\n", __func__, command); */
|
||
return assuan_transact (kcd->ctx, command,
|
||
NULL, NULL, NULL, NULL, NULL, NULL);
|
||
}
|
||
|
||
|
||
/* Send the COMMAND down to the keyboxd associated with KCD.
|
||
* STATUS_CB and STATUS_CB_VALUE are the usual status callback as used
|
||
* by assuan_transact. After this function has returned success
|
||
* kbx_client_data_wait needs to be called to actually return the
|
||
* data. */
|
||
gpg_error_t
|
||
kbx_client_data_cmd (kbx_client_data_t kcd, const char *command,
|
||
gpg_error_t (*status_cb)(void *opaque, const char *line),
|
||
void *status_cb_value)
|
||
{
|
||
gpg_error_t err;
|
||
|
||
xfree (kcd->dlinedata);
|
||
kcd->dlinedata = NULL;
|
||
kcd->dlinedatalen = 0;
|
||
kcd->dlineerr = 0;
|
||
|
||
if (kcd->fp)
|
||
{
|
||
/* log_debug ("%s: sending command '%s'\n", __func__, command); */
|
||
err = assuan_transact (kcd->ctx, command,
|
||
NULL, NULL,
|
||
NULL, NULL,
|
||
status_cb, status_cb_value);
|
||
if (err)
|
||
{
|
||
if (gpg_err_code (err) != GPG_ERR_NOT_FOUND
|
||
&& gpg_err_code (err) != GPG_ERR_NOTHING_FOUND)
|
||
log_debug ("%s: finished command with error: %s\n",
|
||
__func__, gpg_strerror (err));
|
||
/* Fixme: On unexpected errors we need a way to cancel the
|
||
* data stream. Probably it will be best to close and
|
||
* reopen it. */
|
||
}
|
||
}
|
||
else /* Slower D-line version if fd-passing is not available. */
|
||
{
|
||
membuf_t mb;
|
||
size_t len;
|
||
|
||
/* log_debug ("%s: sending command '%s' (no fd-passing)\n", */
|
||
/* __func__, command); */
|
||
init_membuf (&mb, 8192);
|
||
err = assuan_transact (kcd->ctx, command,
|
||
put_membuf_cb, &mb,
|
||
NULL, NULL,
|
||
status_cb, status_cb_value);
|
||
if (err)
|
||
{
|
||
if (gpg_err_code (err) != GPG_ERR_NOT_FOUND
|
||
&& gpg_err_code (err) != GPG_ERR_NOTHING_FOUND)
|
||
log_debug ("%s: finished command with error: %s\n",
|
||
__func__, gpg_strerror (err));
|
||
xfree (get_membuf (&mb, &len));
|
||
kcd->dlineerr = err;
|
||
goto leave;
|
||
}
|
||
|
||
kcd->dlinedata = get_membuf (&mb, &kcd->dlinedatalen);
|
||
if (!kcd->dlinedata)
|
||
{
|
||
err = gpg_error_from_syserror ();
|
||
goto leave;
|
||
}
|
||
}
|
||
|
||
leave:
|
||
return err;
|
||
}
|
||
|
||
|
||
|
||
/* Wait for the data from the server and on success return it at
|
||
* (R_DATA, R_DATALEN). */
|
||
gpg_error_t
|
||
kbx_client_data_wait (kbx_client_data_t kcd, char **r_data, size_t *r_datalen)
|
||
{
|
||
gpg_error_t err = 0;
|
||
int rc;
|
||
|
||
*r_data = NULL;
|
||
*r_datalen = 0;
|
||
if (kcd->fp)
|
||
{
|
||
lock_datastream (kcd);
|
||
if (!kcd->data && !kcd->dataerr)
|
||
{
|
||
/* log_debug ("%s: waiting on datastream_cond ...\n", __func__); */
|
||
rc = npth_cond_wait (&kcd->cond, &kcd->mutex);
|
||
if (rc)
|
||
{
|
||
err = gpg_error_from_errno (rc);
|
||
log_error ("%s: waiting on condition failed: %s\n",
|
||
__func__, gpg_strerror (err));
|
||
}
|
||
/* else */
|
||
/* log_debug ("%s: waiting on datastream.cond done\n", __func__); */
|
||
}
|
||
*r_data = kcd->data;
|
||
kcd->data = NULL;
|
||
*r_datalen = kcd->datalen;
|
||
err = err? err : kcd->dataerr;
|
||
|
||
unlock_datastream (kcd);
|
||
}
|
||
else
|
||
{
|
||
*r_data = kcd->dlinedata;
|
||
kcd->dlinedata = NULL;
|
||
*r_datalen = kcd->dlinedatalen;
|
||
err = kcd->dlineerr;
|
||
}
|
||
|
||
return err;
|
||
}
|