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