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