/mandos/release

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/mandosclient.c

  • Committer: Björn Påhlsson
  • Date: 2008-07-31 16:20:47 UTC
  • mto: (237.7.1 mandos) (24.1.154 mandos)
  • mto: This revision was merged to the branch mainline in revision 30.
  • Revision ID: belorn@braxen-20080731162047-lahe2b2prwjw8b2l
plugbasedclient:
        Added support to disable plugins
        Added support to change plugin directory

mandosclient.c
        Fixed some funtion calls that lacked error handling
        small bugfix

Show diffs side-by-side

added added

removed removed

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