/mandos/trunk

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

« back to all changes in this revision

Viewing changes to plugins.d/mandos-client.c

  • Committer: Teddy Hogeborn
  • Date: 2024-11-17 18:43:11 UTC
  • Revision ID: teddy@recompile.se-20241117184311-ox25kvngy62h209g
Debian package: Avoid suggesting a C compiler unnecessarily

The list of suggested packages, meant to enable the "mandos" program
to find the correct value of SO_BINDTODEVICE by using a C compiler,
are not necessary when Python 3.3 or later is used, since it has the
SO_BINDTODEVICE constant defined in the "socket" module.  Also, Python
2.6 or older has the same constant in the old "IN" module.  Therefore,
we should suggest these Python versions as alternatives to a C
compiler, so that a C compiler is not installed unnecessarily.

debian/control (Package: mandos/Suggests): Add "python3 (>= 3.3)" and
"python (<= 2.6)" as alternatives to "libc6-dev | libc-dev" and
"c-compiler".

Show diffs side-by-side

added added

removed removed

Lines of Context:
9
9
 * "browse_callback", and parts of "main".
10
10
 * 
11
11
 * Everything else is
12
 
 * Copyright © 2008-2011 Teddy Hogeborn
13
 
 * Copyright © 2008-2011 Björn Påhlsson
14
 
 * 
15
 
 * This program is free software: you can redistribute it and/or
16
 
 * modify it under the terms of the GNU General Public License as
17
 
 * published by the Free Software Foundation, either version 3 of the
18
 
 * License, or (at your option) any later version.
19
 
 * 
20
 
 * This program is distributed in the hope that it will be useful, but
 
12
 * Copyright © 2008-2022 Teddy Hogeborn
 
13
 * Copyright © 2008-2022 Björn Påhlsson
 
14
 * 
 
15
 * This file is part of Mandos.
 
16
 * 
 
17
 * Mandos is free software: you can redistribute it and/or modify it
 
18
 * under the terms of the GNU General Public License as published by
 
19
 * the Free Software Foundation, either version 3 of the License, or
 
20
 * (at your option) any later version.
 
21
 * 
 
22
 * Mandos is distributed in the hope that it will be useful, but
21
23
 * WITHOUT ANY WARRANTY; without even the implied warranty of
22
24
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
23
25
 * General Public License for more details.
24
26
 * 
25
27
 * You should have received a copy of the GNU General Public License
26
 
 * along with this program.  If not, see
27
 
 * <http://www.gnu.org/licenses/>.
 
28
 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.
28
29
 * 
29
 
 * Contact the authors at <mandos@fukt.bsnet.se>.
 
30
 * Contact the authors at <mandos@recompile.se>.
30
31
 */
31
32
 
32
33
/* Needed by GPGME, specifically gpgme_data_seek() */
33
34
#ifndef _LARGEFILE_SOURCE
34
35
#define _LARGEFILE_SOURCE
35
 
#endif
 
36
#endif  /* not _LARGEFILE_SOURCE */
36
37
#ifndef _FILE_OFFSET_BITS
37
38
#define _FILE_OFFSET_BITS 64
38
 
#endif
39
 
 
40
 
#define _GNU_SOURCE             /* TEMP_FAILURE_RETRY(), asprintf() */
41
 
 
42
 
#include <stdio.h>              /* fprintf(), stderr, fwrite(),
43
 
                                   stdout, ferror(), remove() */
44
 
#include <stdint.h>             /* uint16_t, uint32_t */
45
 
#include <stddef.h>             /* NULL, size_t, ssize_t */
46
 
#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),
47
 
                                   strtof(), abort() */
 
39
#endif  /* not _FILE_OFFSET_BITS */
 
40
 
 
41
#define _GNU_SOURCE             /* program_invocation_short_name,
 
42
                                   TEMP_FAILURE_RETRY(), O_CLOEXEC,
 
43
                                   scandirat(), asprintf() */
48
44
#include <stdbool.h>            /* bool, false, true */
49
 
#include <string.h>             /* memset(), strcmp(), strlen(),
50
 
                                   strerror(), asprintf(), strcpy() */
51
 
#include <sys/ioctl.h>          /* ioctl */
52
 
#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,
53
 
                                   sockaddr_in6, PF_INET6,
54
 
                                   SOCK_STREAM, uid_t, gid_t, open(),
55
 
                                   opendir(), DIR */
56
 
#include <sys/stat.h>           /* open() */
57
 
#include <sys/socket.h>         /* socket(), struct sockaddr_in6,
58
 
                                   inet_pton(), connect() */
59
 
#include <fcntl.h>              /* open() */
60
 
#include <dirent.h>             /* opendir(), struct dirent, readdir()
61
 
                                 */
62
 
#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,
 
45
#include <argp.h>               /* argp_program_version,
 
46
                                   argp_program_bug_address,
 
47
                                   struct argp_option,
 
48
                                   struct argp_state, argp_error(),
 
49
                                   argp_state_help,
 
50
                                   ARGP_HELP_STD_HELP,
 
51
                                   ARGP_HELP_EXIT_ERR,
 
52
                                   ARGP_HELP_EXIT_OK, ARGP_HELP_USAGE,
 
53
                                   argp_err_exit_status,
 
54
                                   ARGP_ERR_UNKNOWN, struct argp,
 
55
                                   argp_parse(), ARGP_IN_ORDER,
 
56
                                   ARGP_NO_HELP */
 
57
#include <stddef.h>             /* NULL, size_t */
 
58
#include <sys/types.h>          /* uid_t, gid_t, sig_atomic_t,
 
59
                                   seteuid(), setuid(), pid_t,
 
60
                                   setgid(), getuid(), getgid() */
 
61
#include <unistd.h>             /* uid_t, gid_t, TEMP_FAILURE_RETRY(),
 
62
                                   seteuid(), setuid(), close(),
 
63
                                   ssize_t, read(), fork(), setgid(),
 
64
                                   _exit(), dup2(), STDIN_FILENO,
 
65
                                   STDERR_FILENO, STDOUT_FILENO,
 
66
                                   fexecve(), write(), getuid(),
 
67
                                   getgid(), fchown(), symlink(),
 
68
                                   sleep(), unlinkat(), pause() */
 
69
#include <netinet/in.h>         /* in_port_t, struct sockaddr_in6,
 
70
                                   sa_family_t, struct sockaddr_in,
 
71
                                   htons(), IN6_IS_ADDR_LINKLOCAL,
 
72
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN,
 
73
                                   ntohl(), IPPROTO_IP */
 
74
#include <time.h>               /* struct timespec, clock_gettime(),
 
75
                                   CLOCK_MONOTONIC, time_t, struct tm,
 
76
                                   gmtime_r(), clock_settime(),
 
77
                                   CLOCK_REALTIME, nanosleep() */
 
78
#include <errno.h>              /* errno,
 
79
                                   program_invocation_short_name,
 
80
                                   EINTR, EINVAL, ENETUNREACH,
 
81
                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,
 
82
                                   EIO, ENOENT, ENXIO, error_t,
 
83
                                   ENOMEM, EISDIR, ENOTEMPTY */
 
84
#include <stdio.h>              /* fprintf(), stderr, perror(), FILE,
 
85
                                   vfprintf(), off_t, SEEK_SET,
 
86
                                   stdout, fwrite(), ferror(),
 
87
                                   fflush(), asprintf() */
 
88
#include <stdarg.h>             /* va_list, va_start(), vfprintf() */
 
89
#include <stdlib.h>             /* realloc(), free(), malloc(),
 
90
                                   getenv(), EXIT_FAILURE, setenv(),
 
91
                                   EXIT_SUCCESS, strtof(), strtod(),
 
92
                                   srand(), mkdtemp(), abort() */
 
93
#include <string.h>             /* strdup(), strcmp(), strlen(),
 
94
                                   strerror(), strncpy(), strspn(),
 
95
                                   memcpy(), strrchr(), strchr(),
 
96
                                   strsignal() */
 
97
#include <fcntl.h>              /* open(), O_RDONLY, O_DIRECTORY,
 
98
                                   O_PATH, O_CLOEXEC, openat(),
 
99
                                   O_NOFOLLOW, AT_REMOVEDIR */
 
100
#include <iso646.h>             /* or, and, not */
 
101
#include <sys/stat.h>           /* struct stat, fstat(), fstatat(),
 
102
                                   S_ISREG(), S_IXUSR, S_IXGRP,
 
103
                                   S_IXOTH, lstat() */
 
104
#include <net/if.h>             /* IF_NAMESIZE, if_indextoname(),
 
105
                                   if_nametoindex(), SIOCGIFFLAGS,
 
106
                                   IFF_LOOPBACK, IFF_POINTOPOINT,
 
107
                                   IFF_BROADCAST, IFF_NOARP, IFF_UP,
 
108
                                   IFF_RUNNING, SIOCSIFFLAGS */
 
109
#include <sysexits.h>           /* EX_NOPERM, EX_OSERR,
 
110
                                   EX_UNAVAILABLE, EX_USAGE */
 
111
#include <grp.h>                /* setgroups() */
 
112
#include <sys/wait.h>           /* waitpid(), WIFEXITED(),
 
113
                                   WEXITSTATUS(), WIFSIGNALED(),
 
114
                                   WTERMSIG() */
 
115
#include <signal.h>             /* kill(), SIGTERM, struct sigaction,
 
116
                                   SIG_DFL, sigemptyset(),
 
117
                                   sigaddset(), SIGINT, SIGHUP,
 
118
                                   SIG_IGN, raise() */
 
119
#include <sys/socket.h>         /* struct sockaddr_storage, AF_INET6,
 
120
                                   PF_INET6, AF_INET, PF_INET,
 
121
                                   socket(), SOCK_STREAM,
 
122
                                   SOCK_CLOEXEC, struct sockaddr,
 
123
                                   connect(), SOCK_DGRAM */
 
124
#include <argz.h>               /* argz_next(), argz_add_sep(),
 
125
                                   argz_delete(), argz_stringify(),
 
126
                                   argz_add(), argz_count() */
 
127
#include <inttypes.h>           /* PRIuMAX, uintmax_t, uint32_t,
 
128
                                   PRIdMAX, PRIu16, intmax_t,
63
129
                                   strtoimax() */
64
 
#include <assert.h>             /* assert() */
65
 
#include <errno.h>              /* perror(), errno,
66
 
                                   program_invocation_short_name */
67
 
#include <time.h>               /* nanosleep(), time(), sleep() */
68
 
#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,
69
 
                                   SIOCSIFFLAGS, if_indextoname(),
70
 
                                   if_nametoindex(), IF_NAMESIZE */
71
 
#include <netinet/in.h>         /* IN6_IS_ADDR_LINKLOCAL,
72
 
                                   INET_ADDRSTRLEN, INET6_ADDRSTRLEN
73
 
                                */
74
 
#include <unistd.h>             /* close(), SEEK_SET, off_t, write(),
75
 
                                   getuid(), getgid(), seteuid(),
76
 
                                   setgid(), pause() */
77
 
#include <arpa/inet.h>          /* inet_pton(), htons, inet_ntop() */
78
 
#include <iso646.h>             /* not, or, and */
79
 
#include <argp.h>               /* struct argp_option, error_t, struct
80
 
                                   argp_state, struct argp,
81
 
                                   argp_parse(), ARGP_KEY_ARG,
82
 
                                   ARGP_KEY_END, ARGP_ERR_UNKNOWN */
83
 
#include <signal.h>             /* sigemptyset(), sigaddset(),
84
 
                                   sigaction(), SIGTERM, sig_atomic_t,
85
 
                                   raise() */
86
 
#include <sysexits.h>           /* EX_OSERR, EX_USAGE, EX_UNAVAILABLE,
87
 
                                   EX_NOHOST, EX_IOERR, EX_PROTOCOL */
 
130
#include <arpa/inet.h>          /* inet_pton() */
 
131
#include <stdint.h>             /* uint32_t, intptr_t, uint16_t */
 
132
#include <netdb.h>              /* getnameinfo(), NI_NUMERICHOST,
 
133
                                   EAI_SYSTEM, gai_strerror() */
 
134
#include <sys/ioctl.h>          /* ioctl() */
 
135
#include <dirent.h>             /* struct dirent, scandirat(),
 
136
                                   alphasort(), scandir() */
 
137
#include <limits.h>             /* INT_MAX */
88
138
 
89
139
#ifdef __linux__
90
140
#include <sys/klog.h>           /* klogctl() */
103
153
 
104
154
/* GnuTLS */
105
155
#include <gnutls/gnutls.h>      /* All GnuTLS types, constants and
106
 
                                   functions:
107
 
                                   gnutls_*
108
 
                                   init_gnutls_session(),
109
 
                                   GNUTLS_* */
 
156
                                   functions: gnutls_*, GNUTLS_* */
 
157
#if GNUTLS_VERSION_NUMBER < 0x030600
110
158
#include <gnutls/openpgp.h>
111
 
                          /* gnutls_certificate_set_openpgp_key_file(),
112
 
                                   GNUTLS_OPENPGP_FMT_BASE64 */
 
159
                         /* gnutls_certificate_set_openpgp_key_file(),
 
160
                            GNUTLS_OPENPGP_FMT_BASE64 */
 
161
#elif GNUTLS_VERSION_NUMBER >= 0x030606
 
162
#include <gnutls/x509.h>        /* GNUTLS_PKCS_PLAIN,
 
163
                                   GNUTLS_PKCS_NULL_PASSWORD */
 
164
#endif
113
165
 
114
166
/* GPGME */
115
167
#include <gpgme.h>              /* All GPGME types, constants and
116
168
                                   functions:
117
 
                                   gpgme_*
118
 
                                   GPGME_PROTOCOL_OpenPGP,
119
 
                                   GPG_ERR_NO_* */
 
169
                                   gpgme_*, GPG_ERR_NO_*,
 
170
                                   GPGME_IMPORT_*
 
171
                                   GPGME_PROTOCOL_OpenPGP */
120
172
 
121
173
#define BUFFER_SIZE 256
122
174
 
123
175
#define PATHDIR "/conf/conf.d/mandos"
124
176
#define SECKEY "seckey.txt"
125
177
#define PUBKEY "pubkey.txt"
 
178
#define TLS_PRIVKEY "tls-privkey.pem"
 
179
#define TLS_PUBKEY "tls-pubkey.pem"
 
180
#define HOOKDIR "/lib/mandos/network-hooks.d"
126
181
 
127
182
bool debug = false;
128
183
static const char mandos_protocol_version[] = "1";
129
184
const char *argp_program_version = "mandos-client " VERSION;
130
 
const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";
 
185
const char *argp_program_bug_address = "<mandos@recompile.se>";
131
186
static const char sys_class_net[] = "/sys/class/net";
132
187
char *connect_to = NULL;
 
188
const char *hookdir = HOOKDIR;
 
189
int hookdir_fd = -1;
 
190
uid_t uid = 65534;
 
191
gid_t gid = 65534;
133
192
 
