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

  • Committer: Björn Påhlsson
  • Date: 2008-08-15 20:17:32 UTC
  • mto: (237.7.1 mandos) (24.1.154 mandos)
  • mto: This revision was merged to the branch mainline in revision 77.
  • Revision ID: belorn@braxen-20080815201732-b7uux3yqs05b3fy9
Added configuration files support for mandos-client
Removed plus argument support for mandos-client

Show diffs side-by-side

added added

removed removed

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