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 37
- compare with another revision
- download diff
- download tarball
- view history from revision 37
- Committer: Teddy Hogeborn
- Date: 2008-08-02 21:06:12 UTC
- Revision ID: teddy@fukt.bsnet.se-20080802210612-4c1waup4z0f66ya7
Non-tested commit for merge purposes.
* plugbasedclient.c (getplugin, addargument, set_cloexec): Made static.
* plugins.d/passprompt.c (termination_handler): Made static.
* plugbasedclient.c (getplugin, addargument, set_cloexec): Made static.
* plugins.d/passprompt.c (termination_handler): Made static.
- files added:
- ca.pem
- files removed:
- .bzr-builddeb
- debian
- debian/po
- 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,2009 Teddy Hogeborn
13
* Copyright © 2008,2009 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
33
32
#define _LARGEFILE_SOURCE
34
33
#define _FILE_OFFSET_BITS 64
35
34
36
#define _GNU_SOURCE /* TEMP_FAILURE_RETRY(), asprintf() */
37
38
#include <stdio.h> /* fprintf(), stderr, fwrite(),
39
stdout, ferror(), sscanf(),
40
remove() */
41
#include <stdint.h> /* uint16_t, uint32_t */
42
#include <stddef.h> /* NULL, size_t, ssize_t */
43
#include <stdlib.h> /* free(), EXIT_SUCCESS, EXIT_FAILURE,
44
srand() */
45
#include <stdbool.h> /* bool, true */
46
#include <string.h> /* memset(), strcmp(), strlen(),
47
strerror(), asprintf(), strcpy() */
48
#include <sys/ioctl.h> /* ioctl */
49
#include <sys/types.h> /* socket(), inet_pton(), sockaddr,
50
sockaddr_in6, PF_INET6,
51
SOCK_STREAM, INET6_ADDRSTRLEN,
52
uid_t, gid_t, open(), opendir(),
53
DIR */
54
#include <sys/stat.h> /* open() */
55
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
56
struct in6_addr, inet_pton(),
57
connect() */
58
#include <fcntl.h> /* open() */
59
#include <dirent.h> /* opendir(), struct dirent, readdir()
60
*/
61
#include <inttypes.h> /* PRIu16, intmax_t, SCNdMAX */
62
#include <assert.h> /* assert() */
63
#include <errno.h> /* perror(), errno */
64
#include <time.h> /* nanosleep(), time() */
65
#include <net/if.h> /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
66
SIOCSIFFLAGS, if_indextoname(),
67
if_nametoindex(), IF_NAMESIZE */
68
#include <netinet/in.h>
69
#include <unistd.h> /* close(), SEEK_SET, off_t, write(),
70
getuid(), getgid(), setuid(),
71
setgid() */
72
#include <arpa/inet.h> /* inet_pton(), htons */
73
#include <iso646.h> /* not, and, or */
74
#include <argp.h> /* struct argp_option, error_t, struct
75
argp_state, struct argp,
76
argp_parse(), ARGP_KEY_ARG,
77
ARGP_KEY_END, ARGP_ERR_UNKNOWN */
78
#ifdef __linux__
79
#include <sys/klog.h> /* klogctl() */
80
#endif
81
82
/* Avahi */
83
/* All Avahi types, constants and functions
84
Avahi*, avahi_*,
85
AVAHI_* */
35
#include <stdio.h>
36
#include <assert.h>
37
#include <stdlib.h>
38
#include <time.h>
39
#include <net/if.h> /* if_nametoindex */
40
86
41
#include <avahi-core/core.h>
87
42
#include <avahi-core/lookup.h>
88
43
#include <avahi-core/log.h>
90
45
#include <avahi-common/malloc.h>
91
46
#include <avahi-common/error.h>
92
47
93
/* GnuTLS */
94
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
95
functions:
96
gnutls_*
97
init_gnutls_session(),
98
GNUTLS_* */
99
#include <gnutls/openpgp.h>
100
/* gnutls_certificate_set_openpgp_key_file(),
101
GNUTLS_OPENPGP_FMT_BASE64 */
102
103
/* GPGME */
104
#include <gpgme.h> /* All GPGME types, constants and
105
functions:
106
gpgme_*
107
GPGME_PROTOCOL_OpenPGP,
108
GPG_ERR_NO_* */
48
//mandos client part
49
#include <sys/types.h> /* socket(), inet_pton() */
50
#include <sys/socket.h> /* socket(), struct sockaddr_in6,
51
struct in6_addr, inet_pton() */
52
#include <gnutls/gnutls.h> /* All GnuTLS stuff */
53
#include <gnutls/openpgp.h> /* GnuTLS with openpgp stuff */
54
55
#include <unistd.h> /* close() */
56
#include <netinet/in.h>
57
#include <stdbool.h> /* true */
58
#include <string.h> /* memset */
59
#include <arpa/inet.h> /* inet_pton() */
60
#include <iso646.h> /* not */
61
62
// gpgme
63
#include <errno.h> /* perror() */
64
#include <gpgme.h>
65
66
// getopt_long
67
#include <getopt.h>
109
68
110
69
#define BUFFER_SIZE 256
111
70
112
#define PATHDIR "/conf/conf.d/mandos"
113
#define SECKEY "seckey.txt"
114
#define PUBKEY "pubkey.txt"
71
static int dh_bits = 1024;
72
73
static const char *keydir = "/conf/conf.d/mandos";
74
static const char *pubkeyfile = "pubkey.txt";
75
static const char *seckeyfile = "seckey.txt";
115
76
116
77
bool debug = false;
117
static const char mandos_protocol_version[] = "1";
118
const char *argp_program_version = "mandos-client " VERSION;
119
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
120
78
121
/* Used for passing in values through the Avahi callback functions */
79
/* Used for */
122
80
typedef struct {
123
AvahiSimplePoll *simple_poll;
124
AvahiServer *server;
81
gnutls_session_t session;
125
82
gnutls_certificate_credentials_t cred;
126
unsigned int dh_bits;
127
83
gnutls_dh_params_t dh_params;
128
const char *priority;
84
} encrypted_session;
85
86
87
static ssize_t pgp_packet_decrypt (char *packet, size_t packet_size,
88
char **new_packet,
89
const char *homedir){
90
gpgme_data_t dh_crypto, dh_plain;
129
91
gpgme_ctx_t ctx;
130
} mandos_context;
131
132
/*
133
* Make additional room in "buffer" for at least BUFFER_SIZE
134
* additional bytes. "buffer_capacity" is how much is currently
135
* allocated, "buffer_length" is how much is already used.
136
*/
137
size_t incbuffer(char **buffer, size_t buffer_length,
138
size_t buffer_capacity){
139
if(buffer_length + BUFFER_SIZE > buffer_capacity){
140
*buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
141
if(buffer == NULL){
142
return 0;
143
}
144
buffer_capacity += BUFFER_SIZE;
145
}
146
return buffer_capacity;
147
}
148
149
/*
150
* Initialize GPGME.
151
*/
152
static bool init_gpgme(mandos_context *mc, const char *seckey,
153
const char *pubkey, const char *tempdir){
154
int ret;
155
92
gpgme_error_t rc;
93
ssize_t ret;
94
ssize_t new_packet_capacity = 0;
95
ssize_t new_packet_length = 0;
156
96
gpgme_engine_info_t engine_info;
157
158
159
/*
160
* Helper function to insert pub and seckey to the engine keyring.
161
*/
162
bool import_key(const char *filename){
163
int fd;
164
gpgme_data_t pgp_data;
165
166
fd = (int)TEMP_FAILURE_RETRY(open(filename, O_RDONLY));
167
if(fd == -1){
168
perror("open");
169
return false;
170
}
171
172
rc = gpgme_data_new_from_fd(&pgp_data, fd);
173
if(rc != GPG_ERR_NO_ERROR){
174
fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
175
gpgme_strsource(rc), gpgme_strerror(rc));
176
return false;
177
}
178
179
rc = gpgme_op_import(mc->ctx, pgp_data);
180
if(rc != GPG_ERR_NO_ERROR){
181
fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
182
gpgme_strsource(rc), gpgme_strerror(rc));
183
return false;
184
}
185
186
ret = (int)TEMP_FAILURE_RETRY(close(fd));
187
if(ret == -1){
188
perror("close");
189
}
190
gpgme_data_release(pgp_data);
191
return true;
192
}
193
194
if(debug){
195
fprintf(stderr, "Initialize gpgme\n");
97
98
if (debug){
99
fprintf(stderr, "Trying to decrypt OpenPGP packet\n");
196
100
}
197
101
198
102
/* Init GPGME */
199
103
gpgme_check_version(NULL);
200
104
rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
201
if(rc != GPG_ERR_NO_ERROR){
105
if (rc != GPG_ERR_NO_ERROR){
202
106
fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
203
107
gpgme_strsource(rc), gpgme_strerror(rc));
204
return false;
108
return -1;
205
109
}
206
110
207
/* Set GPGME home directory for the OpenPGP engine only */
208
rc = gpgme_get_engine_info(&engine_info);
209
if(rc != GPG_ERR_NO_ERROR){
111
/* Set GPGME home directory */
112
rc = gpgme_get_engine_info (&engine_info);
113
if (rc != GPG_ERR_NO_ERROR){
210
114
fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
211
115
gpgme_strsource(rc), gpgme_strerror(rc));
212
return false;
116
return -1;
213
117
}
214
118
while(engine_info != NULL){
215
119
if(engine_info->protocol == GPGME_PROTOCOL_OpenPGP){
216
120
gpgme_set_engine_info(GPGME_PROTOCOL_OpenPGP,
217
engine_info->file_name, tempdir);
121
engine_info->file_name, homedir);
218
122
break;
219
123
}
220
124
engine_info = engine_info->next;
221
125
}
222
126
if(engine_info == NULL){
223
fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
224
return false;
225
}
226
227
/* Create new GPGME "context" */
228
rc = gpgme_new(&(mc->ctx));
229
if(rc != GPG_ERR_NO_ERROR){
230
fprintf(stderr, "bad gpgme_new: %s: %s\n",
231
gpgme_strsource(rc), gpgme_strerror(rc));
232
return false;
233
}
234
235
if(not import_key(pubkey) or not import_key(seckey)){
236
return false;
237
}
238
239
return true;
240
}
241
242
/*
243
* Decrypt OpenPGP data.
244
* Returns -1 on error
245
*/
246
static ssize_t pgp_packet_decrypt(const mandos_context *mc,
247
const char *cryptotext,
248
size_t crypto_size,
249
char **plaintext){
250
gpgme_data_t dh_crypto, dh_plain;
251
gpgme_error_t rc;
252
ssize_t ret;
253
size_t plaintext_capacity = 0;
254
ssize_t plaintext_length = 0;
255
256
if(debug){
257
fprintf(stderr, "Trying to decrypt OpenPGP data\n");
258
}
259
260
/* Create new GPGME data buffer from memory cryptotext */
261
rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
262
0);
263
if(rc != GPG_ERR_NO_ERROR){
127
fprintf(stderr, "Could not set home dir to %s\n", homedir);
128
return -1;
129
}
130
131
/* Create new GPGME data buffer from packet buffer */
132
rc = gpgme_data_new_from_mem(&dh_crypto, packet, packet_size, 0);
133
if (rc != GPG_ERR_NO_ERROR){
264
134
fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
265
135
gpgme_strsource(rc), gpgme_strerror(rc));
266
136
return -1;
268
138
269
139
/* Create new empty GPGME data buffer for the plaintext */
270
140
rc = gpgme_data_new(&dh_plain);
271
if(rc != GPG_ERR_NO_ERROR){
141
if (rc != GPG_ERR_NO_ERROR){
272
142
fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
273
143
gpgme_strsource(rc), gpgme_strerror(rc));
274
gpgme_data_release(dh_crypto);
275
return -1;
276
}
277
278
/* Decrypt data from the cryptotext data buffer to the plaintext
279
data buffer */
280
rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
281
if(rc != GPG_ERR_NO_ERROR){
144
return -1;
145
}
146
147
/* Create new GPGME "context" */
148
rc = gpgme_new(&ctx);
149
if (rc != GPG_ERR_NO_ERROR){
150
fprintf(stderr, "bad gpgme_new: %s: %s\n",
151
gpgme_strsource(rc), gpgme_strerror(rc));
152
return -1;
153
}
154
155
/* Decrypt data from the FILE pointer to the plaintext data
156
buffer */
157
rc = gpgme_op_decrypt(ctx, dh_crypto, dh_plain);
158
if (rc != GPG_ERR_NO_ERROR){
282
159
fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
283
160
gpgme_strsource(rc), gpgme_strerror(rc));
284
plaintext_length = -1;
285
if(debug){
286
gpgme_decrypt_result_t result;
287
result = gpgme_op_decrypt_result(mc->ctx);
288
if(result == NULL){
289
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
290
} else {
291
fprintf(stderr, "Unsupported algorithm: %s\n",
292
result->unsupported_algorithm);
293
fprintf(stderr, "Wrong key usage: %u\n",
294
result->wrong_key_usage);
295
if(result->file_name != NULL){
296
fprintf(stderr, "File name: %s\n", result->file_name);
297
}
298
gpgme_recipient_t recipient;
299
recipient = result->recipients;
300
if(recipient){
301
while(recipient != NULL){
302
fprintf(stderr, "Public key algorithm: %s\n",
303
gpgme_pubkey_algo_name(recipient->pubkey_algo));
304
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
305
fprintf(stderr, "Secret key available: %s\n",
306
recipient->status == GPG_ERR_NO_SECKEY
307
? "No" : "Yes");
308
recipient = recipient->next;
309
}
161
return -1;
162
}
163
164
if(debug){
165
fprintf(stderr, "Decryption of OpenPGP packet succeeded\n");
166
}
167
168
if (debug){
169
gpgme_decrypt_result_t result;
170
result = gpgme_op_decrypt_result(ctx);
171
if (result == NULL){
172
fprintf(stderr, "gpgme_op_decrypt_result failed\n");
173
} else {
174
fprintf(stderr, "Unsupported algorithm: %s\n",
175
result->unsupported_algorithm);
176
fprintf(stderr, "Wrong key usage: %d\n",
177
result->wrong_key_usage);
178
if(result->file_name != NULL){
179
fprintf(stderr, "File name: %s\n", result->file_name);
180
}
181
gpgme_recipient_t recipient;
182
recipient = result->recipients;
183
if(recipient){
184
while(recipient != NULL){
185
fprintf(stderr, "Public key algorithm: %s\n",
186
gpgme_pubkey_algo_name(recipient->pubkey_algo));
187
fprintf(stderr, "Key ID: %s\n", recipient->keyid);
188
fprintf(stderr, "Secret key available: %s\n",
189
recipient->status == GPG_ERR_NO_SECKEY
190
? "No" : "Yes");
191
recipient = recipient->next;
310
192
}
311
193
}
312
194
}
313
goto decrypt_end;
314
195
}
315
196
316
if(debug){
317
fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
318
}
197
/* Delete the GPGME FILE pointer cryptotext data buffer */
198
gpgme_data_release(dh_crypto);
319
199
320
200
/* Seek back to the beginning of the GPGME plaintext data buffer */
321
if(gpgme_data_seek(dh_plain, (off_t)0, SEEK_SET) == -1){
322
perror("gpgme_data_seek");
323
plaintext_length = -1;
324
goto decrypt_end;
201
if (gpgme_data_seek(dh_plain, (off_t) 0, SEEK_SET) == -1){
202
perror("pgpme_data_seek");
325
203
}
326
204
327
*plaintext = NULL;
205
*new_packet = 0;
328
206
while(true){
329
plaintext_capacity = incbuffer(plaintext,
330
(size_t)plaintext_length,
331
plaintext_capacity);
332
if(plaintext_capacity == 0){
333
perror("incbuffer");
334
plaintext_length = -1;
335
goto decrypt_end;
207
if (new_packet_length + BUFFER_SIZE > new_packet_capacity){
208
*new_packet = realloc(*new_packet,
209
(unsigned int)new_packet_capacity
210
+ BUFFER_SIZE);
211
if (*new_packet == NULL){
212
perror("realloc");
213
return -1;
214
}
215
new_packet_capacity += BUFFER_SIZE;
336
216
}
337
217
338
ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
218
ret = gpgme_data_read(dh_plain, *new_packet + new_packet_length,
339
219
BUFFER_SIZE);
340
220
/* Print the data, if any */
341
if(ret == 0){
342
/* EOF */
221
if (ret == 0){
343
222
break;
344
223
}
345
224
if(ret < 0){
346
225
perror("gpgme_data_read");
347
plaintext_length = -1;
348
goto decrypt_end;
349
}
350
plaintext_length += ret;
351
}
352
353
if(debug){
354
fprintf(stderr, "Decrypted password is: ");
355
for(ssize_t i = 0; i < plaintext_length; i++){
356
fprintf(stderr, "%02hhX ", (*plaintext)[i]);
357
}
358
fprintf(stderr, "\n");
359
}
360
361
decrypt_end:
362
363
/* Delete the GPGME cryptotext data buffer */
364
gpgme_data_release(dh_crypto);
226
return -1;
227
}
228
new_packet_length += ret;
229
}
230
231
/* FIXME: check characters before printing to screen so to not print
232
terminal control characters */
233
/* if(debug){ */
234
/* fprintf(stderr, "decrypted password is: "); */
235
/* fwrite(*new_packet, 1, new_packet_length, stderr); */
236
/* fprintf(stderr, "\n"); */
237
/* } */
365
238
366
239
/* Delete the GPGME plaintext data buffer */
367
240
gpgme_data_release(dh_plain);
368
return plaintext_length;
241
return new_packet_length;
369
242
}
370
243
371
static const char * safer_gnutls_strerror(int value){
372
const char *ret = gnutls_strerror(value); /* Spurious warning from
373
-Wunreachable-code */
374
if(ret == NULL)
244
static const char * safer_gnutls_strerror (int value) {
245
const char *ret = gnutls_strerror (value);
246
if (ret == NULL)
375
247
ret = "(unknown)";
376
248
return ret;
377
249
}
378
250
379
/* GnuTLS log function callback */
380
251
static void debuggnutls(__attribute__((unused)) int level,
381
252
const char* string){
382
fprintf(stderr, "GnuTLS: %s", string);
253
fprintf(stderr, "%s", string);
383
254
}
384
255
385
static int init_gnutls_global(mandos_context *mc,
386
const char *pubkeyfilename,
387
const char *seckeyfilename){
256
static int initgnutls(encrypted_session *es){
257
const char *err;
388
258
int ret;
389
259
390
260
if(debug){
391
261
fprintf(stderr, "Initializing GnuTLS\n");
392
262
}
393
394
ret = gnutls_global_init();
395
if(ret != GNUTLS_E_SUCCESS){
396
fprintf(stderr, "GnuTLS global_init: %s\n",
397
safer_gnutls_strerror(ret));
263
264
if ((ret = gnutls_global_init ())
265
!= GNUTLS_E_SUCCESS) {
266
fprintf (stderr, "global_init: %s\n", safer_gnutls_strerror(ret));
398
267
return -1;
399
268
}
400
401
if(debug){
402
/* "Use a log level over 10 to enable all debugging options."
403
* - GnuTLS manual
404
*/
269
270
if (debug){
405
271
gnutls_global_set_log_level(11);
406
272
gnutls_global_set_log_function(debuggnutls);
407
273
}
408
274
409
/* OpenPGP credentials */
410
gnutls_certificate_allocate_credentials(&mc->cred);
411
if(ret != GNUTLS_E_SUCCESS){
412
fprintf(stderr, "GnuTLS memory error: %s\n", /* Spurious warning
413
* from
414
* -Wunreachable-code
415
*/
416
safer_gnutls_strerror(ret));
417
gnutls_global_deinit();
275
/* openpgp credentials */
276
if ((ret = gnutls_certificate_allocate_credentials (&es->cred))
277
!= GNUTLS_E_SUCCESS) {
278
fprintf (stderr, "memory error: %s\n",
279
safer_gnutls_strerror(ret));
418
280
return -1;
419
281
}
420
282
421
283
if(debug){
422
fprintf(stderr, "Attempting to use OpenPGP public key %s and"
423
" secret key %s as GnuTLS credentials\n", pubkeyfilename,
424
seckeyfilename);
284
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
285
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
286
seckeyfile);
425
287
}
426
288
427
289
ret = gnutls_certificate_set_openpgp_key_file
428
(mc->cred, pubkeyfilename, seckeyfilename,
429
GNUTLS_OPENPGP_FMT_BASE64);
430
if(ret != GNUTLS_E_SUCCESS){
431
fprintf(stderr,
432
"Error[%d] while reading the OpenPGP key pair ('%s',"
433
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
434
fprintf(stderr, "The GnuTLS error is: %s\n",
435
safer_gnutls_strerror(ret));
436
goto globalfail;
437
}
438
439
/* GnuTLS server initialization */
440
ret = gnutls_dh_params_init(&mc->dh_params);
441
if(ret != GNUTLS_E_SUCCESS){
442
fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
443
" %s\n", safer_gnutls_strerror(ret));
444
goto globalfail;
445
}
446
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
447
if(ret != GNUTLS_E_SUCCESS){
448
fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
449
safer_gnutls_strerror(ret));
450
goto globalfail;
451
}
452
453
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
454
455
return 0;
456
457
globalfail:
458
459
gnutls_certificate_free_credentials(mc->cred);
460
gnutls_global_deinit();
461
gnutls_dh_params_deinit(mc->dh_params);
462
return -1;
463
}
464
465
static int init_gnutls_session(mandos_context *mc,
466
gnutls_session_t *session){
467
int ret;
468
/* GnuTLS session creation */
469
ret = gnutls_init(session, GNUTLS_SERVER);
470
if(ret != GNUTLS_E_SUCCESS){
290
(es->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
291
if (ret != GNUTLS_E_SUCCESS) {
292
fprintf
293
(stderr, "Error[%d] while reading the OpenPGP key pair ('%s',"
294
" '%s')\n",
295
ret, pubkeyfile, seckeyfile);
296
fprintf(stdout, "The Error is: %s\n",
297
safer_gnutls_strerror(ret));
298
return -1;
299
}
300
301
//GnuTLS server initialization
302
if ((ret = gnutls_dh_params_init (&es->dh_params))
303
!= GNUTLS_E_SUCCESS) {
304
fprintf (stderr, "Error in dh parameter initialization: %s\n",
305
safer_gnutls_strerror(ret));
306
return -1;
307
}
308
309
if ((ret = gnutls_dh_params_generate2 (es->dh_params, dh_bits))
310
!= GNUTLS_E_SUCCESS) {
311
fprintf (stderr, "Error in prime generation: %s\n",
312
safer_gnutls_strerror(ret));
313
return -1;
314
}
315
316
gnutls_certificate_set_dh_params (es->cred, es->dh_params);
317
318
// GnuTLS session creation
319
if ((ret = gnutls_init (&es->session, GNUTLS_SERVER))
320
!= GNUTLS_E_SUCCESS){
471
321
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
472
322
safer_gnutls_strerror(ret));
473
323
}
474
324
475
{
476
const char *err;
477
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
478
if(ret != GNUTLS_E_SUCCESS){
479
fprintf(stderr, "Syntax error at: %s\n", err);
480
fprintf(stderr, "GnuTLS error: %s\n",
481
safer_gnutls_strerror(ret));
482
gnutls_deinit(*session);
483
return -1;
484
}
325
if ((ret = gnutls_priority_set_direct (es->session, "NORMAL", &err))
326
!= GNUTLS_E_SUCCESS) {
327
fprintf(stderr, "Syntax error at: %s\n", err);
328
fprintf(stderr, "GnuTLS error: %s\n",
329
safer_gnutls_strerror(ret));
330
return -1;
485
331
}
486
332
487
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
488
mc->cred);
489
if(ret != GNUTLS_E_SUCCESS){
490
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
333
if ((ret = gnutls_credentials_set
334
(es->session, GNUTLS_CRD_CERTIFICATE, es->cred))
335
!= GNUTLS_E_SUCCESS) {
336
fprintf(stderr, "Error setting a credentials set: %s\n",
491
337
safer_gnutls_strerror(ret));
492
gnutls_deinit(*session);
493
338
return -1;
494
339
}
495
340
496
341
/* ignore client certificate if any. */
497
gnutls_certificate_server_set_request(*session,
498
GNUTLS_CERT_IGNORE);
342
gnutls_certificate_server_set_request (es->session,
343
GNUTLS_CERT_IGNORE);
499
344
500
gnutls_dh_set_prime_bits(*session, mc->dh_bits);
345
gnutls_dh_set_prime_bits (es->session, dh_bits);
501
346
502
347
return 0;
503
348
}
504
349
505
/* Avahi log function callback */
506
350
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
507
351
__attribute__((unused)) const char *txt){}
508
352
509
/* Called when a Mandos server is found */
510
353
static int start_mandos_communication(const char *ip, uint16_t port,
511
AvahiIfIndex if_index,
512
mandos_context *mc){
354
AvahiIfIndex if_index){
513
355
int ret, tcp_sd;
514
ssize_t sret;
515
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
356
struct sockaddr_in6 to;
357
encrypted_session es;
516
358
char *buffer = NULL;
517
359
char *decrypted_buffer;
518
360
size_t buffer_length = 0;
519
361
size_t buffer_capacity = 0;
520
362
ssize_t decrypted_buffer_size;
521
size_t written;
363
size_t written = 0;
522
364
int retval = 0;
523
365
char interface[IF_NAMESIZE];
524
gnutls_session_t session;
525
526
ret = init_gnutls_session(mc, &session);
527
if(ret != 0){
528
return -1;
529
}
530
366
531
367
if(debug){
532
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
533
"\n", ip, port);
368
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
369
ip, port);
534
370
}
535
371
536
372
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
537
if(tcp_sd < 0){
373
if(tcp_sd < 0) {
538
374
perror("socket");
539
375
return -1;
540
376
}
541
377
542
if(debug){
543
if(if_indextoname((unsigned int)if_index, interface) == NULL){
378
if(if_indextoname((unsigned int)if_index, interface) == NULL){
379
if(debug){
544
380
perror("if_indextoname");
545
return -1;
546
381
}
382
return -1;
383
}
384
385
if(debug){
547
386
fprintf(stderr, "Binding to interface %s\n", interface);
548
387
}
549
388
550
memset(&to, 0, sizeof(to));
551
to.in6.sin6_family = AF_INET6;
552
/* It would be nice to have a way to detect if we were passed an
553
IPv4 address here. Now we assume an IPv6 address. */
554
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
555
if(ret < 0 ){
389
memset(&to,0,sizeof(to)); /* Spurious warning */
390
to.sin6_family = AF_INET6;
391
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
392
if (ret < 0 ){
556
393
perror("inet_pton");
557
394
return -1;
558
}
395
}
559
396
if(ret == 0){
560
397
fprintf(stderr, "Bad address: %s\n", ip);
561
398
return -1;
562
399
}
563
to.in6.sin6_port = htons(port); /* Spurious warnings from
564
-Wconversion and
565
-Wunreachable-code */
400
to.sin6_port = htons(port); /* Spurious warning */
566
401
567
to.in6.sin6_scope_id = (uint32_t)if_index;
402
to.sin6_scope_id = (uint32_t)if_index;
568
403
569
404
if(debug){
570
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
571
port);
405
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
572
406
char addrstr[INET6_ADDRSTRLEN] = "";
573
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
407
if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
574
408
sizeof(addrstr)) == NULL){
575
409
perror("inet_ntop");
576
410
} else {
577
411
if(strcmp(addrstr, ip) != 0){
578
fprintf(stderr, "Canonical address form: %s\n", addrstr);
412
fprintf(stderr, "Canonical address form: %s\n",
413
addrstr, ntohs(to.sin6_port));
579
414
}
580
415
}
581
416
}
582
417
583
ret = connect(tcp_sd, &to.in, sizeof(to));
584
if(ret < 0){
418
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
419
if (ret < 0){
585
420
perror("connect");
586
421
return -1;
587
422
}
588
423
589
const char *out = mandos_protocol_version;
590
written = 0;
591
while(true){
592
size_t out_size = strlen(out);
593
ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
594
out_size - written));
595
if(ret == -1){
596
perror("write");
597
retval = -1;
598
goto mandos_end;
599
}
600
written += (size_t)ret;
601
if(written < out_size){
602
continue;
603
} else {
604
if(out == mandos_protocol_version){
605
written = 0;
606
out = "\r\n";
607
} else {
608
break;
609
}
610
}
424
ret = initgnutls (&es);
425
if (ret != 0){
426
retval = -1;
427
return -1;
611
428
}
612
429
430
gnutls_transport_set_ptr (es.session,
431
(gnutls_transport_ptr_t) tcp_sd);
432
613
433
if(debug){
614
434
fprintf(stderr, "Establishing TLS session with %s\n", ip);
615
435
}
616
436
617
gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
618
619
do{
620
ret = gnutls_handshake(session);
621
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
622
623
if(ret != GNUTLS_E_SUCCESS){
437
ret = gnutls_handshake (es.session);
438
439
if (ret != GNUTLS_E_SUCCESS){
624
440
if(debug){
625
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
626
gnutls_perror(ret);
441
fprintf(stderr, "\n*** Handshake failed ***\n");
442
gnutls_perror (ret);
627
443
}
628
444
retval = -1;
629
goto mandos_end;
445
goto exit;
630
446
}
631
447
632
/* Read OpenPGP packet that contains the wanted password */
448
//Retrieve OpenPGP packet that contains the wanted password
633
449
634
450
if(debug){
635
451
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
636
452
ip);
637
453
}
638
454
639
455
while(true){
640
buffer_capacity = incbuffer(&buffer, buffer_length,
641
buffer_capacity);
642
if(buffer_capacity == 0){
643
perror("incbuffer");
644
retval = -1;
645
goto mandos_end;
456
if (buffer_length + BUFFER_SIZE > buffer_capacity){
457
buffer = realloc(buffer, buffer_capacity + BUFFER_SIZE);
458
if (buffer == NULL){
459
perror("realloc");
460
goto exit;
461
}
462
buffer_capacity += BUFFER_SIZE;
646
463
}
647
464
648
sret = gnutls_record_recv(session, buffer+buffer_length,
649
BUFFER_SIZE);
650
if(sret == 0){
465
ret = gnutls_record_recv
466
(es.session, buffer+buffer_length, BUFFER_SIZE);
467
if (ret == 0){
651
468
break;
652
469
}
653
if(sret < 0){
654
switch(sret){
470
if (ret < 0){
471
switch(ret){
655
472
case GNUTLS_E_INTERRUPTED:
656
473
case GNUTLS_E_AGAIN:
657
474
break;
658
475
case GNUTLS_E_REHANDSHAKE:
659
do{
660
ret = gnutls_handshake(session);
661
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
662
if(ret < 0){
663
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
664
gnutls_perror(ret);
476
ret = gnutls_handshake (es.session);
477
if (ret < 0){
478
fprintf(stderr, "\n*** Handshake failed ***\n");
479
gnutls_perror (ret);
665
480
retval = -1;
666
goto mandos_end;
481
goto exit;
667
482
}
668
483
break;
669
484
default:
670
485
fprintf(stderr, "Unknown error while reading data from"
671
" encrypted session with Mandos server\n");
486
" encrypted session with mandos server\n");
672
487
retval = -1;
673
gnutls_bye(session, GNUTLS_SHUT_RDWR);
674
goto mandos_end;
488
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
489
goto exit;
675
490
}
676
491
} else {
677
buffer_length += (size_t) sret;
492
buffer_length += (size_t) ret;
678
493
}
679
494
}
680
495
681
if(debug){
682
fprintf(stderr, "Closing TLS session\n");
683
}
684
685
gnutls_bye(session, GNUTLS_SHUT_RDWR);
686
687
if(buffer_length > 0){
688
decrypted_buffer_size = pgp_packet_decrypt(mc, buffer,
496
if (buffer_length > 0){
497
decrypted_buffer_size = pgp_packet_decrypt(buffer,
689
498
buffer_length,
690
&decrypted_buffer);
691
if(decrypted_buffer_size >= 0){
692
written = 0;
499
&decrypted_buffer,
500
keydir);
501
if (decrypted_buffer_size >= 0){
693
502
while(written < (size_t) decrypted_buffer_size){
694
ret = (int)fwrite(decrypted_buffer + written, 1,
695
(size_t)decrypted_buffer_size - written,
696
stdout);
503
ret = (int)fwrite (decrypted_buffer + written, 1,
504
(size_t)decrypted_buffer_size - written,
505
stdout);
697
506
if(ret == 0 and ferror(stdout)){
698
507
if(debug){
699
508
fprintf(stderr, "Error writing encrypted data: %s\n",
708
517
} else {
709
518
retval = -1;
710
519
}
711
} else {
712
retval = -1;
713
}
714
715
/* Shutdown procedure */
716
717
mandos_end:
520
}
521
522
//shutdown procedure
523
524
if(debug){
525
fprintf(stderr, "Closing TLS session\n");
526
}
527
718
528
free(buffer);
719
ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
720
if(ret == -1){
721
perror("close");
722
}
723
gnutls_deinit(session);
529
gnutls_bye (es.session, GNUTLS_SHUT_RDWR);
530
exit:
531
close(tcp_sd);
532
gnutls_deinit (es.session);
533
gnutls_certificate_free_credentials (es.cred);
534
gnutls_global_deinit ();
724
535
return retval;
725
536
}
726
537
727
static void resolve_callback(AvahiSServiceResolver *r,
728
AvahiIfIndex interface,
729
AVAHI_GCC_UNUSED AvahiProtocol protocol,
730
AvahiResolverEvent event,
731
const char *name,
732
const char *type,
733
const char *domain,
734
const char *host_name,
735
const AvahiAddress *address,
736
uint16_t port,
737
AVAHI_GCC_UNUSED AvahiStringList *txt,
738
AVAHI_GCC_UNUSED AvahiLookupResultFlags
739
flags,
740
void* userdata){
741
mandos_context *mc = userdata;
742
assert(r);
538
static AvahiSimplePoll *simple_poll = NULL;
539
static AvahiServer *server = NULL;
540
541
static void resolve_callback(
542
AvahiSServiceResolver *r,
543
AvahiIfIndex interface,
544
AVAHI_GCC_UNUSED AvahiProtocol protocol,
545
AvahiResolverEvent event,
546
const char *name,
547
const char *type,
548
const char *domain,
549
const char *host_name,
550
const AvahiAddress *address,
551
uint16_t port,
552
AVAHI_GCC_UNUSED AvahiStringList *txt,
553
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
554
AVAHI_GCC_UNUSED void* userdata) {
555
556
assert(r); /* Spurious warning */
743
557
744
558
/* Called whenever a service has been resolved successfully or
745
559
timed out */
746
560
747
switch(event){
561
switch (event) {
748
562
default:
749
563
case AVAHI_RESOLVER_FAILURE:
750
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
751
" of type '%s' in domain '%s': %s\n", name, type, domain,
752
avahi_strerror(avahi_server_errno(mc->server)));
564
fprintf(stderr, "(Resolver) Failed to resolve service '%s' of"
565
" type '%s' in domain '%s': %s\n", name, type, domain,
566
avahi_strerror(avahi_server_errno(server)));
753
567
break;
754
568
755
569
case AVAHI_RESOLVER_FOUND:
757
571
char ip[AVAHI_ADDRESS_STR_MAX];
758
572
avahi_address_snprint(ip, sizeof(ip), address);
759
573
if(debug){
760
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
761
PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
762
ip, (intmax_t)interface, port);
574
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
575
" port %d\n", name, host_name, ip, port);
763
576
}
764
int ret = start_mandos_communication(ip, port, interface, mc);
765
if(ret == 0){
766
avahi_simple_poll_quit(mc->simple_poll);
577
int ret = start_mandos_communication(ip, port, interface);
578
if (ret == 0){
579
exit(EXIT_SUCCESS);
767
580
}
768
581
}
769
582
}
770
583
avahi_s_service_resolver_free(r);
771
584
}
772
585
773
static void browse_callback(AvahiSServiceBrowser *b,
774
AvahiIfIndex interface,
775
AvahiProtocol protocol,
776
AvahiBrowserEvent event,
777
const char *name,
778
const char *type,
779
const char *domain,
780
AVAHI_GCC_UNUSED AvahiLookupResultFlags
781
flags,
782
void* userdata){
783
mandos_context *mc = userdata;
784
assert(b);
785
786
/* Called whenever a new services becomes available on the LAN or
787
is removed from the LAN */
788
789
switch(event){
790
default:
791
case AVAHI_BROWSER_FAILURE:
792
793
fprintf(stderr, "(Avahi browser) %s\n",
794
avahi_strerror(avahi_server_errno(mc->server)));
795
avahi_simple_poll_quit(mc->simple_poll);
796
return;
797
798
case AVAHI_BROWSER_NEW:
799
/* We ignore the returned Avahi resolver object. In the callback
800
function we free it. If the Avahi server is terminated before
801
the callback function is called the Avahi server will free the
802
resolver for us. */
803
804
if(!(avahi_s_service_resolver_new(mc->server, interface,
805
protocol, name, type, domain,
806
AVAHI_PROTO_INET6, 0,
807
resolve_callback, mc)))
808
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
809
name, avahi_strerror(avahi_server_errno(mc->server)));
810
break;
811
812
case AVAHI_BROWSER_REMOVE:
813
break;
814
815
case AVAHI_BROWSER_ALL_FOR_NOW:
816
case AVAHI_BROWSER_CACHE_EXHAUSTED:
817
if(debug){
818
fprintf(stderr, "No Mandos server found, still searching...\n");
819
}
820
break;
821
}
822
}
823
824
int main(int argc, char *argv[]){
825
AvahiSServiceBrowser *sb = NULL;
826
int error;
827
int ret;
828
intmax_t tmpmax;
829
int numchars;
830
int exitcode = EXIT_SUCCESS;
831
const char *interface = "eth0";
832
struct ifreq network;
833
int sd;
834
uid_t uid;
835
gid_t gid;
836
char *connect_to = NULL;
837
char tempdir[] = "/tmp/mandosXXXXXX";
838
bool tempdir_created = false;
839
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
840
const char *seckey = PATHDIR "/" SECKEY;
841
const char *pubkey = PATHDIR "/" PUBKEY;
842
843
mandos_context mc = { .simple_poll = NULL, .server = NULL,
844
.dh_bits = 1024, .priority = "SECURE256"
845
":!CTYPE-X.509:+CTYPE-OPENPGP" };
846
bool gnutls_initialized = false;
847
bool gpgme_initialized = false;
848
double delay = 2.5;
849
850
{
851
struct argp_option options[] = {
852
{ .name = "debug", .key = 128,
853
.doc = "Debug mode", .group = 3 },
854
{ .name = "connect", .key = 'c',
855
.arg = "ADDRESS:PORT",
856
.doc = "Connect directly to a specific Mandos server",
857
.group = 1 },
858
{ .name = "interface", .key = 'i',
859
.arg = "NAME",
860
.doc = "Interface that will be used to search for Mandos"
861
" servers",
862
.group = 1 },
863
{ .name = "seckey", .key = 's',
864
.arg = "FILE",
865
.doc = "OpenPGP secret key file base name",
866
.group = 1 },
867
{ .name = "pubkey", .key = 'p',
868
.arg = "FILE",
869
.doc = "OpenPGP public key file base name",
870
.group = 2 },
871
{ .name = "dh-bits", .key = 129,
872
.arg = "BITS",
873
.doc = "Bit length of the prime number used in the"
874
" Diffie-Hellman key exchange",
875
.group = 2 },
876
{ .name = "priority", .key = 130,
877
.arg = "STRING",
878
.doc = "GnuTLS priority string for the TLS handshake",
879
.group = 1 },
880
{ .name = "delay", .key = 131,
881
.arg = "SECONDS",
882
.doc = "Maximum delay to wait for interface startup",
883
.group = 2 },
884
{ .name = NULL }
885
};
886
887
error_t parse_opt(int key, char *arg,
888
struct argp_state *state){
889
switch(key){
890
case 128: /* --debug */
891
debug = true;
892
break;
893
case 'c': /* --connect */
894
connect_to = arg;
895
break;
896
case 'i': /* --interface */
897
interface = arg;
898
break;
899
case 's': /* --seckey */
900
seckey = arg;
901
break;
902
case 'p': /* --pubkey */
903
pubkey = arg;
904
break;
905
case 129: /* --dh-bits */
906
ret = sscanf(arg, "%" SCNdMAX "%n", &tmpmax, &numchars);
907
if(ret < 1 or tmpmax != (typeof(mc.dh_bits))tmpmax
908
or arg[numchars] != '\0'){
909
fprintf(stderr, "Bad number of DH bits\n");
910
exit(EXIT_FAILURE);
911
}
912
mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
913
break;
914
case 130: /* --priority */
915
mc.priority = arg;
916
break;
917
case 131: /* --delay */
918
ret = sscanf(arg, "%lf%n", &delay, &numchars);
919
if(ret < 1 or arg[numchars] != '\0'){
920
fprintf(stderr, "Bad delay\n");
921
exit(EXIT_FAILURE);
922
}
923
break;
924
case ARGP_KEY_ARG:
925
argp_usage(state);
926
case ARGP_KEY_END:
927
break;
928
default:
929
return ARGP_ERR_UNKNOWN;
930
}
931
return 0;
932
}
933
934
struct argp argp = { .options = options, .parser = parse_opt,
935
.args_doc = "",
936
.doc = "Mandos client -- Get and decrypt"
937
" passwords from a Mandos server" };
938
ret = argp_parse(&argp, argc, argv, 0, 0, NULL);
939
if(ret == ARGP_ERR_UNKNOWN){
940
fprintf(stderr, "Unknown error while parsing arguments\n");
941
exitcode = EXIT_FAILURE;
942
goto end;
943
}
944
}
945
946
/* If the interface is down, bring it up */
947
{
948
#ifdef __linux__
949
/* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
950
messages to mess up the prompt */
951
ret = klogctl(8, NULL, 5);
952
if(ret == -1){
953
perror("klogctl");
954
}
955
#endif
956
957
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
958
if(sd < 0){
959
perror("socket");
960
exitcode = EXIT_FAILURE;
961
#ifdef __linux__
962
ret = klogctl(7, NULL, 0);
963
if(ret == -1){
964
perror("klogctl");
965
}
966
#endif
967
goto end;
968
}
969
strcpy(network.ifr_name, interface);
970
ret = ioctl(sd, SIOCGIFFLAGS, &network);
971
if(ret == -1){
972
perror("ioctl SIOCGIFFLAGS");
973
#ifdef __linux__
974
ret = klogctl(7, NULL, 0);
975
if(ret == -1){
976
perror("klogctl");
977
}
978
#endif
979
exitcode = EXIT_FAILURE;
980
goto end;
981
}
982
if((network.ifr_flags & IFF_UP) == 0){
983
network.ifr_flags |= IFF_UP;
984
ret = ioctl(sd, SIOCSIFFLAGS, &network);
985
if(ret == -1){
986
perror("ioctl SIOCSIFFLAGS");
987
exitcode = EXIT_FAILURE;
988
#ifdef __linux__
989
ret = klogctl(7, NULL, 0);
990
if(ret == -1){
991
perror("klogctl");
992
}
993
#endif
994
goto end;
995
}
996
}
997
/* sleep checking until interface is running */
998
for(int i=0; i < delay * 4; i++){
999
ret = ioctl(sd, SIOCGIFFLAGS, &network);
1000
if(ret == -1){
1001
perror("ioctl SIOCGIFFLAGS");
1002
} else if(network.ifr_flags & IFF_RUNNING){
1003
break;
1004
}
1005
struct timespec sleeptime = { .tv_nsec = 250000000 };
1006
ret = nanosleep(&sleeptime, NULL);
1007
if(ret == -1 and errno != EINTR){
1008
perror("nanosleep");
1009
}
1010
}
1011
ret = (int)TEMP_FAILURE_RETRY(close(sd));
1012
if(ret == -1){
1013
perror("close");
1014
}
1015
#ifdef __linux__
1016
/* Restores kernel loglevel to default */
1017
ret = klogctl(7, NULL, 0);
1018
if(ret == -1){
1019
perror("klogctl");
1020
}
1021
#endif
1022
}
1023
1024
uid = getuid();
1025
gid = getgid();
1026
1027
setgid(gid);
1028
if(ret == -1){
1029
perror("setgid");
1030
}
1031
1032
ret = setuid(uid);
1033
if(ret == -1){
1034
perror("setuid");
1035
}
1036
1037
ret = init_gnutls_global(&mc, pubkey, seckey);
1038
if(ret == -1){
1039
fprintf(stderr, "init_gnutls_global failed\n");
1040
exitcode = EXIT_FAILURE;
1041
goto end;
1042
} else {
1043
gnutls_initialized = true;
1044
}
1045
1046
if(mkdtemp(tempdir) == NULL){
1047
perror("mkdtemp");
1048
goto end;
1049
}
1050
tempdir_created = true;
1051
1052
if(not init_gpgme(&mc, pubkey, seckey, tempdir)){
1053
fprintf(stderr, "init_gpgme failed\n");
1054
exitcode = EXIT_FAILURE;
1055
goto end;
1056
} else {
1057
gpgme_initialized = true;
1058
}
1059
1060
if_index = (AvahiIfIndex) if_nametoindex(interface);
1061
if(if_index == 0){
1062
fprintf(stderr, "No such interface: \"%s\"\n", interface);
1063
exitcode = EXIT_FAILURE;
1064
goto end;
1065
}
1066
1067
if(connect_to != NULL){
1068
/* Connect directly, do not use Zeroconf */
1069
/* (Mainly meant for debugging) */
1070
char *address = strrchr(connect_to, ':');
1071
if(address == NULL){
1072
fprintf(stderr, "No colon in address\n");
1073
exitcode = EXIT_FAILURE;
1074
goto end;
1075
}
1076
uint16_t port;
1077
ret = sscanf(address+1, "%" SCNdMAX "%n", &tmpmax, &numchars);
1078
if(ret < 1 or tmpmax != (uint16_t)tmpmax
1079
or address[numchars+1] != '\0'){
1080
fprintf(stderr, "Bad port number\n");
1081
exitcode = EXIT_FAILURE;
1082
goto end;
1083
}
1084
port = (uint16_t)tmpmax;
1085
*address = '\0';
1086
address = connect_to;
1087
ret = start_mandos_communication(address, port, if_index, &mc);
1088
if(ret < 0){
1089
exitcode = EXIT_FAILURE;
1090
} else {
1091
exitcode = EXIT_SUCCESS;
1092
}
1093
goto end;
1094
}
1095
1096
if(not debug){
1097
avahi_set_log_function(empty_log);
1098
}
1099
1100
/* Initialize the pseudo-RNG for Avahi */
1101
srand((unsigned int) time(NULL));
1102
1103
/* Allocate main Avahi loop object */
1104
mc.simple_poll = avahi_simple_poll_new();
1105
if(mc.simple_poll == NULL){
1106
fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
1107
exitcode = EXIT_FAILURE;
1108
goto end;
1109
}
1110
1111
{
586
static void browse_callback(
587
AvahiSServiceBrowser *b,
588
AvahiIfIndex interface,
589
AvahiProtocol protocol,
590
AvahiBrowserEvent event,
591
const char *name,
592
const char *type,
593
const char *domain,
594
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
595
void* userdata) {
596
597
AvahiServer *s = userdata;
598
assert(b); /* Spurious warning */
599
600
/* Called whenever a new services becomes available on the LAN or
601
is removed from the LAN */
602
603
switch (event) {
604
default:
605
case AVAHI_BROWSER_FAILURE:
606
607
fprintf(stderr, "(Browser) %s\n",
608
avahi_strerror(avahi_server_errno(server)));
609
avahi_simple_poll_quit(simple_poll);
610
return;
611
612
case AVAHI_BROWSER_NEW:
613
/* We ignore the returned resolver object. In the callback
614
function we free it. If the server is terminated before
615
the callback function is called the server will free
616
the resolver for us. */
617
618
if (!(avahi_s_service_resolver_new(s, interface, protocol, name,
619
type, domain,
620
AVAHI_PROTO_INET6, 0,
621
resolve_callback, s)))
622
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
623
avahi_strerror(avahi_server_errno(s)));
624
break;
625
626
case AVAHI_BROWSER_REMOVE:
627
break;
628
629
case AVAHI_BROWSER_ALL_FOR_NOW:
630
case AVAHI_BROWSER_CACHE_EXHAUSTED:
631
break;
632
}
633
}
634
635
/* Combines file name and path and returns the malloced new
636
string. some sane checks could/should be added */
637
static const char *combinepath(const char *first, const char *second){
638
size_t f_len = strlen(first);
639
size_t s_len = strlen(second);
640
char *tmp = malloc(f_len + s_len + 2);
641
if (tmp == NULL){
642
return NULL;
643
}
644
if(f_len > 0){
645
memcpy(tmp, first, f_len);
646
}
647
tmp[f_len] = '/';
648
if(s_len > 0){
649
memcpy(tmp + f_len + 1, second, s_len);
650
}
651
tmp[f_len + 1 + s_len] = '\0';
652
return tmp;
653
}
654
655
656
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
1112
657
AvahiServerConfig config;
1113
/* Do not publish any local Zeroconf records */
658
AvahiSServiceBrowser *sb = NULL;
659
int error;
660
int ret;
661
int debug_int = 0;
662
int returncode = EXIT_SUCCESS;
663
const char *interface = NULL;
664
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
665
char *connect_to = NULL;
666
667
debug_int = debug ? 1 : 0;
668
while (true){
669
static struct option long_options[] = {
670
{"debug", no_argument, &debug_int, 1},
671
{"connect", required_argument, NULL, 'C'},
672
{"interface", required_argument, NULL, 'i'},
673
{"keydir", required_argument, NULL, 'd'},
674
{"seckey", required_argument, NULL, 'c'},
675
{"pubkey", required_argument, NULL, 'k'},
676
{"dh-bits", required_argument, NULL, 'D'},
677
{0, 0, 0, 0} };
678
679
int option_index = 0;
680
ret = getopt_long (argc, argv, "i:", long_options,
681
&option_index);
682
683
if (ret == -1){
684
break;
685
}
686
687
switch(ret){
688
case 0:
689
break;
690
case 'i':
691
interface = optarg;
692
break;
693
case 'C':
694
connect_to = optarg;
695
break;
696
case 'd':
697
keydir = optarg;
698
break;
699
case 'c':
700
pubkeyfile = optarg;
701
break;
702
case 'k':
703
seckeyfile = optarg;
704
break;
705
case 'D':
706
dh_bits = atoi(optarg);
707
break;
708
case '?':
709
break
710
default:
711
exit(EXIT_FAILURE);
712
}
713
}
714
debug = debug_int ? true : false;
715
716
pubkeyfile = combinepath(keydir, pubkeyfile);
717
if (pubkeyfile == NULL){
718
perror("combinepath");
719
goto exit;
720
}
721
722
if(interface != NULL){
723
if_index = (AvahiIfIndex) if_nametoindex(interface);
724
if(if_index == 0){
725
fprintf(stderr, "No such interface: \"%s\"\n", interface);
726
exit(EXIT_FAILURE);
727
}
728
}
729
730
if(connect_to != NULL){
731
/* Connect directly, do not use Zeroconf */
732
/* (Mainly meant for debugging) */
733
char *address = strrchr(connect_to, ':');
734
if(address == NULL){
735
fprintf(stderr, "No colon in address\n");
736
exit(EXIT_FAILURE);
737
}
738
errno = 0;
739
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
740
if(errno){
741
perror("Bad port number");
742
exit(EXIT_FAILURE);
743
}
744
*address = '\0';
745
address = connect_to;
746
ret = start_mandos_communication(address, port, if_index);
747
if(ret < 0){
748
exit(EXIT_FAILURE);
749
} else {
750
exit(EXIT_SUCCESS);
751
}
752
}
753
754
seckeyfile = combinepath(keydir, seckeyfile);
755
if (seckeyfile == NULL){
756
perror("combinepath");
757
goto exit;
758
}
759
760
if (not debug){
761
avahi_set_log_function(empty_log);
762
}
763
764
/* Initialize the psuedo-RNG */
765
srand((unsigned int) time(NULL));
766
767
/* Allocate main loop object */
768
if (!(simple_poll = avahi_simple_poll_new())) {
769
fprintf(stderr, "Failed to create simple poll object.\n");
770
771
goto exit;
772
}
773
774
/* Do not publish any local records */
1114
775
avahi_server_config_init(&config);
1115
776
config.publish_hinfo = 0;
1116
777
config.publish_addresses = 0;
1117
778
config.publish_workstation = 0;
1118
779
config.publish_domain = 0;
1119
780
1120
781
/* Allocate a new server */
1121
mc.server = avahi_server_new(avahi_simple_poll_get
1122
(mc.simple_poll), &config, NULL,
1123
NULL, &error);
1124
1125
/* Free the Avahi configuration data */
782
server = avahi_server_new(avahi_simple_poll_get(simple_poll),
783
&config, NULL, NULL, &error);
784
785
/* Free the configuration data */
1126
786
avahi_server_config_free(&config);
1127
}
1128
1129
/* Check if creating the Avahi server object succeeded */
1130
if(mc.server == NULL){
1131
fprintf(stderr, "Failed to create Avahi server: %s\n",
1132
avahi_strerror(error));
1133
exitcode = EXIT_FAILURE;
1134
goto end;
1135
}
1136
1137
/* Create the Avahi service browser */
1138
sb = avahi_s_service_browser_new(mc.server, if_index,
1139
AVAHI_PROTO_INET6, "_mandos._tcp",
1140
NULL, 0, browse_callback, &mc);
1141
if(sb == NULL){
1142
fprintf(stderr, "Failed to create service browser: %s\n",
1143
avahi_strerror(avahi_server_errno(mc.server)));
1144
exitcode = EXIT_FAILURE;
1145
goto end;
1146
}
1147
1148
/* Run the main loop */
1149
1150
if(debug){
1151
fprintf(stderr, "Starting Avahi loop search\n");
1152
}
1153
1154
avahi_simple_poll_loop(mc.simple_poll);
1155
1156
end:
1157
1158
if(debug){
1159
fprintf(stderr, "%s exiting\n", argv[0]);
1160
}
1161
1162
/* Cleanup things */
1163
if(sb != NULL)
1164
avahi_s_service_browser_free(sb);
1165
1166
if(mc.server != NULL)
1167
avahi_server_free(mc.server);
1168
1169
if(mc.simple_poll != NULL)
1170
avahi_simple_poll_free(mc.simple_poll);
1171
1172
if(gnutls_initialized){
1173
gnutls_certificate_free_credentials(mc.cred);
1174
gnutls_global_deinit();
1175
gnutls_dh_params_deinit(mc.dh_params);
1176
}
1177
1178
if(gpgme_initialized){
1179
gpgme_release(mc.ctx);
1180
}
1181
1182
/* Removes the temp directory used by GPGME */
1183
if(tempdir_created){
1184
DIR *d;
1185
struct dirent *direntry;
1186
d = opendir(tempdir);
1187
if(d == NULL){
1188
if(errno != ENOENT){
1189
perror("opendir");
1190
}
1191
} else {
1192
while(true){
1193
direntry = readdir(d);
1194
if(direntry == NULL){
1195
break;
1196
}
1197
/* Skip "." and ".." */
1198
if(direntry->d_name[0] == '.'
1199
and (direntry->d_name[1] == '\0'
1200
or (direntry->d_name[1] == '.'
1201
and direntry->d_name[2] == '\0'))){
1202
continue;
1203
}
1204
char *fullname = NULL;
1205
ret = asprintf(&fullname, "%s/%s", tempdir,
1206
direntry->d_name);
1207
if(ret < 0){
1208
perror("asprintf");
1209
continue;
1210
}
1211
ret = remove(fullname);
1212
if(ret == -1){
1213
fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
1214
strerror(errno));
1215
}
1216
free(fullname);
1217
}
1218
closedir(d);
1219
}
1220
ret = rmdir(tempdir);
1221
if(ret == -1 and errno != ENOENT){
1222
perror("rmdir");
1223
}
1224
}
1225
1226
return exitcode;
787
788
/* Check if creating the server object succeeded */
789
if (!server) {
790
fprintf(stderr, "Failed to create server: %s\n",
791
avahi_strerror(error));
792
returncode = EXIT_FAILURE;
793
goto exit;
794
}
795
796
/* Create the service browser */
797
sb = avahi_s_service_browser_new(server, if_index,
798
AVAHI_PROTO_INET6,
799
"_mandos._tcp", NULL, 0,
800
browse_callback, server);
801
if (!sb) {
802
fprintf(stderr, "Failed to create service browser: %s\n",
803
avahi_strerror(avahi_server_errno(server)));
804
returncode = EXIT_FAILURE;
805
goto exit;
806
}
807
808
/* Run the main loop */
809
810
if (debug){
811
fprintf(stderr, "Starting avahi loop search\n");
812
}
813
814
avahi_simple_poll_loop(simple_poll);
815
816
exit:
817
818
if (debug){
819
fprintf(stderr, "%s exiting\n", argv[0]);
820
}
821
822
/* Cleanup things */
823
if (sb)
824
avahi_s_service_browser_free(sb);
825
826
if (server)
827
avahi_server_free(server);
828
829
if (simple_poll)
830
avahi_simple_poll_free(simple_poll);
831
free(pubkeyfile);
832
free(seckeyfile);
833
834
return returncode;
1227
835
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0