134
193
/* Doubly linked list that need to be circularly linked when used */
135
194
typedef struct server{
136
195
  const char *ip;
137
 
  uint16_t port;
 
196
  in_port_t port;
138
197
  AvahiIfIndex if_index;
139
198
  int af;
140
199
  struct timespec last_seen;
144
203
 
145
204
/* Used for passing in values through the Avahi callback functions */
146
205
typedef struct {
147
 
  AvahiSimplePoll *simple_poll;
148
206
  AvahiServer *server;
149
207
  gnutls_certificate_credentials_t cred;
150
208
  unsigned int dh_bits;
152
210
  const char *priority;
153
211
  gpgme_ctx_t ctx;
154
212
  server *current_server;
 
213
  char *interfaces;
 
214
  size_t interfaces_size;
155
215
} mandos_context;
156
216
 
157
 
/* global context so signal handler can reach it*/
158
 
mandos_context mc = { .simple_poll = NULL, .server = NULL,
159
 
                      .dh_bits = 1024, .priority = "SECURE256"
160
 
                      ":!CTYPE-X.509:+CTYPE-OPENPGP",
161
 
                      .current_server = NULL };
 
217
/* global so signal handler can reach it*/
 
218
AvahiSimplePoll *simple_poll;
162
219
 
163
220
sig_atomic_t quit_now = 0;
164
221
int signal_received = 0;
165
222
 
166
223
/* Function to use when printing errors */
167
224
void perror_plus(const char *print_text){
 
225
  int e = errno;
168
226
  fprintf(stderr, "Mandos plugin %s: ",
169
227
          program_invocation_short_name);
 
228
  errno = e;
170
229
  perror(print_text);
171
230
}
172
231
 
 
232
__attribute__((format (gnu_printf, 2, 3), nonnull))
 
233
int fprintf_plus(FILE *stream, const char *format, ...){
 
234
  va_list ap;
 
235
  va_start (ap, format);
 
236
  
 
237
  TEMP_FAILURE_RETRY(fprintf(stream, "Mandos plugin %s: ",
 
238
                             program_invocation_short_name));
 
239
  return (int)TEMP_FAILURE_RETRY(vfprintf(stream, format, ap));
 
240
}
 
241
 
173
242
/*
174
243
 * Make additional room in "buffer" for at least BUFFER_SIZE more
175
244
 * bytes. "buffer_capacity" is how much is currently allocated,
176
245
 * "buffer_length" is how much is already used.
177
246
 */
 
247
__attribute__((nonnull, warn_unused_result))
178
248
size_t incbuffer(char **buffer, size_t buffer_length,
179
 
                  size_t buffer_capacity){
 
249
                 size_t buffer_capacity){
180
250
  if(buffer_length + BUFFER_SIZE > buffer_capacity){
181
 
    *buffer = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
182
 
    if(buffer == NULL){
 
251
    char *new_buf = realloc(*buffer, buffer_capacity + BUFFER_SIZE);
 
252
    if(new_buf == NULL){
 
253
      int old_errno = errno;
 
254
      free(*buffer);
 
255
      errno = old_errno;
 
256
      *buffer = NULL;
183
257
      return 0;
184
258
    }
 
259
    *buffer = new_buf;
185
260
    buffer_capacity += BUFFER_SIZE;
186
261
  }
187
262
  return buffer_capacity;
188
263
}
189
264
 
190
265
/* Add server to set of servers to retry periodically */
191
 
int add_server(const char *ip, uint16_t port,
192
 
                 AvahiIfIndex if_index,
193
 
                 int af){
 
266
__attribute__((nonnull, warn_unused_result))
 
267
bool add_server(const char *ip, in_port_t port, AvahiIfIndex if_index,
 
268
                int af, server **current_server){
194
269
  int ret;
195
270
  server *new_server = malloc(sizeof(server));
196
271
  if(new_server == NULL){
197
272
    perror_plus("malloc");
198
 
    return -1;
 
273
    return false;
199
274
  }
200
275
  *new_server = (server){ .ip = strdup(ip),
201
 
                         .port = port,
202
 
                         .if_index = if_index,
203
 
                         .af = af };
 
276
                          .port = port,
 
277
                          .if_index = if_index,
 
278
                          .af = af };
204
279
  if(new_server->ip == NULL){
205
280
    perror_plus("strdup");
206
 
    return -1;
 
281
    free(new_server);
 
282
    return false;
 
283
  }
 
284
  ret = clock_gettime(CLOCK_MONOTONIC, &(new_server->last_seen));
 
285
  if(ret == -1){
 
286
    perror_plus("clock_gettime");
 
287
#ifdef __GNUC__
 
288
#pragma GCC diagnostic push
 
289
#pragma GCC diagnostic ignored "-Wcast-qual"
 
290
#endif
 
291
    free((char *)(new_server->ip));
 
292
#ifdef __GNUC__
 
293
#pragma GCC diagnostic pop
 
294
#endif
 
295
    free(new_server);
 
296
    return false;
207
297
  }
208
298
  /* Special case of first server */
209
 
  if (mc.current_server == NULL){
 
299
  if(*current_server == NULL){
210
300
    new_server->next = new_server;
211
301
    new_server->prev = new_server;
212
 
    mc.current_server = new_server;
213
 
  /* Place the new server last in the list */
 
302
    *current_server = new_server;
214
303
  } else {
215
 
    new_server->next = mc.current_server;
216
 
    new_server->prev = mc.current_server->prev;
 
304
    /* Place the new server last in the list */
 
305
    new_server->next = *current_server;
 
306
    new_server->prev = (*current_server)->prev;
217
307
    new_server->prev->next = new_server;
218
 
    mc.current_server->prev = new_server;
219
 
  }
220
 
  ret = clock_gettime(CLOCK_MONOTONIC, &mc.current_server->last_seen);
221
 
  if(ret == -1){
222
 
    perror_plus("clock_gettime");
223
 
    return -1;
224
 
  }
225
 
  return 0;
 
308
    (*current_server)->prev = new_server;
 
309
  }
 
310
  return true;
 
311
}
 
312
 
 
313
/* Set effective uid to 0, return errno */
 
314
__attribute__((warn_unused_result))
 
315
int raise_privileges(void){
 
316
  int old_errno = errno;
 
317
  int ret = 0;
 
318
  if(seteuid(0) == -1){
 
319
    ret = errno;
 
320
  }
 
321
  errno = old_errno;
 
322
  return ret;
 
323
}
 
324
 
 
325
/* Set effective and real user ID to 0.  Return errno. */
 
326
__attribute__((warn_unused_result))
 
327
int raise_privileges_permanently(void){
 
328
  int old_errno = errno;
 
329
  int ret = raise_privileges();
 
330
  if(ret != 0){
 
331
    errno = old_errno;
 
332
    return ret;
 
333
  }
 
334
  if(setuid(0) == -1){
 
335
    ret = errno;
 
336
  }
 
337
  errno = old_errno;
 
338
  return ret;
 
339
}
 
340
 
 
341
/* Set effective user ID to unprivileged saved user ID */
 
342
__attribute__((warn_unused_result))
 
343
int lower_privileges(void){
 
344
  int old_errno = errno;
 
345
  int ret = 0;
 
346
  if(seteuid(uid) == -1){
 
347
    ret = errno;
 
348
  }
 
349
  errno = old_errno;
 
350
  return ret;
 
351
}
 
352
 
 
353
/* Lower privileges permanently */
 
354
__attribute__((warn_unused_result))
 
355
int lower_privileges_permanently(void){
 
356
  int old_errno = errno;
 
357
  int ret = 0;
 
358
  if(setuid(uid) == -1){
 
359
    ret = errno;
 
360
  }
 
361
  errno = old_errno;
 
362
  return ret;
226
363
}
227
364
 
228
365
/* 
229
366
 * Initialize GPGME.
230
367
 */
231
 
static bool init_gpgme(const char *seckey,
232
 
                       const char *pubkey, const char *tempdir){
 
368
__attribute__((nonnull, warn_unused_result))
 
369
static bool init_gpgme(const char * const seckey,
 
370
                       const char * const pubkey,
 
371
                       const char * const tempdir,
 
372
                       mandos_context *mc){
233
373
  gpgme_error_t rc;
234
374
  gpgme_engine_info_t engine_info;
235
375
  
236
 
  
237
376
  /*
238
377
   * Helper function to insert pub and seckey to the engine keyring.
239
378
   */
240
 
  bool import_key(const char *filename){
 
379
  bool import_key(const char * const filename){
241
380
    int ret;
242
381
    int fd;
243
382
    gpgme_data_t pgp_data;
248
387
      return false;
249
388
    }
250
389
    
 
390
    /* Workaround for systems without a real-time clock; see also
 
391
       Debian bug #894495: <https://bugs.debian.org/894495> */
 
392
    do {
 
393
      {
 
394
        time_t currtime = time(NULL);
 
395
        if(currtime != (time_t)-1){
 
396
          struct tm tm;
 
397
          if(gmtime_r(&currtime, &tm) == NULL) {
 
398
            perror_plus("gmtime_r");
 
399
            break;
 
400
          }
 
401
          if(tm.tm_year != 70 or tm.tm_mon != 0){
 
402
            break;
 
403
          }
 
404
          if(debug){
 
405
            fprintf_plus(stderr, "System clock is January 1970");
 
406
          }
 
407
        } else {
 
408
          if(debug){
 
409
            fprintf_plus(stderr, "System clock is invalid");
 
410
          }
 
411
        }
 
412
      }
 
413
      struct stat keystat;
 
414
      ret = fstat(fd, &keystat);
 
415
      if(ret != 0){
 
416
        perror_plus("fstat");
 
417
        break;
 
418
      }
 
419
      ret = raise_privileges();
 
420
      if(ret != 0){
 
421
        errno = ret;
 
422
        perror_plus("Failed to raise privileges");
 
423
        break;
 
424
      }
 
425
      if(debug){
 
426
        fprintf_plus(stderr,
 
427
                     "Setting system clock to key file mtime");
 
428
      }
 
429
      if(clock_settime(CLOCK_REALTIME, &keystat.st_mtim) != 0){
 
430
        perror_plus("clock_settime");
 
431
      }
 
432
      ret = lower_privileges();
 
433
      if(ret != 0){
 
434
        errno = ret;
 
435
        perror_plus("Failed to lower privileges");
 
436
      }
 
437
    } while(false);
 
438
 
251
439
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
252
440
    if(rc != GPG_ERR_NO_ERROR){
253
 
      fprintf(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
254
 
              gpgme_strsource(rc), gpgme_strerror(rc));
 
441
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
 
442
                   gpgme_strsource(rc), gpgme_strerror(rc));
255
443
      return false;
256
444
    }
257
445
    
258
 
    rc = gpgme_op_import(mc.ctx, pgp_data);
 
446
    rc = gpgme_op_import(mc->ctx, pgp_data);
259
447
    if(rc != GPG_ERR_NO_ERROR){
260
 
      fprintf(stderr, "bad gpgme_op_import: %s: %s\n",
261
 
              gpgme_strsource(rc), gpgme_strerror(rc));
 
448
      fprintf_plus(stderr, "bad gpgme_op_import: %s: %s\n",
 
449
                   gpgme_strsource(rc), gpgme_strerror(rc));
262
450
      return false;
263
451
    }
 
452
    {
 
453
      gpgme_import_result_t import_result
 
454
        = gpgme_op_import_result(mc->ctx);
 
455
      if((import_result->imported < 1
 
456
          or import_result->not_imported > 0)
 
457
         and import_result->unchanged == 0){
 
458
        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");
 
459
        fprintf_plus(stderr,
 
460
                     "The total number of considered keys: %d\n",
 
461
                     import_result->considered);
 
462
        fprintf_plus(stderr,
 
463
                     "The number of keys without user ID: %d\n",
 
464
                     import_result->no_user_id);
 
465
        fprintf_plus(stderr,
 
466
                     "The total number of imported keys: %d\n",
 
467
                     import_result->imported);
 
468
        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",
 
469
                     import_result->imported_rsa);
 
470
        fprintf_plus(stderr, "The number of unchanged keys: %d\n",
 
471
                     import_result->unchanged);
 
472
        fprintf_plus(stderr, "The number of new user IDs: %d\n",
 
473
                     import_result->new_user_ids);
 
474
        fprintf_plus(stderr, "The number of new sub keys: %d\n",
 
475
                     import_result->new_sub_keys);
 
476
        fprintf_plus(stderr, "The number of new signatures: %d\n",
 
477
                     import_result->new_signatures);
 
478
        fprintf_plus(stderr, "The number of new revocations: %d\n",
 
479
                     import_result->new_revocations);
 
480
        fprintf_plus(stderr,
 
481
                     "The total number of secret keys read: %d\n",
 
482
                     import_result->secret_read);
 
483
        fprintf_plus(stderr,
 
484
                     "The number of imported secret keys: %d\n",
 
485
                     import_result->secret_imported);
 
486
        fprintf_plus(stderr,
 
487
                     "The number of unchanged secret keys: %d\n",
 
488
                     import_result->secret_unchanged);
 
489
        fprintf_plus(stderr, "The number of keys not imported: %d\n",
 
490
                     import_result->not_imported);
 
491
        for(gpgme_import_status_t import_status
 
492
              = import_result->imports;
 
493
            import_status != NULL;
 
494
            import_status = import_status->next){
 
495
          fprintf_plus(stderr, "Import status for key: %s\n",
 
496
                       import_status->fpr);
 
497
          if(import_status->result != GPG_ERR_NO_ERROR){
 
498
            fprintf_plus(stderr, "Import result: %s: %s\n",
 
499
                         gpgme_strsource(import_status->result),
 
500
                         gpgme_strerror(import_status->result));
 
501
          }
 
502
          fprintf_plus(stderr, "Key status:\n");
 
503
          fprintf_plus(stderr,
 
504
                       import_status->status & GPGME_IMPORT_NEW
 
505
                       ? "The key was new.\n"
 
506
                       : "The key was not new.\n");
 
507
          fprintf_plus(stderr,
 
508
                       import_status->status & GPGME_IMPORT_UID
 
509
                       ? "The key contained new user IDs.\n"
 
510
                       : "The key did not contain new user IDs.\n");
 
511
          fprintf_plus(stderr,
 
512
                       import_status->status & GPGME_IMPORT_SIG
 
513
                       ? "The key contained new signatures.\n"
 
514
                       : "The key did not contain new signatures.\n");
 
515
          fprintf_plus(stderr,
 
516
                       import_status->status & GPGME_IMPORT_SUBKEY
 
517
                       ? "The key contained new sub keys.\n"
 
518
                       : "The key did not contain new sub keys.\n");
 
519
          fprintf_plus(stderr,
 
520
                       import_status->status & GPGME_IMPORT_SECRET
 
521
                       ? "The key contained a secret key.\n"
 
522
                       : "The key did not contain a secret key.\n");
 
523
        }
 
524
        return false;
 
525
      }
 
526
    }
264
527
    
265
 
    ret = (int)TEMP_FAILURE_RETRY(close(fd));
 
528
    ret = close(fd);
266
529
    if(ret == -1){
267
530
      perror_plus("close");
268
531
    }
271
534
  }
272
535
  
273
536
  if(debug){
274
 
    fprintf(stderr, "Initializing GPGME\n");
 
537
    fprintf_plus(stderr, "Initializing GPGME\n");
275
538
  }
276
539
  
277
540
  /* Init GPGME */
278
541
  gpgme_check_version(NULL);
279
542
  rc = gpgme_engine_check_version(GPGME_PROTOCOL_OpenPGP);
280
543
  if(rc != GPG_ERR_NO_ERROR){
281
 
    fprintf(stderr, "bad gpgme_engine_check_version: %s: %s\n",
282
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
544
    fprintf_plus(stderr, "bad gpgme_engine_check_version: %s: %s\n",
 
545
                 gpgme_strsource(rc), gpgme_strerror(rc));
283
546
    return false;
284
547
  }
285
548
  
286
549
  /* Set GPGME home directory for the OpenPGP engine only */
287
550
  rc = gpgme_get_engine_info(&engine_info);
288
551
  if(rc != GPG_ERR_NO_ERROR){
289
 
    fprintf(stderr, "bad gpgme_get_engine_info: %s: %s\n",
290
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
552
    fprintf_plus(stderr, "bad gpgme_get_engine_info: %s: %s\n",
 
553
                 gpgme_strsource(rc), gpgme_strerror(rc));
291
554
    return false;
292
555
  }
293
556
  while(engine_info != NULL){
299
562
    engine_info = engine_info->next;
300
563
  }
301
564
  if(engine_info == NULL){
302
 
    fprintf(stderr, "Could not set GPGME home dir to %s\n", tempdir);
 
565
    fprintf_plus(stderr, "Could not set GPGME home dir to %s\n",
 
566
                 tempdir);
303
567
    return false;
304
568
  }
305
569
  
306
570
  /* Create new GPGME "context" */
307
 
  rc = gpgme_new(&(mc.ctx));
 
571
  rc = gpgme_new(&(mc->ctx));
308
572
  if(rc != GPG_ERR_NO_ERROR){
309
 
    fprintf(stderr, "bad gpgme_new: %s: %s\n",
310
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
573
    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",
 
574
                 gpgme_strsource(rc), gpgme_strerror(rc));
311
575
    return false;
312
576
  }
313
577
  
322
586
 * Decrypt OpenPGP data.
323
587
 * Returns -1 on error
324
588
 */
 
589
__attribute__((nonnull, warn_unused_result))
325
590
static ssize_t pgp_packet_decrypt(const char *cryptotext,
326
591
                                  size_t crypto_size,
327
 
                                  char **plaintext){
 
592
                                  char **plaintext,
 
593
                                  mandos_context *mc){
328
594
  gpgme_data_t dh_crypto, dh_plain;
329
595
  gpgme_error_t rc;
330
596
  ssize_t ret;
332
598
  ssize_t plaintext_length = 0;
333
599
  
334
600
  if(debug){
335
 
    fprintf(stderr, "Trying to decrypt OpenPGP data\n");
 
601
    fprintf_plus(stderr, "Trying to decrypt OpenPGP data\n");
336
602
  }
337
603
  
338
604
  /* Create new GPGME data buffer from memory cryptotext */
339
605
  rc = gpgme_data_new_from_mem(&dh_crypto, cryptotext, crypto_size,
340
606
                               0);
341
607
  if(rc != GPG_ERR_NO_ERROR){
342
 
    fprintf(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
343
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
608
    fprintf_plus(stderr, "bad gpgme_data_new_from_mem: %s: %s\n",
 
609
                 gpgme_strsource(rc), gpgme_strerror(rc));
344
610
    return -1;
345
611
  }
346
612
  
347
613
  /* Create new empty GPGME data buffer for the plaintext */
348
614
  rc = gpgme_data_new(&dh_plain);
349
615
  if(rc != GPG_ERR_NO_ERROR){
350
 
    fprintf(stderr, "bad gpgme_data_new: %s: %s\n",
351
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
616
    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",
 
617
                 gpgme_strsource(rc), gpgme_strerror(rc));
352
618
    gpgme_data_release(dh_crypto);
353
619
    return -1;
354
620
  }
355
621
  
356
622
  /* Decrypt data from the cryptotext data buffer to the plaintext
357
623
     data buffer */
358
 
  rc = gpgme_op_decrypt(mc.ctx, dh_crypto, dh_plain);
 
624
  rc = gpgme_op_decrypt(mc->ctx, dh_crypto, dh_plain);
359
625
  if(rc != GPG_ERR_NO_ERROR){
360
 
    fprintf(stderr, "bad gpgme_op_decrypt: %s: %s\n",
361
 
            gpgme_strsource(rc), gpgme_strerror(rc));
 
626
    fprintf_plus(stderr, "bad gpgme_op_decrypt: %s: %s\n",
 
627
                 gpgme_strsource(rc), gpgme_strerror(rc));
362
628
    plaintext_length = -1;
363
629
    if(debug){
364
630
      gpgme_decrypt_result_t result;
365
 
      result = gpgme_op_decrypt_result(mc.ctx);
 
631
      result = gpgme_op_decrypt_result(mc->ctx);
366
632
      if(result == NULL){
367
 
        fprintf(stderr, "gpgme_op_decrypt_result failed\n");
 
633
        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");
368
634
      } else {
369
 
        fprintf(stderr, "Unsupported algorithm: %s\n",
370
 
                result->unsupported_algorithm);
371
 
        fprintf(stderr, "Wrong key usage: %u\n",
372
 
                result->wrong_key_usage);
 
635
        if(result->unsupported_algorithm != NULL) {
 
636
          fprintf_plus(stderr, "Unsupported algorithm: %s\n",
 
637
                       result->unsupported_algorithm);
 
638
        }
 
639
        fprintf_plus(stderr, "Wrong key usage: %s\n",
 
640
                     result->wrong_key_usage ? "Yes" : "No");
373
641
        if(result->file_name != NULL){
374
 
          fprintf(stderr, "File name: %s\n", result->file_name);
 
642
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
375
643
        }
376
 
        gpgme_recipient_t recipient;
377
 
        recipient = result->recipients;
378
 
        while(recipient != NULL){
379
 
          fprintf(stderr, "Public key algorithm: %s\n",
380
 
                  gpgme_pubkey_algo_name(recipient->pubkey_algo));
381
 
          fprintf(stderr, "Key ID: %s\n", recipient->keyid);
382
 
          fprintf(stderr, "Secret key available: %s\n",
383
 
                  recipient->status == GPG_ERR_NO_SECKEY
384
 
                  ? "No" : "Yes");
385
 
          recipient = recipient->next;
 
644
 
 
645
        for(gpgme_recipient_t r = result->recipients; r != NULL;
 
646
            r = r->next){
 
647
          fprintf_plus(stderr, "Public key algorithm: %s\n",
 
648
                       gpgme_pubkey_algo_name(r->pubkey_algo));
 
649
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
 
650
          fprintf_plus(stderr, "Secret key available: %s\n",
 
651
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
386
652
        }
387
653
      }
388
654
    }
390
656
  }
391
657
  
392
658
  if(debug){
393
 
    fprintf(stderr, "Decryption of OpenPGP data succeeded\n");
 
659
    fprintf_plus(stderr, "Decryption of OpenPGP data succeeded\n");
394
660
  }
395
661
  
396
662
  /* Seek back to the beginning of the GPGME plaintext data buffer */
403
669
  *plaintext = NULL;
404
670
  while(true){
405
671
    plaintext_capacity = incbuffer(plaintext,
406
 
                                      (size_t)plaintext_length,
407
 
                                      plaintext_capacity);
 
672
                                   (size_t)plaintext_length,
 
673
                                   plaintext_capacity);
408
674
    if(plaintext_capacity == 0){
409
 
        perror_plus("incbuffer");
410
 
        plaintext_length = -1;
411
 
        goto decrypt_end;
 
675
      perror_plus("incbuffer");
 
676
      plaintext_length = -1;
 
677
      goto decrypt_end;
412
678
    }
413
679
    
414
680
    ret = gpgme_data_read(dh_plain, *plaintext + plaintext_length,
427
693
  }
428
694
  
429
695
  if(debug){
430
 
    fprintf(stderr, "Decrypted password is: ");
 
696
    fprintf_plus(stderr, "Decrypted password is: ");
431
697
    for(ssize_t i = 0; i < plaintext_length; i++){
432
698
      fprintf(stderr, "%02hhX ", (*plaintext)[i]);
433
699
    }
444
710
  return plaintext_length;
445
711
}
446
712
 
447
 
static const char * safer_gnutls_strerror(int value){
448
 
  const char *ret = gnutls_strerror(value); /* Spurious warning from
449
 
                                               -Wunreachable-code */
450
 
  if(ret == NULL)
451
 
    ret = "(unknown)";
452
 
  return ret;
 
713
__attribute__((warn_unused_result, const))
 
714
static const char *safe_string(const char *str){
 
715
  if(str == NULL)
 
716
    return "(unknown)";
 
717
  return str;
 
718
}
 
719
 
 
720
__attribute__((warn_unused_result))
 
721
static const char *safer_gnutls_strerror(int value){
 
722
  const char *ret = gnutls_strerror(value);
 
723
  return safe_string(ret);
453
724
}
454
725
 
455
726
/* GnuTLS log function callback */
 
727
__attribute__((nonnull))
456
728
static void debuggnutls(__attribute__((unused)) int level,
457
729
                        const char* string){
458
 
  fprintf(stderr, "GnuTLS: %s", string);
 
730
  fprintf_plus(stderr, "GnuTLS: %s", string);
459
731
}
460
732
 
 
733
__attribute__((nonnull(1, 2, 4), warn_unused_result))
461
734
static int init_gnutls_global(const char *pubkeyfilename,
462
 
                              const char *seckeyfilename){
 
735
                              const char *seckeyfilename,
 
736
                              const char *dhparamsfilename,
 
737
                              mandos_context *mc){
463
738
  int ret;
464
739
  
465
740
  if(debug){
466
 
    fprintf(stderr, "Initializing GnuTLS\n");
467
 
  }
468
 
  
469
 
  ret = gnutls_global_init();
470
 
  if(ret != GNUTLS_E_SUCCESS){
471
 
    fprintf(stderr, "GnuTLS global_init: %s\n",
472
 
            safer_gnutls_strerror(ret));
473
 
    return -1;
 
741
    fprintf_plus(stderr, "Initializing GnuTLS\n");
474
742
  }
475
743
  
476
744
  if(debug){
482
750
  }
483
751
  
484
752
  /* OpenPGP credentials */
485
 
  ret = gnutls_certificate_allocate_credentials(&mc.cred);
 
753
  ret = gnutls_certificate_allocate_credentials(&mc->cred);
486
754
  if(ret != GNUTLS_E_SUCCESS){
487
 
    fprintf(stderr, "GnuTLS memory error: %s\n",
488
 
            safer_gnutls_strerror(ret));
489
 
    gnutls_global_deinit();
 
755
    fprintf_plus(stderr, "GnuTLS memory error: %s\n",
 
756
                 safer_gnutls_strerror(ret));
490
757
    return -1;
491
758
  }
492
759
  
493
760
  if(debug){
494
 
    fprintf(stderr, "Attempting to use OpenPGP public key %s and"
495
 
            " secret key %s as GnuTLS credentials\n", pubkeyfilename,
496
 
            seckeyfilename);
 
761
    fprintf_plus(stderr, "Attempting to use public key %s and"
 
762
                 " private key %s as GnuTLS credentials\n",
 
763
                 pubkeyfilename,
 
764
                 seckeyfilename);
497
765
  }
498
766
  
 
767
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
768
  ret = gnutls_certificate_set_rawpk_key_file
 
769
    (mc->cred, pubkeyfilename, seckeyfilename,
 
770
     GNUTLS_X509_FMT_PEM,       /* format */
 
771
     NULL,                      /* pass */
 
772
     /* key_usage */
 
773
     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,
 
774
     NULL,                      /* names */
 
775
     0,                         /* names_length */
 
776
     /* privkey_flags */
 
777
     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,
 
778
     0);                        /* pkcs11_flags */
 
779
#elif GNUTLS_VERSION_NUMBER < 0x030600
499
780
  ret = gnutls_certificate_set_openpgp_key_file
500
 
    (mc.cred, pubkeyfilename, seckeyfilename,
 
781
    (mc->cred, pubkeyfilename, seckeyfilename,
501
782
     GNUTLS_OPENPGP_FMT_BASE64);
 
783
#else
 
784
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
785
#endif
502
786
  if(ret != GNUTLS_E_SUCCESS){
503
 
    fprintf(stderr,
504
 
            "Error[%d] while reading the OpenPGP key pair ('%s',"
505
 
            " '%s')\n", ret, pubkeyfilename, seckeyfilename);
506
 
    fprintf(stderr, "The GnuTLS error is: %s\n",
507
 
            safer_gnutls_strerror(ret));
 
787
    fprintf_plus(stderr,
 
788
                 "Error[%d] while reading the key pair ('%s',"
 
789
                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);
 
790
    fprintf_plus(stderr, "The GnuTLS error is: %s\n",
 
791
                 safer_gnutls_strerror(ret));
508
792
    goto globalfail;
509
793
  }
510
794
  
511
795
  /* GnuTLS server initialization */
512
 
  ret = gnutls_dh_params_init(&mc.dh_params);
513
 
  if(ret != GNUTLS_E_SUCCESS){
514
 
    fprintf(stderr, "Error in GnuTLS DH parameter initialization:"
515
 
            " %s\n", safer_gnutls_strerror(ret));
516
 
    goto globalfail;
517
 
  }
518
 
  ret = gnutls_dh_params_generate2(mc.dh_params, mc.dh_bits);
519
 
  if(ret != GNUTLS_E_SUCCESS){
520
 
    fprintf(stderr, "Error in GnuTLS prime generation: %s\n",
521
 
            safer_gnutls_strerror(ret));
522
 
    goto globalfail;
523
 
  }
524
 
  
525
 
  gnutls_certificate_set_dh_params(mc.cred, mc.dh_params);
 
796
  ret = gnutls_dh_params_init(&mc->dh_params);
 
797
  if(ret != GNUTLS_E_SUCCESS){
 
798
    fprintf_plus(stderr, "Error in GnuTLS DH parameter"
 
799
                 " initialization: %s\n",
 
800
                 safer_gnutls_strerror(ret));
 
801
    goto globalfail;
 
802
  }
 
803
  /* If a Diffie-Hellman parameters file was given, try to use it */
 
804
  if(dhparamsfilename != NULL){
 
805
    gnutls_datum_t params = { .data = NULL, .size = 0 };
 
806
    do {
 
807
      int dhpfile = open(dhparamsfilename, O_RDONLY);
 
808
      if(dhpfile == -1){
 
809
        perror_plus("open");
 
810
        dhparamsfilename = NULL;
 
811
        break;
 
812
      }
 
813
      size_t params_capacity = 0;
 
814
      while(true){
 
815
        params_capacity = incbuffer((char **)&params.data,
 
816
                                    (size_t)params.size,
 
817
                                    (size_t)params_capacity);
 
818
        if(params_capacity == 0){
 
819
          perror_plus("incbuffer");
 
820
          free(params.data);
 
821
          params.data = NULL;
 
822
          dhparamsfilename = NULL;
 
823
          break;
 
824
        }
 
825
        ssize_t bytes_read = read(dhpfile,
 
826
                                  params.data + params.size,
 
827
                                  BUFFER_SIZE);
 
828
        /* EOF */
 
829
        if(bytes_read == 0){
 
830
          break;
 
831
        }
 
832
        /* check bytes_read for failure */
 
833
        if(bytes_read < 0){
 
834
          perror_plus("read");
 
835
          free(params.data);
 
836
          params.data = NULL;
 
837
          dhparamsfilename = NULL;
 
838
          break;
 
839
        }
 
840
        params.size += (unsigned int)bytes_read;
 
841
      }
 
842
      ret = close(dhpfile);
 
843
      if(ret == -1){
 
844
        perror_plus("close");
 
845
      }
 
846
      if(params.data == NULL){
 
847
        dhparamsfilename = NULL;
 
848
      }
 
849
      if(dhparamsfilename == NULL){
 
850
        break;
 
851
      }
 
852
      ret = gnutls_dh_params_import_pkcs3(mc->dh_params, &params,
 
853
                                          GNUTLS_X509_FMT_PEM);
 
854
      if(ret != GNUTLS_E_SUCCESS){
 
855
        fprintf_plus(stderr, "Failed to parse DH parameters in file"
 
856
                     " \"%s\": %s\n", dhparamsfilename,
 
857
                     safer_gnutls_strerror(ret));
 
858
        dhparamsfilename = NULL;
 
859
      }
 
860
      free(params.data);
 
861
    } while(false);
 
862
  }
 
863
  if(dhparamsfilename == NULL){
 
864
    if(mc->dh_bits == 0){
 
865
#if GNUTLS_VERSION_NUMBER < 0x030600
 
866
      /* Find out the optimal number of DH bits */
 
867
      /* Try to read the private key file */
 
868
      gnutls_datum_t buffer = { .data = NULL, .size = 0 };
 
869
      do {
 
870
        int secfile = open(seckeyfilename, O_RDONLY);
 
871
        if(secfile == -1){
 
872
          perror_plus("open");
 
873
          break;
 
874
        }
 
875
        size_t buffer_capacity = 0;
 
876
        while(true){
 
877
          buffer_capacity = incbuffer((char **)&buffer.data,
 
878
                                      (size_t)buffer.size,
 
879
                                      (size_t)buffer_capacity);
 
880
          if(buffer_capacity == 0){
 
881
            perror_plus("incbuffer");
 
882
            free(buffer.data);
 
883
            buffer.data = NULL;
 
884
            break;
 
885
          }
 
886
          ssize_t bytes_read = read(secfile,
 
887
                                    buffer.data + buffer.size,
 
888
                                    BUFFER_SIZE);
 
889
          /* EOF */
 
890
          if(bytes_read == 0){
 
891
            break;
 
892
          }
 
893
          /* check bytes_read for failure */
 
894
          if(bytes_read < 0){
 
895
            perror_plus("read");
 
896
            free(buffer.data);
 
897
            buffer.data = NULL;
 
898
            break;
 
899
          }
 
900
          buffer.size += (unsigned int)bytes_read;
 
901
        }
 
902
        close(secfile);
 
903
      } while(false);
 
904
      /* If successful, use buffer to parse private key */
 
905
      gnutls_sec_param_t sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
906
      if(buffer.data != NULL){
 
907
        {
 
908
          gnutls_openpgp_privkey_t privkey = NULL;
 
909
          ret = gnutls_openpgp_privkey_init(&privkey);
 
910
          if(ret != GNUTLS_E_SUCCESS){
 
911
            fprintf_plus(stderr, "Error initializing OpenPGP key"
 
912
                         " structure: %s",
 
913
                         safer_gnutls_strerror(ret));
 
914
            free(buffer.data);
 
915
            buffer.data = NULL;
 
916
          } else {
 
917
            ret = gnutls_openpgp_privkey_import
 
918
              (privkey, &buffer, GNUTLS_OPENPGP_FMT_BASE64, "", 0);
 
919
            if(ret != GNUTLS_E_SUCCESS){
 
920
              fprintf_plus(stderr, "Error importing OpenPGP key : %s",
 
921
                           safer_gnutls_strerror(ret));
 
922
              privkey = NULL;
 
923
            }
 
924
            free(buffer.data);
 
925
            buffer.data = NULL;
 
926
            if(privkey != NULL){
 
927
              /* Use private key to suggest an appropriate
 
928
                 sec_param */
 
929
              sec_param = gnutls_openpgp_privkey_sec_param(privkey);
 
930
              gnutls_openpgp_privkey_deinit(privkey);
 
931
              if(debug){
 
932
                fprintf_plus(stderr, "This OpenPGP key implies using"
 
933
                             " a GnuTLS security parameter \"%s\".\n",
 
934
                             safe_string(gnutls_sec_param_get_name
 
935
                                         (sec_param)));
 
936
              }
 
937
            }
 
938
          }
 
939
        }
 
940
        if(sec_param == GNUTLS_SEC_PARAM_UNKNOWN){
 
941
          /* Err on the side of caution */
 
942
          sec_param = GNUTLS_SEC_PARAM_ULTRA;
 
943
          if(debug){
 
944
            fprintf_plus(stderr, "Falling back to security parameter"
 
945
                         " \"%s\"\n",
 
946
                         safe_string(gnutls_sec_param_get_name
 
947
                                     (sec_param)));
 
948
          }
 
949
        }
 
950
      }
 
951
      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);
 
952
      if(uret != 0){
 
953
        mc->dh_bits = uret;
 
954
        if(debug){
 
955
          fprintf_plus(stderr, "A \"%s\" GnuTLS security parameter"
 
956
                       " implies %u DH bits; using that.\n",
 
957
                       safe_string(gnutls_sec_param_get_name
 
958
                                   (sec_param)),
 
959
                       mc->dh_bits);
 
960
        }
 
961
      } else {
 
962
        fprintf_plus(stderr, "Failed to get implied number of DH"
 
963
                     " bits for security parameter \"%s\"): %s\n",
 
964
                     safe_string(gnutls_sec_param_get_name
 
965
                                 (sec_param)),
 
966
                     safer_gnutls_strerror(ret));
 
967
        goto globalfail;
 
968
      }
 
969
#endif
 
970
    } else {                    /* dh_bits != 0 */
 
971
      if(debug){
 
972
        fprintf_plus(stderr, "DH bits explicitly set to %u\n",
 
973
                     mc->dh_bits);
 
974
      }
 
975
      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);
 
976
      if(ret != GNUTLS_E_SUCCESS){
 
977
        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"
 
978
                     " bits): %s\n", mc->dh_bits,
 
979
                     safer_gnutls_strerror(ret));
 
980
        goto globalfail;
 
981
      }
 
982
      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);
 
983
    }
 
984
  }
526
985
  
527
986
  return 0;
528
987
  
529
988
 globalfail:
530
989
  
531
 
  gnutls_certificate_free_credentials(mc.cred);
532
 
  gnutls_global_deinit();
533
 
  gnutls_dh_params_deinit(mc.dh_params);
 
990
  gnutls_certificate_free_credentials(mc->cred);
 
991
  gnutls_dh_params_deinit(mc->dh_params);
534
992
  return -1;
535
993
}
536
994
 
537
 
static int init_gnutls_session(gnutls_session_t *session){
 
995
__attribute__((nonnull, warn_unused_result))
 
996
static int init_gnutls_session(gnutls_session_t *session,
 
997
                               mandos_context *mc){
538
998
  int ret;
539
999
  /* GnuTLS session creation */
540
1000
  do {
541
 
    ret = gnutls_init(session, GNUTLS_SERVER);
 
1001
    ret = gnutls_init(session, (GNUTLS_SERVER
 
1002
#if GNUTLS_VERSION_NUMBER >= 0x030506
 
1003
                                | GNUTLS_NO_TICKETS
 
1004
#endif
 
1005
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
1006
                                | GNUTLS_ENABLE_RAWPK
 
1007
#endif
 
1008
                                ));
542
1009
    if(quit_now){
543
1010
      return -1;
544
1011
    }
545
1012
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
546
1013
  if(ret != GNUTLS_E_SUCCESS){
547
 
    fprintf(stderr, "Error in GnuTLS session initialization: %s\n",
548
 
            safer_gnutls_strerror(ret));
 
1014
    fprintf_plus(stderr,
 
1015
                 "Error in GnuTLS session initialization: %s\n",
 
1016
                 safer_gnutls_strerror(ret));
549
1017
  }
550
1018
  
551
1019
  {
552
1020
    const char *err;
553
1021
    do {
554
 
      ret = gnutls_priority_set_direct(*session, mc.priority, &err);
 
1022
      ret = gnutls_priority_set_direct(*session, mc->priority, &err);
555
1023
      if(quit_now){
556
1024
        gnutls_deinit(*session);
557
1025
        return -1;
558
1026
      }
559
1027
    } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
560
1028
    if(ret != GNUTLS_E_SUCCESS){
561
 
      fprintf(stderr, "Syntax error at: %s\n", err);
562
 
      fprintf(stderr, "GnuTLS error: %s\n",
563
 
              safer_gnutls_strerror(ret));
 
1029
      fprintf_plus(stderr, "Syntax error at: %s\n", err);
 
1030
      fprintf_plus(stderr, "GnuTLS error: %s\n",
 
1031
                   safer_gnutls_strerror(ret));
564
1032
      gnutls_deinit(*session);
565
1033
      return -1;
566
1034
    }
568
1036
  
569
1037
  do {
570
1038
    ret = gnutls_credentials_set(*session, GNUTLS_CRD_CERTIFICATE,
571
 
                                 mc.cred);
 
1039
                                 mc->cred);
572
1040
    if(quit_now){
573
1041
      gnutls_deinit(*session);
574
1042
      return -1;
575
1043
    }
576
1044
  } while(ret == GNUTLS_E_INTERRUPTED or ret == GNUTLS_E_AGAIN);
577
1045
  if(ret != GNUTLS_E_SUCCESS){
578
 
    fprintf(stderr, "Error setting GnuTLS credentials: %s\n",
579
 
            safer_gnutls_strerror(ret));
 
1046
    fprintf_plus(stderr, "Error setting GnuTLS credentials: %s\n",
 
1047
                 safer_gnutls_strerror(ret));
580
1048
    gnutls_deinit(*session);
581
1049
    return -1;
582
1050
  }
584
1052
  /* ignore client certificate if any. */
585
1053
  gnutls_certificate_server_set_request(*session, GNUTLS_CERT_IGNORE);
586
1054
  
587
 
  gnutls_dh_set_prime_bits(*session, mc.dh_bits);
588
 
  
589
1055
  return 0;
590
1056
}
591
1057
 
593
1059
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
594
1060
                      __attribute__((unused)) const char *txt){}
595
1061
 
 
1062
/* Helper function to add_local_route() and delete_local_route() */
 
1063
__attribute__((nonnull, warn_unused_result))
 
1064
static bool add_delete_local_route(const bool add,
 
1065
                                   const char *address,
 
1066
                                   AvahiIfIndex if_index){
 
1067
  int ret;
 
1068
  char helper[] = "mandos-client-iprouteadddel";
 
1069
  char add_arg[] = "add";
 
1070
  char delete_arg[] = "delete";
 
1071
  char debug_flag[] = "--debug";
 
1072
  char *pluginhelperdir = getenv("MANDOSPLUGINHELPERDIR");
 
1073
  if(pluginhelperdir == NULL){
 
1074
    if(debug){
 
1075
      fprintf_plus(stderr, "MANDOSPLUGINHELPERDIR environment"
 
1076
                   " variable not set; cannot run helper\n");
 
1077
    }
 
1078
    return false;
 
1079
  }
 
1080
  
 
1081
  char interface[IF_NAMESIZE];
 
1082
  if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1083
    perror_plus("if_indextoname");
 
1084
    return false;
 
1085
  }
 
1086
  
 
1087
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
1088
  if(devnull == -1){
 
1089
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
1090
    return false;
 
1091
  }
 
1092
  pid_t pid = fork();
 
1093
  if(pid == 0){
 
1094
    /* Child */
 
1095
    /* Raise privileges */
 
1096
    errno = raise_privileges_permanently();
 
1097
    if(errno != 0){
 
1098
      perror_plus("Failed to raise privileges");
 
1099
      /* _exit(EX_NOPERM); */
 
1100
    } else {
 
1101
      /* Set group */
 
1102
      errno = 0;
 
1103
      ret = setgid(0);
 
1104
      if(ret == -1){
 
1105
        perror_plus("setgid");
 
1106
        close(devnull);
 
1107
        _exit(EX_NOPERM);
 
1108
      }
 
1109
      /* Reset supplementary groups */
 
1110
      errno = 0;
 
1111
      ret = setgroups(0, NULL);
 
1112
      if(ret == -1){
 
1113
        perror_plus("setgroups");
 
1114
        close(devnull);
 
1115
        _exit(EX_NOPERM);
 
1116
      }
 
1117
    }
 
1118
    ret = dup2(devnull, STDIN_FILENO);
 
1119
    if(ret == -1){
 
1120
      perror_plus("dup2(devnull, STDIN_FILENO)");
 
1121
      close(devnull);
 
1122
      _exit(EX_OSERR);
 
1123
    }
 
1124
    ret = close(devnull);
 
1125
    if(ret == -1){
 
1126
      perror_plus("close");
 
1127
    }
 
1128
    ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
1129
    if(ret == -1){
 
1130
      perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
1131
      _exit(EX_OSERR);
 
1132
    }
 
1133
    int helperdir_fd = (int)TEMP_FAILURE_RETRY(open(pluginhelperdir,
 
1134
                                                    O_RDONLY
 
1135
                                                    | O_DIRECTORY
 
1136
                                                    | O_PATH
 
1137
                                                    | O_CLOEXEC));
 
1138
    if(helperdir_fd == -1){
 
1139
      perror_plus("open");
 
1140
      _exit(EX_UNAVAILABLE);
 
1141
    }
 
1142
    int helper_fd = (int)TEMP_FAILURE_RETRY(openat(helperdir_fd,
 
1143
                                                   helper, O_RDONLY));
 
1144
    if(helper_fd == -1){
 
1145
      perror_plus("openat");
 
1146
      close(helperdir_fd);
 
1147
      _exit(EX_UNAVAILABLE);
 
1148
    }
 
1149
    close(helperdir_fd);
 
1150
#ifdef __GNUC__
 
1151
#pragma GCC diagnostic push
 
1152
#pragma GCC diagnostic ignored "-Wcast-qual"
 
1153
#endif
 
1154
    if(fexecve(helper_fd, (char *const [])
 
1155
               { helper, add ? add_arg : delete_arg, (char *)address,
 
1156
                   interface, debug ? debug_flag : NULL, NULL },
 
1157
               environ) == -1){
 
1158
#ifdef __GNUC__
 
1159
#pragma GCC diagnostic pop
 
1160
#endif
 
1161
      perror_plus("fexecve");
 
1162
      _exit(EXIT_FAILURE);
 
1163
    }
 
1164
  }
 
1165
  if(pid == -1){
 
1166
    perror_plus("fork");
 
1167
    close(devnull);
 
1168
    return false;
 
1169
  }
 
1170
  ret = close(devnull);
 
1171
  if(ret == -1){
 
1172
    perror_plus("close");
 
1173
  }
 
1174
  int status;
 
1175
  pid_t pret = -1;
 
1176
  errno = 0;
 
1177
  do {
 
1178
    pret = waitpid(pid, &status, 0);
 
1179
    if(pret == -1 and errno == EINTR and quit_now){
 
1180
      int errno_raising = 0;
 
1181
      if((errno = raise_privileges()) != 0){
 
1182
        errno_raising = errno;
 
1183
        perror_plus("Failed to raise privileges in order to"
 
1184
                    " kill helper program");
 
1185
      }
 
1186
      if(kill(pid, SIGTERM) == -1){
 
1187
        perror_plus("kill");
 
1188
      }
 
1189
      if((errno_raising == 0) and (errno = lower_privileges()) != 0){
 
1190
        perror_plus("Failed to lower privileges after killing"
 
1191
                    " helper program");
 
1192
      }
 
1193
      return false;
 
1194
    }
 
1195
  } while(pret == -1 and errno == EINTR);
 
1196
  if(pret == -1){
 
1197
    perror_plus("waitpid");
 
1198
    return false;
 
1199
  }
 
1200
  if(WIFEXITED(status)){
 
1201
    if(WEXITSTATUS(status) != 0){
 
1202
      fprintf_plus(stderr, "Error: iprouteadddel exited"
 
1203
                   " with status %d\n", WEXITSTATUS(status));
 
1204
      return false;
 
1205
    }
 
1206
    return true;
 
1207
  }
 
1208
  if(WIFSIGNALED(status)){
 
1209
    fprintf_plus(stderr, "Error: iprouteadddel died by"
 
1210
                 " signal %d\n", WTERMSIG(status));
 
1211
    return false;
 
1212
  }
 
1213
  fprintf_plus(stderr, "Error: iprouteadddel crashed\n");
 
1214
  return false;
 
1215
}
 
1216
 
 
1217
__attribute__((nonnull, warn_unused_result))
 
1218
static bool add_local_route(const char *address,
 
1219
                            AvahiIfIndex if_index){
 
1220
  if(debug){
 
1221
    fprintf_plus(stderr, "Adding route to %s\n", address);
 
1222
  }
 
1223
  return add_delete_local_route(true, address, if_index);
 
1224
}
 
1225
 
 
1226
__attribute__((nonnull, warn_unused_result))
 
1227
static bool delete_local_route(const char *address,
 
1228
                               AvahiIfIndex if_index){
 
1229
  if(debug){
 
1230
    fprintf_plus(stderr, "Removing route to %s\n", address);
 
1231
  }
 
1232
  return add_delete_local_route(false, address, if_index);
 
1233
}
 
1234
 
596
1235
/* Called when a Mandos server is found */
597
 
static int start_mandos_communication(const char *ip, uint16_t port,
 
1236
__attribute__((nonnull, warn_unused_result))
 
1237
static int start_mandos_communication(const char *ip, in_port_t port,
598
1238
                                      AvahiIfIndex if_index,
599
 
                                      int af){
 
1239
                                      int af, mandos_context *mc){
600
1240
  int ret, tcp_sd = -1;
601
1241
  ssize_t sret;
602
 
  union {
603
 
    struct sockaddr_in in;
604
 
    struct sockaddr_in6 in6;
605
 
  } to;
 
1242
  struct sockaddr_storage to;
606
1243
  char *buffer = NULL;
607
1244
  char *decrypted_buffer = NULL;
608
1245
  size_t buffer_length = 0;
611
1248
  int retval = -1;
612
1249
  gnutls_session_t session;
613
1250
  int pf;                       /* Protocol family */
 
1251
  bool route_added = false;
614
1252
  
615
1253
  errno = 0;
616
1254
  
627
1265
    pf = PF_INET;
628
1266
    break;
629
1267
  default:
630
 
    fprintf(stderr, "Bad address family: %d\n", af);
 
1268
    fprintf_plus(stderr, "Bad address family: %d\n", af);
631
1269
    errno = EINVAL;
632
1270
    return -1;
633
1271
  }
634
1272
  
635
 
  ret = init_gnutls_session(&session);
 
1273
  /* If the interface is specified and we have a list of interfaces */
 
1274
  if(if_index != AVAHI_IF_UNSPEC and mc->interfaces != NULL){
 
1275
    /* Check if the interface is one of the interfaces we are using */
 
1276
    bool match = false;
 
1277
    {
 
1278
      char *interface = NULL;
 
1279
      while((interface = argz_next(mc->interfaces,
 
1280
                                   mc->interfaces_size,
 
1281
                                   interface))){
 
1282
        if(if_nametoindex(interface) == (unsigned int)if_index){
 
1283
          match = true;
 
1284
          break;
 
1285
        }
 
1286
      }
 
1287
    }
 
1288
    if(not match){
 
1289
      /* This interface does not match any in the list, so we don't
 
1290
         connect to the server */
 
1291
      if(debug){
 
1292
        char interface[IF_NAMESIZE];
 
1293
        if(if_indextoname((unsigned int)if_index, interface) == NULL){
 
1294
          perror_plus("if_indextoname");
 
1295
        } else {
 
1296
          fprintf_plus(stderr, "Skipping server on non-used interface"
 
1297
                       " \"%s\"\n",
 
1298
                       if_indextoname((unsigned int)if_index,
 
1299
                                      interface));
 
1300
        }
 
1301
      }
 
1302
      return -1;
 
1303
    }
 
1304
  }
 
1305
  
 
1306
  ret = init_gnutls_session(&session, mc);
636
1307
  if(ret != 0){
637
1308
    return -1;
638
1309
  }
639
1310
  
640
1311
  if(debug){
641
 
    fprintf(stderr, "Setting up a TCP connection to %s, port %" PRIu16
642
 
            "\n", ip, port);
 
1312
    fprintf_plus(stderr, "Setting up a TCP connection to %s, port %"
 
1313
                 PRIuMAX "\n", ip, (uintmax_t)port);
643
1314
  }
644
1315
  
645
 
  tcp_sd = socket(pf, SOCK_STREAM, 0);
 
1316
  tcp_sd = socket(pf, SOCK_STREAM | SOCK_CLOEXEC, 0);
646
1317
  if(tcp_sd < 0){
647
1318
    int e = errno;
648
1319
    perror_plus("socket");
655
1326
    goto mandos_end;
656
1327
  }
657
1328
  
658
 
  memset(&to, 0, sizeof(to));
659
1329
  if(af == AF_INET6){
660
 
    to.in6.sin6_family = (sa_family_t)af;
661
 
    ret = inet_pton(af, ip, &to.in6.sin6_addr);
 
1330
    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;
 
1331
    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };
 
1332
    ret = inet_pton(af, ip, &to6->sin6_addr);
662
1333
  } else {                      /* IPv4 */
663
 
    to.in.sin_family = (sa_family_t)af;
664
 
    ret = inet_pton(af, ip, &to.in.sin_addr);
 
1334
    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;
 
1335
    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };
 
1336
    ret = inet_pton(af, ip, &to4->sin_addr);
665
1337
  }
666
1338
  if(ret < 0 ){
667
1339
    int e = errno;
671
1343
  }
672
1344
  if(ret == 0){
673
1345
    int e = errno;
674
 
    fprintf(stderr, "Bad address: %s\n", ip);
 
1346
    fprintf_plus(stderr, "Bad address: %s\n", ip);
675
1347
    errno = e;
676
1348
    goto mandos_end;
677
1349
  }
678
1350
  if(af == AF_INET6){
679
 
    to.in6.sin6_port = htons(port); /* Spurious warnings from
680
 
                                       -Wconversion and
681
 
                                       -Wunreachable-code */
682
 
    
683
 
    if(IN6_IS_ADDR_LINKLOCAL /* Spurious warnings from */
684
 
       (&to.in6.sin6_addr)){ /* -Wstrict-aliasing=2 or lower and
685
 
                              -Wunreachable-code*/
 
1351
    ((struct sockaddr_in6 *)&to)->sin6_port = htons(port);
 
1352
    if(IN6_IS_ADDR_LINKLOCAL
 
1353
       (&((struct sockaddr_in6 *)&to)->sin6_addr)){
686
1354
      if(if_index == AVAHI_IF_UNSPEC){
687
 
        fprintf(stderr, "An IPv6 link-local address is incomplete"
688
 
                " without a network interface\n");
 
1355
        fprintf_plus(stderr, "An IPv6 link-local address is"
 
1356
                     " incomplete without a network interface\n");
689
1357
        errno = EINVAL;
690
1358
        goto mandos_end;
691
1359
      }
692
1360
      /* Set the network interface number as scope */
693
 
      to.in6.sin6_scope_id = (uint32_t)if_index;
 
1361
      ((struct sockaddr_in6 *)&to)->sin6_scope_id = (uint32_t)if_index;
694
1362
    }
695
1363
  } else {
696
 
    to.in.sin_port = htons(port); /* Spurious warnings from
697
 
                                     -Wconversion and
698
 
                                     -Wunreachable-code */
 
1364
    ((struct sockaddr_in *)&to)->sin_port = htons(port);
699
1365
  }
700
1366
  
701
1367
  if(quit_now){
709
1375
      if(if_indextoname((unsigned int)if_index, interface) == NULL){
710
1376
        perror_plus("if_indextoname");
711
1377
      } else {
712
 
        fprintf(stderr, "Connection to: %s%%%s, port %" PRIu16 "\n",
713
 
                ip, interface, port);
 
1378
        fprintf_plus(stderr, "Connection to: %s%%%s, port %" PRIuMAX
 
1379
                     "\n", ip, interface, (uintmax_t)port);
714
1380
      }
715
1381
    } else {
716
 
      fprintf(stderr, "Connection to: %s, port %" PRIu16 "\n", ip,
717
 
              port);
 
1382
      fprintf_plus(stderr, "Connection to: %s, port %" PRIuMAX "\n",
 
1383
                   ip, (uintmax_t)port);
718
1384
    }
719
1385
    char addrstr[(INET_ADDRSTRLEN > INET6_ADDRSTRLEN) ?
720
1386
                 INET_ADDRSTRLEN : INET6_ADDRSTRLEN] = "";
721
 
    const char *pcret;
722
 
    if(af == AF_INET6){
723
 
      pcret = inet_ntop(af, &(to.in6.sin6_addr), addrstr,
724
 
                        sizeof(addrstr));
725
 
    } else {
726
 
      pcret = inet_ntop(af, &(to.in.sin_addr), addrstr,
727
 
                        sizeof(addrstr));
728
 
    }
729
 
    if(pcret == NULL){
730
 
      perror_plus("inet_ntop");
731
 
    } else {
732
 
      if(strcmp(addrstr, ip) != 0){
733
 
        fprintf(stderr, "Canonical address form: %s\n", addrstr);
734
 
      }
735
 
    }
736
 
  }
737
 
  
738
 
  if(quit_now){
739
 
    errno = EINTR;
740
 
    goto mandos_end;
741
 
  }
742
 
  
743
 
  if(af == AF_INET6){
744
 
    ret = connect(tcp_sd, &to.in6, sizeof(to));
745
 
  } else {
746
 
    ret = connect(tcp_sd, &to.in, sizeof(to)); /* IPv4 */
747
 
  }
748
 
  if(ret < 0){
749
 
    if ((errno != ECONNREFUSED and errno != ENETUNREACH) or debug){
750
 
      int e = errno;
751
 
      perror_plus("connect");
752
 
      errno = e;
753
 
    }
754
 
    goto mandos_end;
755
 
  }
756
 
  
757
 
  if(quit_now){
758
 
    errno = EINTR;
759
 
    goto mandos_end;
 
1387
    if(af == AF_INET6){
 
1388
      ret = getnameinfo((struct sockaddr *)&to,
 
1389
                        sizeof(struct sockaddr_in6),
 
1390
                        addrstr, sizeof(addrstr), NULL, 0,
 
1391
                        NI_NUMERICHOST);
 
1392
    } else {
 
1393
      ret = getnameinfo((struct sockaddr *)&to,
 
1394
                        sizeof(struct sockaddr_in),
 
1395
                        addrstr, sizeof(addrstr), NULL, 0,
 
1396
                        NI_NUMERICHOST);
 
1397
    }
 
1398
    if(ret == EAI_SYSTEM){
 
1399
      perror_plus("getnameinfo");
 
1400
    } else if(ret != 0) {
 
1401
      fprintf_plus(stderr, "getnameinfo: %s", gai_strerror(ret));
 
1402
    } else if(strcmp(addrstr, ip) != 0){
 
1403
      fprintf_plus(stderr, "Canonical address form: %s\n", addrstr);
 
1404
    }
 
1405
  }
 
1406
  
 
1407
  if(quit_now){
 
1408
    errno = EINTR;
 
1409
    goto mandos_end;
 
1410
  }
 
1411
  
 
1412
  while(true){
 
1413
    if(af == AF_INET6){
 
1414
      ret = connect(tcp_sd, (struct sockaddr *)&to,
 
1415
                    sizeof(struct sockaddr_in6));
 
1416
    } else {
 
1417
      ret = connect(tcp_sd, (struct sockaddr *)&to, /* IPv4 */
 
1418
                    sizeof(struct sockaddr_in));
 
1419
    }
 
1420
    if(ret < 0){
 
1421
      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))
 
1422
         and if_index != AVAHI_IF_UNSPEC
 
1423
         and connect_to == NULL
 
1424
         and not route_added and
 
1425
         ((af == AF_INET6 and not
 
1426
           IN6_IS_ADDR_LINKLOCAL(&(((struct sockaddr_in6 *)
 
1427
                                    &to)->sin6_addr)))
 
1428
          or (af == AF_INET and
 
1429
              /* Not a a IPv4LL address */
 
1430
              (ntohl(((struct sockaddr_in *)&to)->sin_addr.s_addr)
 
1431
               & 0xFFFF0000L) != 0xA9FE0000L))){
 
1432
        /* Work around Avahi bug - Avahi does not announce link-local
 
1433
           addresses if it has a global address, so local hosts with
 
1434
           *only* a link-local address (e.g. Mandos clients) cannot
 
1435
           connect to a Mandos server announced by Avahi on a server
 
1436
           host with a global address.  Work around this by retrying
 
1437
           with an explicit route added with the server's address.
 
1438
           
 
1439
           Avahi bug reference:
 
1440
           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html
 
1441
           https://bugs.debian.org/587961
 
1442
        */
 
1443
        if(debug){
 
1444
          fprintf_plus(stderr, "Mandos server unreachable, trying"
 
1445
                       " direct route\n");
 
1446
        }
 
1447
        int e = errno;
 
1448
        route_added = add_local_route(ip, if_index);
 
1449
        if(route_added){
 
1450
          continue;
 
1451
        }
 
1452
        errno = e;
 
1453
      }
 
1454
      if(errno != ECONNREFUSED or debug){
 
1455
        int e = errno;
 
1456
        perror_plus("connect");
 
1457
        errno = e;
 
1458
      }
 
1459
      goto mandos_end;
 
1460
    }
 
1461
    
 
1462
    if(quit_now){
 
1463
      errno = EINTR;
 
1464
      goto mandos_end;
 
1465
    }
 
1466
    break;
760
1467
  }
761
1468
  
762
1469
  const char *out = mandos_protocol_version;
764
1471
  while(true){
765
1472
    size_t out_size = strlen(out);
766
1473
    ret = (int)TEMP_FAILURE_RETRY(write(tcp_sd, out + written,
767
 
                                   out_size - written));
 
1474
                                        out_size - written));
768
1475
    if(ret == -1){
769
1476
      int e = errno;
770
1477
      perror_plus("write");
790
1497
  }
791
1498
  
792
1499
  if(debug){
793
 
    fprintf(stderr, "Establishing TLS session with %s\n", ip);
 
1500
    fprintf_plus(stderr, "Establishing TLS session with %s\n", ip);
794
1501
  }
795
1502
  
796
1503
  if(quit_now){
798
1505
    goto mandos_end;
799
1506
  }
800
1507
  
801
 
  /* Spurious warning from -Wint-to-pointer-cast */
802
 
  gnutls_transport_set_ptr(session, (gnutls_transport_ptr_t) tcp_sd);
 
1508
  /* This casting via intptr_t is to eliminate warning about casting
 
1509
     an int to a pointer type.  This is exactly how the GnuTLS Guile
 
1510
     function "set-session-transport-fd!" does it. */
 
1511
  gnutls_transport_set_ptr(session,
 
1512
                           (gnutls_transport_ptr_t)(intptr_t)tcp_sd);
803
1513
  
804
1514
  if(quit_now){
805
1515
    errno = EINTR;
816
1526
  
817
1527
  if(ret != GNUTLS_E_SUCCESS){
818
1528
    if(debug){
819
 
      fprintf(stderr, "*** GnuTLS Handshake failed ***\n");
 
1529
      fprintf_plus(stderr, "*** GnuTLS Handshake failed ***\n");
820
1530
      gnutls_perror(ret);
821
1531
    }
822
1532
    errno = EPROTO;
826
1536
  /* Read OpenPGP packet that contains the wanted password */
827
1537
  
828
1538
  if(debug){
829
 
    fprintf(stderr, "Retrieving OpenPGP encrypted password from %s\n",
830
 
            ip);
 
1539
    fprintf_plus(stderr, "Retrieving OpenPGP encrypted password from"
 
1540
                 " %s\n", ip);
831
1541
  }
832
1542
  
833
1543
  while(true){
838
1548
    }
839
1549
    
840
1550
    buffer_capacity = incbuffer(&buffer, buffer_length,
841
 
                                   buffer_capacity);
 
1551
                                buffer_capacity);
842
1552
    if(buffer_capacity == 0){
843
1553
      int e = errno;
844
1554
      perror_plus("incbuffer");
871
1581
          }
872
1582
        } while(ret == GNUTLS_E_AGAIN or ret == GNUTLS_E_INTERRUPTED);
873
1583
        if(ret < 0){
874
 
          fprintf(stderr, "*** GnuTLS Re-handshake failed ***\n");
 
1584
          fprintf_plus(stderr, "*** GnuTLS Re-handshake failed "
 
1585
                       "***\n");
875
1586
          gnutls_perror(ret);
876
1587
          errno = EPROTO;
877
1588
          goto mandos_end;
878
1589
        }
879
1590
        break;
880
1591
      default:
881
 
        fprintf(stderr, "Unknown error while reading data from"
882
 
                " encrypted session with Mandos server\n");
 
1592
        fprintf_plus(stderr, "Unknown error while reading data from"
 
1593
                     " encrypted session with Mandos server\n");
883
1594
        gnutls_bye(session, GNUTLS_SHUT_RDWR);
884
1595
        errno = EIO;
885
1596
        goto mandos_end;
890
1601
  }
