/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/password-request.c

  • Committer: Teddy Hogeborn
  • Date: 2008-08-07 22:30:45 UTC
  • Revision ID: teddy@fukt.bsnet.se-20080807223045-58y7vw4bcqlmesv5
* network-protocol.txt: Flip table.

Show diffs side-by-side

added added

removed removed

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