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 24.1.54
- compare with another revision
- download diff
- download tarball
- view history from revision 24.1.54
- Committer: Björn Påhlsson
- Date: 2008-08-16 18:15:07 UTC
- mto: (24.1.154 mandos) (237.4.3 mandos-release)
- mto: This revision was merged to the branch mainline in revision 80.
- Revision ID: belorn@braxen-20080816181507-hubb1rsmfq9b3agl
plugin-runner
Freeing up memory during run-time.
Freeing up memory during run-time.
- files added:
- COPYING
- 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
#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(), 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 */
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_* */
43
76
#include <avahi-core/core.h>
44
77
#include <avahi-core/lookup.h>
45
78
#include <avahi-core/log.h>
47
80
#include <avahi-common/malloc.h>
48
81
#include <avahi-common/error.h>
49
82
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>
83
/* GnuTLS */
84
#include <gnutls/gnutls.h> /* All GnuTLS types, constants and
85
functions:
86
gnutls_*
87
init_gnutls_session(),
88
GNUTLS_* */
89
#include <gnutls/openpgp.h> /* gnutls_certificate_set_openpgp_key_file(),
90
GNUTLS_OPENPGP_FMT_BASE64 */
91
92
/* GPGME */
93
#include <gpgme.h> /* All GPGME types, constants and
94
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 *pubkeyfilename,
319
const char *seckeyfilename){
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
285
350
if(debug){
286
351
fprintf(stderr, "Attempting to use OpenPGP certificate %s"
287
" and keyfile %s as GnuTLS credentials\n", pubkeyfile,
288
seckeyfile);
352
" and keyfile %s as GnuTLS credentials\n", pubkeyfilename,
353
seckeyfilename);
289
354
}
290
355
291
356
ret = gnutls_certificate_set_openpgp_key_file
292
(mc->cred, pubkeyfile, seckeyfile, GNUTLS_OPENPGP_FMT_BASE64);
357
(mc->cred, pubkeyfilename, seckeyfilename,
358
GNUTLS_OPENPGP_FMT_BASE64);
293
359
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",
360
fprintf(stderr,
361
"Error[%d] while reading the OpenPGP key pair ('%s',"
362
" '%s')\n", ret, pubkeyfilename, seckeyfilename);
363
fprintf(stdout, "The GnuTLS error is: %s\n",
299
364
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){
365
goto globalfail;
366
}
367
368
/* GnuTLS server initialization */
369
ret = gnutls_dh_params_init(&mc->dh_params);
370
if (ret != GNUTLS_E_SUCCESS) {
371
fprintf (stderr, "Error in GnuTLS DH parameter initialization:"
372
" %s\n", safer_gnutls_strerror(ret));
373
goto globalfail;
374
}
375
ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
376
if (ret != GNUTLS_E_SUCCESS) {
377
fprintf (stderr, "Error in GnuTLS prime generation: %s\n",
378
safer_gnutls_strerror(ret));
379
goto globalfail;
380
}
381
382
gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
383
384
return 0;
385
386
globalfail:
387
388
gnutls_certificate_free_credentials(mc->cred);
389
gnutls_global_deinit();
390
return -1;
391
392
}
393
394
static int init_gnutls_session(mandos_context *mc,
395
gnutls_session_t *session){
396
int ret;
397
/* GnuTLS session creation */
398
ret = gnutls_init(session, GNUTLS_SERVER);
399
if (ret != GNUTLS_E_SUCCESS){
323
400
fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
324
401
safer_gnutls_strerror(ret));
325
402
}
326
403
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;
404
{
405
const char *err;
406
ret = gnutls_priority_set_direct(*session, mc->priority, &err);
407
if (ret != GNUTLS_E_SUCCESS) {
408
fprintf(stderr, "Syntax error at: %s\n", err);
409
fprintf(stderr, "GnuTLS error: %s\n",
410
safer_gnutls_strerror(ret));
411
gnutls_deinit (*session);
412
return -1;
413
}
333
414
}
334
415
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",
416
ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
417
mc->cred);
418
if (ret != GNUTLS_E_SUCCESS) {
419
fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
339
420
safer_gnutls_strerror(ret));
421
gnutls_deinit (*session);
340
422
return -1;
341
423
}
342
424
349
431
return 0;
350
432
}
351
433
434
/* Avahi log function callback */
352
435
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
353
436
__attribute__((unused)) const char *txt){}
354
437
438
/* Called when a Mandos server is found */
355
439
static int start_mandos_communication(const char *ip, uint16_t port,
356
440
AvahiIfIndex if_index,
357
441
mandos_context *mc){
358
442
int ret, tcp_sd;
359
struct sockaddr_in6 to;
443
union { struct sockaddr in; struct sockaddr_in6 in6; } to;
360
444
char *buffer = NULL;
361
445
char *decrypted_buffer;
362
446
size_t buffer_length = 0;
363
447
size_t buffer_capacity = 0;
364
448
ssize_t decrypted_buffer_size;
365
size_t written = 0;
449
size_t written;
366
450
int retval = 0;
367
451
char interface[IF_NAMESIZE];
368
452
gnutls_session_t session;
369
gnutls_dh_params_t dh_params;
453
454
ret = init_gnutls_session (mc, &session);
455
if (ret != 0){
456
return -1;
457
}
370
458
371
459
if(debug){
372
fprintf(stderr, "Setting up a tcp connection to %s, port %d\n",
373
ip, port);
460
fprintf(stderr, "Setting up a tcp connection to %s, port %" PRIu16
461
"\n", ip, port);
374
462
}
375
463
376
464
tcp_sd = socket(PF_INET6, SOCK_STREAM, 0);
387
475
fprintf(stderr, "Binding to interface %s\n", interface);
388
476
}
389
477
390
memset(&to,0,sizeof(to)); /* Spurious warning */
391
to.sin6_family = AF_INET6;
392
ret = inet_pton(AF_INET6, ip, &to.sin6_addr);
478
memset(&to, 0, sizeof(to)); /* Spurious warning */
479
to.in6.sin6_family = AF_INET6;
480
/* It would be nice to have a way to detect if we were passed an
481
IPv4 address here. Now we assume an IPv6 address. */
482
ret = inet_pton(AF_INET6, ip, &to.in6.sin6_addr);
393
483
if (ret < 0 ){
394
484
perror("inet_pton");
395
485
return -1;
398
488
fprintf(stderr, "Bad address: %s\n", ip);
399
489
return -1;
400
490
}
401
to.sin6_port = htons(port); /* Spurious warning */
491
to.in6.sin6_port = htons(port); /* Spurious warning */
402
492
403
to.sin6_scope_id = (uint32_t)if_index;
493
to.in6.sin6_scope_id = (uint32_t)if_index;
404
494
405
495
if(debug){
406
fprintf(stderr, "Connection to: %s, port %d\n", ip, port);
496
fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
497
port);
407
498
char addrstr[INET6_ADDRSTRLEN] = "";
408
if(inet_ntop(to.sin6_family, &(to.sin6_addr), addrstr,
499
if(inet_ntop(to.in6.sin6_family, &(to.in6.sin6_addr), addrstr,
409
500
sizeof(addrstr)) == NULL){
410
501
perror("inet_ntop");
411
502
} else {
415
506
}
416
507
}
417
508
418
ret = connect(tcp_sd, (struct sockaddr *) &to, sizeof(to));
509
ret = connect(tcp_sd, &to.in, sizeof(to));
419
510
if (ret < 0){
420
511
perror("connect");
421
512
return -1;
422
513
}
423
424
ret = initgnutls (mc, &session, &dh_params);
425
if (ret != 0){
426
retval = -1;
427
return -1;
514
515
const char *out = mandos_protocol_version;
516
written = 0;
517
while (true){
518
size_t out_size = strlen(out);
519
ret = TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
520
out_size - written));
521
if (ret == -1){
522
perror("write");
523
retval = -1;
524
goto mandos_end;
525
}
526
written += (size_t)ret;
527
if(written < out_size){
528
continue;
529
} else {
530
if (out == mandos_protocol_version){
531
written = 0;
532
out = "\r\n";
533
} else {
534
break;
535
}
536
}
537
}
538
539
if(debug){
540
fprintf(stderr, "Establishing TLS session with %s\n", ip);
428
541
}
429
542
430
543
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);
544
545
do{
546
ret = gnutls_handshake (session);
547
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
437
548
438
549
if (ret != GNUTLS_E_SUCCESS){
439
550
if(debug){
440
fprintf(stderr, "\n*** Handshake failed ***\n");
551
fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
441
552
gnutls_perror (ret);
442
553
}
443
554
retval = -1;
444
goto exit;
555
goto mandos_end;
445
556
}
446
557
447
//Retrieve OpenPGP packet that contains the wanted password
558
/* Read OpenPGP packet that contains the wanted password */
448
559
449
560
if(debug){
450
561
fprintf(stderr, "Retrieving pgp encrypted password from %s\n",
452
563
}
453
564
454
565
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;
566
buffer_capacity = adjustbuffer(&buffer, buffer_length,
567
buffer_capacity);
568
if (buffer_capacity == 0){
569
perror("adjustbuffer");
570
retval = -1;
571
goto mandos_end;
462
572
}
463
573
464
574
ret = gnutls_record_recv(session, buffer+buffer_length,
472
582
case GNUTLS_E_AGAIN:
473
583
break;
474
584
case GNUTLS_E_REHANDSHAKE:
475
ret = gnutls_handshake (session);
585
do{
586
ret = gnutls_handshake (session);
587
} while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
476
588
if (ret < 0){
477
fprintf(stderr, "\n*** Handshake failed ***\n");
589
fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
478
590
gnutls_perror (ret);
479
591
retval = -1;
480
goto exit;
592
goto mandos_end;
481
593
}
482
594
break;
483
595
default:
484
596
fprintf(stderr, "Unknown error while reading data from"
485
" encrypted session with mandos server\n");
597
" encrypted session with Mandos server\n");
486
598
retval = -1;
487
599
gnutls_bye (session, GNUTLS_SHUT_RDWR);
488
goto exit;
600
goto mandos_end;
489
601
}
490
602
} else {
491
603
buffer_length += (size_t) ret;
492
604
}
493
605
}
494
606
607
if(debug){
608
fprintf(stderr, "Closing TLS session\n");
609
}
610
611
gnutls_bye (session, GNUTLS_SHUT_RDWR);
612
495
613
if (buffer_length > 0){
496
614
decrypted_buffer_size = pgp_packet_decrypt(buffer,
497
615
buffer_length,
498
616
&decrypted_buffer,
499
617
keydir);
500
618
if (decrypted_buffer_size >= 0){
619
written = 0;
501
620
while(written < (size_t) decrypted_buffer_size){
502
621
ret = (int)fwrite (decrypted_buffer + written, 1,
503
622
(size_t)decrypted_buffer_size - written,
517
636
retval = -1;
518
637
}
519
638
}
520
521
//shutdown procedure
522
523
if(debug){
524
fprintf(stderr, "Closing TLS session\n");
525
}
526
639
640
/* Shutdown procedure */
641
642
mandos_end:
527
643
free(buffer);
528
gnutls_bye (session, GNUTLS_SHUT_RDWR);
529
exit:
530
644
close(tcp_sd);
531
645
gnutls_deinit (session);
532
gnutls_certificate_free_credentials (mc->cred);
533
gnutls_global_deinit ();
534
646
return retval;
535
647
}
536
648
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) {
649
static void resolve_callback(AvahiSServiceResolver *r,
650
AvahiIfIndex interface,
651
AVAHI_GCC_UNUSED AvahiProtocol protocol,
652
AvahiResolverEvent event,
653
const char *name,
654
const char *type,
655
const char *domain,
656
const char *host_name,
657
const AvahiAddress *address,
658
uint16_t port,
659
AVAHI_GCC_UNUSED AvahiStringList *txt,
660
AVAHI_GCC_UNUSED AvahiLookupResultFlags
661
flags,
662
void* userdata) {
550
663
mandos_context *mc = userdata;
551
664
assert(r); /* Spurious warning */
552
665
556
669
switch (event) {
557
670
default:
558
671
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,
672
fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
673
" of type '%s' in domain '%s': %s\n", name, type, domain,
561
674
avahi_strerror(avahi_server_errno(mc->server)));
562
675
break;
563
676
566
679
char ip[AVAHI_ADDRESS_STR_MAX];
567
680
avahi_address_snprint(ip, sizeof(ip), address);
568
681
if(debug){
569
fprintf(stderr, "Mandos server \"%s\" found on %s (%s) on"
570
" port %d\n", name, host_name, ip, port);
682
fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
683
PRIu16 ") on port %d\n", name, host_name, ip,
684
interface, port);
571
685
}
572
686
int ret = start_mandos_communication(ip, port, interface, mc);
573
687
if (ret == 0){
574
exit(EXIT_SUCCESS);
688
avahi_simple_poll_quit(mc->simple_poll);
575
689
}
576
690
}
577
691
}
585
699
const char *name,
586
700
const char *type,
587
701
const char *domain,
588
AVAHI_GCC_UNUSED AvahiLookupResultFlags flags,
702
AVAHI_GCC_UNUSED AvahiLookupResultFlags
703
flags,
589
704
void* userdata) {
590
705
mandos_context *mc = userdata;
591
706
assert(b); /* Spurious warning */
597
712
default:
598
713
case AVAHI_BROWSER_FAILURE:
599
714
600
fprintf(stderr, "(Browser) %s\n",
715
fprintf(stderr, "(Avahi browser) %s\n",
601
716
avahi_strerror(avahi_server_errno(mc->server)));
602
717
avahi_simple_poll_quit(mc->simple_poll);
603
718
return;
604
719
605
720
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. */
721
/* We ignore the returned Avahi resolver object. In the callback
722
function we free it. If the Avahi server is terminated before
723
the callback function is called the Avahi server will free the
724
resolver for us. */
610
725
611
if (!(avahi_s_service_resolver_new(mc->server, interface, protocol, name,
612
type, domain,
726
if (!(avahi_s_service_resolver_new(mc->server, interface,
727
protocol, name, type, domain,
613
728
AVAHI_PROTO_INET6, 0,
614
729
resolve_callback, mc)))
615
fprintf(stderr, "Failed to resolve service '%s': %s\n", name,
616
avahi_strerror(avahi_server_errno(mc->server)));
730
fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
731
name, avahi_strerror(avahi_server_errno(mc->server)));
617
732
break;
618
733
619
734
case AVAHI_BROWSER_REMOVE:
621
736
622
737
case AVAHI_BROWSER_ALL_FOR_NOW:
623
738
case AVAHI_BROWSER_CACHE_EXHAUSTED:
739
if(debug){
740
fprintf(stderr, "No Mandos server found, still searching...\n");
741
}
624
742
break;
625
743
}
626
744
}
627
745
628
746
/* Combines file name and path and returns the malloced new
629
747
string. some sane checks could/should be added */
630
static const char *combinepath(const char *first, const char *second){
631
size_t f_len = strlen(first);
632
size_t s_len = strlen(second);
633
char *tmp = malloc(f_len + s_len + 2);
634
if (tmp == NULL){
748
static char *combinepath(const char *first, const char *second){
749
char *tmp;
750
int ret = asprintf(&tmp, "%s/%s", first, second);
751
if(ret < 0){
635
752
return NULL;
636
753
}
637
if(f_len > 0){
638
memcpy(tmp, first, f_len); /* Spurious warning */
639
}
640
tmp[f_len] = '/';
641
if(s_len > 0){
642
memcpy(tmp + f_len + 1, second, s_len); /* Spurious warning */
643
}
644
tmp[f_len + 1 + s_len] = '\0';
645
754
return tmp;
646
755
}
647
756
648
757
649
int main(AVAHI_GCC_UNUSED int argc, AVAHI_GCC_UNUSED char*argv[]) {
650
AvahiServerConfig config;
758
int main(int argc, char *argv[]){
651
759
AvahiSServiceBrowser *sb = NULL;
652
760
int error;
653
761
int ret;
654
int debug_int;
655
int returncode = EXIT_SUCCESS;
762
int exitcode = EXIT_SUCCESS;
656
763
const char *interface = "eth0";
657
764
struct ifreq network;
658
765
int sd;
766
uid_t uid;
767
gid_t gid;
659
768
char *connect_to = NULL;
660
769
AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
770
char *pubkeyfilename = NULL;
771
char *seckeyfilename = NULL;
772
const char *pubkeyname = "pubkey.txt";
773
const char *seckeyname = "seckey.txt";
661
774
mandos_context mc = { .simple_poll = NULL, .server = NULL,
662
775
.dh_bits = 1024, .priority = "SECURE256"};
663
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);
709
}
710
break;
711
case 'P':
712
mc.priority = optarg;
713
break;
714
case '?':
715
default:
716
exit(EXIT_FAILURE);
717
}
718
}
719
debug = debug_int ? true : false;
720
721
pubkeyfile = combinepath(keydir, pubkeyfile);
722
if (pubkeyfile == NULL){
723
perror("combinepath");
724
returncode = EXIT_FAILURE;
725
goto exit;
726
}
727
728
seckeyfile = combinepath(keydir, seckeyfile);
729
if (seckeyfile == NULL){
730
perror("combinepath");
731
goto exit;
776
bool gnutls_initalized = false;
777
778
{
779
struct argp_option options[] = {
780
{ .name = "debug", .key = 128,
781
.doc = "Debug mode", .group = 3 },
782
{ .name = "connect", .key = 'c',
783
.arg = "IP",
784
.doc = "Connect directly to a sepcified mandos server",
785
.group = 1 },
786
{ .name = "interface", .key = 'i',
787
.arg = "INTERFACE",
788
.doc = "Interface that Avahi will conntect through",
789
.group = 1 },
790
{ .name = "keydir", .key = 'd',
791
.arg = "KEYDIR",
792
.doc = "Directory where the openpgp keyring is",
793
.group = 1 },
794
{ .name = "seckey", .key = 's',
795
.arg = "SECKEY",
796
.doc = "Secret openpgp key for gnutls authentication",
797
.group = 1 },
798
{ .name = "pubkey", .key = 'p',
799
.arg = "PUBKEY",
800
.doc = "Public openpgp key for gnutls authentication",
801
.group = 2 },
802
{ .name = "dh-bits", .key = 129,
803
.arg = "BITS",
804
.doc = "dh-bits to use in gnutls communication",
805
.group = 2 },
806
{ .name = "priority", .key = 130,
807
.arg = "PRIORITY",
808
.doc = "GNUTLS priority", .group = 1 },
809
{ .name = NULL }
810
};
811
812
813
error_t parse_opt (int key, char *arg,
814
struct argp_state *state) {
815
/* Get the INPUT argument from `argp_parse', which we know is
816
a pointer to our plugin list pointer. */
817
switch (key) {
818
case 128:
819
debug = true;
820
break;
821
case 'c':
822
connect_to = arg;
823
break;
824
case 'i':
825
interface = arg;
826
break;
827
case 'd':
828
keydir = arg;
829
break;
830
case 's':
831
seckeyname = arg;
832
break;
833
case 'p':
834
pubkeyname = arg;
835
break;
836
case 129:
837
errno = 0;
838
mc.dh_bits = (unsigned int) strtol(arg, NULL, 10);
839
if (errno){
840
perror("strtol");
841
exit(EXIT_FAILURE);
842
}
843
break;
844
case 130:
845
mc.priority = arg;
846
break;
847
case ARGP_KEY_ARG:
848
argp_usage (state);
849
case ARGP_KEY_END:
850
break;
851
default:
852
return ARGP_ERR_UNKNOWN;
853
}
854
return 0;
855
}
856
857
struct argp argp = { .options = options, .parser = parse_opt,
858
.args_doc = "",
859
.doc = "Mandos client -- Get and decrypt"
860
" passwords from mandos server" };
861
ret = argp_parse (&argp, argc, argv, 0, 0, NULL);
862
if (ret == ARGP_ERR_UNKNOWN){
863
fprintf(stderr, "Unknown error while parsing arguments\n");
864
exitcode = EXIT_FAILURE;
865
goto end;
866
}
867
}
868
869
pubkeyfilename = combinepath(keydir, pubkeyname);
870
if (pubkeyfilename == NULL){
871
perror("combinepath");
872
exitcode = EXIT_FAILURE;
873
goto end;
874
}
875
876
seckeyfilename = combinepath(keydir, seckeyname);
877
if (seckeyfilename == NULL){
878
perror("combinepath");
879
exitcode = EXIT_FAILURE;
880
goto end;
881
}
882
883
ret = init_gnutls_global(&mc, pubkeyfilename, seckeyfilename);
884
if (ret == -1){
885
fprintf(stderr, "init_gnutls_global failed\n");
886
exitcode = EXIT_FAILURE;
887
goto end;
888
} else {
889
gnutls_initalized = true;
890
}
891
892
/* If the interface is down, bring it up */
893
{
894
sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
895
if(sd < 0) {
896
perror("socket");
897
exitcode = EXIT_FAILURE;
898
goto end;
899
}
900
strcpy(network.ifr_name, interface); /* Spurious warning */
901
ret = ioctl(sd, SIOCGIFFLAGS, &network);
902
if(ret == -1){
903
perror("ioctl SIOCGIFFLAGS");
904
exitcode = EXIT_FAILURE;
905
goto end;
906
}
907
if((network.ifr_flags & IFF_UP) == 0){
908
network.ifr_flags |= IFF_UP;
909
ret = ioctl(sd, SIOCSIFFLAGS, &network);
910
if(ret == -1){
911
perror("ioctl SIOCSIFFLAGS");
912
exitcode = EXIT_FAILURE;
913
goto end;
914
}
915
}
916
close(sd);
917
}
918
919
uid = getuid();
920
gid = getgid();
921
922
ret = setuid(uid);
923
if (ret == -1){
924
perror("setuid");
925
}
926
927
setgid(gid);
928
if (ret == -1){
929
perror("setgid");
732
930
}
733
931
734
932
if_index = (AvahiIfIndex) if_nametoindex(interface);
743
941
char *address = strrchr(connect_to, ':');
744
942
if(address == NULL){
745
943
fprintf(stderr, "No colon in address\n");
746
exit(EXIT_FAILURE);
944
exitcode = EXIT_FAILURE;
945
goto end;
747
946
}
748
947
errno = 0;
749
948
uint16_t port = (uint16_t) strtol(address+1, NULL, 10);
750
949
if(errno){
751
950
perror("Bad port number");
752
exit(EXIT_FAILURE);
951
exitcode = EXIT_FAILURE;
952
goto end;
753
953
}
754
954
*address = '\0';
755
955
address = connect_to;
756
956
ret = start_mandos_communication(address, port, if_index, &mc);
757
957
if(ret < 0){
758
exit(EXIT_FAILURE);
958
exitcode = EXIT_FAILURE;
759
959
} else {
760
exit(EXIT_SUCCESS);
761
}
762
}
763
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);
781
if(ret == -1){
782
perror("ioctl SIOCSIFFLAGS");
783
returncode = EXIT_FAILURE;
784
goto exit;
785
}
786
}
787
close(sd);
960
exitcode = EXIT_SUCCESS;
961
}
962
goto end;
963
}
788
964
789
965
if (not debug){
790
966
avahi_set_log_function(empty_log);
791
967
}
792
968
793
/* Initialize the psuedo-RNG */
969
/* Initialize the pseudo-RNG for Avahi */
794
970
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",
971
972
/* Allocate main Avahi loop object */
973
mc.simple_poll = avahi_simple_poll_new();
974
if (mc.simple_poll == NULL) {
975
fprintf(stderr, "Avahi: Failed to create simple poll"
976
" object.\n");
977
exitcode = EXIT_FAILURE;
978
goto end;
979
}
980
981
{
982
AvahiServerConfig config;
983
/* Do not publish any local Zeroconf records */
984
avahi_server_config_init(&config);
985
config.publish_hinfo = 0;
986
config.publish_addresses = 0;
987
config.publish_workstation = 0;
988
config.publish_domain = 0;
989
990
/* Allocate a new server */
991
mc.server = avahi_server_new(avahi_simple_poll_get
992
(mc.simple_poll), &config, NULL,
993
NULL, &error);
994
995
/* Free the Avahi configuration data */
996
avahi_server_config_free(&config);
997
}
998
999
/* Check if creating the Avahi server object succeeded */
1000
if (mc.server == NULL) {
1001
fprintf(stderr, "Failed to create Avahi server: %s\n",
820
1002
avahi_strerror(error));
821
returncode = EXIT_FAILURE;
822
goto exit;
1003
exitcode = EXIT_FAILURE;
1004
goto end;
823
1005
}
824
1006
825
/* Create the service browser */
1007
/* Create the Avahi service browser */
826
1008
sb = avahi_s_service_browser_new(mc.server, if_index,
827
1009
AVAHI_PROTO_INET6,
828
1010
"_mandos._tcp", NULL, 0,
829
1011
browse_callback, &mc);
830
if (!sb) {
1012
if (sb == NULL) {
831
1013
fprintf(stderr, "Failed to create service browser: %s\n",
832
1014
avahi_strerror(avahi_server_errno(mc.server)));
833
returncode = EXIT_FAILURE;
834
goto exit;
1015
exitcode = EXIT_FAILURE;
1016
goto end;
835
1017
}
836
1018
837
1019
/* Run the main loop */
838
1020
839
1021
if (debug){
840
fprintf(stderr, "Starting avahi loop search\n");
1022
fprintf(stderr, "Starting Avahi loop search\n");
841
1023
}
842
1024
843
1025
avahi_simple_poll_loop(mc.simple_poll);
844
1026
845
exit:
1027
end:
846
1028
847
1029
if (debug){
848
1030
fprintf(stderr, "%s exiting\n", argv[0]);
849
1031
}
850
1032
851
1033
/* Cleanup things */
852
if (sb)
1034
if (sb != NULL)
853
1035
avahi_s_service_browser_free(sb);
854
1036
855
if (mc.server)
1037
if (mc.server != NULL)
856
1038
avahi_server_free(mc.server);
857
1039
858
if (mc.simple_poll)
1040
if (mc.simple_poll != NULL)
859
1041
avahi_simple_poll_free(mc.simple_poll);
860
free(pubkeyfile);
861
free(seckeyfile);
1042
free(pubkeyfilename);
1043
free(seckeyfilename);
1044
1045
if (gnutls_initalized){
1046
gnutls_certificate_free_credentials(mc.cred);
1047
gnutls_global_deinit ();
1048
}
862
1049
863
return returncode;
1050
return exitcode;
864
1051
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0