/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-08-02 21:06:29 UTC
  • mto: (237.7.1 mandos) (24.1.154 mandos)
  • mto: This revision was merged to the branch mainline in revision 38.
  • Revision ID: belorn@braxen-20080802210629-p9jc5515yufcg4ge
not working midwork...

Show diffs side-by-side

added added

removed removed

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