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