/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-07-29 03:35:39 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080729033539-08zecoj3jwlkpjhw
* server.conf: New file.

* mandos-clients.conf: Renamed to clients.conf.

* Makefile (FORTIFY): New.
  (CFLAGS): Include $(FORTIFY).

* plugins.d/mandosclient.c (main): New "if_index" variable.  Bug fix:
                                   check if interface exists.  New
                                   "--connect" option.

* server.py (serviceInterface): Removed; replaced by
                                "AvahiService.interface".  All users
                                changed.
  (AvahiError, AvahiServiceError, AvahiGroupError): New exception
                                                    classes.
  (AvahiService): New class.
  (serviceName): Removed; replaced by "AvahiService.name".  All users
                 changed.
  (serviceType): Removed; replaced by "AvahiService.type".  All users
                 changed.
  (servicePort): Removed; replaced by "AvahiService.port".  All users
                 changed.
  (serviceTXT): Removed; replaced by "AvahiService.TXT".  All users
                changed.
  (domain): Removed; replaced by "AvahiService.domain".  All users
            changed.
  (host): Removed; replaced by "AvahiService.host".  All users
          changed.
  (rename_count): Removed; replaced by "AvahiService.rename_count" and
                 "AvahiService.max_renames".  All users changed.
  (Client.__init__): If no secret or secfile, raise TypeError instead
                     of RuntimeError.
  (Client.last_seen): Renamed to "Client.last_checked_ok".  All users
                      changed.
  (Client.stop, Client.stop_checker): Use "getattr" with default value
                                      instead of "hasattr".
  (Client.still_valid): Removed "now" argument.
  (Client.handle): Separate the "no client found" and "client invalid"
                   cases for clearer code.
  (IPv6_TCPServer.__init__): "options" argument replaced by
                             "settings".  All callers changed.
  (IPv6_TCPServer.options): Replaced by "IPv6_TCPServer.settings".
                            All users changed.
  (IPv6_TCPServer.server_bind): Use getattr instead of hasattr.
  (add_service): Removed; replaced by "AvahiService.add".  All callers
                 changed.
  (remove_service): Removed; replaced by "AvahiService.remove".  All
                    callers changed.
  (entry_group_state_changed): On entry group collision, call the new
                               AvahiService.rename method.  Raise
                               AvahiGroupError on group error.
  (if_nametoindex): Use ctypes.utils.find_library to locate the C
                    library.  Cache the result.  Loop on EINTR.
  (daemon): Use os.path.devnull to locate "/dev/null".
  (killme): Removed.  All callers changed to do "sys.exit()" instead,
            except where stated otherwise.
  (main): Removed "exitstatus".  Removed all default values from all
          non-bool options.  New option "--configdir".  New variables
          "server_defaults" and "server_settings", read from
          "%(configdir)s/server.conf".  Let any supplied command line
          options override server settings.   Variable "defaults"
          renamed to "client_defaults", which is read from
          "clients.conf" instead of "mandos-clients.conf".  New global
          AvahiService object "service" replaces old global variables.
          Catch AvahiError and exit with error if caught.

Show diffs side-by-side

added added

removed removed

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