891
1602
  
892
1603
  if(debug){
893
 
    fprintf(stderr, "Closing TLS session\n");
 
1604
    fprintf_plus(stderr, "Closing TLS session\n");
894
1605
  }
895
1606
  
896
1607
  if(quit_now){
908
1619
  
909
1620
  if(buffer_length > 0){
910
1621
    ssize_t decrypted_buffer_size;
911
 
    decrypted_buffer_size = pgp_packet_decrypt(buffer,
912
 
                                               buffer_length,
913
 
                                               &decrypted_buffer);
 
1622
    decrypted_buffer_size = pgp_packet_decrypt(buffer, buffer_length,
 
1623
                                               &decrypted_buffer, mc);
914
1624
    if(decrypted_buffer_size >= 0){
915
1625
      
 
1626
      clearerr(stdout);
916
1627
      written = 0;
917
1628
      while(written < (size_t) decrypted_buffer_size){
918
1629
        if(quit_now){
926
1637
        if(ret == 0 and ferror(stdout)){
927
1638
          int e = errno;
928
1639
          if(debug){
929
 
            fprintf(stderr, "Error writing encrypted data: %s\n",
930
 
                    strerror(errno));
 
1640
            fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1641
                         strerror(errno));
931
1642
          }
932
1643
          errno = e;
933
1644
          goto mandos_end;
934
1645
        }
935
1646
        written += (size_t)ret;
936
1647
      }
 
1648
      ret = fflush(stdout);
 
1649
      if(ret != 0){
 
1650
        int e = errno;
 
1651
        if(debug){
 
1652
          fprintf_plus(stderr, "Error writing encrypted data: %s\n",
 
1653
                       strerror(errno));
 
1654
        }
 
1655
        errno = e;
 
1656
        goto mandos_end;
 
1657
      }
937
1658
      retval = 0;
938
1659
    }
939
1660
  }
942
1663
  
943
1664
 mandos_end:
944
1665
  {
 
1666
    if(route_added){
 
1667
      if(not delete_local_route(ip, if_index)){
 
1668
        fprintf_plus(stderr, "Failed to delete local route to %s on"
 
1669
                     " interface %d", ip, if_index);
 
1670
      }
 
1671
    }
945
1672
    int e = errno;
946
1673
    free(decrypted_buffer);
947
1674
    free(buffer);
948
1675
    if(tcp_sd >= 0){
949
 
      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));
 
1676
      ret = close(tcp_sd);
950
1677
    }
