/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/password-request.c

  • Committer: Teddy Hogeborn
  • Date: 2008-07-19 18:43:24 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080719184324-iwhoa5in75xa0u2u
* mandos-clients.conf ([foo]/dn, [foo]/password, [braxen_client]/dn,
                       [braxen_client]/password): Removed.
  ([foo]/fingerprint, [braxen_client]/fingerprint): New.
  ([foo]/checker): New.
  ([foo]/secfile): New.
  ([braxen_client]/secret): New.

* server.py: New "--debug" option to set debug flag.  Removed "cert",
             "key", "ca", "crl", and "cred" variables.  Added default
             value for "checker" config file setting.  Do not pass
             credentials to IPv6_TCPServer constructor.
  (debug): New global debug flag.  Used by most debugging output code.
  (Client.__init__): Keyword argument "dn" replaced by "fingerprint",
                     "password" renamed to "secret", and "passfile"
                     renamed to "secfile".  New keyword argument
                     "checker". All callers changed.
  (Client.dn): Removed.
  (Client.fingerprint): New.
  (Client.password): Renamed to "secret"; all users changed.
  (Client.passfile): Renamed to "secfile"; all users changed.
  (Client.timeout, Client.interval): Changed to be properties; now
                                     automatically updates the
                                     "_timeout_milliseconds" and
                                     "_interval_milliseconds" values.
  (Client.timeout_milliseconds): Renamed to "_timeout_milliseconds".
  (Client.interval_milliseconds): Renamed to "_interval_milliseconds".
  (Client.check_command): New.
  (Client.start_checker): Use the new "check_command" attribute.
  (peer_certificate, fingerprint): New functions.

  (tcp_handler.handle): Use ClientSession with empty credentials
                        object instead of ServerSession.  Set gnutls
                        priority string.  Do not verify peer.  Use
                        fingerprint instead of DN when searching for
                        clients.  Bug fix: Loop sending data so even large
                        secret data strings are sent.
  (IPv6_TCPServer.credentials): Removed.
  (if_nametoindex): Do not import ctypes since that is now imported
                    globally.

Show diffs side-by-side

added added

removed removed

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