/mandos/release

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

« back to all changes in this revision

Viewing changes to plugins.d/mandosclient.c

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

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

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

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

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

Show diffs side-by-side

added added

removed removed

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