951
1678
    if(ret == -1){
952
1679
      if(e == 0){
977
1704
                             AVAHI_GCC_UNUSED AvahiStringList *txt,
978
1705
                             AVAHI_GCC_UNUSED AvahiLookupResultFlags
979
1706
                             flags,
980
 
                             AVAHI_GCC_UNUSED void* userdata){
981
 
  assert(r);
 
1707
                             void *mc){
 
1708
  if(r == NULL){
 
1709
    return;
 
1710
  }
982
1711
  
983
1712
  /* Called whenever a service has been resolved successfully or
984
1713
     timed out */
985
1714
  
986
1715
  if(quit_now){
 
1716
    avahi_s_service_resolver_free(r);
987
1717
    return;
988
1718
  }
989
1719
  
990
1720
  switch(event){
991
1721
  default:
992
1722
  case AVAHI_RESOLVER_FAILURE:
993
 
    fprintf(stderr, "(Avahi Resolver) Failed to resolve service '%s'"
994
 
            " of type '%s' in domain '%s': %s\n", name, type, domain,
995
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
1723
    fprintf_plus(stderr, "(Avahi Resolver) Failed to resolve service "
 
1724
                 "'%s' of type '%s' in domain '%s': %s\n", name, type,
 
1725
                 domain,
 
1726
                 avahi_strerror(avahi_server_errno
 
1727
                                (((mandos_context*)mc)->server)));
996
1728
    break;
997
1729
    
998
1730
  case AVAHI_RESOLVER_FOUND:
1000
1732
      char ip[AVAHI_ADDRESS_STR_MAX];
1001
1733
      avahi_address_snprint(ip, sizeof(ip), address);
1002
1734
      if(debug){
1003
 
        fprintf(stderr, "Mandos server \"%s\" found on %s (%s, %"
1004
 
                PRIdMAX ") on port %" PRIu16 "\n", name, host_name,
1005
 
                ip, (intmax_t)interface, port);
 
1735
        fprintf_plus(stderr, "Mandos server \"%s\" found on %s (%s, %"
 
1736
                     PRIdMAX ") on port %" PRIu16 "\n", name,
 
1737
                     host_name, ip, (intmax_t)interface, port);
1006
1738
      }
1007
 
      int ret = start_mandos_communication(ip, port, interface,
1008
 
                                           avahi_proto_to_af(proto));
 
1739
      int ret = start_mandos_communication(ip, (in_port_t)port,
 
1740
                                           interface,
 
1741
                                           avahi_proto_to_af(proto),
 
1742
                                           mc);
1009
1743
      if(ret == 0){
1010
 
        avahi_simple_poll_quit(mc.simple_poll);
 
1744
        avahi_simple_poll_quit(simple_poll);
1011
1745
      } else {
1012
 
        ret = add_server(ip, port, interface,
1013
 
                         avahi_proto_to_af(proto));
 
1746
        if(not add_server(ip, (in_port_t)port, interface,
 
1747
                          avahi_proto_to_af(proto),
 
1748
                          &((mandos_context*)mc)->current_server)){
 
1749
          fprintf_plus(stderr, "Failed to add server \"%s\" to server"
 
1750
                       " list\n", name);
 
1751
        }
1014
1752
      }
1015
1753
    }
1016
1754
  }
1026
1764
                            const char *domain,
1027
1765
                            AVAHI_GCC_UNUSED AvahiLookupResultFlags
1028
1766
                            flags,
1029
 
                            AVAHI_GCC_UNUSED void* userdata){
1030
 
  assert(b);
 
1767
                            void *mc){
 
1768
  if(b == NULL){
 
1769
    return;
 
1770
  }
1031
1771
  
1032
1772
  /* Called whenever a new services becomes available on the LAN or
1033
1773
     is removed from the LAN */
1040
1780
  default:
1041
1781
  case AVAHI_BROWSER_FAILURE:
1042
1782
    
1043
 
    fprintf(stderr, "(Avahi browser) %s\n",
1044
 
            avahi_strerror(avahi_server_errno(mc.server)));
1045
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1783
    fprintf_plus(stderr, "(Avahi browser) %s\n",
 
1784
                 avahi_strerror(avahi_server_errno
 
1785
                                (((mandos_context*)mc)->server)));
 
1786
    avahi_simple_poll_quit(simple_poll);
1046
1787
    return;
1047
1788
    
1048
1789
  case AVAHI_BROWSER_NEW:
1051
1792
       the callback function is called the Avahi server will free the
1052
1793
       resolver for us. */
1053
1794
    
1054
 
    if(avahi_s_service_resolver_new(mc.server, interface, protocol,
1055
 
                                    name, type, domain, protocol, 0,
1056
 
                                    resolve_callback, NULL) == NULL)
1057
 
      fprintf(stderr, "Avahi: Failed to resolve service '%s': %s\n",
1058
 
              name, avahi_strerror(avahi_server_errno(mc.server)));
 
1795
    if(avahi_s_service_resolver_new(((mandos_context*)mc)->server,
 
1796
                                    interface, protocol, name, type,
 
1797
                                    domain, protocol, 0,
 
1798
                                    resolve_callback, mc) == NULL)
 
1799
      fprintf_plus(stderr, "Avahi: Failed to resolve service '%s':"
 
1800
                   " %s\n", name,
 
1801
                   avahi_strerror(avahi_server_errno
 
1802
                                  (((mandos_context*)mc)->server)));
1059
1803
    break;
1060
1804
    
1061
1805
  case AVAHI_BROWSER_REMOVE:
1064
1808
  case AVAHI_BROWSER_ALL_FOR_NOW:
1065
1809
  case AVAHI_BROWSER_CACHE_EXHAUSTED:
1066
1810
    if(debug){
1067
 
      fprintf(stderr, "No Mandos server found, still searching...\n");
 
1811
      fprintf_plus(stderr, "No Mandos server found, still"
 
1812
                   " searching...\n");
1068
1813
    }
1069
1814
    break;
1070
1815
  }
1079
1824
  signal_received = sig;
1080
1825
  int old_errno = errno;
1081
1826
  /* set main loop to exit */
1082
 
  if(mc.simple_poll != NULL){
1083
 
    avahi_simple_poll_quit(mc.simple_poll);
 
1827
  if(simple_poll != NULL){
 
1828
    avahi_simple_poll_quit(simple_poll);
1084
1829
  }
1085
1830
  errno = old_errno;
1086
1831
}
1087
1832
 
 
1833
__attribute__((nonnull, warn_unused_result))
 
1834
bool get_flags(const char *ifname, struct ifreq *ifr){
 
1835
  int ret;
 
1836
  int old_errno;
 
1837
  
 
1838
  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
1839
  if(s < 0){
 
1840
    old_errno = errno;
 
1841
    perror_plus("socket");
 
1842
    errno = old_errno;
 
1843
    return false;
 
1844
  }
 
1845
  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);
 
1846
  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */
 
1847
  ret = ioctl(s, SIOCGIFFLAGS, ifr);
 
1848
  if(ret == -1){
 
1849
    if(debug){
 
1850
      old_errno = errno;
 
1851
      perror_plus("ioctl SIOCGIFFLAGS");
 
1852
      errno = old_errno;
 
1853
    }
 
1854
    if((close(s) == -1) and debug){
 
1855
      old_errno = errno;
 
1856
      perror_plus("close");
 
1857
      errno = old_errno;
 
1858
    }
 
1859
    return false;
 
1860
  }
 
1861
  if((close(s) == -1) and debug){
 
1862
    old_errno = errno;
 
1863
    perror_plus("close");
 
1864
    errno = old_errno;
 
1865
  }
 
1866
  return true;
 
1867
}
 
