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/mandosclient.c
- browse files at revision 39
- compare with another revision
- download diff
- download tarball
- view history from revision 39
- Committer: Teddy Hogeborn
- Date: 2008-08-03 03:33:56 UTC
- Revision ID: teddy@fukt.bsnet.se-20080803033356-6aemgj0g0hoz91ow
* plugins.d/mandosclient.c (pgp_packet_decrypt): Renamed variables.
On debug, show
decrypted plaintext
in hexadecimal. Free
the GPGME data
buffers even on
errors.
On debug, show
decrypted plaintext
in hexadecimal. Free
the GPGME data
buffers even on
errors.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- debian/source
- files renamed:
- plugin-runner.c => plugbasedclient.c
- plugins.d/mandos-client.c => plugins.d/mandosclient.c
- plugins.d/password-prompt.c => plugins.d/passprompt.c
- mandos.conf => server.conf
- mandos => server.py
- files modified:
- Makefile
added
removed
plugins.d/mandosclient.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-2011 Teddy Hogeborn
13
* Copyright © 2008-2011 Björn Påhlsson
12
* Copyright © 2007-2008 Teddy Hogeborn & Björn Påhlsson
14
13
*
15
14
* This program is free software: you can redistribute it and/or
16
15
* modify it under the terms of the GNU General Public License as
30
29
*/
31
30
32
31
/* Needed by GPGME, specifically gpgme_data_seek() */
33
#ifndef _LARGEFILE_SOURCE
34
32
#define _LARGEFILE_SOURCE
35
#endif
36
#ifndef _FILE_OFFSET_BITS
37
33
#define _FILE_OFFSET_BITS 64
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 */
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() */
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
#include <time.h> /* nanosleep(), time(), sleep() */
34
35
#include <stdio.h>
36
#include <assert.h>
37
#include <stdlib.h>
38
#include <time.h>
39
#include <net/if.h> /* if_nametoindex */
40
#include <sys/ioctl.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
41
SIOCSIFFLAGS */
67
42
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
68
SIOCSIFFLAGS, if_indextoname(),
69
if_nametoindex(), IF_NAMESIZE */
70
#include <netinet/in.h> /* IN6_IS_ADDR_LINKLOCAL,
71
INET_ADDRSTRLEN, INET6_ADDRSTRLEN
72
*/
73
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
74
getuid(), getgid(), seteuid(),
75
setgid(), pause() */
76
#include <arpa/inet.h> /* inet_pton(), htons, inet_ntop() */
77
#include <iso646.h> /* not, or, and */
78
#include <argp.h> /* struct argp_option, error_t, struct
79
argp_state, struct argp,
80
argp_parse(), ARGP_KEY_ARG,
81
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
88
#ifdef __linux__
89
#include <sys/klog.h> /* klogctl() */
90
#endif /* __linux__ */
91
92
/* Avahi */
93
/* All Avahi types, constants and functions
94
Avahi*, avahi_*,
95
AVAHI_* */
43
SIOCSIFFLAGS */
44
96
45
#include <avahi-core/core.h>
97
46
#include <avahi-core/lookup.h>
98
47
#include <avahi-core/log.h>
100
49
#include <avahi-common/malloc.h>
101
50
#include <avahi-common/error.h>
102
51
103
/* GnuTLS */
104
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
105
functions:
106
gnutls_*
107
init_gnutls_session(),
108
GNUTLS_* */
109
#include <gnutls/openpgp.h>
110
/* gnutls_certificate_set_openpgp_key_file(),
111
GNUTLS_OPENPGP_FMT_BASE64 */
112
113
/* GPGME */
114
#include <gpgme.h> /* All GPGME types, constants and
115
functions:
116
gpgme_*
117
GPGME_PROTOCOL_OpenPGP,
118
GPG_ERR_NO_* */
52
//mandos client part
53
#include <sys/types.h> /* socket(), inet_pton() */
54
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
55
struct in6_addr, inet_pton() */
56
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
57
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
58
59
#include <unistd.h> /* close() */
60
#include <netinet/in.h>
61
#include <stdbool.h> /* true */
62
#include <string.h> /* memset */
63
#include <arpa/inet.h> /* inet_pton() */
64
#include <iso646.h> /* not */
65
66
// gpgme
67
#include <errno.h> /* perror() */
68
#include <gpgme.h>
69
70
// getopt_long
71
#include <getopt.h>
119
72
120
73
#define BUFFER_SIZE 256
121
74
122
#define PATHDIR "/conf/conf.d/mandos"
123
#define SECKEY "seckey.txt"
124
#define PUBKEY "pubkey.txt"
75
static const char *keydir = "/conf/conf.d/mandos";
76
static const char *pubkeyfile = "pubkey.txt";
77
static const char *seckeyfile = "seckey.txt";
125
78
126
79
bool debug = false;
127
static const char mandos_protocol_version[] = "1";
128
const char *argp_program_version = "mandos-client " VERSION;
129
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
130
static const char sys_class_net[] = "/sys/class/net";
131
char *connect_to = NULL;
132
80
133
/* Used for passing in values through the Avahi callback functions */
81
/* Used for passing in values through all the callback functions */
134
82
typedef struct {
135
83
AvahiSimplePoll *simple_poll;
136
84
AvahiServer *server;
137
85
gnutls_certificate_credentials_t cred;
138
86
unsigned int dh_bits;
139
gnutls_dh_params_t dh_params;
140
87
const char *priority;
88
} mandos_context;
89
90
/*
91
* Decrypt OpenPGP data using keyrings in HOMEDIR.
92
* Returns -1 on error
93
*/
94
static ssize_t pgp_packet_decrypt (const char *cryptotext,
95
size_t crypto_size,
96
char **plaintext,
97
const char *homedir){
98
gpgme_data_t dh_crypto, dh_plain;
141
99
gpgme_ctx_t ctx;
142
} mandos_context;
143
144
/* global context so signal handler can reach it*/
145
mandos_context mc = { .simple_poll = NULL, .server = NULL,
146
.dh_bits = 1024, .priority = "SECURE256"
147
":!CTYPE-X.509:+CTYPE-OPENPGP" };
148
149
sig_atomic_t quit_now = 0;
150
int signal_received = 0;
151
152
/*
153
* Make additional room in "buffer" for at least BUFFER_SIZE more
154
* bytes. "buffer_capacity" is how much is currently allocated,
155
* "buffer_length" is how much is already used.
156
*/
157
size_t incbuffer(char **buffer, size_t buffer_length,
158
size_t buffer_capacity){
159
if(buffer_length + BUFFER_SIZE > buffer_capacity){
160
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
161
if(buffer == NULL){
162
return 0;
163
}
164
buffer_capacity += BUFFER_SIZE;
165
}
166
return buffer_capacity;
167
}
168
169
/*
170
* Initialize GPGME.
171
*/
172
static bool init_gpgme(const char *seckey,
173
const char *pubkey, const char *tempdir){
174
100
gpgme_error_t rc;
101
ssize_t ret;
102
ssize_t plaintext_capacity = 0;
103
ssize_t plaintext_length = 0;
175
104
gpgme_engine_info_t engine_info;
176
105
177
178
/*
179
* Helper function to insert pub and seckey to the engine keyring.
180
*/
181
bool import_key(const char *filename){
182
int ret;
183
int fd;
184
gpgme_data_t pgp_data;
185
186
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
187
if(fd == -1){
188
perror("open");
189
return false;
190
}
191
192
rc = gpgme_data_new_from_fd(&pgp_data, fd);
193
if(rc != GPG_ERR_NO_ERROR){
194
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
195
gpgme_strsource(rc), gpgme_strerror(rc));
196
return false;
197
}
198
199
rc = gpgme_op_import(mc.ctx, pgp_data);
200
if(rc != GPG_ERR_NO_ERROR){
201
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
202
gpgme_strsource(rc), gpgme_strerror(rc));
203
return false;
204
}
205
206
ret = (int)TEMP_FAILURE_RETRY(close(fd));
207
if(ret == -1){
208
perror("close");
209
}
210
gpgme_data_release(pgp_data);
211
return true;
212
}
213
214
if(debug){
215
fprintf(stderr, "Initializing GPGME\n");
106
if (debug){
107
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
216
108
}
217
109
218
110
/* Init GPGME */
219
111
gpgme_check_version(NULL);
220
112
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
221
if(rc != GPG_ERR_NO_ERROR){
113
if (rc != GPG_ERR_NO_ERROR){
222
114
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
223
115
gpgme_strsource(rc), gpgme_strerror(rc));
224
return false;
116
return -1;
225
117
}
226
118
227
/* Set GPGME home directory for the OpenPGP engine only */
228
rc = gpgme_get_engine_info(&engine_info);
229
if(rc != GPG_ERR_NO_ERROR){
119
/* Set GPGME home directory for the OpenPGP engine only */
120
rc = gpgme_get_engine_info (&engine_info);
121
if (rc != GPG_ERR_NO_ERROR){
230
122
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
231
123
gpgme_strsource(rc), gpgme_strerror(rc));
232
return false;
124
return -1;
233
125
}
234
126
while(engine_info != NULL){
235
127
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
236
128
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
237
engine_info->file_name, tempdir);
129
engine_info->file_name, homedir);
238
130
break;
239
131
}
240
132
engine_info = engine_info->next;
241
133
}
242
134
if(engine_info == NULL){
243
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
244
return false;
245
}
246
247
/* Create new GPGME "context" */
248
rc = gpgme_new(&(mc.ctx));
249
if(rc != GPG_ERR_NO_ERROR){
250
fprintf(stderr, "bad gpgme_new: %s: %s\n",
251
gpgme_strsource(rc), gpgme_strerror(rc));
252
return false;
253
}
254
255
if(not import_key(pubkey) or not import_key(seckey)){
256
return false;
257
}
258
259
return true;
260
}
261
262
/*
263
* Decrypt OpenPGP data.
264
* Returns -1 on error
265
*/
266
static ssize_t pgp_packet_decrypt(const char *cryptotext,
267
size_t crypto_size,
268
char **plaintext){
269
gpgme_data_t dh_crypto, dh_plain;
270
gpgme_error_t rc;
271
ssize_t ret;
272
size_t plaintext_capacity = 0;
273
ssize_t plaintext_length = 0;
274
275
if(debug){
276
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
135
fprintf(stderr, "Could not set GPGME home dir to %s\n", homedir);
136
return -1;
277
137
}
278
138
279
139
/* Create new GPGME data buffer from memory cryptotext */
280
140
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
281
141
0);
282
if(rc != GPG_ERR_NO_ERROR){
142
if (rc != GPG_ERR_NO_ERROR){
283
143
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
284
144
gpgme_strsource(rc), gpgme_strerror(rc));
285
145
return -1;
287
147
288
148
/* Create new empty GPGME data buffer for the plaintext */
289
149
rc = gpgme_data_new(&dh_plain);
290
if(rc != GPG_ERR_NO_ERROR){
150
if (rc != GPG_ERR_NO_ERROR){
291
151
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
292
152
gpgme_strsource(rc), gpgme_strerror(rc));
293
153
gpgme_data_release(dh_crypto);
294
154
return -1;
295
155
}
296
156
157
/* Create new GPGME "context" */
158
rc = gpgme_new(&ctx);
159
if (rc != GPG_ERR_NO_ERROR){
160
fprintf(stderr, "bad gpgme_new: %s: %s\n",
161
gpgme_strsource(rc), gpgme_strerror(rc));
162
plaintext_length = -1;
163
goto decrypt_end;
164
}
165
297
166
/* Decrypt data from the cryptotext data buffer to the plaintext
298
167
data buffer */
299
rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
300
if(rc != GPG_ERR_NO_ERROR){
168
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
169
if (rc != GPG_ERR_NO_ERROR){
301
170
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
302
171
gpgme_strsource(rc), gpgme_strerror(rc));
303
172
plaintext_length = -1;
304
if(debug){
305
gpgme_decrypt_result_t result;
306
result = gpgme_op_decrypt_result(mc.ctx);
307
if(result == NULL){
308
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
309
} else {
310
fprintf(stderr, "Unsupported algorithm: %s\n",
311
result->unsupported_algorithm);
312
fprintf(stderr, "Wrong key usage: %u\n",
313
result->wrong_key_usage);
314
if(result->file_name != NULL){
315
fprintf(stderr, "File name: %s\n", result->file_name);
316
}
317
gpgme_recipient_t recipient;
318
recipient = result->recipients;
173
goto decrypt_end;
174
}
175
176
if(debug){
177
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
178
}
179
180
if (debug){
181
gpgme_decrypt_result_t result;
182
result = gpgme_op_decrypt_result(ctx);
183
if (result == NULL){
184
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
185
} else {
186
fprintf(stderr, "Unsupported algorithm: %s\n",
187
result->unsupported_algorithm);
188
fprintf(stderr, "Wrong key usage: %d\n",
189
result->wrong_key_usage);
190
if(result->file_name != NULL){
191
fprintf(stderr, "File name: %s\n", result->file_name);
192
}
193
gpgme_recipient_t recipient;
194
recipient = result->recipients;
195
if(recipient){
319
196
while(recipient != NULL){
320
197
fprintf(stderr, "Public key algorithm: %s\n",
321
198
gpgme_pubkey_algo_name(recipient->pubkey_algo));
327
204
}
328
205
}
329
206
}
330
goto decrypt_end;
331
}
332
333
if(debug){
334
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
335
207
}
336
208
337
209
/* Seek back to the beginning of the GPGME plaintext data buffer */
338
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
339
perror("gpgme_data_seek");
210
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
211
perror("pgpme_data_seek");
340
212
plaintext_length = -1;
341
213
goto decrypt_end;
342
214
}
343
215
344
216
*plaintext = NULL;
345
217
while(true){
346
plaintext_capacity = incbuffer(plaintext,
347
(size_t)plaintext_length,
348
plaintext_capacity);
349
if(plaintext_capacity == 0){
350
perror("incbuffer");
218
if (plaintext_length + BUFFER_SIZE > plaintext_capacity){
219
*plaintext = realloc(*plaintext,
220
(unsigned int)plaintext_capacity
221
+ BUFFER_SIZE);
222
if (*plaintext == NULL){
223
perror("realloc");
351
224
plaintext_length = -1;
352
225
goto decrypt_end;
226
}
227
plaintext_capacity += BUFFER_SIZE;
353
228
}
354
229
355
230
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
356
231
BUFFER_SIZE);
357
232
/* Print the data, if any */
358
if(ret == 0){
233
if (ret == 0){
359
234
/* EOF */
360
235
break;
361
236
}
366
241
}
367
242
plaintext_length += ret;
368
243
}
369
244
370
245
if(debug){
371
246
fprintf(stderr, "Decrypted password is: ");
372
for(ssize_t i = 0; i < plaintext_length; i++){
247
for(size_t i = 0; i < plaintext_length; i++){
373
248
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
374
249
}
375
250
fprintf(stderr, "\n");
385
260
return plaintext_length;
386
261
}
387
262
388
static const char * safer_gnutls_strerror(int value){
389
const char *ret = gnutls_strerror(value); /* Spurious warning from
390
-Wunreachable-code */
391
if(ret == NULL)
263
static const char * safer_gnutls_strerror (int value) {
264
const char *ret = gnutls_strerror (value);
265
if (ret == NULL)
392
266
ret = "(unknown)";
393
267
return ret;
394
268
}
395
269
396
/* GnuTLS log function callback */
397
270
static void debuggnutls(__attribute__((unused)) int level,
398
271
const char* string){
399
fprintf(stderr, "GnuTLS: %s", string);
272
fprintf(stderr, "%s", string);
400
273
}
401
274
402
static int init_gnutls_global(const char *pubkeyfilename,
403
const char *seckeyfilename){
275
static int initgnutls(mandos_context *mc, gnutls_session_t *session,
276
gnutls_dh_params_t *dh_params){
277
const char *err;
404
278
int ret;
405
279
406
280
if(debug){
407
281
fprintf(stderr, "Initializing GnuTLS\n");
408
282
}
409
410
ret = gnutls_global_init();
411
if(ret != GNUTLS_E_SUCCESS){
412
fprintf(stderr, "GnuTLS global_init: %s\n",
413
safer_gnutls_strerror(ret));
283
284
if ((ret = gnutls_global_init ())
285
!= GNUTLS_E_SUCCESS) {
286
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
414
287
return -1;
415
288
}
416
289
417
if(debug){
418
/* "Use a log level over 10 to enable all debugging options."
419
* - GnuTLS manual
420
*/
290
if (debug){
421
291
gnutls_global_set_log_level(11);
422
292
gnutls_global_set_log_function(debuggnutls);
423
293
}
424
294
425
/* OpenPGP credentials */
426
ret = gnutls_certificate_allocate_credentials(&mc.cred);
427
if(ret != GNUTLS_E_SUCCESS){
428
fprintf(stderr, "GnuTLS memory error: %s\n",
429
safer_gnutls_strerror(ret));
430
gnutls_global_deinit();
295
/* openpgp credentials */
296
if ((ret = gnutls_certificate_allocate_credentials (&mc->cred))
297
!= GNUTLS_E_SUCCESS) {
298
fprintf (stderr, "memory error: %s\n",
299
safer_gnutls_strerror(ret));
431
300
return -1;
432
301
}
433
302
434
303
if(debug){
435
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
436
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
437
seckeyfilename);
304
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
305
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
306
seckeyfile);
438
307
}
439
308
440
309
ret = gnutls_certificate_set_openpgp_key_file
441
(mc.cred, pubkeyfilename, seckeyfilename,
442
GNUTLS_OPENPGP_FMT_BASE64);
443
if(ret != GNUTLS_E_SUCCESS){
444
fprintf(stderr,
445
"Error[%d] while reading the OpenPGP key pair ('%s',"
446
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
447
fprintf(stderr, "The GnuTLS error is: %s\n",
448
safer_gnutls_strerror(ret));
449
goto globalfail;
450
}
451
452
/* GnuTLS server initialization */
453
ret = gnutls_dh_params_init(&mc.dh_params);
454
if(ret != GNUTLS_E_SUCCESS){
455
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
456
" %s\n", safer_gnutls_strerror(ret));
457
goto globalfail;
458
}
459
ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
460
if(ret != GNUTLS_E_SUCCESS){
461
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
462
safer_gnutls_strerror(ret));
463
goto globalfail;
464
}
465
466
gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
467
468
return 0;
469
470
globalfail:
471
472
gnutls_certificate_free_credentials(mc.cred);
473
gnutls_global_deinit();
474
gnutls_dh_params_deinit(mc.dh_params);
475
return -1;
476
}
477
478
static int init_gnutls_session(gnutls_session_t *session){
479
int ret;
480
/* GnuTLS session creation */
481
do {
482
ret = gnutls_init(session, GNUTLS_SERVER);
483
if(quit_now){
484
return -1;
485
}
486
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
487
if(ret != GNUTLS_E_SUCCESS){
310
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
311
if (ret != GNUTLS_E_SUCCESS) {
312
fprintf
313
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
314
" '%s')\n",
315
ret, pubkeyfile, seckeyfile);
316
fprintf(stdout, "The Error is: %s\n",
317
safer_gnutls_strerror(ret));
318
return -1;
319
}
320
321
//GnuTLS server initialization
322
if ((ret = gnutls_dh_params_init(dh_params))
323
!= GNUTLS_E_SUCCESS) {
324
fprintf (stderr, "Error in dh parameter initialization: %s\n",
325
safer_gnutls_strerror(ret));
326
return -1;
327
}
328
329
if ((ret = gnutls_dh_params_generate2(*dh_params, mc->dh_bits))
330
!= GNUTLS_E_SUCCESS) {
331
fprintf (stderr, "Error in prime generation: %s\n",
332
safer_gnutls_strerror(ret));
333
return -1;
334
}
335
336
gnutls_certificate_set_dh_params(mc->cred, *dh_params);
337
338
// GnuTLS session creation
339
if ((ret = gnutls_init(session, GNUTLS_SERVER))
340
!= GNUTLS_E_SUCCESS){
488
341
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
489
342
safer_gnutls_strerror(ret));
490
343
}
491
344
492
{
493
const char *err;
494
do {
495
ret = gnutls_priority_set_direct(*session, mc.priority, &err);
496
if(quit_now){
497
gnutls_deinit(*session);
498
return -1;
499
}
500
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
501
if(ret != GNUTLS_E_SUCCESS){
502
fprintf(stderr, "Syntax error at: %s\n", err);
503
fprintf(stderr, "GnuTLS error: %s\n",
504
safer_gnutls_strerror(ret));
505
gnutls_deinit(*session);
506
return -1;
507
}
345
if ((ret = gnutls_priority_set_direct(*session, mc->priority, &err))
346
!= GNUTLS_E_SUCCESS) {
347
fprintf(stderr, "Syntax error at: %s\n", err);
348
fprintf(stderr, "GnuTLS error: %s\n",
349
safer_gnutls_strerror(ret));
350
return -1;
508
351
}
509
352
510
do {
511
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
512
mc.cred);
513
if(quit_now){
514
gnutls_deinit(*session);
515
return -1;
516
}
517
} while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
518
if(ret != GNUTLS_E_SUCCESS){
519
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
353
if ((ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
354
mc->cred))
355
!= GNUTLS_E_SUCCESS) {
356
fprintf(stderr, "Error setting a credentials set: %s\n",
520
357
safer_gnutls_strerror(ret));
521
gnutls_deinit(*session);
522
358
return -1;
523
359
}
524
360
525
361
/* ignore client certificate if any. */
526
gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
362
gnutls_certificate_server_set_request (*session,
363
GNUTLS_CERT_IGNORE);
527
364
528
gnutls_dh_set_prime_bits(*session, mc.dh_bits);
365
gnutls_dh_set_prime_bits (*session, mc->dh_bits);
529
366
530
367
return 0;
531
368
}
532
369
533
/* Avahi log function callback */
534
370
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
535
371
__attribute__((unused)) const char *txt){}
536
372
537
/* Called when a Mandos server is found */
538
373
static int start_mandos_communication(const char *ip, uint16_t port,
539
374
AvahiIfIndex if_index,
540
int af){
541
int ret, tcp_sd = -1;
542
ssize_t sret;
543
union {
544
struct sockaddr_in in;
545
struct sockaddr_in6 in6;
546
} to;
375
mandos_context *mc){
376
int ret, tcp_sd;
377
struct sockaddr_in6 to;
547
378
char *buffer = NULL;
548
char *decrypted_buffer = NULL;
379
char *decrypted_buffer;
549
380
size_t buffer_length = 0;
550
381
size_t buffer_capacity = 0;
551
size_t written;
552
int retval = -1;
382
ssize_t decrypted_buffer_size;
383
size_t written = 0;
384
int retval = 0;
385
char interface[IF_NAMESIZE];
553
386
gnutls_session_t session;
554
int pf; /* Protocol family */
555
556
errno = 0;
557
558
if(quit_now){
559
errno = EINTR;
560
return -1;
561
}
562
563
switch(af){
564
case AF_INET6:
565
pf = PF_INET6;
566
break;
567
case AF_INET:
568
pf = PF_INET;
569
break;
570
default:
571
fprintf(stderr, "Bad address family: %d\n", af);
572
errno = EINVAL;
573
return -1;
574
}
575
576
ret = init_gnutls_session(&session);
577
if(ret != 0){
578
return -1;
579
}
387
gnutls_dh_params_t dh_params;
580
388
581
389
if(debug){
582
fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
583
"\n", ip, port);
390
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
391
ip, port);
584
392
}
585
393
586
tcp_sd = socket(pf, SOCK_STREAM, 0);
587
if(tcp_sd < 0){
588
int e = errno;
394
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
395
if(tcp_sd < 0) {
589
396
perror("socket");
590
errno = e;
591
goto mandos_end;
592
}
593
594
if(quit_now){
595
errno = EINTR;
596
goto mandos_end;
597
}
598
599
memset(&to, 0, sizeof(to));
600
if(af == AF_INET6){
601
to.in6.sin6_family = (sa_family_t)af;
602
ret = inet_pton(af, ip, &to.in6.sin6_addr);
603
} else { /* IPv4 */
604
to.in.sin_family = (sa_family_t)af;
605
ret = inet_pton(af, ip, &to.in.sin_addr);
606
}
607
if(ret < 0 ){
608
int e = errno;
397
return -1;
398
}
399
400
if(debug){
401
if(if_indextoname((unsigned int)if_index, interface) == NULL){
402
perror("if_indextoname");
403
return -1;
404
}
405
fprintf(stderr, "Binding to interface %s\n", interface);
406
}
407
408
memset(&to,0,sizeof(to)); /* Spurious warning */
409
to.sin6_family = AF_INET6;
410
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
411
if (ret < 0 ){
609
412
perror("inet_pton");
610
errno = e;
611
goto mandos_end;
413
return -1;
612
414
}
613
415
if(ret == 0){
614
int e = errno;
615
416
fprintf(stderr, "Bad address: %s\n", ip);
616
errno = e;
617
goto mandos_end;
618
}
619
if(af == AF_INET6){
620
to.in6.sin6_port = htons(port); /* Spurious warnings from
621
-Wconversion and
622
-Wunreachable-code */
623
624
if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
625
(&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
626
-Wunreachable-code*/
627
if(if_index == AVAHI_IF_UNSPEC){
628
fprintf(stderr, "An IPv6 link-local address is incomplete"
629
" without a network interface\n");
630
errno = EINVAL;
631
goto mandos_end;
632
}
633
/* Set the network interface number as scope */
634
to.in6.sin6_scope_id = (uint32_t)if_index;
635
}
636
} else {
637
to.in.sin_port = htons(port); /* Spurious warnings from
638
-Wconversion and
639
-Wunreachable-code */
640
}
417
return -1;
418
}
419
to.sin6_port = htons(port); /* Spurious warning */
641
420
642
if(quit_now){
643
errno = EINTR;
644
goto mandos_end;
645
}
421
to.sin6_scope_id = (uint32_t)if_index;
646
422
647
423
if(debug){
648
if(af == AF_INET6 and if_index != AVAHI_IF_UNSPEC){
649
char interface[IF_NAMESIZE];
650
if(if_indextoname((unsigned int)if_index, interface) == NULL){
651
perror("if_indextoname");
652
} else {
653
fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
654
ip, interface, port);
655
}
656
} else {
657
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
658
port);
659
}
660
char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
661
INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
662
const char *pcret;
663
if(af == AF_INET6){
664
pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
665
sizeof(addrstr));
666
} else {
667
pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
668
sizeof(addrstr));
669
}
670
if(pcret == NULL){
424
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
425
char addrstr[INET6_ADDRSTRLEN] = "";
426
if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
427
sizeof(addrstr)) == NULL){
671
428
perror("inet_ntop");
672
429
} else {
673
430
if(strcmp(addrstr, ip) != 0){
676
433
}
677
434
}
678
435
679
if(quit_now){
680
errno = EINTR;
681
goto mandos_end;
682
}
683
684
if(af == AF_INET6){
685
ret = connect(tcp_sd, &to.in6, sizeof(to));
686
} else {
687
ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
688
}
689
if(ret < 0){
690
if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
691
int e = errno;
692
perror("connect");
693
errno = e;
694
}
695
goto mandos_end;
696
}
697
698
if(quit_now){
699
errno = EINTR;
700
goto mandos_end;
701
}
702
703
const char *out = mandos_protocol_version;
704
written = 0;
705
while(true){
706
size_t out_size = strlen(out);
707
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
708
out_size - written));
709
if(ret == -1){
710
int e = errno;
711
perror("write");
712
errno = e;
713
goto mandos_end;
714
}
715
written += (size_t)ret;
716
if(written < out_size){
717
continue;
718
} else {
719
if(out == mandos_protocol_version){
720
written = 0;
721
out = "\r\n";
722
} else {
723
break;
724
}
725
}
726
727
if(quit_now){
728
errno = EINTR;
729
goto mandos_end;
730
}
731
}
436
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
437
if (ret < 0){
438
perror("connect");
439
return -1;
440
}
441
442
ret = initgnutls (mc, &session, &dh_params);
443
if (ret != 0){
444
retval = -1;
445
return -1;
446
}
447
448
gnutls_transport_set_ptr (session, (gnutls_transport_ptr_t) tcp_sd);
732
449
733
450
if(debug){
734
451
fprintf(stderr, "Establishing TLS session with %s\n", ip);
735
452
}
736
453
737
if(quit_now){
738
errno = EINTR;
739
goto mandos_end;
740
}
741
742
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
743
744
if(quit_now){
745
errno = EINTR;
746
goto mandos_end;
747
}
748
749
do {
750
ret = gnutls_handshake(session);
751
if(quit_now){
752
errno = EINTR;
753
goto mandos_end;
754
}
755
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
756
757
if(ret != GNUTLS_E_SUCCESS){
454
ret = gnutls_handshake (session);
455
456
if (ret != GNUTLS_E_SUCCESS){
758
457
if(debug){
759
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
760
gnutls_perror(ret);
458
fprintf(stderr, "\n*** Handshake failed ***\n");
459
gnutls_perror (ret);
761
460
}
762
errno = EPROTO;
763
goto mandos_end;
461
retval = -1;
462
goto exit;
764
463
}
765
464
766
/* Read OpenPGP packet that contains the wanted password */
465
//Retrieve OpenPGP packet that contains the wanted password
767
466
768
467
if(debug){
769
fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
468
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
770
469
ip);
771
470
}
772
471
773
472
while(true){
774
775
if(quit_now){
776
errno = EINTR;
777
goto mandos_end;
778
}
779
780
buffer_capacity = incbuffer(&buffer, buffer_length,
781
buffer_capacity);
782
if(buffer_capacity == 0){
783
int e = errno;
784
perror("incbuffer");
785
errno = e;
786
goto mandos_end;
787
}
788
789
if(quit_now){
790
errno = EINTR;
791
goto mandos_end;
792
}
793
794
sret = gnutls_record_recv(session, buffer+buffer_length,
795
BUFFER_SIZE);
796
if(sret == 0){
473
if (buffer_length + BUFFER_SIZE > buffer_capacity){
474
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
475
if (buffer == NULL){
476
perror("realloc");
477
goto exit;
478
}
479
buffer_capacity += BUFFER_SIZE;
480
}
481
482
ret = gnutls_record_recv(session, buffer+buffer_length,
483
BUFFER_SIZE);
484
if (ret == 0){
797
485
break;
798
486
}
799
if(sret < 0){
800
switch(sret){
487
if (ret < 0){
488
switch(ret){
801
489
case GNUTLS_E_INTERRUPTED:
802
490
case GNUTLS_E_AGAIN:
803
491
break;
804
492
case GNUTLS_E_REHANDSHAKE:
805
do {
806
ret = gnutls_handshake(session);
807
808
if(quit_now){
809
errno = EINTR;
810
goto mandos_end;
811
}
812
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
813
if(ret < 0){
814
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
815
gnutls_perror(ret);
816
errno = EPROTO;
817
goto mandos_end;
493
ret = gnutls_handshake (session);
494
if (ret < 0){
495
fprintf(stderr, "\n*** Handshake failed ***\n");
496
gnutls_perror (ret);
497
retval = -1;
498
goto exit;
818
499
}
819
500
break;
820
501
default:
821
502
fprintf(stderr, "Unknown error while reading data from"
822
" encrypted session with Mandos server\n");
823
gnutls_bye(session, GNUTLS_SHUT_RDWR);
824
errno = EIO;
825
goto mandos_end;
503
" encrypted session with mandos server\n");
504
retval = -1;
505
gnutls_bye (session, GNUTLS_SHUT_RDWR);
506
goto exit;
826
507
}
827
508
} else {
828
buffer_length += (size_t) sret;
829
}
830
}
831
832
if(debug){
833
fprintf(stderr, "Closing TLS session\n");
834
}
835
836
if(quit_now){
837
errno = EINTR;
838
goto mandos_end;
839
}
840
841
do {
842
ret = gnutls_bye(session, GNUTLS_SHUT_RDWR);
843
if(quit_now){
844
errno = EINTR;
845
goto mandos_end;
846
}
847
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
848
849
if(buffer_length > 0){
850
ssize_t decrypted_buffer_size;
509
buffer_length += (size_t) ret;
510
}
511
}
512
513
if (buffer_length > 0){
851
514
decrypted_buffer_size = pgp_packet_decrypt(buffer,
852
515
buffer_length,
853
&decrypted_buffer);
854
if(decrypted_buffer_size >= 0){
855
856
written = 0;
516
&decrypted_buffer,
517
keydir);
518
if (decrypted_buffer_size >= 0){
857
519
while(written < (size_t) decrypted_buffer_size){
858
if(quit_now){
859
errno = EINTR;
860
goto mandos_end;
861
}
862
863
ret = (int)fwrite(decrypted_buffer + written, 1,
864
(size_t)decrypted_buffer_size - written,
865
stdout);
520
ret = (int)fwrite (decrypted_buffer + written, 1,
521
(size_t)decrypted_buffer_size - written,
522
stdout);
866
523
if(ret == 0 and ferror(stdout)){
867
int e = errno;
868
524
if(debug){
869
525
fprintf(stderr, "Error writing encrypted data: %s\n",
870
526
strerror(errno));
871
527
}
872
errno = e;
873
goto mandos_end;
528
retval = -1;
529
break;
874
530
}
875
531
written += (size_t)ret;
876
532
}
877
retval = 0;
878
}
879
}
880
881
/* Shutdown procedure */
882
883
mandos_end:
884
{
885
int e = errno;
886
free(decrypted_buffer);
887
free(buffer);
888
if(tcp_sd >= 0){
889
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
890
}
891
if(ret == -1){
892
if(e == 0){
893
e = errno;
894
}
895
perror("close");
896
}
897
gnutls_deinit(session);
898
if(quit_now){
899
e = EINTR;
533
free(decrypted_buffer);
534
} else {
900
535
retval = -1;
901
536
}
902
errno = e;
903
}
537
}
538
539
//shutdown procedure
540
541
if(debug){
542
fprintf(stderr, "Closing TLS session\n");
543
}
544
545
free(buffer);
546
gnutls_bye (session, GNUTLS_SHUT_RDWR);
547
exit:
548
close(tcp_sd);
549
gnutls_deinit (session);
550
gnutls_certificate_free_credentials (mc->cred);
551
gnutls_global_deinit ();
904
552
return retval;
905
553
}
906
554
907
555
static void resolve_callback(AvahiSServiceResolver *r,
908
556
AvahiIfIndex interface,
909
AvahiProtocol proto,
557
AVAHI_GCC_UNUSED AvahiProtocol protocol,
910
558
AvahiResolverEvent event,
911
559
const char *name,
912
560
const char *type,
917
565
AVAHI_GCC_UNUSED AvahiStringList *txt,
918
566
AVAHI_GCC_UNUSED AvahiLookupResultFlags
919
567
flags,
920
AVAHI_GCC_UNUSED void* userdata){
921
assert(r);
568
void* userdata) {
569
mandos_context *mc = userdata;
570
assert(r); /* Spurious warning */
922
571
923
572
/* Called whenever a service has been resolved successfully or
924
573
timed out */
925
574
926
if(quit_now){
927
return;
928
}
929
930
switch(event){
575
switch (event) {
931
576
default:
932
577
case AVAHI_RESOLVER_FAILURE:
933
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
934
" of type '%s' in domain '%s': %s\n", name, type, domain,
935
avahi_strerror(avahi_server_errno(mc.server)));
578
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
579
" type '%s' in domain '%s': %s\n", name, type, domain,
580
avahi_strerror(avahi_server_errno(mc->server)));
936
581
break;
937
582
938
583
case AVAHI_RESOLVER_FOUND:
940
585
char ip[AVAHI_ADDRESS_STR_MAX];
941
586
avahi_address_snprint(ip, sizeof(ip), address);
942
587
if(debug){
943
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
944
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
945
ip, (intmax_t)interface, port);
588
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
589
" port %d\n", name, host_name, ip, port);
946
590
}
947
int ret = start_mandos_communication(ip, port, interface,
948
avahi_proto_to_af(proto));
949
if(ret == 0){
950
avahi_simple_poll_quit(mc.simple_poll);
591
int ret = start_mandos_communication(ip, port, interface, mc);
592
if (ret == 0){
593
exit(EXIT_SUCCESS);
951
594
}
952
595
}
953
596
}
954
597
avahi_s_service_resolver_free(r);
955
598
}
956
599
957
static void browse_callback(AvahiSServiceBrowser *b,
958
AvahiIfIndex interface,
959
AvahiProtocol protocol,
960
AvahiBrowserEvent event,
961
const char *name,
962
const char *type,
963
const char *domain,
964
AVAHI_GCC_UNUSED AvahiLookupResultFlags
965
flags,
966
AVAHI_GCC_UNUSED void* userdata){
967
assert(b);
600
static void browse_callback( AvahiSServiceBrowser *b,
601
AvahiIfIndex interface,
602
AvahiProtocol protocol,
603
AvahiBrowserEvent event,
604
const char *name,
605
const char *type,
606
const char *domain,
607
AVAHI_GCC_UNUSED AvahiLookupResultFlags
608
flags,
609
void* userdata) {
610
mandos_context *mc = userdata;
611
assert(b); /* Spurious warning */
968
612
969
613
/* Called whenever a new services becomes available on the LAN or
970
614
is removed from the LAN */
971
615
972
if(quit_now){
973
return;
974
}
975
976
switch(event){
616
switch (event) {
977
617
default:
978
618
case AVAHI_BROWSER_FAILURE:
979
619
980
fprintf(stderr, "(Avahi browser) %s\n",
981
avahi_strerror(avahi_server_errno(mc.server)));
982
avahi_simple_poll_quit(mc.simple_poll);
620
fprintf(stderr, "(Browser) %s\n",
621
avahi_strerror(avahi_server_errno(mc->server)));
622
avahi_simple_poll_quit(mc->simple_poll);
983
623
return;
984
624
985
625
case AVAHI_BROWSER_NEW:
986
/* We ignore the returned Avahi resolver object. In the callback
987
function we free it. If the Avahi server is terminated before
988
the callback function is called the Avahi server will free the
989
resolver for us. */
626
/* We ignore the returned resolver object. In the callback
627
function we free it. If the server is terminated before
628
the callback function is called the server will free
629
the resolver for us. */
990
630
991
if(avahi_s_service_resolver_new(mc.server, interface, protocol,
992
name, type, domain, protocol, 0,
993
resolve_callback, NULL) == NULL)
994
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
995
name, avahi_strerror(avahi_server_errno(mc.server)));
631
if (!(avahi_s_service_resolver_new(mc->server, interface,
632
protocol, name, type, domain,
633
AVAHI_PROTO_INET6, 0,
634
resolve_callback, mc)))
635
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
636
avahi_strerror(avahi_server_errno(mc->server)));
996
637
break;
997
638
998
639
case AVAHI_BROWSER_REMOVE:
1000
641
1001
642
case AVAHI_BROWSER_ALL_FOR_NOW:
1002
643
case AVAHI_BROWSER_CACHE_EXHAUSTED:
1003
if(debug){
1004
fprintf(stderr, "No Mandos server found, still searching...\n");
1005
}
1006
644
break;
1007
645
}
1008
646
}
1009
647
1010
/* stop main loop after sigterm has been called */
1011
static void handle_sigterm(int sig){
1012
if(quit_now){
1013
return;
1014
}
1015
quit_now = 1;
1016
signal_received = sig;
1017
int old_errno = errno;
1018
if(mc.simple_poll != NULL){
1019
avahi_simple_poll_quit(mc.simple_poll);
1020
}
1021
errno = old_errno;
1022
}
1023
1024
/*
1025
* This function determines if a directory entry in /sys/class/net
1026
* corresponds to an acceptable network device.
1027
* (This function is passed to scandir(3) as a filter function.)
1028
*/
1029
int good_interface(const struct dirent *if_entry){
1030
ssize_t ssret;
1031
char *flagname = NULL;
1032
if(if_entry->d_name[0] == '.'){
1033
return 0;
1034
}
1035
int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1036
if_entry->d_name);
1037
if(ret < 0){
1038
perror("asprintf");
1039
return 0;
1040
}
1041
int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1042
if(flags_fd == -1){
1043
perror("open");
1044
free(flagname);
1045
return 0;
1046
}
1047
free(flagname);
1048
typedef short ifreq_flags; /* ifreq.ifr_flags in netdevice(7) */
1049
/* read line from flags_fd */
1050
ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1051
char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1052
flagstring[(size_t)to_read] = '\0';
1053
if(flagstring == NULL){
1054
perror("malloc");
1055
close(flags_fd);
1056
return 0;
1057
}
1058
while(to_read > 0){
1059
ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1060
(size_t)to_read));
1061
if(ssret == -1){
1062
perror("read");
1063
free(flagstring);
1064
close(flags_fd);
1065
return 0;
1066
}
1067
to_read -= ssret;
1068
if(ssret == 0){
1069
break;
1070
}
1071
}
1072
close(flags_fd);
1073
intmax_t tmpmax;
1074
char *tmp;
1075
errno = 0;
1076
tmpmax = strtoimax(flagstring, &tmp, 0);
1077
if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1078
and not (isspace(*tmp)))
1079
or tmpmax != (ifreq_flags)tmpmax){
1080
if(debug){
1081
fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1082
flagstring, if_entry->d_name);
1083
}
1084
free(flagstring);
1085
return 0;
1086
}
1087
free(flagstring);
1088
ifreq_flags flags = (ifreq_flags)tmpmax;
1089
/* Reject the loopback device */
1090
if(flags & IFF_LOOPBACK){
1091
if(debug){
1092
fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1093
if_entry->d_name);
1094
}
1095
return 0;
1096
}
1097
/* Accept point-to-point devices only if connect_to is specified */
1098
if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1099
if(debug){
1100
fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1101
if_entry->d_name);
1102
}
1103
return 1;
1104
}
1105
/* Otherwise, reject non-broadcast-capable devices */
1106
if(not (flags & IFF_BROADCAST)){
1107
if(debug){
1108
fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1109
if_entry->d_name);
1110
}
1111
return 0;
1112
}
1113
/* Reject non-ARP interfaces (including dummy interfaces) */
1114
if(flags & IFF_NOARP){
1115
if(debug){
1116
fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1117
if_entry->d_name);
1118
}
1119
return 0;
1120
}
1121
/* Accept this device */
1122
if(debug){
1123
fprintf(stderr, "Interface \"%s\" is acceptable\n",
1124
if_entry->d_name);
1125
}
1126
return 1;
1127
}
1128
1129
int main(int argc, char *argv[]){
1130
AvahiSServiceBrowser *sb = NULL;
1131
int error;
1132
int ret;
1133
intmax_t tmpmax;
1134
char *tmp;
1135
int exitcode = EXIT_SUCCESS;
1136
const char *interface = "";
1137
struct ifreq network;
1138
int sd = -1;
1139
bool take_down_interface = false;
1140
uid_t uid;
1141
gid_t gid;
1142
char tempdir[] = "/tmp/mandosXXXXXX";
1143
bool tempdir_created = false;
1144
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1145
const char *seckey = PATHDIR "/" SECKEY;
1146
const char *pubkey = PATHDIR "/" PUBKEY;
1147
1148
bool gnutls_initialized = false;
1149
bool gpgme_initialized = false;
1150
float delay = 2.5f;
1151
1152
struct sigaction old_sigterm_action = { .sa_handler = SIG_DFL };
1153
struct sigaction sigterm_action = { .sa_handler = handle_sigterm };
1154
1155
uid = getuid();
1156
gid = getgid();
1157
1158
/* Lower any group privileges we might have, just to be safe */
1159
errno = 0;
1160
ret = setgid(gid);
1161
if(ret == -1){
1162
perror("setgid");
1163
}
1164
1165
/* Lower user privileges (temporarily) */
1166
errno = 0;
1167
ret = seteuid(uid);
1168
if(ret == -1){
1169
perror("seteuid");
1170
}
1171
1172
if(quit_now){
1173
goto end;
1174
}
1175
1176
{
1177
struct argp_option options[] = {
1178
{ .name = "debug", .key = 128,
1179
.doc = "Debug mode", .group = 3 },
1180
{ .name = "connect", .key = 'c',
1181
.arg = "ADDRESS:PORT",
1182
.doc = "Connect directly to a specific Mandos server",
1183
.group = 1 },
1184
{ .name = "interface", .key = 'i',
1185
.arg = "NAME",
1186
.doc = "Network interface that will be used to search for"
1187
" Mandos servers",
1188
.group = 1 },
1189
{ .name = "seckey", .key = 's',
1190
.arg = "FILE",
1191
.doc = "OpenPGP secret key file base name",
1192
.group = 1 },
1193
{ .name = "pubkey", .key = 'p',
1194
.arg = "FILE",
1195
.doc = "OpenPGP public key file base name",
1196
.group = 2 },
1197
{ .name = "dh-bits", .key = 129,
1198
.arg = "BITS",
1199
.doc = "Bit length of the prime number used in the"
1200
" Diffie-Hellman key exchange",
1201
.group = 2 },
1202
{ .name = "priority", .key = 130,
1203
.arg = "STRING",
1204
.doc = "GnuTLS priority string for the TLS handshake",
1205
.group = 1 },
1206
{ .name = "delay", .key = 131,
1207
.arg = "SECONDS",
1208
.doc = "Maximum delay to wait for interface startup",
1209
.group = 2 },
1210
/*
1211
* These reproduce what we would get without ARGP_NO_HELP
1212
*/
1213
{ .name = "help", .key = '?',
1214
.doc = "Give this help list", .group = -1 },
1215
{ .name = "usage", .key = -3,
1216
.doc = "Give a short usage message", .group = -1 },
1217
{ .name = "version", .key = 'V',
1218
.doc = "Print program version", .group = -1 },
1219
{ .name = NULL }
1220
};
648
/* Combines file name and path and returns the malloced new
649
string. some sane checks could/should be added */
650
static const char *combinepath(const char *first, const char *second){
651
size_t f_len = strlen(first);
652
size_t s_len = strlen(second);
653
char *tmp = malloc(f_len + s_len + 2);
654
if (tmp == NULL){
655
return NULL;
656
}
657
if(f_len > 0){
658
memcpy(tmp, first, f_len); /* Spurious warning */
659
}
660
tmp[f_len] = '/';
661
if(s_len > 0){
662
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
663
}
664
tmp[f_len + 1 + s_len] = '\0';
665
return tmp;
666
}
667
668
669
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
670
AvahiServerConfig config;
671
AvahiSServiceBrowser *sb = NULL;
672
int error;
673
int ret;
674
int debug_int;
675
int returncode = EXIT_SUCCESS;
676
const char *interface = "eth0";
677
struct ifreq network;
678
int sd;
679
char *connect_to = NULL;
680
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
681
mandos_context mc = { .simple_poll = NULL, .server = NULL,
682
.dh_bits = 1024, .priority = "SECURE256"};
1221
683
1222
error_t parse_opt(int key, char *arg,
1223
struct argp_state *state){
1224
errno = 0;
1225
switch(key){
1226
case 128: /* --debug */
1227
debug = true;
1228
break;
1229
case 'c': /* --connect */
1230
connect_to = arg;
1231
break;
1232
case 'i': /* --interface */
1233
interface = arg;
1234
break;
1235
case 's': /* --seckey */
1236
seckey = arg;
1237
break;
1238
case 'p': /* --pubkey */
1239
pubkey = arg;
1240
break;
1241
case 129: /* --dh-bits */
1242
errno = 0;
1243
tmpmax = strtoimax(arg, &tmp, 10);
1244
if(errno != 0 or tmp == arg or *tmp != '\0'
1245
or tmpmax != (typeof(mc.dh_bits))tmpmax){
1246
argp_error(state, "Bad number of DH bits");
1247
}
1248
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1249
break;
1250
case 130: /* --priority */
1251
mc.priority = arg;
1252
break;
1253
case 131: /* --delay */
1254
errno = 0;
1255
delay = strtof(arg, &tmp);
1256
if(errno != 0 or tmp == arg or *tmp != '\0'){
1257
argp_error(state, "Bad delay");
1258
}
1259
break;
1260
/*
1261
* These reproduce what we would get without ARGP_NO_HELP
1262
*/
1263
case '?': /* --help */
1264
argp_state_help(state, state->out_stream,
1265
(ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1266
& ~(unsigned int)ARGP_HELP_EXIT_OK);
1267
case -3: /* --usage */
1268
argp_state_help(state, state->out_stream,
1269
ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
1270
case 'V': /* --version */
1271
fprintf(state->out_stream, "%s\n", argp_program_version);
1272
exit(argp_err_exit_status);
1273
break;
684
debug_int = debug ? 1 : 0;
685
while (true){
686
struct option long_options[] = {
687
{"debug", no_argument, &debug_int, 1},
688
{"connect", required_argument, NULL, 'c'},
689
{"interface", required_argument, NULL, 'i'},
690
{"keydir", required_argument, NULL, 'd'},
691
{"seckey", required_argument, NULL, 's'},
692
{"pubkey", required_argument, NULL, 'p'},
693
{"dh-bits", required_argument, NULL, 'D'},
694
{"priority", required_argument, NULL, 'P'},
695
{0, 0, 0, 0} };
696
697
int option_index = 0;
698
ret = getopt_long (argc, argv, "i:", long_options,
699
&option_index);
700
701
if (ret == -1){
702
break;
703
}
704
705
switch(ret){
706
case 0:
707
break;
708
case 'i':
709
interface = optarg;
710
break;
711
case 'c':
712
connect_to = optarg;
713
break;
714
case 'd':
715
keydir = optarg;
716
break;
717
case 'p':
718
pubkeyfile = optarg;
719
break;
720
case 's':
721
seckeyfile = optarg;
722
break;
723
case 'D':
724
errno = 0;
725
mc.dh_bits = (unsigned int) strtol(optarg, NULL, 10);
726
if (errno){
727
perror("strtol");
728
exit(EXIT_FAILURE);
729
}
730
break;
731
case 'P':
732
mc.priority = optarg;
733
break;
734
case '?':
1274
735
default:
1275
return ARGP_ERR_UNKNOWN;
1276
}
1277
return errno;
1278
}
1279
1280
struct argp argp = { .options = options, .parser = parse_opt,
1281
.args_doc = "",
1282
.doc = "Mandos client -- Get and decrypt"
1283
" passwords from a Mandos server" };
1284
ret = argp_parse(&argp, argc, argv,
1285
ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1286
switch(ret){
1287
case 0:
1288
break;
1289
case ENOMEM:
1290
default:
1291
errno = ret;
1292
perror("argp_parse");
1293
exitcode = EX_OSERR;
1294
goto end;
1295
case EINVAL:
1296
exitcode = EX_USAGE;
1297
goto end;
1298
}
1299
}
1300
1301
if(not debug){
1302
avahi_set_log_function(empty_log);
1303
}
1304
1305
if(interface[0] == '\0'){
1306
struct dirent **direntries;
1307
ret = scandir(sys_class_net, &direntries, good_interface,
1308
alphasort);
1309
if(ret >= 1){
1310
/* Pick the first good interface */
1311
interface = strdup(direntries[0]->d_name);
1312
if(debug){
1313
fprintf(stderr, "Using interface \"%s\"\n", interface);
1314
}
1315
if(interface == NULL){
1316
perror("malloc");
1317
free(direntries);
1318
exitcode = EXIT_FAILURE;
1319
goto end;
1320
}
1321
free(direntries);
1322
} else {
1323
free(direntries);
1324
fprintf(stderr, "Could not find a network interface\n");
1325
exitcode = EXIT_FAILURE;
1326
goto end;
1327
}
1328
}
1329
1330
/* Initialize Avahi early so avahi_simple_poll_quit() can be called
1331
from the signal handler */
1332
/* Initialize the pseudo-RNG for Avahi */
1333
srand((unsigned int) time(NULL));
1334
mc.simple_poll = avahi_simple_poll_new();
1335
if(mc.simple_poll == NULL){
1336
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1337
exitcode = EX_UNAVAILABLE;
1338
goto end;
1339
}
1340
1341
sigemptyset(&sigterm_action.sa_mask);
1342
ret = sigaddset(&sigterm_action.sa_mask, SIGINT);
1343
if(ret == -1){
1344
perror("sigaddset");
1345
exitcode = EX_OSERR;
1346
goto end;
1347
}
1348
ret = sigaddset(&sigterm_action.sa_mask, SIGHUP);
1349
if(ret == -1){
1350
perror("sigaddset");
1351
exitcode = EX_OSERR;
1352
goto end;
1353
}
1354
ret = sigaddset(&sigterm_action.sa_mask, SIGTERM);
1355
if(ret == -1){
1356
perror("sigaddset");
1357
exitcode = EX_OSERR;
1358
goto end;
1359
}
1360
/* Need to check if the handler is SIG_IGN before handling:
1361
| [[info:libc:Initial Signal Actions]] |
1362
| [[info:libc:Basic Signal Handling]] |
1363
*/
1364
ret = sigaction(SIGINT, NULL, &old_sigterm_action);
1365
if(ret == -1){
1366
perror("sigaction");
1367
return EX_OSERR;
1368
}
1369
if(old_sigterm_action.sa_handler != SIG_IGN){
1370
ret = sigaction(SIGINT, &sigterm_action, NULL);
1371
if(ret == -1){
1372
perror("sigaction");
1373
exitcode = EX_OSERR;
1374
goto end;
1375
}
1376
}
1377
ret = sigaction(SIGHUP, NULL, &old_sigterm_action);
1378
if(ret == -1){
1379
perror("sigaction");
1380
return EX_OSERR;
1381
}
1382
if(old_sigterm_action.sa_handler != SIG_IGN){
1383
ret = sigaction(SIGHUP, &sigterm_action, NULL);
1384
if(ret == -1){
1385
perror("sigaction");
1386
exitcode = EX_OSERR;
1387
goto end;
1388
}
1389
}
1390
ret = sigaction(SIGTERM, NULL, &old_sigterm_action);
1391
if(ret == -1){
1392
perror("sigaction");
1393
return EX_OSERR;
1394
}
1395
if(old_sigterm_action.sa_handler != SIG_IGN){
1396
ret = sigaction(SIGTERM, &sigterm_action, NULL);
1397
if(ret == -1){
1398
perror("sigaction");
1399
exitcode = EX_OSERR;
1400
goto end;
1401
}
1402
}
1403
1404
/* If the interface is down, bring it up */
1405
if(strcmp(interface, "none") != 0){
736
exit(EXIT_FAILURE);
737
}
738
}
739
debug = debug_int ? true : false;
740
741
pubkeyfile = combinepath(keydir, pubkeyfile);
742
if (pubkeyfile == NULL){
743
perror("combinepath");
744
returncode = EXIT_FAILURE;
745
goto exit;
746
}
747
748
seckeyfile = combinepath(keydir, seckeyfile);
749
if (seckeyfile == NULL){
750
perror("combinepath");
751
goto exit;
752
}
753
1406
754
if_index = (AvahiIfIndex) if_nametoindex(interface);
1407
755
if(if_index == 0){
1408
756
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1409
exitcode = EX_UNAVAILABLE;
1410
goto end;
1411
}
1412
1413
if(quit_now){
1414
goto end;
1415
}
1416
1417
/* Re-raise priviliges */
1418
errno = 0;
1419
ret = seteuid(0);
1420
if(ret == -1){
1421
perror("seteuid");
1422
}
1423
1424
#ifdef __linux__
1425
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1426
messages about the network interface to mess up the prompt */
1427
ret = klogctl(8, NULL, 5);
1428
bool restore_loglevel = true;
1429
if(ret == -1){
1430
restore_loglevel = false;
1431
perror("klogctl");
1432
}
1433
#endif /* __linux__ */
757
exit(EXIT_FAILURE);
758
}
759
760
if(connect_to != NULL){
761
/* Connect directly, do not use Zeroconf */
762
/* (Mainly meant for debugging) */
763
char *address = strrchr(connect_to, ':');
764
if(address == NULL){
765
fprintf(stderr, "No colon in address\n");
766
exit(EXIT_FAILURE);
767
}
768
errno = 0;
769
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
770
if(errno){
771
perror("Bad port number");
772
exit(EXIT_FAILURE);
773
}
774
*address = '\0';
775
address = connect_to;
776
ret = start_mandos_communication(address, port, if_index, &mc);
777
if(ret < 0){
778
exit(EXIT_FAILURE);
779
} else {
780
exit(EXIT_SUCCESS);
781
}
782
}
1434
783
1435
784
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1436
if(sd < 0){
785
if(sd < 0) {
1437
786
perror("socket");
1438
exitcode = EX_OSERR;
1439
#ifdef __linux__
1440
if(restore_loglevel){
1441
ret = klogctl(7, NULL, 0);
1442
if(ret == -1){
1443
perror("klogctl");
1444
}
1445
}
1446
#endif /* __linux__ */
1447
/* Lower privileges */
1448
errno = 0;
1449
ret = seteuid(uid);
1450
if(ret == -1){
1451
perror("seteuid");
1452
}
1453
goto end;
787
returncode = EXIT_FAILURE;
788
goto exit;
1454
789
}
1455
strcpy(network.ifr_name, interface);
790
strcpy(network.ifr_name, interface); /* Spurious warning */
1456
791
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1457
792
if(ret == -1){
793
1458
794
perror("ioctl SIOCGIFFLAGS");
1459
#ifdef __linux__
1460
if(restore_loglevel){
1461
ret = klogctl(7, NULL, 0);
1462
if(ret == -1){
1463
perror("klogctl");
1464
}
1465
}
1466
#endif /* __linux__ */
1467
exitcode = EX_OSERR;
1468
/* Lower privileges */
1469
errno = 0;
1470
ret = seteuid(uid);
1471
if(ret == -1){
1472
perror("seteuid");
1473
}
1474
goto end;
795
returncode = EXIT_FAILURE;
796
goto exit;
1475
797
}
1476
798
if((network.ifr_flags & IFF_UP) == 0){
1477
799
network.ifr_flags |= IFF_UP;
1478
take_down_interface = true;
1479
800
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1480
801
if(ret == -1){
1481
take_down_interface = false;
1482
perror("ioctl SIOCSIFFLAGS +IFF_UP");
1483
exitcode = EX_OSERR;
1484
#ifdef __linux__
1485
if(restore_loglevel){
1486
ret = klogctl(7, NULL, 0);
1487
if(ret == -1){
1488
perror("klogctl");
1489
}
1490
}
1491
#endif /* __linux__ */
1492
/* Lower privileges */
1493
errno = 0;
1494
ret = seteuid(uid);
1495
if(ret == -1){
1496
perror("seteuid");
1497
}
1498
goto end;
1499
}
1500
}
1501
/* sleep checking until interface is running */
1502
for(int i=0; i < delay * 4; i++){
1503
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1504
if(ret == -1){
1505
perror("ioctl SIOCGIFFLAGS");
1506
} else if(network.ifr_flags & IFF_RUNNING){
1507
break;
1508
}
1509
struct timespec sleeptime = { .tv_nsec = 250000000 };
1510
ret = nanosleep(&sleeptime, NULL);
1511
if(ret == -1 and errno != EINTR){
1512
perror("nanosleep");
1513
}
1514
}
1515
if(not take_down_interface){
1516
/* We won't need the socket anymore */
1517
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1518
if(ret == -1){
1519
perror("close");
1520
}
1521
}
1522
#ifdef __linux__
1523
if(restore_loglevel){
1524
/* Restores kernel loglevel to default */
1525
ret = klogctl(7, NULL, 0);
1526
if(ret == -1){
1527
perror("klogctl");
1528
}
1529
}
1530
#endif /* __linux__ */
1531
/* Lower privileges */
1532
errno = 0;
1533
if(take_down_interface){
1534
/* Lower privileges */
1535
ret = seteuid(uid);
1536
if(ret == -1){
1537
perror("seteuid");
1538
}
1539
} else {
1540
/* Lower privileges permanently */
1541
ret = setuid(uid);
1542
if(ret == -1){
1543
perror("setuid");
1544
}
1545
}
1546
}
1547
1548
if(quit_now){
1549
goto end;
1550
}
1551
1552
ret = init_gnutls_global(pubkey, seckey);
1553
if(ret == -1){
1554
fprintf(stderr, "init_gnutls_global failed\n");
1555
exitcode = EX_UNAVAILABLE;
1556
goto end;
1557
} else {
1558
gnutls_initialized = true;
1559
}
1560
1561
if(quit_now){
1562
goto end;
1563
}
1564
1565
tempdir_created = true;
1566
if(mkdtemp(tempdir) == NULL){
1567
tempdir_created = false;
1568
perror("mkdtemp");
1569
goto end;
1570
}
1571
1572
if(quit_now){
1573
goto end;
1574
}
1575
1576
if(not init_gpgme(pubkey, seckey, tempdir)){
1577
fprintf(stderr, "init_gpgme failed\n");
1578
exitcode = EX_UNAVAILABLE;
1579
goto end;
1580
} else {
1581
gpgme_initialized = true;
1582
}
1583
1584
if(quit_now){
1585
goto end;
1586
}
1587
1588
if(connect_to != NULL){
1589
/* Connect directly, do not use Zeroconf */
1590
/* (Mainly meant for debugging) */
1591
char *address = strrchr(connect_to, ':');
1592
if(address == NULL){
1593
fprintf(stderr, "No colon in address\n");
1594
exitcode = EX_USAGE;
1595
goto end;
1596
}
1597
1598
if(quit_now){
1599
goto end;
1600
}
1601
1602
uint16_t port;
1603
errno = 0;
1604
tmpmax = strtoimax(address+1, &tmp, 10);
1605
if(errno != 0 or tmp == address+1 or *tmp != '\0'
1606
or tmpmax != (uint16_t)tmpmax){
1607
fprintf(stderr, "Bad port number\n");
1608
exitcode = EX_USAGE;
1609
goto end;
1610
}
1611
1612
if(quit_now){
1613
goto end;
1614
}
1615
1616
port = (uint16_t)tmpmax;
1617
*address = '\0';
1618
address = connect_to;
1619
/* Colon in address indicates IPv6 */
1620
int af;
1621
if(strchr(address, ':') != NULL){
1622
af = AF_INET6;
1623
} else {
1624
af = AF_INET;
1625
}
1626
1627
if(quit_now){
1628
goto end;
1629
}
1630
1631
while(not quit_now){
1632
ret = start_mandos_communication(address, port, if_index, af);
1633
if(quit_now or ret == 0){
1634
break;
1635
}
1636
sleep(15);
1637
};
1638
1639
if (not quit_now){
1640
exitcode = EXIT_SUCCESS;
1641
}
1642
1643
goto end;
1644
}
1645
1646
if(quit_now){
1647
goto end;
1648
}
1649
1650
{
1651
AvahiServerConfig config;
1652
/* Do not publish any local Zeroconf records */
802
perror("ioctl SIOCSIFFLAGS");
803
returncode = EXIT_FAILURE;
804
goto exit;
805
}
806
}
807
close(sd);
808
809
if (not debug){
810
avahi_set_log_function(empty_log);
811
}
812
813
/* Initialize the psuedo-RNG */
814
srand((unsigned int) time(NULL));
815
816
/* Allocate main loop object */
817
if (!(mc.simple_poll = avahi_simple_poll_new())) {
818
fprintf(stderr, "Failed to create simple poll object.\n");
819
returncode = EXIT_FAILURE;
820
goto exit;
821
}
822
823
/* Do not publish any local records */
1653
824
avahi_server_config_init(&config);
1654
825
config.publish_hinfo = 0;
1655
826
config.publish_addresses = 0;
1656
827
config.publish_workstation = 0;
1657
828
config.publish_domain = 0;
1658
829
1659
830
/* Allocate a new server */
1660
mc.server = avahi_server_new(avahi_simple_poll_get
1661
(mc.simple_poll), &config, NULL,
1662
NULL, &error);
831
mc.server=avahi_server_new(avahi_simple_poll_get(mc.simple_poll),
832
&config, NULL, NULL, &error);
1663
833
1664
/* Free the Avahi configuration data */
834
/* Free the configuration data */
1665
835
avahi_server_config_free(&config);
1666
}
1667
1668
/* Check if creating the Avahi server object succeeded */
1669
if(mc.server == NULL){
1670
fprintf(stderr, "Failed to create Avahi server: %s\n",
1671
avahi_strerror(error));
1672
exitcode = EX_UNAVAILABLE;
1673
goto end;
1674
}
1675
1676
if(quit_now){
1677
goto end;
1678
}
1679
1680
/* Create the Avahi service browser */
1681
sb = avahi_s_service_browser_new(mc.server, if_index,
1682
AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1683
NULL, 0, browse_callback, NULL);
1684
if(sb == NULL){
1685
fprintf(stderr, "Failed to create service browser: %s\n",
1686
avahi_strerror(avahi_server_errno(mc.server)));
1687
exitcode = EX_UNAVAILABLE;
1688
goto end;
1689
}
1690
1691
if(quit_now){
1692
goto end;
1693
}
1694
1695
/* Run the main loop */
1696
1697
if(debug){
1698
fprintf(stderr, "Starting Avahi loop search\n");
1699
}
1700
1701
avahi_simple_poll_loop(mc.simple_poll);
1702
1703
end:
1704
1705
if(debug){
1706
fprintf(stderr, "%s exiting\n", argv[0]);
1707
}
1708
1709
/* Cleanup things */
1710
if(sb != NULL)
1711
avahi_s_service_browser_free(sb);
1712
1713
if(mc.server != NULL)
1714
avahi_server_free(mc.server);
1715
1716
if(mc.simple_poll != NULL)
1717
avahi_simple_poll_free(mc.simple_poll);
1718
1719
if(gnutls_initialized){
1720
gnutls_certificate_free_credentials(mc.cred);
1721
gnutls_global_deinit();
1722
gnutls_dh_params_deinit(mc.dh_params);
1723
}
1724
1725
if(gpgme_initialized){
1726
gpgme_release(mc.ctx);
1727
}
1728
1729
/* Take down the network interface */
1730
if(take_down_interface){
1731
/* Re-raise priviliges */
1732
errno = 0;
1733
ret = seteuid(0);
1734
if(ret == -1){
1735
perror("seteuid");
1736
}
1737
if(geteuid() == 0){
1738
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1739
if(ret == -1){
1740
perror("ioctl SIOCGIFFLAGS");
1741
} else if(network.ifr_flags & IFF_UP) {
1742
network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1743
ret = ioctl(sd, SIOCSIFFLAGS, &network);
1744
if(ret == -1){
1745
perror("ioctl SIOCSIFFLAGS -IFF_UP");
1746
}
1747
}
1748
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1749
if(ret == -1){
1750
perror("close");
1751
}
1752
/* Lower privileges permanently */
1753
errno = 0;
1754
ret = setuid(uid);
1755
if(ret == -1){
1756
perror("setuid");
1757
}
1758
}
1759
}
1760
1761
/* Removes the temp directory used by GPGME */
1762
if(tempdir_created){
1763
DIR *d;
1764
struct dirent *direntry;
1765
d = opendir(tempdir);
1766
if(d == NULL){
1767
if(errno != ENOENT){
1768
perror("opendir");
1769
}
1770
} else {
1771
while(true){
1772
direntry = readdir(d);
1773
if(direntry == NULL){
1774
break;
1775
}
1776
/* Skip "." and ".." */
1777
if(direntry->d_name[0] == '.'
1778
and (direntry->d_name[1] == '\0'
1779
or (direntry->d_name[1] == '.'
1780
and direntry->d_name[2] == '\0'))){
1781
continue;
1782
}
1783
char *fullname = NULL;
1784
ret = asprintf(&fullname, "%s/%s", tempdir,
1785
direntry->d_name);
1786
if(ret < 0){
1787
perror("asprintf");
1788
continue;
1789
}
1790
ret = remove(fullname);
1791
if(ret == -1){
1792
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1793
strerror(errno));
1794
}
1795
free(fullname);
1796
}
1797
closedir(d);
1798
}
1799
ret = rmdir(tempdir);
1800
if(ret == -1 and errno != ENOENT){
1801
perror("rmdir");
1802
}
1803
}
1804
1805
if(quit_now){
1806
sigemptyset(&old_sigterm_action.sa_mask);
1807
old_sigterm_action.sa_handler = SIG_DFL;
1808
ret = (int)TEMP_FAILURE_RETRY(sigaction(signal_received,
1809
&old_sigterm_action,
1810
NULL));
1811
if(ret == -1){
1812
perror("sigaction");
1813
}
1814
do {
1815
ret = raise(signal_received);
1816
} while(ret != 0 and errno == EINTR);
1817
if(ret != 0){
1818
perror("raise");
1819
abort();
1820
}
1821
TEMP_FAILURE_RETRY(pause());
1822
}
1823
1824
return exitcode;
836
837
/* Check if creating the server object succeeded */
838
if (!mc.server) {
839
fprintf(stderr, "Failed to create server: %s\n",
840
avahi_strerror(error));
841
returncode = EXIT_FAILURE;
842
goto exit;
843
}
844
845
/* Create the service browser */
846
sb = avahi_s_service_browser_new(mc.server, if_index,
847
AVAHI_PROTO_INET6,
848
"_mandos._tcp", NULL, 0,
849
browse_callback, &mc);
850
if (!sb) {
851
fprintf(stderr, "Failed to create service browser: %s\n",
852
avahi_strerror(avahi_server_errno(mc.server)));
853
returncode = EXIT_FAILURE;
854
goto exit;
855
}
856
857
/* Run the main loop */
858
859
if (debug){
860
fprintf(stderr, "Starting avahi loop search\n");
861
}
862
863
avahi_simple_poll_loop(mc.simple_poll);
864
865
exit:
866
867
if (debug){
868
fprintf(stderr, "%s exiting\n", argv[0]);
869
}
870
871
/* Cleanup things */
872
if (sb)
873
avahi_s_service_browser_free(sb);
874
875
if (mc.server)
876
avahi_server_free(mc.server);
877
878
if (mc.simple_poll)
879
avahi_simple_poll_free(mc.simple_poll);
880
free(pubkeyfile);
881
free(seckeyfile);
882
883
return returncode;
1825
884
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0