To get this branch, use:
bzr branch
http://bzr.recompile.se/loggerhead/mandos/trunk
« back to all changes in this revision
Viewing changes to plugins.d/mandos-client.c
- browse files at revision 238
- compare with another revision
- download diff
- download tarball
- view history from revision 238
- Committer: Teddy Hogeborn
- Date: 2008-12-10 01:26:02 UTC
- mfrom: (237.1.2 mandos)
- Revision ID: teddy@fukt.bsnet.se-20081210012602-vhz3h75xkj24t340
First version of a somewhat complete D-Bus server interface. Also
change user/group name to "_mandos".
* debian/mandos.postinst: Rename old "mandos" user and group to
"_mandos"; create "_mandos" user and group
if none exist.
* debian/mandos-client.postinst: - '' -
* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
group name.
* mandos (_datetime_to_dbus_struct): New; was previously local.
(Client.started): Renamed to "last_started". All users changed.
(Client.started): New; boolean.
(Client.dbus_object_path): New.
(Client.check_command): Renamed to "checker_command". All users
changed.
(Client.__init__): Set and use "self.dbus_object_path". Set
"self.started".
(Client.start): Update "self.started". Emit "self.PropertyChanged"
signals for both "started" and "last_started".
(Client.stop): Update "self.started". Emit "self.PropertyChanged"
signal for "started".
(Client.checker_callback): Take additional "command" argument. All
callers changed. Emit
"self.PropertyChanged" signal.
(Client.bump_timeout): Emit "self.PropertyChanged" signal for
"last_checked_ok".
(Client.start_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.stop_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.still_valid): Bug fix: use "getattr(self, started, False)"
instead of "self.started" in case this client
object is so new that the "started" attribute
has not been created yet.
(Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
Client.GetCreated, Client.GetFingerprint, Client.GetHost,
Client.GetInterval, Client.GetName, Client.GetStarted,
Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
Removed; all callers changed.
(Client.CheckerCompleted): Add "condition" and "command" arguments.
All callers changed.
(Client.GetAllProperties, Client.PropertyChanged): New.
(Client.StillValid): Renamed to "IsStillValid".
(Client.StartChecker): Changed to its own function to avoid the
return value from "Client.start_checker()".
(Client.Stop): Changed to its own function to avoid the return value
from "Client.stop()".
(main): Try "_mandos" before "mandos" as user and group name.
Removed inner function "remove_from_clients". New inner
class "MandosServer".
change user/group name to "_mandos".
* debian/mandos.postinst: Rename old "mandos" user and group to
"_mandos"; create "_mandos" user and group
if none exist.
* debian/mandos-client.postinst: - '' -
* initramfs-tools-hook: Try "_mandos" before "mandos" as user and
group name.
* mandos (_datetime_to_dbus_struct): New; was previously local.
(Client.started): Renamed to "last_started". All users changed.
(Client.started): New; boolean.
(Client.dbus_object_path): New.
(Client.check_command): Renamed to "checker_command". All users
changed.
(Client.__init__): Set and use "self.dbus_object_path". Set
"self.started".
(Client.start): Update "self.started". Emit "self.PropertyChanged"
signals for both "started" and "last_started".
(Client.stop): Update "self.started". Emit "self.PropertyChanged"
signal for "started".
(Client.checker_callback): Take additional "command" argument. All
callers changed. Emit
"self.PropertyChanged" signal.
(Client.bump_timeout): Emit "self.PropertyChanged" signal for
"last_checked_ok".
(Client.start_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.stop_checker): Emit "self.PropertyChanged" signal for
"checker_running".
(Client.still_valid): Bug fix: use "getattr(self, started, False)"
instead of "self.started" in case this client
object is so new that the "started" attribute
has not been created yet.
(Client.IntervalChanged, Client.CheckerIsRunning, Client.GetChecker,
Client.GetCreated, Client.GetFingerprint, Client.GetHost,
Client.GetInterval, Client.GetName, Client.GetStarted,
Client.GetTimeout, Client.StateChanged, Client.TimeoutChanged):
Removed; all callers changed.
(Client.CheckerCompleted): Add "condition" and "command" arguments.
All callers changed.
(Client.GetAllProperties, Client.PropertyChanged): New.
(Client.StillValid): Renamed to "IsStillValid".
(Client.StartChecker): Changed to its own function to avoid the
return value from "Client.start_checker()".
(Client.Stop): Changed to its own function to avoid the return value
from "Client.stop()".
(main): Try "_mandos" before "mandos" as user and group name.
Removed inner function "remove_from_clients". New inner
class "MandosServer".
- files added:
- debian/mandos-client.config
- files removed:
- DBUS-API
- debian/source
- network-hooks.d
- files modified:
- .bzrignore
added
removed
plugins.d/mandos-client.c
1
1
/* -*- coding: utf-8 -*- */
2
2
/*
3
* Mandos-client - get and decrypt data from a Mandos server
3
* Mandos client - get and decrypt data from a Mandos server
4
4
*
5
5
* This program is partly derived from an example program for an Avahi
6
6
* service browser, downloaded from
9
9
* "browse_callback", and parts of "main".
10
10
*
11
11
* Everything else is
12
* Copyright © 2008-2012 Teddy Hogeborn
13
* Copyright © 2008-2012 Björn Påhlsson
12
* Copyright © 2008 Teddy Hogeborn
13
* Copyright © 2008 Björn Påhlsson
14
14
*
15
15
* This program is free software: you can redistribute it and/or
16
16
* modify it under the terms of the GNU General Public License as
26
26
* along with this program. If not, see
27
27
* <http://www.gnu.org/licenses/>.
28
28
*
29
* Contact the authors at <mandos@recompile.se>.
29
* Contact the authors at <mandos@fukt.bsnet.se>.
30
30
*/
31
31
32
32
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
34
33
#define _LARGEFILE_SOURCE
35
#endif
36
#ifndef _FILE_OFFSET_BITS
37
34
#define _FILE_OFFSET_BITS 64
38
#endif
39
35
40
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
41
37
42
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
43
stdout, ferror(), remove() */
44
#include <stdint.h> /* uint16_t, uint32_t, intptr_t */
39
stdout, ferror() */
40
#include <stdint.h> /* uint16_t, uint32_t */
45
41
#include <stddef.h> /* NULL, size_t, ssize_t */
46
#include <stdlib.h> /* free(), EXIT_SUCCESS, srand(),
47
strtof(), abort() */
48
#include <stdbool.h> /* bool, false, true */
42
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
43
srand() */
44
#include <stdbool.h> /* bool, true */
49
45
#include <string.h> /* memset(), strcmp(), strlen(),
50
46
strerror(), asprintf(), strcpy() */
51
#include <sys/ioctl.h> /* ioctl */
47
#include <sys/ioctl.h> /* ioctl */
52
48
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
53
49
sockaddr_in6, PF_INET6,
54
SOCK_STREAM, uid_t, gid_t, open(),
55
opendir(), DIR */
56
#include <sys/stat.h> /* open(), S_ISREG */
50
SOCK_STREAM, INET6_ADDRSTRLEN,
51
uid_t, gid_t, open(), opendir(), DIR */
52
#include <sys/stat.h> /* open() */
57
53
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
58
inet_pton(), connect() */
54
struct in6_addr, inet_pton(),
55
connect() */
59
56
#include <fcntl.h> /* open() */
60
#include <dirent.h> /* opendir(), struct dirent, readdir()
61
*/
62
#include <inttypes.h> /* PRIu16, PRIdMAX, intmax_t,
63
strtoimax() */
64
#include <errno.h> /* perror(), errno,
65
program_invocation_short_name */
66
#include <time.h> /* nanosleep(), time(), sleep() */
57
#include <dirent.h> /* opendir(), struct dirent, readdir() */
58
#include <inttypes.h> /* PRIu16 */
59
#include <assert.h> /* assert() */
60
#include <errno.h> /* perror(), errno */
61
#include <time.h> /* time() */
67
62
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
68
63
SIOCSIFFLAGS, if_indextoname(),
69
64
if_nametoindex(), IF_NAMESIZE */
70
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
71
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
72
*/
65
#include <netinet/in.h>
73
66
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
getuid(), getgid(), seteuid(),
75
setgid(), pause(), _exit() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
77
#include <iso646.h> /* not, or, and */
67
getuid(), getgid(), setuid(),
68
setgid() */
69
#include <arpa/inet.h> /* inet_pton(), htons */
70
#include <iso646.h> /* not, and */
78
71
#include <argp.h> /* struct argp_option, error_t, struct
79
72
argp_state, struct argp,
80
73
argp_parse(), ARGP_KEY_ARG,
81
74
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
82
#include <signal.h> /* sigemptyset(), sigaddset(),
83
sigaction(), SIGTERM, sig_atomic_t,
84
raise() */
85
#include <sysexits.h> /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
86
EX_NOHOST, EX_IOERR, EX_PROTOCOL */
87
#include <sys/wait.h> /* waitpid(), WIFEXITED(),
88
WEXITSTATUS(), WTERMSIG() */
89
#include <grp.h> /* setgroups() */
90
#include <argz.h> /* argz_add_sep(), argz_next(),
91
argz_delete(), argz_append(),
92
argz_stringify(), argz_add(),
93
argz_count() */
94
95
#ifdef __linux__
96
#include <sys/klog.h> /* klogctl() */
97
#endif /* __linux__ */
98
75
99
76
/* Avahi */
100
77
/* All Avahi types, constants and functions
113
90
gnutls_*
114
91
init_gnutls_session(),
115
92
GNUTLS_* */
116
#include <gnutls/openpgp.h>
117
/* gnutls_certificate_set_openpgp_key_file(),
118
GNUTLS_OPENPGP_FMT_BASE64 */
93
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
94
GNUTLS_OPENPGP_FMT_BASE64 */
119
95
120
96
/* GPGME */
121
97
#include <gpgme.h> /* All GPGME types, constants and
129
105
#define PATHDIR "/conf/conf.d/mandos"
130
106
#define SECKEY "seckey.txt"
131
107
#define PUBKEY "pubkey.txt"
132
#define HOOKDIR "/lib/mandos/network-hooks.d"
133
108
134
109
bool debug = false;
135
110
static const char mandos_protocol_version[] = "1";
136
111
const char *argp_program_version = "mandos-client " VERSION;
137
const char *argp_program_bug_address = "<mandos@recompile.se>";
138
static const char sys_class_net[] = "/sys/class/net";
139
char *connect_to = NULL;
140
const char *hookdir = HOOKDIR;
141
uid_t uid = 65534;
142
gid_t gid = 65534;
143
144
/* Doubly linked list that need to be circularly linked when used */
145
typedef struct server{
146
const char *ip;
147
in_port_t port;
148
AvahiIfIndex if_index;
149
int af;
150
struct timespec last_seen;
151
struct server *next;
152
struct server *prev;
153
} server;
112
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
154
113
155
114
/* Used for passing in values through the Avahi callback functions */
156
115
typedef struct {
116
AvahiSimplePoll *simple_poll;
157
117
AvahiServer *server;
158
118
gnutls_certificate_credentials_t cred;
159
119
unsigned int dh_bits;
160
120
gnutls_dh_params_t dh_params;
161
121
const char *priority;
162
122
gpgme_ctx_t ctx;
163
server *current_server;
164
char *interfaces;
165
size_t interfaces_size;
166
123
} mandos_context;
167
124
168
/* global so signal handler can reach it*/
169
AvahiSimplePoll *simple_poll;
170
171
sig_atomic_t quit_now = 0;
172
int signal_received = 0;
173
174
/* Function to use when printing errors */
175
void perror_plus(const char *print_text){
176
int e = errno;
177
fprintf(stderr, "Mandos plugin %s: ",
178
program_invocation_short_name);
179
errno = e;
180
perror(print_text);
181
}
182
183
__attribute__((format (gnu_printf, 2, 3)))
184
int fprintf_plus(FILE *stream, const char *format, ...){
185
va_list ap;
186
va_start (ap, format);
187
188
TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
189
program_invocation_short_name));
190
return TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
191
}
192
193
125
/*
194
* Make additional room in "buffer" for at least BUFFER_SIZE more
195
* bytes. "buffer_capacity" is how much is currently allocated,
126
* Make room in "buffer" for at least BUFFER_SIZE additional bytes.
127
* "buffer_capacity" is how much is currently allocated,
196
128
* "buffer_length" is how much is already used.
197
129
*/
198
size_t incbuffer(char **buffer, size_t buffer_length,
199
size_t buffer_capacity){
200
if(buffer_length + BUFFER_SIZE > buffer_capacity){
130
size_t adjustbuffer(char **buffer, size_t buffer_length,
131
size_t buffer_capacity){
132
if (buffer_length + BUFFER_SIZE > buffer_capacity){
201
133
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
202
if(buffer == NULL){
134
if (buffer == NULL){
203
135
return 0;
204
136
}
205
137
buffer_capacity += BUFFER_SIZE;
207
139
return buffer_capacity;
208
140
}
209
141
210
/* Add server to set of servers to retry periodically */
211
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
212
int af, server **current_server){
213
int ret;
214
server *new_server = malloc(sizeof(server));
215
if(new_server == NULL){
216
perror_plus("malloc");
217
return false;
218
}
219
*new_server = (server){ .ip = strdup(ip),
220
.port = port,
221
.if_index = if_index,
222
.af = af };
223
if(new_server->ip == NULL){
224
perror_plus("strdup");
225
return false;
226
}
227
/* Special case of first server */
228
if(*current_server == NULL){
229
new_server->next = new_server;
230
new_server->prev = new_server;
231
*current_server = new_server;
232
/* Place the new server last in the list */
233
} else {
234
new_server->next = *current_server;
235
new_server->prev = (*current_server)->prev;
236
new_server->prev->next = new_server;
237
(*current_server)->prev = new_server;
238
}
239
ret = clock_gettime(CLOCK_MONOTONIC, &(*current_server)->last_seen);
240
if(ret == -1){
241
perror_plus("clock_gettime");
242
return false;
243
}
244
return true;
245
}
246
247
142
/*
248
143
* Initialize GPGME.
249
144
*/
250
static bool init_gpgme(const char *seckey, const char *pubkey,
251
const char *tempdir, mandos_context *mc){
145
static bool init_gpgme(mandos_context *mc, const char *seckey,
146
const char *pubkey, const char *tempdir){
147
int ret;
252
148
gpgme_error_t rc;
253
149
gpgme_engine_info_t engine_info;
254
150
151
255
152
/*
256
* Helper function to insert pub and seckey to the engine keyring.
153
* Helper function to insert pub and seckey to the enigne keyring.
257
154
*/
258
155
bool import_key(const char *filename){
259
int ret;
260
156
int fd;
261
157
gpgme_data_t pgp_data;
262
158
263
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
159
fd = TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
264
160
if(fd == -1){
265
perror_plus("open");
161
perror("open");
266
162
return false;
267
163
}
268
164
269
165
rc = gpgme_data_new_from_fd(&pgp_data, fd);
270
if(rc != GPG_ERR_NO_ERROR){
271
fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
272
gpgme_strsource(rc), gpgme_strerror(rc));
166
if (rc != GPG_ERR_NO_ERROR){
167
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
168
gpgme_strsource(rc), gpgme_strerror(rc));
273
169
return false;
274
170
}
275
171
276
172
rc = gpgme_op_import(mc->ctx, pgp_data);
277
if(rc != GPG_ERR_NO_ERROR){
278
fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
279
gpgme_strsource(rc), gpgme_strerror(rc));
173
if (rc != GPG_ERR_NO_ERROR){
174
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
175
gpgme_strsource(rc), gpgme_strerror(rc));
280
176
return false;
281
177
}
282
178
283
ret = (int)TEMP_FAILURE_RETRY(close(fd));
179
ret = TEMP_FAILURE_RETRY(close(fd));
284
180
if(ret == -1){
285
perror_plus("close");
181
perror("close");
286
182
}
287
183
gpgme_data_release(pgp_data);
288
184
return true;
289
185
}
290
186
291
if(debug){
292
fprintf_plus(stderr, "Initializing GPGME\n");
187
if (debug){
188
fprintf(stderr, "Initialize gpgme\n");
293
189
}
294
190
295
191
/* Init GPGME */
296
192
gpgme_check_version(NULL);
297
193
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
298
if(rc != GPG_ERR_NO_ERROR){
299
fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
300
gpgme_strsource(rc), gpgme_strerror(rc));
194
if (rc != GPG_ERR_NO_ERROR){
195
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
196
gpgme_strsource(rc), gpgme_strerror(rc));
301
197
return false;
302
198
}
303
199
304
/* Set GPGME home directory for the OpenPGP engine only */
305
rc = gpgme_get_engine_info(&engine_info);
306
if(rc != GPG_ERR_NO_ERROR){
307
fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
308
gpgme_strsource(rc), gpgme_strerror(rc));
200
/* Set GPGME home directory for the OpenPGP engine only */
201
rc = gpgme_get_engine_info (&engine_info);
202
if (rc != GPG_ERR_NO_ERROR){
203
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
204
gpgme_strsource(rc), gpgme_strerror(rc));
309
205
return false;
310
206
}
311
207
while(engine_info != NULL){
317
213
engine_info = engine_info->next;
318
214
}
319
215
if(engine_info == NULL){
320
fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
321
tempdir);
216
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
322
217
return false;
323
218
}
324
219
325
220
/* Create new GPGME "context" */
326
221
rc = gpgme_new(&(mc->ctx));
327
if(rc != GPG_ERR_NO_ERROR){
328
fprintf_plus(stderr, "Mandos plugin mandos-client: "
329
"bad gpgme_new: %s: %s\n", gpgme_strsource(rc),
330
gpgme_strerror(rc));
331
return false;
332
}
333
334
if(not import_key(pubkey) or not import_key(seckey)){
335
return false;
336
}
337
338
return true;
222
if (rc != GPG_ERR_NO_ERROR){
223
fprintf(stderr, "bad gpgme_new: %s: %s\n",
224
gpgme_strsource(rc), gpgme_strerror(rc));
225
return false;
226
}
227
228
if (not import_key(pubkey) or not import_key(seckey)){
229
return false;
230
}
231
232
return true;
339
233
}
340
234
341
235
/*
342
236
* Decrypt OpenPGP data.
343
237
* Returns -1 on error
344
238
*/
345
static ssize_t pgp_packet_decrypt(const char *cryptotext,
346
size_t crypto_size,
347
char **plaintext,
348
mandos_context *mc){
239
static ssize_t pgp_packet_decrypt (const mandos_context *mc,
240
const char *cryptotext,
241
size_t crypto_size,
242
char **plaintext){
349
243
gpgme_data_t dh_crypto, dh_plain;
350
244
gpgme_error_t rc;
351
245
ssize_t ret;
352
246
size_t plaintext_capacity = 0;
353
247
ssize_t plaintext_length = 0;
354
248
355
if(debug){
356
fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
249
if (debug){
250
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
357
251
}
358
252
359
253
/* Create new GPGME data buffer from memory cryptotext */
360
254
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
361
255
0);
362
if(rc != GPG_ERR_NO_ERROR){
363
fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
364
gpgme_strsource(rc), gpgme_strerror(rc));
256
if (rc != GPG_ERR_NO_ERROR){
257
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
258
gpgme_strsource(rc), gpgme_strerror(rc));
365
259
return -1;
366
260
}
367
261
368
262
/* Create new empty GPGME data buffer for the plaintext */
369
263
rc = gpgme_data_new(&dh_plain);
370
if(rc != GPG_ERR_NO_ERROR){
371
fprintf_plus(stderr, "Mandos plugin mandos-client: "
372
"bad gpgme_data_new: %s: %s\n",
373
gpgme_strsource(rc), gpgme_strerror(rc));
264
if (rc != GPG_ERR_NO_ERROR){
265
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
266
gpgme_strsource(rc), gpgme_strerror(rc));
374
267
gpgme_data_release(dh_crypto);
375
268
return -1;
376
269
}
378
271
/* Decrypt data from the cryptotext data buffer to the plaintext
379
272
data buffer */
380
273
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
381
if(rc != GPG_ERR_NO_ERROR){
382
fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
383
gpgme_strsource(rc), gpgme_strerror(rc));
274
if (rc != GPG_ERR_NO_ERROR){
275
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
276
gpgme_strsource(rc), gpgme_strerror(rc));
384
277
plaintext_length = -1;
385
if(debug){
278
if (debug){
386
279
gpgme_decrypt_result_t result;
387
280
result = gpgme_op_decrypt_result(mc->ctx);
388
if(result == NULL){
389
fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
281
if (result == NULL){
282
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
390
283
} else {
391
fprintf_plus(stderr, "Unsupported algorithm: %s\n",
392
result->unsupported_algorithm);
393
fprintf_plus(stderr, "Wrong key usage: %u\n",
394
result->wrong_key_usage);
284
fprintf(stderr, "Unsupported algorithm: %s\n",
285
result->unsupported_algorithm);
286
fprintf(stderr, "Wrong key usage: %u\n",
287
result->wrong_key_usage);
395
288
if(result->file_name != NULL){
396
fprintf_plus(stderr, "File name: %s\n", result->file_name);
289
fprintf(stderr, "File name: %s\n", result->file_name);
397
290
}
398
291
gpgme_recipient_t recipient;
399
292
recipient = result->recipients;
400
while(recipient != NULL){
401
fprintf_plus(stderr, "Public key algorithm: %s\n",
402
gpgme_pubkey_algo_name
403
(recipient->pubkey_algo));
404
fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
405
fprintf_plus(stderr, "Secret key available: %s\n",
406
recipient->status == GPG_ERR_NO_SECKEY
407
? "No" : "Yes");
408
recipient = recipient->next;
293
if(recipient){
294
while(recipient != NULL){
295
fprintf(stderr, "Public key algorithm: %s\n",
296
gpgme_pubkey_algo_name(recipient->pubkey_algo));
297
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
298
fprintf(stderr, "Secret key available: %s\n",
299
recipient->status == GPG_ERR_NO_SECKEY
300
? "No" : "Yes");
301
recipient = recipient->next;
302
}
409
303
}
410
304
}
411
305
}
413
307
}
414
308
415
309
if(debug){
416
fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
310
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
417
311
}
418
312
419
313
/* Seek back to the beginning of the GPGME plaintext data buffer */
420
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
421
perror_plus("gpgme_data_seek");
314
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
315
perror("gpgme_data_seek");
422
316
plaintext_length = -1;
423
317
goto decrypt_end;
424
318
}
425
319
426
320
*plaintext = NULL;
427
321
while(true){
428
plaintext_capacity = incbuffer(plaintext,
429
(size_t)plaintext_length,
430
plaintext_capacity);
431
if(plaintext_capacity == 0){
432
perror_plus("incbuffer");
433
plaintext_length = -1;
434
goto decrypt_end;
322
plaintext_capacity = adjustbuffer(plaintext,
323
(size_t)plaintext_length,
324
plaintext_capacity);
325
if (plaintext_capacity == 0){
326
perror("adjustbuffer");
327
plaintext_length = -1;
328
goto decrypt_end;
435
329
}
436
330
437
331
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
438
332
BUFFER_SIZE);
439
333
/* Print the data, if any */
440
if(ret == 0){
334
if (ret == 0){
441
335
/* EOF */
442
336
break;
443
337
}
444
338
if(ret < 0){
445
perror_plus("gpgme_data_read");
339
perror("gpgme_data_read");
446
340
plaintext_length = -1;
447
341
goto decrypt_end;
448
342
}
450
344
}
451
345
452
346
if(debug){
453
fprintf_plus(stderr, "Decrypted password is: ");
347
fprintf(stderr, "Decrypted password is: ");
454
348
for(ssize_t i = 0; i < plaintext_length; i++){
455
349
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
456
350
}
467
361
return plaintext_length;
468
362
}
469
363
470
static const char * safer_gnutls_strerror(int value){
471
const char *ret = gnutls_strerror(value);
472
if(ret == NULL)
364
static const char * safer_gnutls_strerror (int value) {
365
const char *ret = gnutls_strerror (value); /* Spurious warning */
366
if (ret == NULL)
473
367
ret = "(unknown)";
474
368
return ret;
475
369
}
477
371
/* GnuTLS log function callback */
478
372
static void debuggnutls(__attribute__((unused)) int level,
479
373
const char* string){
480
fprintf_plus(stderr, "GnuTLS: %s", string);
374
fprintf(stderr, "GnuTLS: %s", string);
481
375
}
482
376
483
static int init_gnutls_global(const char *pubkeyfilename,
484
const char *seckeyfilename,
485
mandos_context *mc){
377
static int init_gnutls_global(mandos_context *mc,
378
const char *pubkeyfilename,
379
const char *seckeyfilename){
486
380
int ret;
487
381
488
382
if(debug){
489
fprintf_plus(stderr, "Initializing GnuTLS\n");
383
fprintf(stderr, "Initializing GnuTLS\n");
490
384
}
491
385
492
386
ret = gnutls_global_init();
493
if(ret != GNUTLS_E_SUCCESS){
494
fprintf_plus(stderr, "GnuTLS global_init: %s\n",
495
safer_gnutls_strerror(ret));
387
if (ret != GNUTLS_E_SUCCESS) {
388
fprintf (stderr, "GnuTLS global_init: %s\n",
389
safer_gnutls_strerror(ret));
496
390
return -1;
497
391
}
498
392
499
if(debug){
393
if (debug){
500
394
/* "Use a log level over 10 to enable all debugging options."
501
395
* - GnuTLS manual
502
396
*/
505
399
}
506
400
507
401
/* OpenPGP credentials */
508
ret = gnutls_certificate_allocate_credentials(&mc->cred);
509
if(ret != GNUTLS_E_SUCCESS){
510
fprintf_plus(stderr, "GnuTLS memory error: %s\n",
511
safer_gnutls_strerror(ret));
512
gnutls_global_deinit();
402
gnutls_certificate_allocate_credentials(&mc->cred);
403
if (ret != GNUTLS_E_SUCCESS){
404
fprintf (stderr, "GnuTLS memory error: %s\n", /* Spurious
405
warning */
406
safer_gnutls_strerror(ret));
407
gnutls_global_deinit ();
513
408
return -1;
514
409
}
515
410
516
411
if(debug){
517
fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"
518
" secret key %s as GnuTLS credentials\n",
519
pubkeyfilename,
520
seckeyfilename);
412
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
413
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
414
seckeyfilename);
521
415
}
522
416
523
417
ret = gnutls_certificate_set_openpgp_key_file
524
418
(mc->cred, pubkeyfilename, seckeyfilename,
525
419
GNUTLS_OPENPGP_FMT_BASE64);
526
if(ret != GNUTLS_E_SUCCESS){
527
fprintf_plus(stderr,
528
"Error[%d] while reading the OpenPGP key pair ('%s',"
529
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
530
fprintf_plus(stderr, "The GnuTLS error is: %s\n",
531
safer_gnutls_strerror(ret));
420
if (ret != GNUTLS_E_SUCCESS) {
421
fprintf(stderr,
422
"Error[%d] while reading the OpenPGP key pair ('%s',"
423
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
424
fprintf(stderr, "The GnuTLS error is: %s\n",
425
safer_gnutls_strerror(ret));
532
426
goto globalfail;
533
427
}
534
428
535
429
/* GnuTLS server initialization */
536
430
ret = gnutls_dh_params_init(&mc->dh_params);
537
if(ret != GNUTLS_E_SUCCESS){
538
fprintf_plus(stderr, "Error in GnuTLS DH parameter"
539
" initialization: %s\n",
540
safer_gnutls_strerror(ret));
431
if (ret != GNUTLS_E_SUCCESS) {
432
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
433
" %s\n", safer_gnutls_strerror(ret));
541
434
goto globalfail;
542
435
}
543
436
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
544
if(ret != GNUTLS_E_SUCCESS){
545
fprintf_plus(stderr, "Error in GnuTLS prime generation: %s\n",
546
safer_gnutls_strerror(ret));
437
if (ret != GNUTLS_E_SUCCESS) {
438
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
439
safer_gnutls_strerror(ret));
547
440
goto globalfail;
548
441
}
549
442
559
452
return -1;
560
453
}
561
454
562
static int init_gnutls_session(gnutls_session_t *session,
563
mandos_context *mc){
455
static int init_gnutls_session(mandos_context *mc,
456
gnutls_session_t *session){
564
457
int ret;
565
458
/* GnuTLS session creation */
566
do {
567
ret = gnutls_init(session, GNUTLS_SERVER);
568
if(quit_now){
569
return -1;
570
}
571
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
572
if(ret != GNUTLS_E_SUCCESS){
573
fprintf_plus(stderr,
574
"Error in GnuTLS session initialization: %s\n",
575
safer_gnutls_strerror(ret));
459
ret = gnutls_init(session, GNUTLS_SERVER);
460
if (ret != GNUTLS_E_SUCCESS){
461
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
462
safer_gnutls_strerror(ret));
576
463
}
577
464
578
465
{
579
466
const char *err;
580
do {
581
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
582
if(quit_now){
583
gnutls_deinit(*session);
584
return -1;
585
}
586
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
587
if(ret != GNUTLS_E_SUCCESS){
588
fprintf_plus(stderr, "Syntax error at: %s\n", err);
589
fprintf_plus(stderr, "GnuTLS error: %s\n",
590
safer_gnutls_strerror(ret));
591
gnutls_deinit(*session);
467
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
468
if (ret != GNUTLS_E_SUCCESS) {
469
fprintf(stderr, "Syntax error at: %s\n", err);
470
fprintf(stderr, "GnuTLS error: %s\n",
471
safer_gnutls_strerror(ret));
472
gnutls_deinit (*session);
592
473
return -1;
593
474
}
594
475
}
595
476
596
do {
597
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
598
mc->cred);
599
if(quit_now){
600
gnutls_deinit(*session);
601
return -1;
602
}
603
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
604
if(ret != GNUTLS_E_SUCCESS){
605
fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
606
safer_gnutls_strerror(ret));
607
gnutls_deinit(*session);
477
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
478
mc->cred);
479
if (ret != GNUTLS_E_SUCCESS) {
480
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
481
safer_gnutls_strerror(ret));
482
gnutls_deinit (*session);
608
483
return -1;
609
484
}
610
485
611
486
/* ignore client certificate if any. */
612
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
487
gnutls_certificate_server_set_request (*session,
488
GNUTLS_CERT_IGNORE);
613
489
614
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
490
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
615
491
616
492
return 0;
617
493
}
621
497
__attribute__((unused)) const char *txt){}
622
498
623
499
/* Called when a Mandos server is found */
624
static int start_mandos_communication(const char *ip, in_port_t port,
500
static int start_mandos_communication(const char *ip, uint16_t port,
625
501
AvahiIfIndex if_index,
626
int af, mandos_context *mc){
627
int ret, tcp_sd = -1;
628
ssize_t sret;
629
union {
630
struct sockaddr_in in;
631
struct sockaddr_in6 in6;
632
} to;
502
mandos_context *mc){
503
int ret, tcp_sd;
504
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
633
505
char *buffer = NULL;
634
char *decrypted_buffer = NULL;
506
char *decrypted_buffer;
635
507
size_t buffer_length = 0;
636
508
size_t buffer_capacity = 0;
509
ssize_t decrypted_buffer_size;
637
510
size_t written;
638
int retval = -1;
511
int retval = 0;
512
char interface[IF_NAMESIZE];
639
513
gnutls_session_t session;
640
int pf; /* Protocol family */
641
642
errno = 0;
643
644
if(quit_now){
645
errno = EINTR;
646
return -1;
647
}
648
649
switch(af){
650
case AF_INET6:
651
pf = PF_INET6;
652
break;
653
case AF_INET:
654
pf = PF_INET;
655
break;
656
default:
657
fprintf_plus(stderr, "Bad address family: %d\n", af);
658
errno = EINVAL;
659
return -1;
660
}
661
662
ret = init_gnutls_session(&session, mc);
663
if(ret != 0){
664
return -1;
665
}
666
667
if(debug){
668
fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
669
PRIuMAX "\n", ip, (uintmax_t)port);
670
}
671
672
tcp_sd = socket(pf, SOCK_STREAM, 0);
673
if(tcp_sd < 0){
674
int e = errno;
675
perror_plus("socket");
676
errno = e;
677
goto mandos_end;
678
}
679
680
if(quit_now){
681
errno = EINTR;
682
goto mandos_end;
514
515
ret = init_gnutls_session (mc, &session);
516
if (ret != 0){
517
return -1;
518
}
519
520
if(debug){
521
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
522
"\n", ip, port);
523
}
524
525
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
526
if(tcp_sd < 0) {
527
perror("socket");
528
return -1;
529
}
530
531
if(debug){
532
if(if_indextoname((unsigned int)if_index, interface) == NULL){
533
perror("if_indextoname");
534
return -1;
535
}
536
fprintf(stderr, "Binding to interface %s\n", interface);
683
537
}
684
538
685
539
memset(&to, 0, sizeof(to));
686
if(af == AF_INET6){
687
to.in6.sin6_family = (sa_family_t)af;
688
ret = inet_pton(af, ip, &to.in6.sin6_addr);
689
} else { /* IPv4 */
690
to.in.sin_family = (sa_family_t)af;
691
ret = inet_pton(af, ip, &to.in.sin_addr);
692
}
693
if(ret < 0 ){
694
int e = errno;
695
perror_plus("inet_pton");
696
errno = e;
697
goto mandos_end;
540
to.in6.sin6_family = AF_INET6;
541
/* It would be nice to have a way to detect if we were passed an
542
IPv4 address here. Now we assume an IPv6 address. */
543
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
544
if (ret < 0 ){
545
perror("inet_pton");
546
return -1;
698
547
}
699
548
if(ret == 0){
700
int e = errno;
701
fprintf_plus(stderr, "Bad address: %s\n", ip);
702
errno = e;
703
goto mandos_end;
704
}
705
if(af == AF_INET6){
706
to.in6.sin6_port = htons(port);
707
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
708
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
709
-Wunreachable-code*/
710
if(if_index == AVAHI_IF_UNSPEC){
711
fprintf_plus(stderr, "An IPv6 link-local address is"
712
" incomplete without a network interface\n");
713
errno = EINVAL;
714
goto mandos_end;
715
}
716
/* Set the network interface number as scope */
717
to.in6.sin6_scope_id = (uint32_t)if_index;
718
}
719
} else {
720
to.in.sin_port = htons(port); /* Spurious warnings from
721
-Wconversion and
722
-Wunreachable-code */
723
}
549
fprintf(stderr, "Bad address: %s\n", ip);
550
return -1;
551
}
552
to.in6.sin6_port = htons(port); /* Spurious warning */
724
553
725
if(quit_now){
726
errno = EINTR;
727
goto mandos_end;
728
}
554
to.in6.sin6_scope_id = (uint32_t)if_index;
729
555
730
556
if(debug){
731
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
732
char interface[IF_NAMESIZE];
733
if(if_indextoname((unsigned int)if_index, interface) == NULL){
734
perror_plus("if_indextoname");
735
} else {
736
fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
737
"\n", ip, interface, (uintmax_t)port);
738
}
739
} else {
740
fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
741
ip, (uintmax_t)port);
742
}
743
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
744
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
745
const char *pcret;
746
if(af == AF_INET6){
747
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
748
sizeof(addrstr));
749
} else {
750
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
751
sizeof(addrstr));
752
}
753
if(pcret == NULL){
754
perror_plus("inet_ntop");
557
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
558
port);
559
char addrstr[INET6_ADDRSTRLEN] = "";
560
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
561
sizeof(addrstr)) == NULL){
562
perror("inet_ntop");
755
563
} else {
756
564
if(strcmp(addrstr, ip) != 0){
757
fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
565
fprintf(stderr, "Canonical address form: %s\n", addrstr);
758
566
}
759
567
}
760
568
}
761
569
762
if(quit_now){
763
errno = EINTR;
764
goto mandos_end;
765
}
766
767
if(af == AF_INET6){
768
ret = connect(tcp_sd, &to.in6, sizeof(to));
769
} else {
770
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
771
}
772
if(ret < 0){
773
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
774
int e = errno;
775
perror_plus("connect");
776
errno = e;
777
}
778
goto mandos_end;
779
}
780
781
if(quit_now){
782
errno = EINTR;
783
goto mandos_end;
570
ret = connect(tcp_sd, &to.in, sizeof(to));
571
if (ret < 0){
572
perror("connect");
573
return -1;
784
574
}
785
575
786
576
const char *out = mandos_protocol_version;
787
577
written = 0;
788
while(true){
578
while (true){
789
579
size_t out_size = strlen(out);
790
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
791
out_size - written));
792
if(ret == -1){
793
int e = errno;
794
perror_plus("write");
795
errno = e;
580
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
581
out_size - written));
582
if (ret == -1){
583
perror("write");
584
retval = -1;
796
585
goto mandos_end;
797
586
}
798
587
written += (size_t)ret;
799
588
if(written < out_size){
800
589
continue;
801
590
} else {
802
if(out == mandos_protocol_version){
591
if (out == mandos_protocol_version){
803
592
written = 0;
804
593
out = "\r\n";
805
594
} else {
806
595
break;
807
596
}
808
597
}
809
810
if(quit_now){
811
errno = EINTR;
812
goto mandos_end;
813
}
814
598
}
815
599
816
600
if(debug){
817
fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
818
}
819
820
if(quit_now){
821
errno = EINTR;
822
goto mandos_end;
823
}
824
825
/* This casting via intptr_t is to eliminate warning about casting
826
an int to a pointer type. This is exactly how the GnuTLS Guile
827
function "set-session-transport-fd!" does it. */
828
gnutls_transport_set_ptr(session,
829
(gnutls_transport_ptr_t)(intptr_t)tcp_sd);
830
831
if(quit_now){
832
errno = EINTR;
833
goto mandos_end;
834
}
835
836
do {
837
ret = gnutls_handshake(session);
838
if(quit_now){
839
errno = EINTR;
840
goto mandos_end;
841
}
601
fprintf(stderr, "Establishing TLS session with %s\n", ip);
602
}
603
604
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
605
606
do{
607
ret = gnutls_handshake (session);
842
608
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
843
609
844
if(ret != GNUTLS_E_SUCCESS){
610
if (ret != GNUTLS_E_SUCCESS){
845
611
if(debug){
846
fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
847
gnutls_perror(ret);
612
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
613
gnutls_perror (ret);
848
614
}
849
errno = EPROTO;
615
retval = -1;
850
616
goto mandos_end;
851
617
}
852
618
853
619
/* Read OpenPGP packet that contains the wanted password */
854
620
855
621
if(debug){
856
fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
857
" %s\n", ip);
622
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
623
ip);
858
624
}
859
625
860
626
while(true){
861
862
if(quit_now){
863
errno = EINTR;
864
goto mandos_end;
865
}
866
867
buffer_capacity = incbuffer(&buffer, buffer_length,
868
buffer_capacity);
869
if(buffer_capacity == 0){
870
int e = errno;
871
perror_plus("incbuffer");
872
errno = e;
873
goto mandos_end;
874
}
875
876
if(quit_now){
877
errno = EINTR;
878
goto mandos_end;
879
}
880
881
sret = gnutls_record_recv(session, buffer+buffer_length,
882
BUFFER_SIZE);
883
if(sret == 0){
627
buffer_capacity = adjustbuffer(&buffer, buffer_length,
628
buffer_capacity);
629
if (buffer_capacity == 0){
630
perror("adjustbuffer");
631
retval = -1;
632
goto mandos_end;
633
}
634
635
ret = gnutls_record_recv(session, buffer+buffer_length,
636
BUFFER_SIZE);
637
if (ret == 0){
884
638
break;
885
639
}
886
if(sret < 0){
887
switch(sret){
640
if (ret < 0){
641
switch(ret){
888
642
case GNUTLS_E_INTERRUPTED:
889
643
case GNUTLS_E_AGAIN:
890
644
break;
891
645
case GNUTLS_E_REHANDSHAKE:
892
do {
893
ret = gnutls_handshake(session);
894
895
if(quit_now){
896
errno = EINTR;
897
goto mandos_end;
898
}
646
do{
647
ret = gnutls_handshake (session);
899
648
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
900
if(ret < 0){
901
fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
902
"***\n");
903
gnutls_perror(ret);
904
errno = EPROTO;
649
if (ret < 0){
650
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
651
gnutls_perror (ret);
652
retval = -1;
905
653
goto mandos_end;
906
654
}
907
655
break;
908
656
default:
909
fprintf_plus(stderr, "Unknown error while reading data from"
910
" encrypted session with Mandos server\n");
911
gnutls_bye(session, GNUTLS_SHUT_RDWR);
912
errno = EIO;
657
fprintf(stderr, "Unknown error while reading data from"
658
" encrypted session with Mandos server\n");
659
retval = -1;
660
gnutls_bye (session, GNUTLS_SHUT_RDWR);
913
661
goto mandos_end;
914
662
}
915
663
} else {
916
buffer_length += (size_t) sret;
664
buffer_length += (size_t) ret;
917
665
}
918
666
}
919
667
920
668
if(debug){
921
fprintf_plus(stderr, "Closing TLS session\n");
922
}
923
924
if(quit_now){
925
errno = EINTR;
926
goto mandos_end;
927
}
928
929
do {
930
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
931
if(quit_now){
932
errno = EINTR;
933
goto mandos_end;
934
}
935
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
936
937
if(buffer_length > 0){
938
ssize_t decrypted_buffer_size;
939
decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
940
&decrypted_buffer, mc);
941
if(decrypted_buffer_size >= 0){
942
669
fprintf(stderr, "Closing TLS session\n");
670
}
671
672
gnutls_bye (session, GNUTLS_SHUT_RDWR);
673
674
if (buffer_length > 0){
675
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
676
buffer_length,
677
&decrypted_buffer);
678
if (decrypted_buffer_size >= 0){
943
679
written = 0;
944
680
while(written < (size_t) decrypted_buffer_size){
945
if(quit_now){
946
errno = EINTR;
947
goto mandos_end;
948
}
949
950
ret = (int)fwrite(decrypted_buffer + written, 1,
951
(size_t)decrypted_buffer_size - written,
952
stdout);
681
ret = (int)fwrite (decrypted_buffer + written, 1,
682
(size_t)decrypted_buffer_size - written,
683
stdout);
953
684
if(ret == 0 and ferror(stdout)){
954
int e = errno;
955
685
if(debug){
956
fprintf_plus(stderr, "Error writing encrypted data: %s\n",
957
strerror(errno));
686
fprintf(stderr, "Error writing encrypted data: %s\n",
687
strerror(errno));
958
688
}
959
errno = e;
960
goto mandos_end;
689
retval = -1;
690
break;
961
691
}
962
692
written += (size_t)ret;
963
693
}
964
retval = 0;
694
free(decrypted_buffer);
695
} else {
696
retval = -1;
965
697
}
698
} else {
699
retval = -1;
966
700
}
967
701
968
702
/* Shutdown procedure */
969
703
970
704
mandos_end:
971
{
972
int e = errno;
973
free(decrypted_buffer);
974
free(buffer);
975
if(tcp_sd >= 0){
976
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
977
}
978
if(ret == -1){
979
if(e == 0){
980
e = errno;
981
}
982
perror_plus("close");
983
}
984
gnutls_deinit(session);
985
errno = e;
986
if(quit_now){
987
errno = EINTR;
988
retval = -1;
989
}
705
free(buffer);
706
ret = TEMP_FAILURE_RETRY(close(tcp_sd));
707
if(ret == -1){
708
perror("close");
990
709
}
710
gnutls_deinit (session);
991
711
return retval;
992
712
}
993
713
994
714
static void resolve_callback(AvahiSServiceResolver *r,
995
715
AvahiIfIndex interface,
996
AvahiProtocol proto,
716
AVAHI_GCC_UNUSED AvahiProtocol protocol,
997
717
AvahiResolverEvent event,
998
718
const char *name,
999
719
const char *type,
1004
724
AVAHI_GCC_UNUSED AvahiStringList *txt,
1005
725
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1006
726
flags,
1007
void* mc){
1008
if(r == NULL){
1009
return;
1010
}
727
void* userdata) {
728
mandos_context *mc = userdata;
729
assert(r);
1011
730
1012
731
/* Called whenever a service has been resolved successfully or
1013
732
timed out */
1014
733
1015
if(quit_now){
1016
return;
1017
}
1018
1019
switch(event){
734
switch (event) {
1020
735
default:
1021
736
case AVAHI_RESOLVER_FAILURE:
1022
fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
1023
"'%s' of type '%s' in domain '%s': %s\n", name, type,
1024
domain,
1025
avahi_strerror(avahi_server_errno
1026
(((mandos_context*)mc)->server)));
737
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
738
" of type '%s' in domain '%s': %s\n", name, type, domain,
739
avahi_strerror(avahi_server_errno(mc->server)));
1027
740
break;
1028
741
1029
742
case AVAHI_RESOLVER_FOUND:
1031
744
char ip[AVAHI_ADDRESS_STR_MAX];
1032
745
avahi_address_snprint(ip, sizeof(ip), address);
1033
746
if(debug){
1034
fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
1035
PRIdMAX ") on port %" PRIu16 "\n", name,
1036
host_name, ip, (intmax_t)interface, port);
747
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
748
PRIu16 ") on port %d\n", name, host_name, ip,
749
interface, port);
1037
750
}
1038
int ret = start_mandos_communication(ip, (in_port_t)port,
1039
interface,
1040
avahi_proto_to_af(proto),
1041
mc);
1042
if(ret == 0){
1043
avahi_simple_poll_quit(simple_poll);
1044
} else {
1045
if(not add_server(ip, (in_port_t)port, interface,
1046
avahi_proto_to_af(proto),
1047
&((mandos_context*)mc)->current_server)){
1048
fprintf_plus(stderr, "Failed to add server \"%s\" to server"
1049
" list\n", name);
1050
}
751
int ret = start_mandos_communication(ip, port, interface, mc);
752
if (ret == 0){
753
avahi_simple_poll_quit(mc->simple_poll);
1051
754
}
1052
755
}
1053
756
}
1054
757
avahi_s_service_resolver_free(r);
1055
758
}
1056
759
1057
static void browse_callback(AvahiSServiceBrowser *b,
1058
AvahiIfIndex interface,
1059
AvahiProtocol protocol,
1060
AvahiBrowserEvent event,
1061
const char *name,
1062
const char *type,
1063
const char *domain,
1064
AVAHI_GCC_UNUSED AvahiLookupResultFlags
1065
flags,
1066
void* mc){
1067
if(b == NULL){
1068
return;
1069
}
760
static void browse_callback( AvahiSServiceBrowser *b,
761
AvahiIfIndex interface,
762
AvahiProtocol protocol,
763
AvahiBrowserEvent event,
764
const char *name,
765
const char *type,
766
const char *domain,
767
AVAHI_GCC_UNUSED AvahiLookupResultFlags
768
flags,
769
void* userdata) {
770
mandos_context *mc = userdata;
771
assert(b);
1070
772
1071
773
/* Called whenever a new services becomes available on the LAN or
1072
774
is removed from the LAN */
1073
775
1074
if(quit_now){
1075
return;
1076
}
1077
1078
switch(event){
776
switch (event) {
1079
777
default:
1080
778
case AVAHI_BROWSER_FAILURE:
1081
779
1082
fprintf_plus(stderr, "(Avahi browser) %s\n",
1083
avahi_strerror(avahi_server_errno
1084
(((mandos_context*)mc)->server)));
1085
avahi_simple_poll_quit(simple_poll);
780
fprintf(stderr, "(Avahi browser) %s\n",
781
avahi_strerror(avahi_server_errno(mc->server)));
782
avahi_simple_poll_quit(mc->simple_poll);
1086
783
return;
1087
784
1088
785
case AVAHI_BROWSER_NEW:
1091
788
the callback function is called the Avahi server will free the
1092
789
resolver for us. */
1093
790
1094
if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
1095
interface, protocol, name, type,
1096
domain, protocol, 0,
1097
resolve_callback, mc) == NULL)
1098
fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
1099
" %s\n", name,
1100
avahi_strerror(avahi_server_errno
1101
(((mandos_context*)mc)->server)));
791
if (!(avahi_s_service_resolver_new(mc->server, interface,
792
protocol, name, type, domain,
793
AVAHI_PROTO_INET6, 0,
794
resolve_callback, mc)))
795
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
796
name, avahi_strerror(avahi_server_errno(mc->server)));
1102
797
break;
1103
798
1104
799
case AVAHI_BROWSER_REMOVE:
1107
802
case AVAHI_BROWSER_ALL_FOR_NOW:
1108
803
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1109
804
if(debug){
1110
fprintf_plus(stderr, "No Mandos server found, still"
1111
" searching...\n");
805
fprintf(stderr, "No Mandos server found, still searching...\n");
1112
806
}
1113
807
break;
1114
808
}
1115
809
}
1116
810
1117
/* Signal handler that stops main loop after SIGTERM */
1118
static void handle_sigterm(int sig){
1119
if(quit_now){
1120
return;
1121
}
1122
quit_now = 1;
1123
signal_received = sig;
1124
int old_errno = errno;
1125
/* set main loop to exit */
1126
if(simple_poll != NULL){
1127
avahi_simple_poll_quit(simple_poll);
1128
}
1129
errno = old_errno;
1130
}
1131
1132
bool get_flags(const char *ifname, struct ifreq *ifr){
1133
int ret;
1134
error_t ret_errno;
1135
1136
int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1137
if(s < 0){
1138
ret_errno = errno;
1139
perror_plus("socket");
1140
errno = ret_errno;
1141
return false;
1142
}
1143
strcpy(ifr->ifr_name, ifname);
1144
ret = ioctl(s, SIOCGIFFLAGS, ifr);
1145
if(ret == -1){
1146
if(debug){
1147
ret_errno = errno;
1148
perror_plus("ioctl SIOCGIFFLAGS");
1149
errno = ret_errno;
1150
}
1151
return false;
1152
}
1153
return true;
1154
}
1155
1156
bool good_flags(const char *ifname, const struct ifreq *ifr){
1157
1158
/* Reject the loopback device */
1159
if(ifr->ifr_flags & IFF_LOOPBACK){
1160
if(debug){
1161
fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
1162
ifname);
1163
}
1164
return false;
1165
}
1166
/* Accept point-to-point devices only if connect_to is specified */
1167
if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
1168
if(debug){
1169
fprintf_plus(stderr, "Accepting point-to-point interface"
1170
" \"%s\"\n", ifname);
1171
}
1172
return true;
1173
}
1174
/* Otherwise, reject non-broadcast-capable devices */
1175
if(not (ifr->ifr_flags & IFF_BROADCAST)){
1176
if(debug){
1177
fprintf_plus(stderr, "Rejecting non-broadcast interface"
1178
" \"%s\"\n", ifname);
1179
}
1180
return false;
1181
}
1182
/* Reject non-ARP interfaces (including dummy interfaces) */
1183
if(ifr->ifr_flags & IFF_NOARP){
1184
if(debug){
1185
fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
1186
ifname);
1187
}
1188
return false;
1189
}
1190
1191
/* Accept this device */
1192
if(debug){
1193
fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
1194
}
1195
return true;
1196
}
1197
1198
/*
1199
* This function determines if a directory entry in /sys/class/net
1200
* corresponds to an acceptable network device.
1201
* (This function is passed to scandir(3) as a filter function.)
1202
*/
1203
int good_interface(const struct dirent *if_entry){
1204
if(if_entry->d_name[0] == '.'){
1205
return 0;
1206
}
1207
1208
struct ifreq ifr;
1209
if(not get_flags(if_entry->d_name, &ifr)){
1210
if(debug){
1211
fprintf_plus(stderr, "Failed to get flags for interface "
1212
"\"%s\"\n", if_entry->d_name);
1213
}
1214
return 0;
1215
}
1216
1217
if(not good_flags(if_entry->d_name, &ifr)){
1218
return 0;
1219
}
1220
return 1;
1221
}
1222
1223
/*
1224
* This function determines if a network interface is up.
1225
*/
1226
bool interface_is_up(const char *interface){
1227
struct ifreq ifr;
1228
if(not get_flags(interface, &ifr)){
1229
if(debug){
1230
fprintf_plus(stderr, "Failed to get flags for interface "
1231
"\"%s\"\n", interface);
1232
}
1233
return false;
1234
}
1235
1236
return (bool)(ifr.ifr_flags & IFF_UP);
1237
}
1238
1239
/*
1240
* This function determines if a network interface is running
1241
*/
1242
bool interface_is_running(const char *interface){
1243
struct ifreq ifr;
1244
if(not get_flags(interface, &ifr)){
1245
if(debug){
1246
fprintf_plus(stderr, "Failed to get flags for interface "
1247
"\"%s\"\n", interface);
1248
}
1249
return false;
1250
}
1251
1252
return (bool)(ifr.ifr_flags & IFF_RUNNING);
1253
}
1254
1255
int notdotentries(const struct dirent *direntry){
1256
/* Skip "." and ".." */
1257
if(direntry->d_name[0] == '.'
1258
and (direntry->d_name[1] == '\0'
1259
or (direntry->d_name[1] == '.'
1260
and direntry->d_name[2] == '\0'))){
1261
return 0;
1262
}
1263
return 1;
1264
}
1265
1266
/* Is this directory entry a runnable program? */
1267
int runnable_hook(const struct dirent *direntry){
1268
int ret;
1269
size_t sret;
1270
struct stat st;
1271
1272
if((direntry->d_name)[0] == '\0'){
1273
/* Empty name? */
1274
return 0;
1275
}
1276
1277
sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
1278
"abcdefghijklmnopqrstuvwxyz"
1279
"0123456789"
1280
"_-");
1281
if((direntry->d_name)[sret] != '\0'){
1282
/* Contains non-allowed characters */
1283
if(debug){
1284
fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
1285
direntry->d_name);
1286
}
1287
return 0;
1288
}
1289
1290
char *fullname = NULL;
1291
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
1292
if(ret < 0){
1293
perror_plus("asprintf");
1294
return 0;
1295
}
1296
1297
ret = stat(fullname, &st);
1298
if(ret == -1){
1299
if(debug){
1300
perror_plus("Could not stat hook");
1301
}
1302
return 0;
1303
}
1304
if(not (S_ISREG(st.st_mode))){
1305
/* Not a regular file */
1306
if(debug){
1307
fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
1308
direntry->d_name);
1309
}
1310
return 0;
1311
}
1312
if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
1313
/* Not executable */
1314
if(debug){
1315
fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
1316
direntry->d_name);
1317
}
1318
return 0;
1319
}
1320
if(debug){
1321
fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
1322
direntry->d_name);
1323
}
1324
return 1;
1325
}
1326
1327
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
1328
mandos_context *mc){
1329
int ret;
1330
struct timespec now;
1331
struct timespec waited_time;
1332
intmax_t block_time;
1333
1334
while(true){
1335
if(mc->current_server == NULL){
1336
if (debug){
1337
fprintf_plus(stderr, "Wait until first server is found."
1338
" No timeout!\n");
1339
}
1340
ret = avahi_simple_poll_iterate(s, -1);
1341
} else {
1342
if (debug){
1343
fprintf_plus(stderr, "Check current_server if we should run"
1344
" it, or wait\n");
1345
}
1346
/* the current time */
1347
ret = clock_gettime(CLOCK_MONOTONIC, &now);
811
int main(int argc, char *argv[]){
812
AvahiSServiceBrowser *sb = NULL;
813
int error;
814
int ret;
815
int exitcode = EXIT_SUCCESS;
816
const char *interface = "eth0";
817
struct ifreq network;
818
int sd;
819
uid_t uid;
820
gid_t gid;
821
char *connect_to = NULL;
822
char tempdir[] = "/tmp/mandosXXXXXX";
823
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
824
const char *seckey = PATHDIR "/" SECKEY;
825
const char *pubkey = PATHDIR "/" PUBKEY;
826
827
mandos_context mc = { .simple_poll = NULL, .server = NULL,
828
.dh_bits = 1024, .priority = "SECURE256"
829
":!CTYPE-X.509:+CTYPE-OPENPGP" };
830
bool gnutls_initalized = false;
831
bool gpgme_initalized = false;
832
833
{
834
struct argp_option options[] = {
835
{ .name = "debug", .key = 128,
836
.doc = "Debug mode", .group = 3 },
837
{ .name = "connect", .key = 'c',
838
.arg = "ADDRESS:PORT",
839
.doc = "Connect directly to a specific Mandos server",
840
.group = 1 },
841
{ .name = "interface", .key = 'i',
842
.arg = "NAME",
843
.doc = "Interface that will be used to search for Mandos"
844
" servers",
845
.group = 1 },
846
{ .name = "seckey", .key = 's',
847
.arg = "FILE",
848
.doc = "OpenPGP secret key file base name",
849
.group = 1 },
850
{ .name = "pubkey", .key = 'p',
851
.arg = "FILE",
852
.doc = "OpenPGP public key file base name",
853
.group = 2 },
854
{ .name = "dh-bits", .key = 129,
855
.arg = "BITS",
856
.doc = "Bit length of the prime number used in the"
857
" Diffie-Hellman key exchange",
858
.group = 2 },
859
{ .name = "priority", .key = 130,
860
.arg = "STRING",
861
.doc = "GnuTLS priority string for the TLS handshake",
862
.group = 1 },
863
{ .name = NULL }
864
};
865
866
error_t parse_opt (int key, char *arg,
867
struct argp_state *state) {
868
/* Get the INPUT argument from `argp_parse', which we know is
869
a pointer to our plugin list pointer. */
870
switch (key) {
871
case 128: /* --debug */
872
debug = true;
873
break;
874
case 'c': /* --connect */
875
connect_to = arg;
876
break;
877
case 'i': /* --interface */
878
interface = arg;
879
break;
880
case 's': /* --seckey */
881
seckey = arg;
882
break;
883
case 'p': /* --pubkey */
884
pubkey = arg;
885
break;
886
case 129: /* --dh-bits */
887
errno = 0;
888
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
889
if (errno){
890
perror("strtol");
891
exit(EXIT_FAILURE);
892
}
893
break;
894
case 130: /* --priority */
895
mc.priority = arg;
896
break;
897
case ARGP_KEY_ARG:
898
argp_usage (state);
899
case ARGP_KEY_END:
900
break;
901
default:
902
return ARGP_ERR_UNKNOWN;
903
}
904
return 0;
905
}
906
907
struct argp argp = { .options = options, .parser = parse_opt,
908
.args_doc = "",
909
.doc = "Mandos client -- Get and decrypt"
910
" passwords from a Mandos server" };
911
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
912
if (ret == ARGP_ERR_UNKNOWN){
913
fprintf(stderr, "Unknown error while parsing arguments\n");
914
exitcode = EXIT_FAILURE;
915
goto end;
916
}
917
}
918
919
/* If the interface is down, bring it up */
920
{
921
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
922
if(sd < 0) {
923
perror("socket");
924
exitcode = EXIT_FAILURE;
925
goto end;
926
}
927
strcpy(network.ifr_name, interface);
928
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1348
929
if(ret == -1){
1349
perror_plus("clock_gettime");
1350
return -1;
1351
}
1352
/* Calculating in ms how long time between now and server
1353
who we visted longest time ago. Now - last seen. */
1354
waited_time.tv_sec = (now.tv_sec
1355
- mc->current_server->last_seen.tv_sec);
1356
waited_time.tv_nsec = (now.tv_nsec
1357
- mc->current_server->last_seen.tv_nsec);
1358
/* total time is 10s/10,000ms.
1359
Converting to s from ms by dividing by 1,000,
1360
and ns to ms by dividing by 1,000,000. */
1361
block_time = ((retry_interval
1362
- ((intmax_t)waited_time.tv_sec * 1000))
1363
- ((intmax_t)waited_time.tv_nsec / 1000000));
1364
1365
if (debug){
1366
fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
1367
block_time);
1368
}
1369
1370
if(block_time <= 0){
1371
ret = start_mandos_communication(mc->current_server->ip,
1372
mc->current_server->port,
1373
mc->current_server->if_index,
1374
mc->current_server->af, mc);
1375
if(ret == 0){
1376
avahi_simple_poll_quit(s);
1377
return 0;
1378
}
1379
ret = clock_gettime(CLOCK_MONOTONIC,
1380
&mc->current_server->last_seen);
930
perror("ioctl SIOCGIFFLAGS");
931
exitcode = EXIT_FAILURE;
932
goto end;
933
}
934
if((network.ifr_flags & IFF_UP) == 0){
935
network.ifr_flags |= IFF_UP;
936
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1381
937
if(ret == -1){
1382
perror_plus("clock_gettime");
1383
return -1;
938
perror("ioctl SIOCSIFFLAGS");
939
exitcode = EXIT_FAILURE;
940
goto end;
1384
941
}
1385
mc->current_server = mc->current_server->next;
1386
block_time = 0; /* Call avahi to find new Mandos
1387
servers, but don't block */
1388
}
1389
1390
ret = avahi_simple_poll_iterate(s, (int)block_time);
1391
}
1392
if(ret != 0){
1393
if (ret > 0 or errno != EINTR){
1394
return (ret != 1) ? ret : 0;
1395
}
1396
}
1397
}
1398
}
1399
1400
/* Set effective uid to 0, return errno */
1401
error_t raise_privileges(void){
1402
error_t old_errno = errno;
1403
error_t ret_errno = 0;
1404
if(seteuid(0) == -1){
1405
ret_errno = errno;
1406
perror_plus("seteuid");
1407
}
1408
errno = old_errno;
1409
return ret_errno;
1410
}
1411
1412
/* Set effective and real user ID to 0. Return errno. */
1413
error_t raise_privileges_permanently(void){
1414
error_t old_errno = errno;
1415
error_t ret_errno = raise_privileges();
1416
if(ret_errno != 0){
1417
errno = old_errno;
1418
return ret_errno;
1419
}
1420
if(setuid(0) == -1){
1421
ret_errno = errno;
1422
perror_plus("seteuid");
1423
}
1424
errno = old_errno;
1425
return ret_errno;
1426
}
1427
1428
/* Set effective user ID to unprivileged saved user ID */
1429
error_t lower_privileges(void){
1430
error_t old_errno = errno;
1431
error_t ret_errno = 0;
1432
if(seteuid(uid) == -1){
1433
ret_errno = errno;
1434
perror_plus("seteuid");
1435
}
1436
errno = old_errno;
1437
return ret_errno;
1438
}
1439
1440
/* Lower privileges permanently */
1441
error_t lower_privileges_permanently(void){
1442
error_t old_errno = errno;
1443
error_t ret_errno = 0;
1444
if(setuid(uid) == -1){
1445
ret_errno = errno;
1446
perror_plus("setuid");
1447
}
1448
errno = old_errno;
1449
return ret_errno;
1450
}
1451
1452
bool run_network_hooks(const char *mode, const char *interface,
1453
const float delay){
1454
struct dirent **direntries;
1455
struct dirent *direntry;
1456
int ret;
1457
int numhooks = scandir(hookdir, &direntries, runnable_hook,
1458
alphasort);
1459
if(numhooks == -1){
1460
if(errno == ENOENT){
1461
if(debug){
1462
fprintf_plus(stderr, "Network hook directory \"%s\" not"
1463
" found\n", hookdir);
1464
}
1465
} else {
1466
perror_plus("scandir");
1467
}
1468
} else {
1469
int devnull = open("/dev/null", O_RDONLY);
1470
for(int i = 0; i < numhooks; i++){
1471
direntry = direntries[i];
1472
char *fullname = NULL;
1473
ret = asprintf(&fullname, "%s/%s", hookdir, direntry->d_name);
942
}
943
ret = TEMP_FAILURE_RETRY(close(sd));
944
if(ret == -1){
945
perror("close");
946
}
947
}
948
949
uid = getuid();
950
gid = getgid();
951
952
ret = setuid(uid);
953
if (ret == -1){
954
perror("setuid");
955
}
956
957
setgid(gid);
958
if (ret == -1){
959
perror("setgid");
960
}
961
962
ret = init_gnutls_global(&mc, pubkey, seckey);
963
if (ret == -1){
964
fprintf(stderr, "init_gnutls_global failed\n");
965
exitcode = EXIT_FAILURE;
966
goto end;
967
} else {
968
gnutls_initalized = true;
969
}
970
971
if(mkdtemp(tempdir) == NULL){
972
perror("mkdtemp");
973
tempdir[0] = '\0';
974
goto end;
975
}
976
977
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
978
fprintf(stderr, "gpgme_initalized failed\n");
979
exitcode = EXIT_FAILURE;
980
goto end;
981
} else {
982
gpgme_initalized = true;
983
}
984
985
if_index = (AvahiIfIndex) if_nametoindex(interface);
986
if(if_index == 0){
987
fprintf(stderr, "No such interface: \"%s\"\n", interface);
988
exit(EXIT_FAILURE);
989
}
990
991
if(connect_to != NULL){
992
/* Connect directly, do not use Zeroconf */
993
/* (Mainly meant for debugging) */
994
char *address = strrchr(connect_to, ':');
995
if(address == NULL){
996
fprintf(stderr, "No colon in address\n");
997
exitcode = EXIT_FAILURE;
998
goto end;
999
}
1000
errno = 0;
1001
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
1002
if(errno){
1003
perror("Bad port number");
1004
exitcode = EXIT_FAILURE;
1005
goto end;
1006
}
1007
*address = '\0';
1008
address = connect_to;
1009
ret = start_mandos_communication(address, port, if_index, &mc);
1474
1010
if(ret < 0){
1475
perror_plus("asprintf");
1476
continue;
1477
}
1478
if(debug){
1479
fprintf_plus(stderr, "Running network hook \"%s\"\n",
1480
direntry->d_name);
1481
}
1482
pid_t hook_pid = fork();
1483
if(hook_pid == 0){
1484
/* Child */
1485
/* Raise privileges */
1486
raise_privileges_permanently();
1487
/* Set group */
1488
errno = 0;
1489
ret = setgid(0);
1490
if(ret == -1){
1491
perror_plus("setgid");
1492
}
1493
/* Reset supplementary groups */
1494
errno = 0;
1495
ret = setgroups(0, NULL);
1496
if(ret == -1){
1497
perror_plus("setgroups");
1498
}
1499
dup2(devnull, STDIN_FILENO);
1500
close(devnull);
1501
dup2(STDERR_FILENO, STDOUT_FILENO);
1502
ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
1503
if(ret == -1){
1504
perror_plus("setenv");
1505
_exit(EX_OSERR);
1506
}
1507
ret = setenv("DEVICE", interface, 1);
1508
if(ret == -1){
1509
perror_plus("setenv");
1510
_exit(EX_OSERR);
1511
}
1512
ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
1513
if(ret == -1){
1514
perror_plus("setenv");
1515
_exit(EX_OSERR);
1516
}
1517
ret = setenv("MODE", mode, 1);
1518
if(ret == -1){
1519
perror_plus("setenv");
1520
_exit(EX_OSERR);
1521
}
1522
char *delaystring;
1523
ret = asprintf(&delaystring, "%f", delay);
1524
if(ret == -1){
1525
perror_plus("asprintf");
1526
_exit(EX_OSERR);
1527
}
1528
ret = setenv("DELAY", delaystring, 1);
1529
if(ret == -1){
1530
free(delaystring);
1531
perror_plus("setenv");
1532
_exit(EX_OSERR);
1533
}
1534
free(delaystring);
1535
if(connect_to != NULL){
1536
ret = setenv("CONNECT", connect_to, 1);
1537
if(ret == -1){
1538
perror_plus("setenv");
1539
_exit(EX_OSERR);
1011
exitcode = EXIT_FAILURE;
1012
} else {
1013
exitcode = EXIT_SUCCESS;
1014
}
1015
goto end;
1016
}
1017
1018
if (not debug){
1019
avahi_set_log_function(empty_log);
1020
}
1021
1022
/* Initialize the pseudo-RNG for Avahi */
1023
srand((unsigned int) time(NULL));
1024
1025
/* Allocate main Avahi loop object */
1026
mc.simple_poll = avahi_simple_poll_new();
1027
if (mc.simple_poll == NULL) {
1028
fprintf(stderr, "Avahi: Failed to create simple poll"
1029
" object.\n");
1030
exitcode = EXIT_FAILURE;
1031
goto end;
1032
}
1033
1034
{
1035
AvahiServerConfig config;
1036
/* Do not publish any local Zeroconf records */
1037
avahi_server_config_init(&config);
1038
config.publish_hinfo = 0;
1039
config.publish_addresses = 0;
1040
config.publish_workstation = 0;
1041
config.publish_domain = 0;
1042
1043
/* Allocate a new server */
1044
mc.server = avahi_server_new(avahi_simple_poll_get
1045
(mc.simple_poll), &config, NULL,
1046
NULL, &error);
1047
1048
/* Free the Avahi configuration data */
1049
avahi_server_config_free(&config);
1050
}
1051
1052
/* Check if creating the Avahi server object succeeded */
1053
if (mc.server == NULL) {
1054
fprintf(stderr, "Failed to create Avahi server: %s\n",
1055
avahi_strerror(error));
1056
exitcode = EXIT_FAILURE;
1057
goto end;
1058
}
1059
1060
/* Create the Avahi service browser */
1061
sb = avahi_s_service_browser_new(mc.server, if_index,
1062
AVAHI_PROTO_INET6,
1063
"_mandos._tcp", NULL, 0,
1064
browse_callback, &mc);
1065
if (sb == NULL) {
1066
fprintf(stderr, "Failed to create service browser: %s\n",
1067
avahi_strerror(avahi_server_errno(mc.server)));
1068
exitcode = EXIT_FAILURE;
1069
goto end;
1070
}
1071
1072
/* Run the main loop */
1073
1074
if (debug){
1075
fprintf(stderr, "Starting Avahi loop search\n");
1076
}
1077
1078
avahi_simple_poll_loop(mc.simple_poll);
1079
1080
end:
1081
1082
if (debug){
1083
fprintf(stderr, "%s exiting\n", argv[0]);
1084
}
1085
1086
/* Cleanup things */
1087
if (sb != NULL)
1088
avahi_s_service_browser_free(sb);
1089
1090
if (mc.server != NULL)
1091
avahi_server_free(mc.server);
1092
1093
if (mc.simple_poll != NULL)
1094
avahi_simple_poll_free(mc.simple_poll);
1095
1096
if (gnutls_initalized){
1097
gnutls_certificate_free_credentials(mc.cred);
1098
gnutls_global_deinit ();
1099
gnutls_dh_params_deinit(mc.dh_params);
1100
}
1101
1102
if(gpgme_initalized){
1103
gpgme_release(mc.ctx);
1104
}
1105
1106
/* Removes the temp directory used by GPGME */
1107
if(tempdir[0] != '\0'){
1108
DIR *d;
1109
struct dirent *direntry;
1110
d = opendir(tempdir);
1111
if(d == NULL){
1112
perror("opendir");
1113
} else {
1114
while(true){
1115
direntry = readdir(d);
1116
if(direntry == NULL){
1117
break;
1540
1118
}
1541
}
1542
if(execl(fullname, direntry->d_name, mode, NULL) == -1){
1543
perror_plus("execl");
1544
_exit(EXIT_FAILURE);
1545
}
1546
} else {
1547
int status;
1548
if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
1549
perror_plus("waitpid");
1550
free(fullname);
1551
continue;
1552
}
1553
if(WIFEXITED(status)){
1554
if(WEXITSTATUS(status) != 0){
1555
fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
1556
" with status %d\n", direntry->d_name,
1557
WEXITSTATUS(status));
1119
if (direntry->d_type == DT_REG){
1120
char *fullname = NULL;
1121
ret = asprintf(&fullname, "%s/%s", tempdir,
1122
direntry->d_name);
1123
if(ret < 0){
1124
perror("asprintf");
1125
continue;
1126
}
1127
ret = unlink(fullname);
1128
if(ret == -1){
1129
fprintf(stderr, "unlink(\"%s\"): %s",
1130
fullname, strerror(errno));
1131
}
1558
1132
free(fullname);
1559
continue;
1560
}
1561
} else if(WIFSIGNALED(status)){
1562
fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
1563
" signal %d\n", direntry->d_name,
1564
WTERMSIG(status));
1565
free(fullname);
1566
continue;
1567
} else {
1568
fprintf_plus(stderr, "Warning: network hook \"%s\""
1569
" crashed\n", direntry->d_name);
1570
free(fullname);
1571
continue;
1572
}
1573
}
1574
free(fullname);
1575
if(debug){
1576
fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
1577
direntry->d_name);
1578
}
1579
}
1580
close(devnull);
1581
}
1582
return true;
1583
}
1584
1585
error_t bring_up_interface(const char *const interface,
1586
const float delay){
1587
int sd = -1;
1588
error_t old_errno = errno;
1589
error_t ret_errno = 0;
1590
int ret, ret_setflags;
1591
struct ifreq network;
1592
unsigned int if_index = if_nametoindex(interface);
1593
if(if_index == 0){
1594
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1595
errno = old_errno;
1596
return ENXIO;
1597
}
1598
1599
if(quit_now){
1600
errno = old_errno;
1601
return EINTR;
1602
}
1603
1604
if(not interface_is_up(interface)){
1605
if(not get_flags(interface, &network) and debug){
1606
ret_errno = errno;
1607
fprintf_plus(stderr, "Failed to get flags for interface "
1608
"\"%s\"\n", interface);
1609
return ret_errno;
1610
}
1611
network.ifr_flags |= IFF_UP;
1612
1613
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1614
if(sd < 0){
1615
ret_errno = errno;
1616
perror_plus("socket");
1617
errno = old_errno;
1618
return ret_errno;
1619
}
1620
1621
if(quit_now){
1622
close(sd);
1623
errno = old_errno;
1624
return EINTR;
1625
}
1626
1627
if(debug){
1628
fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
1629
interface);
1630
}
1631
1632
/* Raise priviliges */
1633
raise_privileges();
1634
1635
#ifdef __linux__
1636
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1637
messages about the network interface to mess up the prompt */
1638
int ret_linux = klogctl(8, NULL, 5);
1639
bool restore_loglevel = true;
1640
if(ret_linux == -1){
1641
restore_loglevel = false;
1642
perror_plus("klogctl");
1643
}
1644
#endif /* __linux__ */
1645
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1646
ret_errno = errno;
1647
#ifdef __linux__
1648
if(restore_loglevel){
1649
ret_linux = klogctl(7, NULL, 0);
1650
if(ret_linux == -1){
1651
perror_plus("klogctl");
1652
}
1653
}
1654
#endif /* __linux__ */
1655
1656
/* Lower privileges */
1657
lower_privileges();
1658
1659
/* Close the socket */
1660
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1661
if(ret == -1){
1662
perror_plus("close");
1663
}
1664
1665
if(ret_setflags == -1){
1666
errno = ret_errno;
1667
perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1668
errno = old_errno;
1669
return ret_errno;
1670
}
1671
} else if(debug){
1672
fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
1673
interface);
1674
}
1675
1676
/* Sleep checking until interface is running.
1677
Check every 0.25s, up to total time of delay */
1678
for(int i=0; i < delay * 4; i++){
1679
if(interface_is_running(interface)){
1680
break;
1681
}
1682
struct timespec sleeptime = { .tv_nsec = 250000000 };
1683
ret = nanosleep(&sleeptime, NULL);
1684
if(ret == -1 and errno != EINTR){
1685
perror_plus("nanosleep");
1686
}
1687
}
1688
1689
errno = old_errno;
1690
return 0;
1691
}
1692
1693
error_t take_down_interface(const char *const interface){
1694
int sd = -1;
1695
error_t old_errno = errno;
1696
error_t ret_errno = 0;
1697
int ret, ret_setflags;
1698
struct ifreq network;
1699
unsigned int if_index = if_nametoindex(interface);
1700
if(if_index == 0){
1701
fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
1702
errno = old_errno;
1703
return ENXIO;
1704
}
1705
if(interface_is_up(interface)){
1706
if(not get_flags(interface, &network) and debug){
1707
ret_errno = errno;
1708
fprintf_plus(stderr, "Failed to get flags for interface "
1709
"\"%s\"\n", interface);
1710
return ret_errno;
1711
}
1712
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1713
1714
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1715
if(sd < 0){
1716
ret_errno = errno;
1717
perror_plus("socket");
1718
errno = old_errno;
1719
return ret_errno;
1720
}
1721
1722
if(debug){
1723
fprintf_plus(stderr, "Taking down interface \"%s\"\n",
1724
interface);
1725
}
1726
1727
/* Raise priviliges */
1728
raise_privileges();
1729
1730
ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
1731
ret_errno = errno;
1732
1733
/* Lower privileges */
1734
lower_privileges();
1735
1736
/* Close the socket */
1737
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1738
if(ret == -1){
1739
perror_plus("close");
1740
}
1741
1742
if(ret_setflags == -1){
1743
errno = ret_errno;
1744
perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1745
errno = old_errno;
1746
return ret_errno;
1747
}
1748
} else if(debug){
1749
fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
1750
interface);
1751
}
1752
1753
errno = old_errno;
1754
return 0;
1755
}
1756
1757
int main(int argc, char *argv[]){
1758
mandos_context mc = { .server = NULL, .dh_bits = 1024,
1759
.priority = "SECURE256:!CTYPE-X.509:"
1760
"+CTYPE-OPENPGP", .current_server = NULL,
1761
.interfaces = NULL, .interfaces_size = 0 };
1762
AvahiSServiceBrowser *sb = NULL;
1763
error_t ret_errno;
1764
int ret;
1765
intmax_t tmpmax;
1766
char *tmp;
1767
int exitcode = EXIT_SUCCESS;
1768
char *interfaces_to_take_down = NULL;
1769
size_t interfaces_to_take_down_size = 0;
1770
char tempdir[] = "/tmp/mandosXXXXXX";
1771
bool tempdir_created = false;
1772
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1773
const char *seckey = PATHDIR "/" SECKEY;
1774
const char *pubkey = PATHDIR "/" PUBKEY;
1775
char *interfaces_hooks = NULL;
1776
size_t interfaces_hooks_size = 0;
1777
1778
bool gnutls_initialized = false;
1779
bool gpgme_initialized = false;
1780
float delay = 2.5f;
1781
double retry_interval = 10; /* 10s between trying a server and
1782
retrying the same server again */
1783
1784
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1785
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1786
1787
uid = getuid();
1788
gid = getgid();
1789
1790
/* Lower any group privileges we might have, just to be safe */
1791
errno = 0;
1792
ret = setgid(gid);
1793
if(ret == -1){
1794
perror_plus("setgid");
1795
}
1796
1797
/* Lower user privileges (temporarily) */
1798
errno = 0;
1799
ret = seteuid(uid);
1800
if(ret == -1){
1801
perror_plus("seteuid");
1802
}
1803
1804
if(quit_now){
1805
goto end;
1806
}
1807
1808
{
1809
struct argp_option options[] = {
1810
{ .name = "debug", .key = 128,
1811
.doc = "Debug mode", .group = 3 },
1812
{ .name = "connect", .key = 'c',
1813
.arg = "ADDRESS:PORT",
1814
.doc = "Connect directly to a specific Mandos server",
1815
.group = 1 },
1816
{ .name = "interface", .key = 'i',
1817
.arg = "NAME",
1818
.doc = "Network interface that will be used to search for"
1819
" Mandos servers",
1820
.group = 1 },
1821
{ .name = "seckey", .key = 's',
1822
.arg = "FILE",
1823
.doc = "OpenPGP secret key file base name",
1824
.group = 1 },
1825
{ .name = "pubkey", .key = 'p',
1826
.arg = "FILE",
1827
.doc = "OpenPGP public key file base name",
1828
.group = 2 },
1829
{ .name = "dh-bits", .key = 129,
1830
.arg = "BITS",
1831
.doc = "Bit length of the prime number used in the"
1832
" Diffie-Hellman key exchange",
1833
.group = 2 },
1834
{ .name = "priority", .key = 130,
1835
.arg = "STRING",
1836
.doc = "GnuTLS priority string for the TLS handshake",
1837
.group = 1 },
1838
{ .name = "delay", .key = 131,
1839
.arg = "SECONDS",
1840
.doc = "Maximum delay to wait for interface startup",
1841
.group = 2 },
1842
{ .name = "retry", .key = 132,
1843
.arg = "SECONDS",
1844
.doc = "Retry interval used when denied by the Mandos server",
1845
.group = 2 },
1846
{ .name = "network-hook-dir", .key = 133,
1847
.arg = "DIR",
1848
.doc = "Directory where network hooks are located",
1849
.group = 2 },
1850
/*
1851
* These reproduce what we would get without ARGP_NO_HELP
1852
*/
1853
{ .name = "help", .key = '?',
1854
.doc = "Give this help list", .group = -1 },
1855
{ .name = "usage", .key = -3,
1856
.doc = "Give a short usage message", .group = -1 },
1857
{ .name = "version", .key = 'V',
1858
.doc = "Print program version", .group = -1 },
1859
{ .name = NULL }
1860
};
1861
1862
error_t parse_opt(int key, char *arg,
1863
struct argp_state *state){
1864
errno = 0;
1865
switch(key){
1866
case 128: /* --debug */
1867
debug = true;
1868
break;
1869
case 'c': /* --connect */
1870
connect_to = arg;
1871
break;
1872
case 'i': /* --interface */
1873
ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
1874
arg, (int)',');
1875
if(ret_errno != 0){
1876
argp_error(state, "%s", strerror(ret_errno));
1877
}
1878
break;
1879
case 's': /* --seckey */
1880
seckey = arg;
1881
break;
1882
case 'p': /* --pubkey */
1883
pubkey = arg;
1884
break;
1885
case 129: /* --dh-bits */
1886
errno = 0;
1887
tmpmax = strtoimax(arg, &tmp, 10);
1888
if(errno != 0 or tmp == arg or *tmp != '\0'
1889
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1890
argp_error(state, "Bad number of DH bits");
1891
}
1892
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1893
break;
1894
case 130: /* --priority */
1895
mc.priority = arg;
1896
break;
1897
case 131: /* --delay */
1898
errno = 0;
1899
delay = strtof(arg, &tmp);
1900
if(errno != 0 or tmp == arg or *tmp != '\0'){
1901
argp_error(state, "Bad delay");
1902
}
1903
case 132: /* --retry */
1904
errno = 0;
1905
retry_interval = strtod(arg, &tmp);
1906
if(errno != 0 or tmp == arg or *tmp != '\0'
1907
or (retry_interval * 1000) > INT_MAX
1908
or retry_interval < 0){
1909
argp_error(state, "Bad retry interval");
1910
}
1911
break;
1912
case 133: /* --network-hook-dir */
1913
hookdir = arg;
1914
break;
1915
/*
1916
* These reproduce what we would get without ARGP_NO_HELP
1917
*/
1918
case '?': /* --help */
1919
argp_state_help(state, state->out_stream,
1920
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1921
& ~(unsigned int)ARGP_HELP_EXIT_OK);
1922
case -3: /* --usage */
1923
argp_state_help(state, state->out_stream,
1924
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1925
case 'V': /* --version */
1926
fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1927
exit(argp_err_exit_status);
1928
break;
1929
default:
1930
return ARGP_ERR_UNKNOWN;
1931
}
1932
return errno;
1933
}
1934
1935
struct argp argp = { .options = options, .parser = parse_opt,
1936
.args_doc = "",
1937
.doc = "Mandos client -- Get and decrypt"
1938
" passwords from a Mandos server" };
1939
ret = argp_parse(&argp, argc, argv,
1940
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1941
switch(ret){
1942
case 0:
1943
break;
1944
case ENOMEM:
1945
default:
1946
errno = ret;
1947
perror_plus("argp_parse");
1948
exitcode = EX_OSERR;
1949
goto end;
1950
case EINVAL:
1951
exitcode = EX_USAGE;
1952
goto end;
1953
}
1954
}
1955
1956
{
1957
/* Work around Debian bug #633582:
1958
<http://bugs.debian.org/633582> */
1959
1960
/* Re-raise priviliges */
1961
if(raise_privileges() == 0){
1962
struct stat st;
1963
1964
if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1965
int seckey_fd = open(seckey, O_RDONLY);
1966
if(seckey_fd == -1){
1967
perror_plus("open");
1968
} else {
1969
ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1970
if(ret == -1){
1971
perror_plus("fstat");
1972
} else {
1973
if(S_ISREG(st.st_mode)
1974
and st.st_uid == 0 and st.st_gid == 0){
1975
ret = fchown(seckey_fd, uid, gid);
1976
if(ret == -1){
1977
perror_plus("fchown");
1978
}
1979
}
1980
}
1981
TEMP_FAILURE_RETRY(close(seckey_fd));
1982
}
1983
}
1984
1985
if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1986
int pubkey_fd = open(pubkey, O_RDONLY);
1987
if(pubkey_fd == -1){
1988
perror_plus("open");
1989
} else {
1990
ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1991
if(ret == -1){
1992
perror_plus("fstat");
1993
} else {
1994
if(S_ISREG(st.st_mode)
1995
and st.st_uid == 0 and st.st_gid == 0){
1996
ret = fchown(pubkey_fd, uid, gid);
1997
if(ret == -1){
1998
perror_plus("fchown");
1999
}
2000
}
2001
}
2002
TEMP_FAILURE_RETRY(close(pubkey_fd));
2003
}
2004
}
2005
2006
/* Lower privileges */
2007
errno = 0;
2008
ret = seteuid(uid);
1133
}
1134
}
1135
closedir(d);
1136
}
1137
ret = rmdir(tempdir);
2009
1138
if(ret == -1){
2010
perror_plus("seteuid");
2011
}
2012
}
2013
}
2014
2015
/* Remove empty interface names */
2016
{
2017
char *interface = NULL;
2018
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2019
interface))){
2020
if(if_nametoindex(interface) == 0){
2021
if(interface[0] != '\0' and strcmp(interface, "none") != 0){
2022
fprintf_plus(stderr, "Not using nonexisting interface"
2023
" \"%s\"\n", interface);
2024
}
2025
argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
2026
interface = NULL;
2027
}
2028
}
2029
}
2030
2031
/* Run network hooks */
2032
{
2033
2034
if(mc.interfaces != NULL){
2035
interfaces_hooks = malloc(mc.interfaces_size);
2036
if(interfaces_hooks == NULL){
2037
perror_plus("malloc");
2038
goto end;
2039
}
2040
memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
2041
interfaces_hooks_size = mc.interfaces_size;
2042
argz_stringify(interfaces_hooks, interfaces_hooks_size,
2043
(int)',');
2044
}
2045
if(not run_network_hooks("start", interfaces_hooks != NULL ?
2046
interfaces_hooks : "", delay)){
2047
goto end;
2048
}
2049
}
2050
2051
if(not debug){
2052
avahi_set_log_function(empty_log);
2053
}
2054
2055
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
2056
from the signal handler */
2057
/* Initialize the pseudo-RNG for Avahi */
2058
srand((unsigned int) time(NULL));
2059
simple_poll = avahi_simple_poll_new();
2060
if(simple_poll == NULL){
2061
fprintf_plus(stderr,
2062
"Avahi: Failed to create simple poll object.\n");
2063
exitcode = EX_UNAVAILABLE;
2064
goto end;
2065
}
2066
2067
sigemptyset(&sigterm_action.sa_mask);
2068
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
2069
if(ret == -1){
2070
perror_plus("sigaddset");
2071
exitcode = EX_OSERR;
2072
goto end;
2073
}
2074
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
2075
if(ret == -1){
2076
perror_plus("sigaddset");
2077
exitcode = EX_OSERR;
2078
goto end;
2079
}
2080
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
2081
if(ret == -1){
2082
perror_plus("sigaddset");
2083
exitcode = EX_OSERR;
2084
goto end;
2085
}
2086
/* Need to check if the handler is SIG_IGN before handling:
2087
| [[info:libc:Initial Signal Actions]] |
2088
| [[info:libc:Basic Signal Handling]] |
2089
*/
2090
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
2091
if(ret == -1){
2092
perror_plus("sigaction");
2093
return EX_OSERR;
2094
}
2095
if(old_sigterm_action.sa_handler != SIG_IGN){
2096
ret = sigaction(SIGINT, &sigterm_action, NULL);
2097
if(ret == -1){
2098
perror_plus("sigaction");
2099
exitcode = EX_OSERR;
2100
goto end;
2101
}
2102
}
2103
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
2104
if(ret == -1){
2105
perror_plus("sigaction");
2106
return EX_OSERR;
2107
}
2108
if(old_sigterm_action.sa_handler != SIG_IGN){
2109
ret = sigaction(SIGHUP, &sigterm_action, NULL);
2110
if(ret == -1){
2111
perror_plus("sigaction");
2112
exitcode = EX_OSERR;
2113
goto end;
2114
}
2115
}
2116
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
2117
if(ret == -1){
2118
perror_plus("sigaction");
2119
return EX_OSERR;
2120
}
2121
if(old_sigterm_action.sa_handler != SIG_IGN){
2122
ret = sigaction(SIGTERM, &sigterm_action, NULL);
2123
if(ret == -1){
2124
perror_plus("sigaction");
2125
exitcode = EX_OSERR;
2126
goto end;
2127
}
2128
}
2129
2130
/* If no interfaces were specified, make a list */
2131
if(mc.interfaces == NULL){
2132
struct dirent **direntries;
2133
/* Look for any good interfaces */
2134
ret = scandir(sys_class_net, &direntries, good_interface,
2135
alphasort);
2136
if(ret >= 1){
2137
/* Add all found interfaces to interfaces list */
2138
for(int i = 0; i < ret; ++i){
2139
ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
2140
direntries[i]->d_name);
2141
if(ret_errno != 0){
2142
perror_plus("argz_add");
2143
continue;
2144
}
2145
if(debug){
2146
fprintf_plus(stderr, "Will use interface \"%s\"\n",
2147
direntries[i]->d_name);
2148
}
2149
}
2150
free(direntries);
2151
} else {
2152
free(direntries);
2153
fprintf_plus(stderr, "Could not find a network interface\n");
2154
exitcode = EXIT_FAILURE;
2155
goto end;
2156
}
2157
}
2158
2159
/* If we only got one interface, explicitly use only that one */
2160
if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
2161
if(debug){
2162
fprintf_plus(stderr, "Using only interface \"%s\"\n",
2163
mc.interfaces);
2164
}
2165
if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
2166
}
2167
2168
/* Bring up interfaces which are down */
2169
if(not (argz_count(mc.interfaces, mc.interfaces_size) == 1
2170
and strcmp(mc.interfaces, "none") == 0)){
2171
char *interface = NULL;
2172
while((interface = argz_next(mc.interfaces, mc.interfaces_size,
2173
interface))){
2174
bool interface_was_up = interface_is_up(interface);
2175
ret = bring_up_interface(interface, delay);
2176
if(not interface_was_up){
2177
if(ret != 0){
2178
errno = ret;
2179
perror_plus("Failed to bring up interface");
2180
} else {
2181
ret_errno = argz_add(&interfaces_to_take_down,
2182
&interfaces_to_take_down_size,
2183
interface);
2184
}
2185
}
2186
}
2187
free(mc.interfaces);
2188
mc.interfaces = NULL;
2189
mc.interfaces_size = 0;
2190
if(debug and (interfaces_to_take_down == NULL)){
2191
fprintf_plus(stderr, "No interfaces were brought up\n");
2192
}
2193
}
2194
2195
if(quit_now){
2196
goto end;
2197
}
2198
2199
ret = init_gnutls_global(pubkey, seckey, &mc);
2200
if(ret == -1){
2201
fprintf_plus(stderr, "init_gnutls_global failed\n");
2202
exitcode = EX_UNAVAILABLE;
2203
goto end;
2204
} else {
2205
gnutls_initialized = true;
2206
}
2207
2208
if(quit_now){
2209
goto end;
2210
}
2211
2212
if(mkdtemp(tempdir) == NULL){
2213
perror_plus("mkdtemp");
2214
goto end;
2215
}
2216
tempdir_created = true;
2217
2218
if(quit_now){
2219
goto end;
2220
}
2221
2222
if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
2223
fprintf_plus(stderr, "init_gpgme failed\n");
2224
exitcode = EX_UNAVAILABLE;
2225
goto end;
2226
} else {
2227
gpgme_initialized = true;
2228
}
2229
2230
if(quit_now){
2231
goto end;
2232
}
2233
2234
if(connect_to != NULL){
2235
/* Connect directly, do not use Zeroconf */
2236
/* (Mainly meant for debugging) */
2237
char *address = strrchr(connect_to, ':');
2238
2239
if(address == NULL){
2240
fprintf_plus(stderr, "No colon in address\n");
2241
exitcode = EX_USAGE;
2242
goto end;
2243
}
2244
2245
if(quit_now){
2246
goto end;
2247
}
2248
2249
in_port_t port;
2250
errno = 0;
2251
tmpmax = strtoimax(address+1, &tmp, 10);
2252
if(errno != 0 or tmp == address+1 or *tmp != '\0'
2253
or tmpmax != (in_port_t)tmpmax){
2254
fprintf_plus(stderr, "Bad port number\n");
2255
exitcode = EX_USAGE;
2256
goto end;
2257
}
2258
2259
if(quit_now){
2260
goto end;
2261
}
2262
2263
port = (in_port_t)tmpmax;
2264
*address = '\0';
2265
/* Colon in address indicates IPv6 */
2266
int af;
2267
if(strchr(connect_to, ':') != NULL){
2268
af = AF_INET6;
2269
/* Accept [] around IPv6 address - see RFC 5952 */
2270
if(connect_to[0] == '[' and address[-1] == ']')
2271
{
2272
connect_to++;
2273
address[-1] = '\0';
2274
}
2275
} else {
2276
af = AF_INET;
2277
}
2278
address = connect_to;
2279
2280
if(quit_now){
2281
goto end;
2282
}
2283
2284
while(not quit_now){
2285
ret = start_mandos_communication(address, port, if_index, af,
2286
&mc);
2287
if(quit_now or ret == 0){
2288
break;
2289
}
2290
if(debug){
2291
fprintf_plus(stderr, "Retrying in %d seconds\n",
2292
(int)retry_interval);
2293
}
2294
sleep((int)retry_interval);
2295
}
2296
2297
if (not quit_now){
2298
exitcode = EXIT_SUCCESS;
2299
}
2300
2301
goto end;
2302
}
2303
2304
if(quit_now){
2305
goto end;
2306
}
2307
2308
{
2309
AvahiServerConfig config;
2310
/* Do not publish any local Zeroconf records */
2311
avahi_server_config_init(&config);
2312
config.publish_hinfo = 0;
2313
config.publish_addresses = 0;
2314
config.publish_workstation = 0;
2315
config.publish_domain = 0;
2316
2317
/* Allocate a new server */
2318
mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
2319
&config, NULL, NULL, &ret_errno);
2320
2321
/* Free the Avahi configuration data */
2322
avahi_server_config_free(&config);
2323
}
2324
2325
/* Check if creating the Avahi server object succeeded */
2326
if(mc.server == NULL){
2327
fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
2328
avahi_strerror(ret_errno));
2329
exitcode = EX_UNAVAILABLE;
2330
goto end;
2331
}
2332
2333
if(quit_now){
2334
goto end;
2335
}
2336
2337
/* Create the Avahi service browser */
2338
sb = avahi_s_service_browser_new(mc.server, if_index,
2339
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
2340
NULL, 0, browse_callback,
2341
(void *)&mc);
2342
if(sb == NULL){
2343
fprintf_plus(stderr, "Failed to create service browser: %s\n",
2344
avahi_strerror(avahi_server_errno(mc.server)));
2345
exitcode = EX_UNAVAILABLE;
2346
goto end;
2347
}
2348
2349
if(quit_now){
2350
goto end;
2351
}
2352
2353
/* Run the main loop */
2354
2355
if(debug){
2356
fprintf_plus(stderr, "Starting Avahi loop search\n");
2357
}
2358
2359
ret = avahi_loop_with_timeout(simple_poll,
2360
(int)(retry_interval * 1000), &mc);
2361
if(debug){
2362
fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
2363
(ret == 0) ? "successfully" : "with error");
2364
}
2365
2366
end:
2367
2368
if(debug){
2369
fprintf_plus(stderr, "%s exiting\n", argv[0]);
2370
}
2371
2372
/* Cleanup things */
2373
if(sb != NULL)
2374
avahi_s_service_browser_free(sb);
2375
2376
if(mc.server != NULL)
2377
avahi_server_free(mc.server);
2378
2379
if(simple_poll != NULL)
2380
avahi_simple_poll_free(simple_poll);
2381
2382
if(gnutls_initialized){
2383
gnutls_certificate_free_credentials(mc.cred);
2384
gnutls_global_deinit();
2385
gnutls_dh_params_deinit(mc.dh_params);
2386
}
2387
2388
if(gpgme_initialized){
2389
gpgme_release(mc.ctx);
2390
}
2391
2392
/* Cleans up the circular linked list of Mandos servers the client
2393
has seen */
2394
if(mc.current_server != NULL){
2395
mc.current_server->prev->next = NULL;
2396
while(mc.current_server != NULL){
2397
server *next = mc.current_server->next;
2398
free(mc.current_server);
2399
mc.current_server = next;
2400
}
2401
}
2402
2403
/* Re-raise priviliges */
2404
{
2405
raise_privileges();
2406
2407
/* Run network hooks */
2408
run_network_hooks("stop", interfaces_hooks != NULL ?
2409
interfaces_hooks : "", delay);
2410
2411
/* Take down the network interfaces which were brought up */
2412
{
2413
char *interface = NULL;
2414
while((interface=argz_next(interfaces_to_take_down,
2415
interfaces_to_take_down_size,
2416
interface))){
2417
ret_errno = take_down_interface(interface);
2418
if(ret_errno != 0){
2419
errno = ret_errno;
2420
perror_plus("Failed to take down interface");
2421
}
2422
}
2423
if(debug and (interfaces_to_take_down == NULL)){
2424
fprintf_plus(stderr, "No interfaces needed to be taken"
2425
" down\n");
2426
}
2427
}
2428
2429
lower_privileges_permanently();
2430
}
2431
2432
free(interfaces_to_take_down);
2433
free(interfaces_hooks);
2434
2435
/* Removes the GPGME temp directory and all files inside */
2436
if(tempdir_created){
2437
struct dirent **direntries = NULL;
2438
struct dirent *direntry = NULL;
2439
int numentries = scandir(tempdir, &direntries, notdotentries,
2440
alphasort);
2441
if (numentries > 0){
2442
for(int i = 0; i < numentries; i++){
2443
direntry = direntries[i];
2444
char *fullname = NULL;
2445
ret = asprintf(&fullname, "%s/%s", tempdir,
2446
direntry->d_name);
2447
if(ret < 0){
2448
perror_plus("asprintf");
2449
continue;
2450
}
2451
ret = remove(fullname);
2452
if(ret == -1){
2453
fprintf_plus(stderr, "remove(\"%s\"): %s\n", fullname,
2454
strerror(errno));
2455
}
2456
free(fullname);
2457
}
2458
}
2459
2460
/* need to clean even if 0 because man page doesn't specify */
2461
free(direntries);
2462
if (numentries == -1){
2463
perror_plus("scandir");
2464
}
2465
ret = rmdir(tempdir);
2466
if(ret == -1 and errno != ENOENT){
2467
perror_plus("rmdir");
2468
}
2469
}
2470
2471
if(quit_now){
2472
sigemptyset(&old_sigterm_action.sa_mask);
2473
old_sigterm_action.sa_handler = SIG_DFL;
2474
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
2475
&old_sigterm_action,
2476
NULL));
2477
if(ret == -1){
2478
perror_plus("sigaction");
2479
}
2480
do {
2481
ret = raise(signal_received);
2482
} while(ret != 0 and errno == EINTR);
2483
if(ret != 0){
2484
perror_plus("raise");
2485
abort();
2486
}
2487
TEMP_FAILURE_RETRY(pause());
2488
}
2489
2490
return exitcode;
1139
perror("rmdir");
1140
}
1141
}
1142
1143
return exitcode;
2491
1144
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0