1868
 
 
1869
__attribute__((nonnull, warn_unused_result))
 
1870
bool good_flags(const char *ifname, const struct ifreq *ifr){
 
1871
  
 
1872
  /* Reject the loopback device */
 
1873
  if(ifr->ifr_flags & IFF_LOOPBACK){
 
1874
    if(debug){
 
1875
      fprintf_plus(stderr, "Rejecting loopback interface \"%s\"\n",
 
1876
                   ifname);
 
1877
    }
 
1878
    return false;
 
1879
  }
 
1880
  /* Accept point-to-point devices only if connect_to is specified */
 
1881
  if(connect_to != NULL and (ifr->ifr_flags & IFF_POINTOPOINT)){
 
1882
    if(debug){
 
1883
      fprintf_plus(stderr, "Accepting point-to-point interface"
 
1884
                   " \"%s\"\n", ifname);
 
1885
    }
 
1886
    return true;
 
1887
  }
 
1888
  /* Otherwise, reject non-broadcast-capable devices */
 
1889
  if(not (ifr->ifr_flags & IFF_BROADCAST)){
 
1890
    if(debug){
 
1891
      fprintf_plus(stderr, "Rejecting non-broadcast interface"
 
1892
                   " \"%s\"\n", ifname);
 
1893
    }
 
1894
    return false;
 
1895
  }
 
1896
  /* Reject non-ARP interfaces (including dummy interfaces) */
 
1897
  if(ifr->ifr_flags & IFF_NOARP){
 
1898
    if(debug){
 
1899
      fprintf_plus(stderr, "Rejecting non-ARP interface \"%s\"\n",
 
1900
                   ifname);
 
1901
    }
 
1902
    return false;
 
1903
  }
 
1904
  
 
1905
  /* Accept this device */
 
1906
  if(debug){
 
1907
    fprintf_plus(stderr, "Interface \"%s\" is good\n", ifname);
 
1908
  }
 
1909
  return true;
 
1910
}
 
1911
 
1088
1912
/* 
1089
1913
 * This function determines if a directory entry in /sys/class/net
1090
1914
 * corresponds to an acceptable network device.
1091
1915
 * (This function is passed to scandir(3) as a filter function.)
1092
1916
 */
 
1917
__attribute__((nonnull, warn_unused_result))
1093
1918
int good_interface(const struct dirent *if_entry){
1094
 
  ssize_t ssret;
1095
 
  char *flagname = NULL;
1096
1919
  if(if_entry->d_name[0] == '.'){
1097
1920
    return 0;
1098
1921
  }
1099
 
  int ret = asprintf(&flagname, "%s/%s/flags", sys_class_net,
1100
 
                     if_entry->d_name);
1101
 
  if(ret < 0){
1102
 
    perror_plus("asprintf");
1103
 
    return 0;
1104
 
  }
1105
 
  int flags_fd = (int)TEMP_FAILURE_RETRY(open(flagname, O_RDONLY));
1106
 
  if(flags_fd == -1){
1107
 
    perror_plus("open");
1108
 
    free(flagname);
1109
 
    return 0;
1110
 
  }
1111
 
  free(flagname);
1112
 
  typedef short ifreq_flags;    /* ifreq.ifr_flags in netdevice(7) */
1113
 
  /* read line from flags_fd */
1114
 
  ssize_t to_read = 2+(sizeof(ifreq_flags)*2)+1; /* "0x1003\n" */
1115
 
  char *flagstring = malloc((size_t)to_read+1); /* +1 for final \0 */
1116
 
  flagstring[(size_t)to_read] = '\0';
1117
 
  if(flagstring == NULL){
1118
 
    perror_plus("malloc");
1119
 
    close(flags_fd);
1120
 
    return 0;
1121
 
  }
1122
 
  while(to_read > 0){
1123
 
    ssret = (ssize_t)TEMP_FAILURE_RETRY(read(flags_fd, flagstring,
1124
 
                                             (size_t)to_read));
1125
 
    if(ssret == -1){
1126
 
      perror_plus("read");
1127
 
      free(flagstring);
1128
 
      close(flags_fd);
1129
 
      return 0;
1130
 
    }
1131
 
    to_read -= ssret;
1132
 
    if(ssret == 0){
1133
 
      break;
1134
 
    }
1135
 
  }
1136
 
  close(flags_fd);
1137
 
  intmax_t tmpmax;
1138
 
  char *tmp;
1139
 
  errno = 0;
1140
 
  tmpmax = strtoimax(flagstring, &tmp, 0);
1141
 
  if(errno != 0 or tmp == flagstring or (*tmp != '\0'
1142
 
                                         and not (isspace(*tmp)))
1143
 
     or tmpmax != (ifreq_flags)tmpmax){
1144
 
    if(debug){
1145
 
      fprintf(stderr, "Invalid flags \"%s\" for interface \"%s\"\n",
1146
 
              flagstring, if_entry->d_name);
1147
 
    }
1148
 
    free(flagstring);
1149
 
    return 0;
1150
 
  }
1151
 
  free(flagstring);
1152
 
  ifreq_flags flags = (ifreq_flags)tmpmax;
1153
 
  /* Reject the loopback device */
1154
 
  if(flags & IFF_LOOPBACK){
1155
 
    if(debug){
1156
 
      fprintf(stderr, "Rejecting loopback interface \"%s\"\n",
1157
 
              if_entry->d_name);
1158
 
    }
1159
 
    return 0;
1160
 
  }
1161
 
  /* Accept point-to-point devices only if connect_to is specified */
1162
 
  if(connect_to != NULL and (flags & IFF_POINTOPOINT)){
1163
 
    if(debug){
1164
 
      fprintf(stderr, "Accepting point-to-point interface \"%s\"\n",
1165
 
              if_entry->d_name);
1166
 
    }
1167
 
    return 1;
1168
 
  }
1169
 
  /* Otherwise, reject non-broadcast-capable devices */
1170
 
  if(not (flags & IFF_BROADCAST)){
1171
 
    if(debug){
1172
 
      fprintf(stderr, "Rejecting non-broadcast interface \"%s\"\n",
1173
 
              if_entry->d_name);
1174
 
    }
1175
 
    return 0;
1176
 
  }
1177
 
  /* Reject non-ARP interfaces (including dummy interfaces) */
1178
 
  if(flags & IFF_NOARP){
1179
 
    if(debug){
1180
 
      fprintf(stderr, "Rejecting non-ARP interface \"%s\"\n",
1181
 
              if_entry->d_name);
1182
 
    }
1183
 
    return 0;
1184
 
  }
1185
 
  /* Accept this device */
1186
 
  if(debug){
1187
 
    fprintf(stderr, "Interface \"%s\" is acceptable\n",
1188
 
            if_entry->d_name);
 
1922
  
 
1923
  struct ifreq ifr;
 
1924
  if(not get_flags(if_entry->d_name, &ifr)){
 
1925
    if(debug){
 
1926
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1927
                   "\"%s\"\n", if_entry->d_name);
 
1928
    }
 
1929
    return 0;
 
1930
  }
 
1931
  
 
1932
  if(not good_flags(if_entry->d_name, &ifr)){
 
1933
    return 0;
1189
1934
  }
1190
1935
  return 1;
1191
1936
}
1192
1937
 
 
1938
/* 
 
1939
 * This function determines if a network interface is up.
 
1940
 */
 
1941
__attribute__((nonnull, warn_unused_result))
 
1942
bool interface_is_up(const char *interface){
 
1943
  struct ifreq ifr;
 
1944
  if(not get_flags(interface, &ifr)){
 
1945
    if(debug){
 
1946
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1947
                   "\"%s\"\n", interface);
 
1948
    }
 
1949
    return false;
 
1950
  }
 
1951
  
 
1952
  return (bool)(ifr.ifr_flags & IFF_UP);
 
1953
}
 
1954
 
 
1955
/* 
 
1956
 * This function determines if a network interface is running
 
1957
 */
 
1958
__attribute__((nonnull, warn_unused_result))
 
1959
bool interface_is_running(const char *interface){
 
1960
  struct ifreq ifr;
 
1961
  if(not get_flags(interface, &ifr)){
 
1962
    if(debug){
 
1963
      fprintf_plus(stderr, "Failed to get flags for interface "
 
1964
                   "\"%s\"\n", interface);
 
1965
    }
 
1966
    return false;
 
1967
  }
 
1968
  
 
1969
  return (bool)(ifr.ifr_flags & IFF_RUNNING);
 
1970
}
 
1971
 
 
1972
__attribute__((nonnull, pure, warn_unused_result))
1193
1973
int notdotentries(const struct dirent *direntry){
1194
1974
  /* Skip "." and ".." */
1195
1975
  if(direntry->d_name[0] == '.'
1201
1981
  return 1;
1202
1982
}
1203
1983
 
1204
 
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval){
 
1984
/* Is this directory entry a runnable program? */
 
1985
__attribute__((nonnull, warn_unused_result))
 
1986
int runnable_hook(const struct dirent *direntry){
 
1987
  int ret;
 
1988
  size_t sret;
 
1989
  struct stat st;
 
1990
  
 
1991
  if((direntry->d_name)[0] == '\0'){
 
1992
    /* Empty name? */
 
1993
    return 0;
 
1994
  }
 
1995
  
 
1996
  sret = strspn(direntry->d_name, "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 
1997
                "abcdefghijklmnopqrstuvwxyz"
 
1998
                "0123456789"
 
1999
                "_.-");
 
2000
  if((direntry->d_name)[sret] != '\0'){
 
2001
    /* Contains non-allowed characters */
 
2002
    if(debug){
 
2003
      fprintf_plus(stderr, "Ignoring hook \"%s\" with bad name\n",
 
2004
                   direntry->d_name);
 
2005
    }
 
2006
    return 0;
 
2007
  }
 
2008
  
 
2009
  ret = fstatat(hookdir_fd, direntry->d_name, &st, 0);
 
2010
  if(ret == -1){
 
2011
    if(debug){
 
2012
      perror_plus("Could not stat hook");
 
2013
    }
 
2014
    return 0;
 
2015
  }
 
2016
  if(not (S_ISREG(st.st_mode))){
 
2017
    /* Not a regular file */
 
2018
    if(debug){
 
2019
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not a file\n",
 
2020
                   direntry->d_name);
 
2021
    }
 
2022
    return 0;
 
2023
  }
 
2024
  if(not (st.st_mode & (S_IXUSR | S_IXGRP | S_IXOTH))){
 
2025
    /* Not executable */
 
2026
    if(debug){
 
2027
      fprintf_plus(stderr, "Ignoring hook \"%s\" - not executable\n",
 
2028
                   direntry->d_name);
 
2029
    }
 
2030
    return 0;
 
2031
  }
 
2032
  if(debug){
 
2033
    fprintf_plus(stderr, "Hook \"%s\" is acceptable\n",
 
2034
                 direntry->d_name);
 
2035
  }
 
2036
  return 1;
 
2037
}
 
2038
 
 
2039
__attribute__((nonnull, warn_unused_result))
 
