/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

* plugins.d/askpass-fifo.c: Fix name in header.
* plugins.d/mandos-client.c: - '' -
* plugins.d/password-prompt.c: - '' -
* plugins.d/splashy.c: - '' -
* plugins.d/usplash.c: - '' -

Show diffs side-by-side

added added

removed removed

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