/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/mandos-client.c

* debian/mandos.README.Debian: Updated to reflect code changes.

Show diffs side-by-side

added added

removed removed

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