2040
int avahi_loop_with_timeout(AvahiSimplePoll *s, int retry_interval,
 
2041
                            mandos_context *mc){
1205
2042
  int ret;
1206
2043
  struct timespec now;
1207
2044
  struct timespec waited_time;
1208
2045
  intmax_t block_time;
1209
2046
  
1210
2047
  while(true){
1211
 
    if(mc.current_server == NULL){
1212
 
      if (debug){
1213
 
        fprintf(stderr,
1214
 
                "Wait until first server is found. No timeout!\n");
 
2048
    if(mc->current_server == NULL){
 
2049
      if(debug){
 
2050
        fprintf_plus(stderr, "Wait until first server is found."
 
2051
                     " No timeout!\n");
1215
2052
      }
1216
2053
      ret = avahi_simple_poll_iterate(s, -1);
1217
2054
    } else {
1218
 
      if (debug){
1219
 
        fprintf(stderr, "Check current_server if we should run it,"
1220
 
                " or wait\n");
 
2055
      if(debug){
 
2056
        fprintf_plus(stderr, "Check current_server if we should run"
 
2057
                     " it, or wait\n");
1221
2058
      }
1222
2059
      /* the current time */
1223
2060
      ret = clock_gettime(CLOCK_MONOTONIC, &now);
1228
2065
      /* Calculating in ms how long time between now and server
1229
2066
         who we visted longest time ago. Now - last seen.  */
1230
2067
      waited_time.tv_sec = (now.tv_sec
1231
 
                            - mc.current_server->last_seen.tv_sec);
 
2068
                            - mc->current_server->last_seen.tv_sec);
1232
2069
      waited_time.tv_nsec = (now.tv_nsec
1233
 
                             - mc.current_server->last_seen.tv_nsec);
 
2070
                             - mc->current_server->last_seen.tv_nsec);
1234
2071
      /* total time is 10s/10,000ms.
1235
2072
         Converting to s from ms by dividing by 1,000,
1236
2073
         and ns to ms by dividing by 1,000,000. */
1238
2075
                     - ((intmax_t)waited_time.tv_sec * 1000))
1239
2076
                    - ((intmax_t)waited_time.tv_nsec / 1000000));
1240
2077
      
1241
 
      if (debug){
1242
 
        fprintf(stderr, "Blocking for %" PRIdMAX " ms\n", block_time);
 
2078
      if(debug){
 
2079
        fprintf_plus(stderr, "Blocking for %" PRIdMAX " ms\n",
 
2080
                     block_time);
1243
2081
      }
1244
2082
      
1245
2083
      if(block_time <= 0){
1246
 
        ret = start_mandos_communication(mc.current_server->ip,
1247
 
                                         mc.current_server->port,
1248
 
                                         mc.current_server->if_index,
1249
 
                                         mc.current_server->af);
 
2084
        ret = start_mandos_communication(mc->current_server->ip,
 
2085
                                         mc->current_server->port,
 
2086
                                         mc->current_server->if_index,
 
2087
                                         mc->current_server->af, mc);
1250
2088
        if(ret == 0){
1251
 
          avahi_simple_poll_quit(mc.simple_poll);
 
2089
          avahi_simple_poll_quit(s);
1252
2090
          return 0;
1253
2091
        }
1254
2092
        ret = clock_gettime(CLOCK_MONOTONIC,
1255
 
                            &mc.current_server->last_seen);
 
2093
                            &mc->current_server->last_seen);
1256
2094
        if(ret == -1){
1257
2095
          perror_plus("clock_gettime");
1258
2096
          return -1;
1259
2097
        }
1260
 
        mc.current_server = mc.current_server->next;
 
2098
        mc->current_server = mc->current_server->next;
1261
2099
        block_time = 0;         /* Call avahi to find new Mandos
1262
2100
                                   servers, but don't block */
1263
2101
      }
1265
2103
      ret = avahi_simple_poll_iterate(s, (int)block_time);
1266
2104
    }
1267
2105
    if(ret != 0){
1268
 
      if (ret > 0 or errno != EINTR) {
 
2106
      if(ret > 0 or errno != EINTR){
1269
2107
        return (ret != 1) ? ret : 0;
1270
2108
      }
1271
2109
    }
1272
2110
  }
1273
2111
}
1274
2112
 
 
2113
__attribute__((nonnull))
 
2114
void run_network_hooks(const char *mode, const char *interface,
 
2115
                       const float delay){
 
2116
  struct dirent **direntries = NULL;
 
2117
  if(hookdir_fd == -1){
 
2118
    hookdir_fd = open(hookdir, O_RDONLY | O_DIRECTORY | O_PATH
 
2119
                      | O_CLOEXEC);
 
2120
    if(hookdir_fd == -1){
 
2121
      if(errno == ENOENT){
 
2122
        if(debug){
 
2123
          fprintf_plus(stderr, "Network hook directory \"%s\" not"
 
2124
                       " found\n", hookdir);
 
2125
        }
 
2126
      } else {
 
2127
        perror_plus("open");
 
2128
      }
 
2129
      return;
 
2130
    }
 
2131
  }
 
2132
  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));
 
2133
  if(devnull == -1){
 
2134
    perror_plus("open(\"/dev/null\", O_RDONLY)");
 
2135
    return;
 
2136
  }
 
2137
  int numhooks = scandirat(hookdir_fd, ".", &direntries,
 
2138
                           runnable_hook, alphasort);
 
2139
  if(numhooks == -1){
 
2140
    perror_plus("scandir");
 
2141
    close(devnull);
 
2142
    return;
 
2143
  }
 
2144
  struct dirent *direntry;
 
2145
  int ret;
 
2146
  for(int i = 0; i < numhooks; i++){
 
2147
    direntry = direntries[i];
 
2148
    if(debug){
 
2149
      fprintf_plus(stderr, "Running network hook \"%s\"\n",
 
2150
                   direntry->d_name);
 
2151
    }
 
2152
    pid_t hook_pid = fork();
 
2153
    if(hook_pid == 0){
 
2154
      /* Child */
 
2155
      /* Raise privileges */
 
2156
      errno = raise_privileges_permanently();
 
2157
      if(errno != 0){
 
2158
        perror_plus("Failed to raise privileges");
 
2159
        _exit(EX_NOPERM);
 
2160
      }
 
2161
      /* Set group */
 
2162
      errno = 0;
 
2163
      ret = setgid(0);
 
2164
      if(ret == -1){
 
2165
        perror_plus("setgid");
 
2166
        _exit(EX_NOPERM);
 
2167
      }
 
2168
      /* Reset supplementary groups */
 
2169
      errno = 0;
 
2170
      ret = setgroups(0, NULL);
 
2171
      if(ret == -1){
 
2172
        perror_plus("setgroups");
 
2173
        _exit(EX_NOPERM);
 
2174
      }
 
2175
      ret = setenv("MANDOSNETHOOKDIR", hookdir, 1);
 
2176
      if(ret == -1){
 
2177
        perror_plus("setenv");
 
2178
        _exit(EX_OSERR);
 
2179
      }
 
2180
      ret = setenv("DEVICE", interface, 1);
 
2181
      if(ret == -1){
 
2182
        perror_plus("setenv");
 
2183
        _exit(EX_OSERR);
 
2184
      }
 
2185
      ret = setenv("VERBOSITY", debug ? "1" : "0", 1);
 
2186
      if(ret == -1){
 
2187
        perror_plus("setenv");
 
2188
        _exit(EX_OSERR);
 
2189
      }
 
2190
      ret = setenv("MODE", mode, 1);
 
2191
      if(ret == -1){
 
2192
        perror_plus("setenv");
 
2193
        _exit(EX_OSERR);
 
2194
      }
 
2195
      char *delaystring;
 
2196
      ret = asprintf(&delaystring, "%f", (double)delay);
 
2197
      if(ret == -1){
 
2198
        perror_plus("asprintf");
 
2199
        _exit(EX_OSERR);
 
2200
      }
 
2201
      ret = setenv("DELAY", delaystring, 1);
 
2202
      if(ret == -1){
 
2203
        free(delaystring);
 
2204
        perror_plus("setenv");
 
2205
        _exit(EX_OSERR);
 
2206
      }
 
2207
      free(delaystring);
 
2208
      if(connect_to != NULL){
 
2209
        ret = setenv("CONNECT", connect_to, 1);
 
2210
        if(ret == -1){
 
2211
          perror_plus("setenv");
 
2212
          _exit(EX_OSERR);
 
2213
        }
 
2214
      }
 
2215
      int hook_fd = (int)TEMP_FAILURE_RETRY(openat(hookdir_fd,
 
2216
                                                   direntry->d_name,
 
2217
                                                   O_RDONLY));
 
2218
      if(hook_fd == -1){
 
2219
        perror_plus("openat");
 
2220
        _exit(EXIT_FAILURE);
 
2221
      }
 
2222
      if(close(hookdir_fd) == -1){
 
2223
        perror_plus("close");
 
2224
        _exit(EXIT_FAILURE);
 
2225
      }
 
2226
      ret = dup2(devnull, STDIN_FILENO);
 
2227
      if(ret == -1){
 
2228
        perror_plus("dup2(devnull, STDIN_FILENO)");
 
2229
        _exit(EX_OSERR);
 
2230
      }
 
2231
      ret = close(devnull);
 
2232
      if(ret == -1){
 
2233
        perror_plus("close");
 
2234
        _exit(EX_OSERR);
 
2235
      }
 
2236
      ret = dup2(STDERR_FILENO, STDOUT_FILENO);
 
2237
      if(ret == -1){
 
2238
        perror_plus("dup2(STDERR_FILENO, STDOUT_FILENO)");
 
2239
        _exit(EX_OSERR);
 
2240
      }
 
2241
      if(fexecve(hook_fd, (char *const []){ direntry->d_name, NULL },
 
2242
                 environ) == -1){
 
2243
        perror_plus("fexecve");
 
2244
        _exit(EXIT_FAILURE);
 
2245
      }
 
2246
    } else {
 
2247
      if(hook_pid == -1){
 
2248
        perror_plus("fork");
 
2249
        free(direntry);
 
2250
        continue;
 
2251
      }
 
2252
      int status;
 
2253
      if(TEMP_FAILURE_RETRY(waitpid(hook_pid, &status, 0)) == -1){
 
2254
        perror_plus("waitpid");
 
2255
        free(direntry);
 
2256
        continue;
 
2257
      }
 
2258
      if(WIFEXITED(status)){
 
2259
        if(WEXITSTATUS(status) != 0){
 
2260
          fprintf_plus(stderr, "Warning: network hook \"%s\" exited"
 
2261
                       " with status %d\n", direntry->d_name,
 
2262
                       WEXITSTATUS(status));
 
2263
          free(direntry);
 
2264
          continue;
 
2265
        }
 
2266
      } else if(WIFSIGNALED(status)){
 
2267
        fprintf_plus(stderr, "Warning: network hook \"%s\" died by"
 
2268
                     " signal %d\n", direntry->d_name,
 
2269
                     WTERMSIG(status));
 
2270
        free(direntry);
 
2271
        continue;
 
2272
      } else {
 
2273
        fprintf_plus(stderr, "Warning: network hook \"%s\""
 
2274
                     " crashed\n", direntry->d_name);
 
2275
        free(direntry);
 
2276
        continue;
 
2277
      }
 
2278
    }
 
2279
    if(debug){
 
2280
      fprintf_plus(stderr, "Network hook \"%s\" ran successfully\n",
 
2281
                   direntry->d_name);
 
2282
    }
 
2283
    free(direntry);
 
2284
  }
 
2285
  free(direntries);
 
2286
  if(close(hookdir_fd) == -1){
 
2287
    perror_plus("close");
 
2288
  } else {
 
2289
    hookdir_fd = -1;
 
2290
  }
 
2291
  close(devnull);
 
2292
}
 
2293
 
 
2294
__attribute__((nonnull, warn_unused_result))
 
2295
int bring_up_interface(const char *const interface,
 
2296
                       const float delay){
 
2297
  int old_errno = errno;
 
2298
  int ret;
 
2299
  struct ifreq network;
 
2300
  unsigned int if_index = if_nametoindex(interface);
 
2301
  if(if_index == 0){
 
2302
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
2303
    errno = old_errno;
 
2304
    return ENXIO;
 
2305
  }
 
2306
  
 
2307
  if(quit_now){
 
2308
    errno = old_errno;
 
2309
    return EINTR;
 
2310
  }
 
2311
  
 
2312
  if(not interface_is_up(interface)){
 
2313
    int ret_errno = 0;
 
2314
    int ioctl_errno = 0;
 
2315
    if(not get_flags(interface, &network)){
 
2316
      ret_errno = errno;
 
2317
      fprintf_plus(stderr, "Failed to get flags for interface "
 
2318
                   "\"%s\"\n", interface);
 
2319
      errno = old_errno;
 
2320
      return ret_errno;
 
2321
    }
 
2322
    network.ifr_flags |= IFF_UP; /* set flag */
 
2323
    
 
2324
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2325
    if(sd == -1){
 
2326
      ret_errno = errno;
 
2327
      perror_plus("socket");
 
2328
      errno = old_errno;
 
2329
      return ret_errno;
 
2330
    }
 
2331
    
 
2332
    if(quit_now){
 
2333
      ret = close(sd);
 
2334
      if(ret == -1){
 
2335
        perror_plus("close");
 
2336
      }
 
2337
      errno = old_errno;
 
2338
      return EINTR;
 
2339
    }
 
2340
    
 
2341
    if(debug){
 
2342
      fprintf_plus(stderr, "Bringing up interface \"%s\"\n",
 
2343
                   interface);
 
2344
    }
 
2345
    
 
2346
    /* Raise privileges */
 
2347
    ret_errno = raise_privileges();
 
2348
    if(ret_errno != 0){
 
2349
      errno = ret_errno;
 
2350
      perror_plus("Failed to raise privileges");
 
2351
    }
 
2352
    
 
2353
#ifdef __linux__
 
2354
    int ret_linux;
 
2355
    bool restore_loglevel = false;
 
2356
    if(ret_errno == 0){
 
2357
      /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
 
2358
         messages about the network interface to mess up the prompt */
 
2359
      ret_linux = klogctl(8, NULL, 5);
 
2360
      if(ret_linux == -1){
 
2361
        perror_plus("klogctl");
 
2362
      } else {
 
2363
        restore_loglevel = true;
 
2364
      }
 
2365
    }
 
2366
#endif  /* __linux__ */
 
2367
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2368
    ioctl_errno = errno;
 
2369
#ifdef __linux__
 
2370
    if(restore_loglevel){
 
2371
      ret_linux = klogctl(7, NULL, 0);
 
2372
      if(ret_linux == -1){
 
2373
        perror_plus("klogctl");
 
2374
      }
 
2375
    }
 
2376
#endif  /* __linux__ */
 
2377
    
 
2378
    /* If raise_privileges() succeeded above */
 
2379
    if(ret_errno == 0){
 
2380
      /* Lower privileges */
 
2381
      ret_errno = lower_privileges();
 
2382
      if(ret_errno != 0){
 
2383
        errno = ret_errno;
 
2384
        perror_plus("Failed to lower privileges");
 
2385
      }
 
2386
    }
 
2387
    
 
2388
    /* Close the socket */
 
2389
    ret = close(sd);
 
2390
    if(ret == -1){
 
2391
      perror_plus("close");
 
2392
    }
 
2393
    
 
2394
    if(ret_setflags == -1){
 
2395
      errno = ioctl_errno;
 
2396
      perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
 
2397
      errno = old_errno;
 
2398
      return ioctl_errno;
 
2399
    }
 
2400
  } else if(debug){
 
2401
    fprintf_plus(stderr, "Interface \"%s\" is already up; good\n",
 
2402
                 interface);
 
2403
  }
 
2404
  
 
2405
  /* Sleep checking until interface is running.
 
2406
     Check every 0.25s, up to total time of delay */
 
2407
  for(int i = 0; i < delay * 4; i++){
 
2408
    if(interface_is_running(interface)){
 
2409
      break;
 
2410
    }
 
2411
    struct timespec sleeptime = { .tv_nsec = 250000000 };
 
2412
    ret = nanosleep(&sleeptime, NULL);
 
2413
    if(ret == -1 and errno != EINTR){
 
2414
      perror_plus("nanosleep");
 
2415
    }
 
2416
  }
 
2417
  
 
2418
  errno = old_errno;
 
2419
  return 0;
 
2420
}
 
2421
 
 
2422
__attribute__((nonnull, warn_unused_result))
 
2423
int take_down_interface(const char *const interface){
 
2424
  int old_errno = errno;
 
2425
  struct ifreq network;
 
2426
  unsigned int if_index = if_nametoindex(interface);
 
2427
  if(if_index == 0){
 
2428
    fprintf_plus(stderr, "No such interface: \"%s\"\n", interface);
 
2429
    errno = old_errno;
 
2430
    return ENXIO;
 
2431
  }
 
2432
  if(interface_is_up(interface)){
 
2433
    int ret_errno = 0;
 
2434
    int ioctl_errno = 0;
 
2435
    if(not get_flags(interface, &network) and debug){
 
2436
      ret_errno = errno;
 
2437
      fprintf_plus(stderr, "Failed to get flags for interface "
 
2438
                   "\"%s\"\n", interface);
 
2439
      errno = old_errno;
 
2440
      return ret_errno;
 
2441
    }
 
2442
    network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
 
2443
    
 
2444
    int sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
 
2445
    if(sd == -1){
 
2446
      ret_errno = errno;
 
2447
      perror_plus("socket");
 
2448
      errno = old_errno;
 
2449
      return ret_errno;
 
2450
    }
 
2451
    
 
2452
    if(debug){
 
2453
      fprintf_plus(stderr, "Taking down interface \"%s\"\n",
 
2454
                   interface);
 
2455
    }
 
2456
    
 
2457
    /* Raise privileges */
 
2458
    ret_errno = raise_privileges();
 
2459
    if(ret_errno != 0){
 
2460
      errno = ret_errno;
 
2461
      perror_plus("Failed to raise privileges");
 
2462
    }
 
2463
    
 
2464
    int ret_setflags = ioctl(sd, SIOCSIFFLAGS, &network);
 
2465
    ioctl_errno = errno;
 
2466
    
 
2467
    /* If raise_privileges() succeeded above */
 
2468
    if(ret_errno == 0){
 
2469
      /* Lower privileges */
 
2470
      ret_errno = lower_privileges();
 
2471
      if(ret_errno != 0){
 
2472
        errno = ret_errno;
 
2473
        perror_plus("Failed to lower privileges");
 
2474
      }
 
2475
    }
 
2476
    
 
2477
    /* Close the socket */
 
2478
    int ret = close(sd);
 
2479
    if(ret == -1){
 
2480
      perror_plus("close");
 
2481
    }
 
2482
    
 
2483
    if(ret_setflags == -1){
 
2484
      errno = ioctl_errno;
 
2485
      perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
 
2486
      errno = old_errno;
 
2487
      return ioctl_errno;
 
2488
    }
 
2489
  } else if(debug){
 
2490
    fprintf_plus(stderr, "Interface \"%s\" is already down; odd\n",
 
2491
                 interface);
 
2492
  }
 
2493
  
 
2494
  errno = old_errno;
 
2495
  return 0;
 
2496
}
 
2497
 
1275
2498
int main(int argc, char *argv[]){
 
2499
  mandos_context mc = { .server = NULL, .dh_bits = 0,
 
2500
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2501
                        .priority = "SECURE128:!CTYPE-X.509"
 
2502
                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"
 
2503
                        ":%PROFILE_ULTRA",
 
2504
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
2505
                        .priority = "SECURE256:!CTYPE-X.509"
 
2506
                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",
 
2507
#else
 
2508
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
2509
#endif
 
2510
                        .current_server = NULL, .interfaces = NULL,
 
2511
                        .interfaces_size = 0 };
1276
2512
  AvahiSServiceBrowser *sb = NULL;
1277
 
  int error;
 
2513
  error_t ret_errno;
1278
2514
  int ret;
1279
2515
  intmax_t tmpmax;
1280
2516
  char *tmp;
1281
2517
  int exitcode = EXIT_SUCCESS;
1282
 
  const char *interface = "";
1283
 
  struct ifreq network;
1284
 
  int sd = -1;
1285
 
  bool take_down_interface = false;
1286
 
  uid_t uid;
1287
 
  gid_t gid;
1288
 
  char tempdir[] = "/tmp/mandosXXXXXX";
1289
 
  bool tempdir_created = false;
 
2518
  char *interfaces_to_take_down = NULL;
 
2519
  size_t interfaces_to_take_down_size = 0;
 
2520
  char run_tempdir[] = "/run/tmp/mandosXXXXXX";
 
2521
  char old_tempdir[] = "/tmp/mandosXXXXXX";
 
2522
  char *tempdir = NULL;
1290
2523
  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;
1291
2524
  const char *seckey = PATHDIR "/" SECKEY;
1292
2525
  const char *pubkey = PATHDIR "/" PUBKEY;
 
2526
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2527
  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;
 
2528
  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;
 
2529
#endif
 
2530
  const char *dh_params_file = NULL;
 
2531
  char *interfaces_hooks = NULL;
1293
2532
  
1294
2533
  bool gnutls_initialized = false;
1295
2534
  bool gpgme_initialized = false;
1341
2580
      { .name = "pubkey", .key = 'p',
1342
2581
        .arg = "FILE",
1343
2582
        .doc = "OpenPGP public key file base name",
1344
 
        .group = 2 },
 
2583
        .group = 1 },
 
