/mandos/trunk

To get this branch, use:
bzr branch http://bzr.recompile.se/loggerhead/mandos/trunk

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-03 01:09:36 UTC
  • mfrom: (24.1.9 mandos)
  • Revision ID: teddy@fukt.bsnet.se-20080803010936-ujme8tgxceszfbi1
* plugbasedclient.c (main): New "--userid" and "--groupid" options.
                            Take an additional non-option argument and
                            parse it as a plus-separated and -prefixed
                            list of additional options.

* plugins.d/mandosclient.c (DH_BITS): Replaced with
                                      "mandos_context.dh_bits".  All
                                      users changed.
  (certdir): Renamed to "keydir".  All users changed.
  (certfile): Renamed to "pubkeyfile".  All users changed.
  (certkey): Renamed to "seckeyfile".  All users changed.
  (encrypted_session): Replaced with "mandos_context".  All users
                       changed.
  (initgnutls): Take additional "session" and "dh_params" arguments.
                All callers changed.
  (start_mandos_communication): Take additional "mc" argument.  All
                                callers changed.  Print target IPv6
                                address if different than supplied
                                string.
  (simple_poll) Replaced with "mandos_context.simple_poll".  All users
                changed.
  (server): Replaced with "mandos_context.server".  All users changed.
  (main): Default interface to "eth0".  Rename "--certdir" to
          "--keydir", "--certkey" to "--seckey", and "--certfile" to
          "--pubkey".  New options "--dh-bits" and "--priority".  If
          the interface is not up, bring it up.

Show diffs side-by-side

added added

removed removed

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