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