/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/mandosclient.c

  • Committer: Teddy Hogeborn
  • Date: 2008-07-21 15:34:44 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080721153444-lugbjkj1oq65ugq3
* Makefile (CFLAGS): Changed to use $(WARN), $(DEBUG), $(COVERAGE) and
                     $(LANGUAGE).
  (WARN, DEBUG, COVERAGE, LANGUAGE): New.
  (LDFLAGS): New; use $(COVERAGE)

* plugbasedclient.c: Added copyright header.
  (process.buffer_size, process.buffer_length): Changed to "size_t".
  (main): Cast arguments to malloc and realloc.  Detect read errors
          from processes.

* mandosclient.c: Added copyright header.
  (interface): Moved to inside "main".
  (gpg_packet_decrypt): Renamed to "pgp_packet_decrypt"; all callers
                        changed.  Changed "new_packet_capacity" and
                        "new_packet_length" to be ssize_t.  Cast
                        arguments to realloc.
  (debuggnutls): Attribute "level" argument as unused.
  (empty_log): Attribute "level" and "txt" arguments as unused.
  (start_mandos_communication): New argument "if_index".  Bug fix:
                                check ret, no tcp_sd, for errors from
                                setsockopt.  Use "if_index" directly
                                instead of looking up the index.  Loop
                                around fwrite until all data is written.
  (resolve_callback): Attribute "txt", and "flags" as usused.  Added
                      default case to switch.  Also show server host
                      name.  Call start_mandos_communication with
                      "interface".
  (browse_callback): Added default case to switch.
  (main): Variable "interface" moved here.  Cast "srand" argument.
          Bug fix: Call avahi_s_service_browser_new with index of
          "interface", not "eth0".

* passprompt.c: Added copyright header.
  (termination_handler): Attribute "signum" argument as unused.

Show diffs side-by-side

added added

removed removed

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