2584
      { .name = "tls-privkey", .key = 't',
 
2585
        .arg = "FILE",
 
2586
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2587
        .doc = "TLS private key file base name",
 
2588
#else
 
2589
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2590
#endif
 
2591
        .group = 1 },
 
2592
      { .name = "tls-pubkey", .key = 'T',
 
2593
        .arg = "FILE",
 
2594
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2595
        .doc = "TLS public key file base name",
 
2596
#else
 
2597
        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",
 
2598
#endif
 
2599
        .group = 1 },
1345
2600
      { .name = "dh-bits", .key = 129,
1346
2601
        .arg = "BITS",
1347
2602
        .doc = "Bit length of the prime number used in the"
1348
2603
        " Diffie-Hellman key exchange",
1349
2604
        .group = 2 },
 
2605
      { .name = "dh-params", .key = 134,
 
2606
        .arg = "FILE",
 
2607
        .doc = "PEM-encoded PKCS#3 file with pre-generated parameters"
 
2608
        " for the Diffie-Hellman key exchange",
 
2609
        .group = 2 },
1350
2610
      { .name = "priority", .key = 130,
1351
2611
        .arg = "STRING",
1352
2612
        .doc = "GnuTLS priority string for the TLS handshake",
1357
2617
        .group = 2 },
1358
2618
      { .name = "retry", .key = 132,
1359
2619
        .arg = "SECONDS",
1360
 
        .doc = "Retry interval used when denied by the mandos server",
 
2620
        .doc = "Retry interval used when denied by the Mandos server",
 
2621
        .group = 2 },
 
2622
      { .name = "network-hook-dir", .key = 133,
 
2623
        .arg = "DIR",
 
2624
        .doc = "Directory where network hooks are located",
1361
2625
        .group = 2 },
1362
2626
      /*
1363
2627
       * These reproduce what we would get without ARGP_NO_HELP
1382
2646
        connect_to = arg;
1383
2647
        break;
1384
2648
      case 'i':                 /* --interface */
1385
 
        interface = arg;
 
2649
        ret_errno = argz_add_sep(&mc.interfaces, &mc.interfaces_size,
 
2650
                                 arg, (int)',');
 
2651
        if(ret_errno != 0){
 
2652
          argp_error(state, "%s", strerror(ret_errno));
 
2653
        }
1386
2654
        break;
1387
2655
      case 's':                 /* --seckey */
1388
2656
        seckey = arg;
1390
2658
      case 'p':                 /* --pubkey */
1391
2659
        pubkey = arg;
1392
2660
        break;
 
2661
      case 't':                 /* --tls-privkey */
 
2662
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2663
        tls_privkey = arg;
 
2664
#endif
 
2665
        break;
 
2666
      case 'T':                 /* --tls-pubkey */
 
2667
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
2668
        tls_pubkey = arg;
 
2669
#endif
 
2670
        break;
1393
2671
      case 129:                 /* --dh-bits */
1394
2672
        errno = 0;
1395
2673
        tmpmax = strtoimax(arg, &tmp, 10);
1399
2677
        }
1400
2678
        mc.dh_bits = (typeof(mc.dh_bits))tmpmax;
1401
2679
        break;
 
2680
      case 134:                 /* --dh-params */
 
2681
        dh_params_file = arg;
 
2682
        break;
1402
2683
      case 130:                 /* --priority */
1403
2684
        mc.priority = arg;
1404
2685
        break;
1417
2698
          argp_error(state, "Bad retry interval");
1418
2699
        }
1419
2700
        break;
 
2701
      case 133:                 /* --network-hook-dir */
 
2702
        hookdir = arg;
 
2703
        break;
1420
2704
        /*
1421
2705
         * These reproduce what we would get without ARGP_NO_HELP
1422
2706
         */
1424
2708
        argp_state_help(state, state->out_stream,
1425
2709
                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)
1426
2710
                        & ~(unsigned int)ARGP_HELP_EXIT_OK);
 
2711
        __builtin_unreachable();
1427
2712
      case -3:                  /* --usage */
1428
2713
        argp_state_help(state, state->out_stream,
1429
2714
                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);
 
2715
        __builtin_unreachable();
1430
2716
      case 'V':                 /* --version */
1431
 
        fprintf(state->out_stream, "%s\n", argp_program_version);
 
2717
        fprintf_plus(state->out_stream, "%s\n", argp_program_version);
1432
2718
        exit(argp_err_exit_status);
1433
2719
        break;
1434
2720
      default:
1441
2727
                         .args_doc = "",
1442
2728
                         .doc = "Mandos client -- Get and decrypt"
1443
2729
                         " passwords from a Mandos server" };
1444
 
    ret = argp_parse(&argp, argc, argv,
1445
 
                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
1446
 
    switch(ret){
 
2730
    ret_errno = argp_parse(&argp, argc, argv,
 
2731
                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);
 
2732
    switch(ret_errno){
1447
2733
    case 0:
1448
2734
      break;
1449
2735
    case ENOMEM:
1450
2736
    default:
1451
 
      errno = ret;
 
2737
      errno = ret_errno;
1452
2738
      perror_plus("argp_parse");
1453
2739
      exitcode = EX_OSERR;
1454
2740
      goto end;
1457
2743
      goto end;
1458
2744
    }
1459
2745
  }
1460
 
    
1461
 
  {
1462
 
    /* Work around Debian bug #633582:
1463
 
       <http://bugs.debian.org/633582> */
1464
 
    struct stat st;
1465
 
    
1466
 
    /* Re-raise priviliges */
1467
 
    errno = 0;
1468
 
    ret = seteuid(0);
1469
 
    if(ret == -1){
1470
 
      perror_plus("seteuid");
1471
 
    }
1472
 
    
1473
 
    if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
1474
 
      int seckey_fd = open(seckey, O_RDONLY);
1475
 
      if(seckey_fd == -1){
1476
 
        perror_plus("open");
1477
 
      } else {
1478
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
1479
 
        if(ret == -1){
1480
 
          perror_plus("fstat");
1481
 
        } else {
1482
 
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1483
 
            ret = fchown(seckey_fd, uid, gid);
1484
 
            if(ret == -1){
1485
 
              perror_plus("fchown");
1486
 
            }
1487
 
          }
1488
 
        }
1489
 
        TEMP_FAILURE_RETRY(close(seckey_fd));
1490
 
      }
1491
 
    }
1492
 
    
1493
 
    if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
1494
 
      int pubkey_fd = open(pubkey, O_RDONLY);
1495
 
      if(pubkey_fd == -1){
1496
 
        perror_plus("open");
1497
 
      } else {
1498
 
        ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
1499
 
        if(ret == -1){
1500
 
          perror_plus("fstat");
1501
 
        } else {
1502
 
          if(S_ISREG(st.st_mode) and st.st_uid == 0 and st.st_gid == 0){
1503
 
            ret = fchown(pubkey_fd, uid, gid);
1504
 
            if(ret == -1){
1505
 
              perror_plus("fchown");
1506
 
            }
1507
 
          }
1508
 
        }
1509
 
        TEMP_FAILURE_RETRY(close(pubkey_fd));
1510
 
      }
1511
 
    }
1512
 
    
1513
 
    /* Lower privileges */
1514
 
    errno = 0;
1515
 
    ret = seteuid(uid);
1516
 
    if(ret == -1){
1517
 
      perror_plus("seteuid");
1518
 
    }
 
2746
  
 
2747
  {
 
2748
    /* Re-raise privileges */
 
2749
    ret = raise_privileges();
 
2750
    if(ret != 0){
 
2751
      errno = ret;
 
2752
      perror_plus("Failed to raise privileges");
 
2753
    } else {
 
2754
      struct stat st;
 
2755
      
 
2756
      /* Work around Debian bug #633582:
 
2757
         <https://bugs.debian.org/633582> */
 
2758
 
 
2759
      if(strcmp(seckey, PATHDIR "/" SECKEY) == 0){
 
2760
        int seckey_fd = open(seckey, O_RDONLY);
 
2761
        if(seckey_fd == -1){
 
2762
          perror_plus("open");
 
2763
        } else {
 
2764
          ret = (int)TEMP_FAILURE_RETRY(fstat(seckey_fd, &st));
 
2765
          if(ret == -1){
 
2766
            perror_plus("fstat");
 
2767
          } else {
 
2768
            if(S_ISREG(st.st_mode)
 
2769
               and st.st_uid == 0 and st.st_gid == 0){
 
2770
              ret = fchown(seckey_fd, uid, gid);
 
2771
              if(ret == -1){
 
2772
                perror_plus("fchown");
 
2773
              }
 
2774
            }
 
2775
          }
 
2776
          close(seckey_fd);
 
2777
        }
 
2778
      }
 
2779
      
 
2780
      if(strcmp(pubkey, PATHDIR "/" PUBKEY) == 0){
 
2781
        int pubkey_fd = open(pubkey, O_RDONLY);
 
2782
        if(pubkey_fd == -1){
 
2783
          perror_plus("open");
 
2784
        } else {
 
2785
          ret = (int)TEMP_FAILURE_RETRY(fstat(pubkey_fd, &st));
 
2786
          if(ret == -1){
 
2787
            perror_plus("fstat");
 
2788
          } else {
 
2789
            if(S_ISREG(st.st_mode)
 
2790
               and st.st_uid == 0 and st.st_gid == 0){
 
2791
              ret = fchown(pubkey_fd, uid, gid);
 
2792
              if(ret == -1){
 
2793
                perror_plus("fchown");
 
2794
              }
 
2795
            }
 
2796
          }
 
2797
          close(pubkey_fd);
 
2798
        }
 
2799
      }
 
2800
      
 
2801
      if(dh_params_file != NULL
 
2802
         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){
 
2803
        int dhparams_fd = open(dh_params_file, O_RDONLY);
 
2804
        if(dhparams_fd == -1){
 
2805
          perror_plus("open");
 
2806
        } else {
 
2807
          ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));
 
2808
          if(ret == -1){
 
2809
            perror_plus("fstat");
 
2810
          } else {
 
2811
            if(S_ISREG(st.st_mode)
 
2812
               and st.st_uid == 0 and st.st_gid == 0){
 
2813
              ret = fchown(dhparams_fd, uid, gid);
 
2814
              if(ret == -1){
 
2815
                perror_plus("fchown");
 
2816
              }
 
2817
            }
 
2818
          }
 
2819
          close(dhparams_fd);
 
2820
        }
 
2821
      }
 
2822
      
 
2823
      /* Work around Debian bug #981302
 
2824
         <https://bugs.debian.org/981302> */
 
2825
      if(lstat("/dev/fd", &st) != 0 and errno == ENOENT){
 
2826
        ret = symlink("/proc/self/fd", "/dev/fd");
 
2827
        if(ret == -1){
 
2828
          perror_plus("Failed to create /dev/fd symlink");
 
2829
        }
 
2830
      }
 
2831
 
 
2832
      /* Lower privileges */
 
2833
      ret = lower_privileges();
 
2834
      if(ret != 0){
 
2835
        errno = ret;
 
2836
        perror_plus("Failed to lower privileges");
 
2837
      }
 
2838
    }
 
2839
  }
 
2840
  
 
2841
  /* Remove invalid interface names (except "none") */
 
2842
  {
 
2843
    char *interface = NULL;
 
2844
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2845
                                 interface))){
 
2846
      if(strcmp(interface, "none") != 0
 
2847
         and if_nametoindex(interface) == 0){
 
2848
        if(interface[0] != '\0'){
 
2849
          fprintf_plus(stderr, "Not using nonexisting interface"
 
2850
                       " \"%s\"\n", interface);
 
2851
        }
 
2852
        argz_delete(&mc.interfaces, &mc.interfaces_size, interface);
 
2853
        interface = NULL;
 
2854
      }
 
2855
    }
 
2856
  }
 
2857
  
 
2858
  /* Run network hooks */
 
2859
  {
 
2860
    if(mc.interfaces != NULL){
 
2861
      interfaces_hooks = malloc(mc.interfaces_size);
 
2862
      if(interfaces_hooks == NULL){
 
2863
        perror_plus("malloc");
 
2864
        goto end;
 
2865
      }
 
2866
      memcpy(interfaces_hooks, mc.interfaces, mc.interfaces_size);
 
2867
      argz_stringify(interfaces_hooks, mc.interfaces_size, (int)',');
 
2868
    }
 
2869
    run_network_hooks("start", interfaces_hooks != NULL ?
 
2870
                      interfaces_hooks : "", delay);
1519
2871
  }
1520
2872
  
1521
2873
  if(not debug){
1522
2874
    avahi_set_log_function(empty_log);
1523
2875
  }
1524
 
 
1525
 
  if(interface[0] == '\0'){
1526
 
    struct dirent **direntries;
1527
 
    ret = scandir(sys_class_net, &direntries, good_interface,
1528
 
                  alphasort);
1529
 
    if(ret >= 1){
1530
 
      /* Pick the first good interface */
1531
 
      interface = strdup(direntries[0]->d_name);
1532
 
      if(debug){
1533
 
        fprintf(stderr, "Using interface \"%s\"\n", interface);
1534
 
      }
1535
 
      if(interface == NULL){
1536
 
        perror_plus("malloc");
1537
 
        free(direntries);
1538
 
        exitcode = EXIT_FAILURE;
1539
 
        goto end;
1540
 
      }
1541
 
      free(direntries);
1542
 
    } else {
1543
 
      free(direntries);
1544
 
      fprintf(stderr, "Could not find a network interface\n");
1545
 
      exitcode = EXIT_FAILURE;
1546
 
      goto end;
1547
 
    }
1548
 
  }
1549
2876
  
1550
2877
  /* Initialize Avahi early so avahi_simple_poll_quit() can be called
1551
2878
     from the signal handler */
1552
2879
  /* Initialize the pseudo-RNG for Avahi */
1553
2880
  srand((unsigned int) time(NULL));
1554
 
  mc.simple_poll = avahi_simple_poll_new();
1555
 
  if(mc.simple_poll == NULL){
1556
 
    fprintf(stderr, "Avahi: Failed to create simple poll object.\n");
 
2881
  simple_poll = avahi_simple_poll_new();
 
2882
  if(simple_poll == NULL){
 
2883
    fprintf_plus(stderr,
 
2884
                 "Avahi: Failed to create simple poll object.\n");
1557
2885
    exitcode = EX_UNAVAILABLE;
1558
2886
    goto end;
1559
2887
  }
1621
2949
    }
1622
2950
  }
1623
2951
  
1624
 
  /* If the interface is down, bring it up */
1625
 
  if(strcmp(interface, "none") != 0){
1626
 
    if_index = (AvahiIfIndex) if_nametoindex(interface);
1627
 
    if(if_index == 0){
1628
 
      fprintf(stderr, "No such interface: \"%s\"\n", interface);
1629
 
      exitcode = EX_UNAVAILABLE;
1630
 
      goto end;
1631
 
    }
1632
 
    
1633
 
    if(quit_now){
1634
 
      goto end;
1635
 
    }
1636
 
    
1637
 
    /* Re-raise priviliges */
1638
 
    errno = 0;
1639
 
    ret = seteuid(0);
1640
 
    if(ret == -1){
1641
 
      perror_plus("seteuid");
1642
 
    }
1643
 
    
1644
 
#ifdef __linux__
1645
 
    /* Lower kernel loglevel to KERN_NOTICE to avoid KERN_INFO
1646
 
       messages about the network interface to mess up the prompt */
1647
 
    ret = klogctl(8, NULL, 5);
1648
 
    bool restore_loglevel = true;
1649
 
    if(ret == -1){
1650
 
      restore_loglevel = false;
1651
 
      perror_plus("klogctl");
1652
 
    }
1653
 
#endif  /* __linux__ */
1654
 
    
1655
 
    sd = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);
1656
 
    if(sd < 0){
1657
 
      perror_plus("socket");
1658
 
      exitcode = EX_OSERR;
1659
 
#ifdef __linux__
1660
 
      if(restore_loglevel){
1661
 
        ret = klogctl(7, NULL, 0);
1662
 
        if(ret == -1){
1663
 
          perror_plus("klogctl");
1664
 
        }
1665
 
      }
1666
 
#endif  /* __linux__ */
1667
 
      /* Lower privileges */
1668
 
      errno = 0;
1669
 
      ret = seteuid(uid);
1670
 
      if(ret == -1){
1671
 
        perror_plus("seteuid");
1672
 
      }
1673
 
      goto end;
1674
 
    }
1675
 
    strcpy(network.ifr_name, interface);
1676
 
    ret = ioctl(sd, SIOCGIFFLAGS, &network);
1677
 
    if(ret == -1){
1678
 
      perror_plus("ioctl SIOCGIFFLAGS");
1679
 
#ifdef __linux__
1680
 
      if(restore_loglevel){
1681
 
        ret = klogctl(7, NULL, 0);
1682
 
        if(ret == -1){
1683
 
          perror_plus("klogctl");
1684
 
        }
1685
 
      }
1686
 
#endif  /* __linux__ */
1687
 
      exitcode = EX_OSERR;
1688
 
      /* Lower privileges */
1689
 
      errno = 0;
1690
 
      ret = seteuid(uid);
1691
 
      if(ret == -1){
1692
 
        perror_plus("seteuid");
1693
 
      }
1694
 
      goto end;
1695
 
    }
