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