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