1696
 
    if((network.ifr_flags & IFF_UP) == 0){
1697
 
      network.ifr_flags |= IFF_UP;
1698
 
      take_down_interface = true;
1699
 
      ret = ioctl(sd, SIOCSIFFLAGS, &network);
1700
 
      if(ret == -1){
1701
 
        take_down_interface = false;
1702
 
        perror_plus("ioctl SIOCSIFFLAGS +IFF_UP");
1703
 
        exitcode = EX_OSERR;
1704
 
#ifdef __linux__
1705
 
        if(restore_loglevel){
1706
 
          ret = klogctl(7, NULL, 0);
1707
 
          if(ret == -1){
1708
 
            perror_plus("klogctl");
 
2952
  /* If no interfaces were specified, make a list */
 
2953
  if(mc.interfaces == NULL){
 
2954
    struct dirent **direntries = NULL;
 
2955
    /* Look for any good interfaces */
 
2956
    ret = scandir(sys_class_net, &direntries, good_interface,
 
2957
                  alphasort);
 
2958
    if(ret >= 1){
 
2959
      /* Add all found interfaces to interfaces list */
 
2960
      for(int i = 0; i < ret; ++i){
 
2961
        ret_errno = argz_add(&mc.interfaces, &mc.interfaces_size,
 
2962
                             direntries[i]->d_name);
 
2963
        if(ret_errno != 0){
 
2964
          errno = ret_errno;
 
2965
          perror_plus("argz_add");
 
2966
          free(direntries[i]);
 
2967
          continue;
 
2968
        }
 
2969
        if(debug){
 
2970
          fprintf_plus(stderr, "Will use interface \"%s\"\n",
 
2971
                       direntries[i]->d_name);
 
2972
        }
 
2973
        free(direntries[i]);
 
2974
      }
 
2975
      free(direntries);
 
2976
    } else {
 
2977
      if(ret == 0){
 
2978
        free(direntries);
 
2979
      }
 
2980
      fprintf_plus(stderr, "Could not find a network interface\n");
 
2981
      exitcode = EXIT_FAILURE;
 
2982
      goto end;
 
2983
    }
 
2984
  }
 
2985
  
 
2986
  /* Bring up interfaces which are down, and remove any "none"s */
 
2987
  {
 
2988
    char *interface = NULL;
 
2989
    while((interface = argz_next(mc.interfaces, mc.interfaces_size,
 
2990
                                 interface))){
 
2991
      /* If interface name is "none", stop bringing up interfaces.
 
2992
         Also remove all instances of "none" from the list */
 
2993
      if(strcmp(interface, "none") == 0){
 
2994
        argz_delete(&mc.interfaces, &mc.interfaces_size,
 
2995
                    interface);
 
2996
        interface = NULL;
 
2997
        while((interface = argz_next(mc.interfaces,
 
2998
                                     mc.interfaces_size, interface))){
 
2999
          if(strcmp(interface, "none") == 0){
 
3000
            argz_delete(&mc.interfaces, &mc.interfaces_size,
 
3001
                        interface);
 
3002
            interface = NULL;
1709
3003
          }
1710
3004
        }
1711
 
#endif  /* __linux__ */
1712
 
        /* Lower privileges */
1713
 
        errno = 0;
1714
 
        ret = seteuid(uid);
1715
 
        if(ret == -1){
1716
 
          perror_plus("seteuid");
1717
 
        }
1718
 
        goto end;
1719
 
      }
1720
 
    }
1721
 
    /* Sleep checking until interface is running.
1722
 
       Check every 0.25s, up to total time of delay */
1723
 
    for(int i=0; i < delay * 4; i++){
1724
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1725
 
      if(ret == -1){
1726
 
        perror_plus("ioctl SIOCGIFFLAGS");
1727
 
      } else if(network.ifr_flags & IFF_RUNNING){
1728
3005
        break;
1729
3006
      }
1730
 
      struct timespec sleeptime = { .tv_nsec = 250000000 };
1731
 
      ret = nanosleep(&sleeptime, NULL);
1732
 
      if(ret == -1 and errno != EINTR){
1733
 
        perror_plus("nanosleep");
1734
 
      }
1735
 
    }
1736
 
    if(not take_down_interface){
1737
 
      /* We won't need the socket anymore */
1738
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1739
 
      if(ret == -1){
1740
 
        perror_plus("close");
1741
 
      }
1742
 
    }
1743
 
#ifdef __linux__
1744
 
    if(restore_loglevel){
1745
 
      /* Restores kernel loglevel to default */
1746
 
      ret = klogctl(7, NULL, 0);
1747
 
      if(ret == -1){
1748
 
        perror_plus("klogctl");
1749
 
      }
1750
 
    }
1751
 
#endif  /* __linux__ */
1752
 
    /* Lower privileges */
1753
 
    errno = 0;
1754
 
    if(take_down_interface){
1755
 
      /* Lower privileges */
1756
 
      ret = seteuid(uid);
1757
 
      if(ret == -1){
1758
 
        perror_plus("seteuid");
1759
 
      }
1760
 
    } else {
1761
 
      /* Lower privileges permanently */
1762
 
      ret = setuid(uid);
1763
 
      if(ret == -1){
1764
 
        perror_plus("setuid");
1765
 
      }
1766
 
    }
 
3007
      bool interface_was_up = interface_is_up(interface);
 
3008
      errno = bring_up_interface(interface, delay);
 
3009
      if(not interface_was_up){
 
3010
        if(errno != 0){
 
3011
          fprintf_plus(stderr, "Failed to bring up interface \"%s\":"
 
3012
                       " %s\n", interface, strerror(errno));
 
3013
        } else {
 
3014
          errno = argz_add(&interfaces_to_take_down,
 
3015
                           &interfaces_to_take_down_size,
 
3016
                           interface);
 
3017
          if(errno != 0){
 
3018
            perror_plus("argz_add");
 
3019
          }
 
3020
        }
 
3021
      }
 
3022
    }
 
3023
    if(debug and (interfaces_to_take_down == NULL)){
 
3024
      fprintf_plus(stderr, "No interfaces were brought up\n");
 
3025
    }
 
3026
  }
 
3027
  
 
3028
  /* If we only got one interface, explicitly use only that one */
 
3029
  if(argz_count(mc.interfaces, mc.interfaces_size) == 1){
 
3030
    if(debug){
 
3031
      fprintf_plus(stderr, "Using only interface \"%s\"\n",
 
3032
                   mc.interfaces);
 
3033
    }
 
3034
    if_index = (AvahiIfIndex)if_nametoindex(mc.interfaces);
1767
3035
  }
1768
3036
  
1769
3037
  if(quit_now){
1770
3038
    goto end;
1771
3039
  }
1772
3040
  
1773
 
  ret = init_gnutls_global(pubkey, seckey);
 
3041
#if GNUTLS_VERSION_NUMBER >= 0x030606
 
3042
  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);
 
3043
#elif GNUTLS_VERSION_NUMBER < 0x030600
 
3044
  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);
 
3045
#else
 
3046
#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"
 
3047
#endif
1774
3048
  if(ret == -1){
1775
 
    fprintf(stderr, "init_gnutls_global failed\n");
 
3049
    fprintf_plus(stderr, "init_gnutls_global failed\n");
1776
3050
    exitcode = EX_UNAVAILABLE;
1777
3051
    goto end;
1778
3052
  } else {
1783
3057
    goto end;
1784
3058
  }
1785
3059
  
1786
 
  if(mkdtemp(tempdir) == NULL){
 
3060
  /* Try /run/tmp before /tmp */
 
3061
  tempdir = mkdtemp(run_tempdir);
 
3062
  if(tempdir == NULL and errno == ENOENT){
 
3063
      if(debug){
 
3064
        fprintf_plus(stderr, "Tempdir %s did not work, trying %s\n",
 
3065
                     run_tempdir, old_tempdir);
 
3066
      }
 
3067
      tempdir = mkdtemp(old_tempdir);
 
3068
  }
 
3069
  if(tempdir == NULL){
1787
3070
    perror_plus("mkdtemp");
1788
3071
    goto end;
1789
3072
  }
1790
 
  tempdir_created = true;
1791
3073
  
1792
3074
  if(quit_now){
1793
3075
    goto end;
1794
3076
  }
1795
3077
  
1796
 
  if(not init_gpgme(pubkey, seckey, tempdir)){
1797
 
    fprintf(stderr, "init_gpgme failed\n");
 
3078
  if(not init_gpgme(pubkey, seckey, tempdir, &mc)){
 
3079
    fprintf_plus(stderr, "init_gpgme failed\n");
1798
3080
    exitcode = EX_UNAVAILABLE;
1799
3081
    goto end;
1800
3082
  } else {
1809
3091
    /* Connect directly, do not use Zeroconf */
1810
3092
    /* (Mainly meant for debugging) */
1811
3093
    char *address = strrchr(connect_to, ':');
 
3094
    
1812
3095
    if(address == NULL){
1813
 
      fprintf(stderr, "No colon in address\n");
 
3096
      fprintf_plus(stderr, "No colon in address\n");
1814
3097
      exitcode = EX_USAGE;
1815
3098
      goto end;
1816
3099
    }
1819
3102
      goto end;
1820
3103
    }
1821
3104
    
1822
 
    uint16_t port;
 
3105
    in_port_t port;
1823
3106
    errno = 0;
1824
3107
    tmpmax = strtoimax(address+1, &tmp, 10);
1825
3108
    if(errno != 0 or tmp == address+1 or *tmp != '\0'
1826
 
       or tmpmax != (uint16_t)tmpmax){
1827
 
      fprintf(stderr, "Bad port number\n");
 
3109
       or tmpmax != (in_port_t)tmpmax){
 
3110
      fprintf_plus(stderr, "Bad port number\n");
1828
3111
      exitcode = EX_USAGE;
1829
3112
      goto end;
1830
3113
    }
1831
 
  
 
3114
    
1832
3115
    if(quit_now){
1833
3116
      goto end;
1834
3117
    }
1835
3118
    
1836
 
    port = (uint16_t)tmpmax;
 
3119
    port = (in_port_t)tmpmax;
1837
3120
    *address = '\0';
1838
3121
    /* Colon in address indicates IPv6 */
1839
3122
    int af;
1855
3138
    }
1856
3139
    
1857
3140
    while(not quit_now){
1858
 
      ret = start_mandos_communication(address, port, if_index, af);
 
3141
      ret = start_mandos_communication(address, port, if_index, af,
 
3142
                                       &mc);
1859
3143
      if(quit_now or ret == 0){
1860
3144
        break;
1861
3145
      }
1862
3146
      if(debug){
1863
 
        fprintf(stderr, "Retrying in %d seconds\n",
1864
 
                (int)retry_interval);
 
3147
        fprintf_plus(stderr, "Retrying in %d seconds\n",
 
3148
                     (int)retry_interval);
1865
3149
      }
1866
 
      sleep((int)retry_interval);
 
3150
      sleep((unsigned int)retry_interval);
1867
3151
    }
1868
3152
    
1869
 
    if (not quit_now){
 
3153
    if(not quit_now){
1870
3154
      exitcode = EXIT_SUCCESS;
1871
3155
    }
1872
 
 
 
3156
    
1873
3157
    goto end;
1874
3158
  }
1875
3159
  
1887
3171
    config.publish_domain = 0;
1888
3172
    
1889
3173
    /* Allocate a new server */
1890
 
    mc.server = avahi_server_new(avahi_simple_poll_get
1891
 
                                 (mc.simple_poll), &config, NULL,
1892
 
                                 NULL, &error);
 
3174
    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),
 
3175
                                 &config, NULL, NULL, &ret);
1893
3176
    
1894
3177
    /* Free the Avahi configuration data */
1895
3178
    avahi_server_config_free(&config);
1897
3180
  
1898
3181
  /* Check if creating the Avahi server object succeeded */
1899
3182
  if(mc.server == NULL){
1900
 
    fprintf(stderr, "Failed to create Avahi server: %s\n",
1901
 
            avahi_strerror(error));
 
3183
    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",
 
3184
                 avahi_strerror(ret));
1902
3185
    exitcode = EX_UNAVAILABLE;
1903
3186
    goto end;
1904
3187
  }
1910
3193
  /* Create the Avahi service browser */
1911
3194
  sb = avahi_s_service_browser_new(mc.server, if_index,
1912
3195
                                   AVAHI_PROTO_UNSPEC, "_mandos._tcp",
1913
 
                                   NULL, 0, browse_callback, NULL);
 
3196
                                   NULL, 0, browse_callback,
 
3197
                                   (void *)&mc);
1914
3198
  if(sb == NULL){
1915
 
    fprintf(stderr, "Failed to create service browser: %s\n",
1916
 
            avahi_strerror(avahi_server_errno(mc.server)));
 
3199
    fprintf_plus(stderr, "Failed to create service browser: %s\n",
 
3200
                 avahi_strerror(avahi_server_errno(mc.server)));
1917
3201
    exitcode = EX_UNAVAILABLE;
1918
3202
    goto end;
1919
3203
  }
1925
3209
  /* Run the main loop */
1926
3210
  
1927
3211
  if(debug){
1928
 
    fprintf(stderr, "Starting Avahi loop search\n");
 
3212
    fprintf_plus(stderr, "Starting Avahi loop search\n");
1929
3213
  }
1930
 
 
1931
 
  ret = avahi_loop_with_timeout(mc.simple_poll,
1932
 
                                (int)(retry_interval * 1000));
 
3214
  
 
3215
  ret = avahi_loop_with_timeout(simple_poll,
 
3216
                                (int)(retry_interval * 1000), &mc);
1933
3217
  if(debug){
1934
 
    fprintf(stderr, "avahi_loop_with_timeout exited %s\n",
1935
 
            (ret == 0) ? "successfully" : "with error");
 
3218
    fprintf_plus(stderr, "avahi_loop_with_timeout exited %s\n",
 
3219
                 (ret == 0) ? "successfully" : "with error");
1936
3220
  }
1937
3221
  
1938
3222
 end:
1939
3223
  
1940
3224
  if(debug){
1941
 
    fprintf(stderr, "%s exiting\n", argv[0]);
 
3225
    if(signal_received){
 
3226
      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",
 
3227
                   argv[0], signal_received,
 
3228
                   strsignal(signal_received));
 
3229
    } else {
 
3230
      fprintf_plus(stderr, "%s exiting\n", argv[0]);
 
3231
    }
1942
3232
  }
1943
3233
  
1944
3234
  /* Cleanup things */
 
3235
  free(mc.interfaces);
 
3236
  
1945
3237
  if(sb != NULL)
1946
3238
    avahi_s_service_browser_free(sb);
1947
3239
  
1948
3240
  if(mc.server != NULL)
1949
3241
    avahi_server_free(mc.server);
1950
3242
  
1951
 
  if(mc.simple_poll != NULL)
1952
 
    avahi_simple_poll_free(mc.simple_poll);
 
3243
  if(simple_poll != NULL)
 
3244
    avahi_simple_poll_free(simple_poll);
1953
3245
  
1954
3246
  if(gnutls_initialized){
1955
3247
    gnutls_certificate_free_credentials(mc.cred);
1956
 
    gnutls_global_deinit();
1957
3248
    gnutls_dh_params_deinit(mc.dh_params);
1958
3249
  }
1959
3250
  
1960
3251
  if(gpgme_initialized){
1961
3252
    gpgme_release(mc.ctx);
1962
3253
  }
1963
 
 
 
3254
  
1964
3255
  /* Cleans up the circular linked list of Mandos servers the client
1965
3256
     has seen */
1966
3257
  if(mc.current_server != NULL){
1967
3258
    mc.current_server->prev->next = NULL;
1968
3259
    while(mc.current_server != NULL){
1969
3260
      server *next = mc.current_server->next;
 
3261
#ifdef __GNUC__
 
3262
#pragma GCC diagnostic push
 
3263
#pragma GCC diagnostic ignored "-Wcast-qual"
 
3264
#endif
 
3265
      free((char *)(mc.current_server->ip));
 
3266
#ifdef __GNUC__
 
3267
#pragma GCC diagnostic pop
 
3268
#endif
1970
3269
      free(mc.current_server);
1971
3270
      mc.current_server = next;
1972
3271
    }
1973
3272
  }
1974
3273
  
1975
 
  /* Take down the network interface */
1976
 
  if(take_down_interface){
1977
 
    /* Re-raise priviliges */
1978
 
    errno = 0;
1979
 
    ret = seteuid(0);
1980
 
    if(ret == -1){
1981
 
      perror_plus("seteuid");
1982
 
    }
1983
 
    if(geteuid() == 0){
1984
 
      ret = ioctl(sd, SIOCGIFFLAGS, &network);
1985
 
      if(ret == -1){
1986
 
        perror_plus("ioctl SIOCGIFFLAGS");
1987
 
      } else if(network.ifr_flags & IFF_UP) {
1988
 
        network.ifr_flags &= ~(short)IFF_UP; /* clear flag */
1989
 
        ret = ioctl(sd, SIOCSIFFLAGS, &network);
1990
 
        if(ret == -1){
1991
 
          perror_plus("ioctl SIOCSIFFLAGS -IFF_UP");
1992
 
        }
1993
 
      }
1994
 
      ret = (int)TEMP_FAILURE_RETRY(close(sd));
1995
 
      if(ret == -1){
1996
 
        perror_plus("close");
1997
 
      }
1998
 
      /* Lower privileges permanently */
1999
 
      errno = 0;
2000
 
      ret = setuid(uid);
2001
 
      if(ret == -1){
2002
 
        perror_plus("setuid");
2003
 
      }
2004
 
    }
 
3274
  /* Re-raise privileges */
 
3275
  {
 
3276
    ret = raise_privileges();
 
3277
    if(ret != 0){
 
3278
      errno = ret;
 
3279
      perror_plus("Failed to raise privileges");
 
3280
    } else {
 
3281
      
 
3282
      /* Run network hooks */
 
3283
      run_network_hooks("stop", interfaces_hooks != NULL ?
 
3284
                        interfaces_hooks : "", delay);
 
3285
      
 
3286
      /* Take down the network interfaces which were brought up */
 
3287
      {
 
3288
        char *interface = NULL;
 
3289
        while((interface = argz_next(interfaces_to_take_down,
 
3290
                                     interfaces_to_take_down_size,
 
3291
                                     interface))){
 
3292
          ret = take_down_interface(interface);
 
3293
          if(ret != 0){
 
3294
            errno = ret;
 
3295
            perror_plus("Failed to take down interface");
 
3296
          }
 
3297
        }
 
3298
        if(debug and (interfaces_to_take_down == NULL)){
 
3299
          fprintf_plus(stderr, "No interfaces needed to be taken"
 
3300
                       " down\n");
 
3301
        }
 
3302
      }
 
3303
    }
 
3304
    
 
3305
    ret = lower_privileges_permanently();
 
3306
    if(ret != 0){
 
3307
      errno = ret;
 
3308
      perror_plus("Failed to lower privileges permanently");
 
3309
    }
 
3310
  }
 
3311
  
 
3312
  free(interfaces_to_take_down);
 
3313
  free(interfaces_hooks);
 
3314
  
 
3315
  void clean_dir_at(int base, const char * const dirname,
 
3316
                    uintmax_t level){
 
3317
    struct dirent **direntries = NULL;
 
3318
    int dret;
 
3319
    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,
 
3320
                                                O_RDONLY
 
3321
                                                | O_NOFOLLOW
 
3322
                                                | O_DIRECTORY
 
3323
                                                | O_PATH));
 
3324
    if(dir_fd == -1){
 
3325
      perror_plus("open");
 
3326
      return;
 
3327
    }
 
3328
    int numentries = scandirat(dir_fd, ".", &direntries,
 
3329
                               notdotentries, alphasort);
 
3330
    if(numentries >= 0){
 
3331
      for(int i = 0; i < numentries; i++){
 
3332
        if(debug){
 
3333
          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",
 
3334
                       dirname, direntries[i]->d_name);
 
3335
        }
 
3336
        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);
 
3337
        if(dret == -1){
 
3338
          if(errno == EISDIR){
 
3339
              dret = unlinkat(dir_fd, direntries[i]->d_name,
 
3340
                              AT_REMOVEDIR);
 
3341
          }         
 
3342
          if((dret == -1) and (errno == ENOTEMPTY)
 
3343
             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")
 
3344
                  == 0) and (level == 0)){
 
3345
            /* Recurse only in this special case */
 
3346
            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);
 
3347
            dret = 0;
 
3348
          }
 
3349
          if((dret == -1) and (errno != ENOENT)){
 
3350
            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,
 
3351
                         direntries[i]->d_name, strerror(errno));
 
3352
          }
 
3353
        }
 
3354
        free(direntries[i]);
 
3355
      }
 
3356
      
 
3357
      /* need to clean even if 0 because man page doesn't specify */
 
3358
      free(direntries);
 
3359
      dret = unlinkat(base, dirname, AT_REMOVEDIR);
 
3360
      if(dret == -1 and errno != ENOENT){
 
3361
        perror_plus("rmdir");
 
3362
      }
 
3363
    } else {
 
3364
      perror_plus("scandirat");
 
3365
    }
 
3366
    close(dir_fd);
2005
3367
  }
2006
3368
  
2007
3369
  /* Removes the GPGME temp directory and all files inside */
2008
 
  if(tempdir_created){
2009
 
    struct dirent **direntries = NULL;
2010
 
    struct dirent *direntry = NULL;
2011
 
    int numentries = scandir(tempdir, &direntries, notdotentries,
2012
 
                             alphasort);
2013
 
    if (numentries > 0){
2014
 
      for(int i = 0; i < numentries; i++){
2015
 
        direntry = direntries[i];
2016
 
        char *fullname = NULL;
2017
 
        ret = asprintf(&fullname, "%s/%s", tempdir,
2018
 
                       direntry->d_name);
2019
 
        if(ret < 0){
2020
 
          perror_plus("asprintf");
2021
 
          continue;
2022
 
        }
2023
 
        ret = remove(fullname);
2024
 
        if(ret == -1){
2025
 
          fprintf(stderr, "remove(\"%s\"): %s\n", fullname,
2026
 
                  strerror(errno));
2027
 
        }
2028
 
        free(fullname);
2029
 
      }
2030
 
    }
2031
 
 
2032
 
    /* need to clean even if 0 because man page doesn't specify */
2033
 
    free(direntries);
2034
 
    if (numentries == -1){
2035
 
      perror_plus("scandir");
2036
 
    }
2037
 
    ret = rmdir(tempdir);
2038
 
    if(ret == -1 and errno != ENOENT){
2039
 
      perror_plus("rmdir");
2040
 
    }
 
3370
  if(tempdir != NULL){
 
3371
    clean_dir_at(-1, tempdir, 0);
2041
3372
  }
2042
3373
  
2043
3374
  if(quit_now){