/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

* Makefile (install-client-nokey): Move "initramfs-tools-script" from
                                   "/scripts/local-top/mandos" to
                                   "/scripts/init-premount/mandos".
  (uninstall-client): - '' -
* debian/mandos-client.dirs: - '' -
* initramfs-tools-script (PREREQ): Added "udev".

Show diffs side-by-side

added added

removed removed

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