git.tinc-vpn.org Git - tinc/blob - src/fsck.c

   1 /*
   2     fsck.c -- Check the configuration files for problems
   3     Copyright (C) 2014 Guus Sliepen <guus@tinc-vpn.org>
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License along
  16     with this program; if not, write to the Free Software Foundation, Inc.,
  17     51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  18 */
  19
  20 #include "system.h"
  21
  22 #include "crypto.h"
  23 #include "ecdsa.h"
  24 #include "ecdsagen.h"
  25 #include "fsck.h"
  26 #include "names.h"
  27 #ifndef DISABLE_LEGACY
  28 #include "rsa.h"
  29 #include "rsagen.h"
  30 #endif
  31 #include "tincctl.h"
  32 #include "utils.h"
  33
  34 static bool ask_fix(void) {
  35         if(force)
  36                 return true;
  37         if(!tty)
  38                 return false;
  39 again:
  40         fprintf(stderr, "Fix y/n? ");
  41         char buf[1024];
  42         if(!fgets(buf, sizeof buf, stdin)) {
  43                 tty = false;
  44                 return false;
  45         }
  46         if(buf[0] == 'y' || buf[0] == 'Y')
  47                 return true;
  48         if(buf[0] == 'n' || buf[0] == 'N')
  49                 return false;
  50         goto again;
  51 }
  52
  53 static void print_tinc_cmd(const char *argv0, const char *format, ...) {
  54         if(confbasegiven)
  55                 fprintf(stderr, "%s -c %s ", argv0, confbase);
  56         else if(netname)
  57                 fprintf(stderr, "%s -n %s ", argv0, netname);
  58         else
  59                 fprintf(stderr, "%s ", argv0);
  60         va_list va;
  61         va_start(va, format);
  62         vfprintf(stderr, format, va);
  63         va_end(va);
  64         fputc('\n', stderr);
  65 }
  66
  67 static int strtailcmp(const char *str, const char *tail) {
  68         size_t slen = strlen(str);
  69         size_t tlen = strlen(tail);
  70         if(tlen > slen)
  71                 return -1;
  72         return memcmp(str + slen - tlen, tail, tlen);
  73 }
  74
  75 static void check_conffile(const char *fname, bool server) {
  76         FILE *f = fopen(fname, "r");
  77         if(!f) {
  78                 fprintf(stderr, "ERROR: cannot read %s: %s\n", fname, strerror(errno));
  79                 return;
  80         }
  81
  82         char line[2048];
  83         int lineno = 0;
  84         bool skip = false;
  85         const int maxvariables = 50;
  86         int count[maxvariables];
  87         memset(count, 0, sizeof count);
  88
  89         while(fgets(line, sizeof line, f)) {
  90                 if(skip) {
  91                         if(!strncmp(line, "-----END", 8))
  92                                 skip = false;
  93                         continue;
  94                 } else {
  95                         if(!strncmp(line, "-----BEGIN", 10)) {
  96                                 skip = true;
  97                                 continue;
  98                         }
  99                 }
 100
 101                 int len;
 102                 char *variable, *value, *eol;
 103                 variable = value = line;
 104
 105                 lineno++;
 106
 107                 eol = line + strlen(line);
 108                 while(strchr("\t \r\n", *--eol))
 109                         *eol = '\0';
 110
 111                 if(!line[0] || line[0] == '#')
 112                         continue;
 113
 114                 len = strcspn(value, "\t =");
 115                 value += len;
 116                 value += strspn(value, "\t ");
 117                 if(*value == '=') {
 118                         value++;
 119                         value += strspn(value, "\t ");
 120                 }
 121                 variable[len] = '\0';
 122
 123                 bool found = false;
 124
 125                 for(int i = 0; variables[i].name; i++) {
 126                         if(strcasecmp(variables[i].name, variable))
 127                                 continue;
 128
 129                         found = true;
 130
 131                         if(variables[i].type & VAR_OBSOLETE) {
 132                                 fprintf(stderr, "WARNING: obsolete variable %s in %s line %d\n", variable, fname, lineno);
 133                         }
 134
 135                         if(i < maxvariables)
 136                                 count[i]++;
 137                 }
 138
 139                 if(!found)
 140                         fprintf(stderr, "WARNING: unknown variable %s in %s line %d\n", variable, fname, lineno);
 141
 142                 if(!*value)
 143                         fprintf(stderr, "ERROR: no value for variable %s in %s line %d\n", variable, fname, lineno);
 144         }
 145
 146         for(int i = 0; variables[i].name && i < maxvariables; i++) {
 147                 if(count[i] > 1 && !(variables[i].type & VAR_MULTIPLE))
 148                         fprintf(stderr, "WARNING: multiple instances of variable %s in %s\n", variables[i].name, fname);
 149         }
 150
 151         if(ferror(f))
 152                 fprintf(stderr, "ERROR: while reading %s: %s\n", fname, strerror(errno));
 153
 154         fclose(f);
 155 }
 156
 157 int fsck(const char *argv0) {
 158 #ifdef HAVE_MINGW
 159         int uid = 0;
 160 #else
 161         uid_t uid = getuid();
 162 #endif
 163
 164         // Check that tinc.conf is readable.
 165
 166         if(access(tinc_conf, R_OK)) {
 167                 fprintf(stderr, "ERROR: cannot read %s: %s\n", tinc_conf, strerror(errno));
 168                 if(errno == ENOENT) {
 169                         fprintf(stderr, "No tinc configuration found. Create a new one with:\n\n");
 170                         print_tinc_cmd(argv0, "init");
 171                 } else if(errno == EACCES) {
 172                         if(uid != 0)
 173                                 fprintf(stderr, "You are currently not running tinc as root. Use sudo?\n");
 174                         else
 175                                 fprintf(stderr, "Check the permissions of each component of the path %s.\n", tinc_conf);
 176                 }
 177                 return 1;
 178         }
 179
 180         char *name = get_my_name(true);
 181         if(!name) {
 182                 fprintf(stderr, "ERROR: tinc cannot run without a valid Name.\n");
 183                 return 1;
 184         }
 185
 186         // Check for private keys.
 187         // TODO: use RSAPrivateKeyFile and Ed25519PrivateKeyFile variables if present.
 188
 189         struct stat st;
 190         char fname[PATH_MAX];
 191         char dname[PATH_MAX];
 192
 193 #ifndef DISABLE_LEGACY
 194         rsa_t *rsa_priv = NULL;
 195         snprintf(fname, sizeof fname, "%s/rsa_key.priv", confbase);
 196
 197         if(stat(fname, &st)) {
 198                 if(errno != ENOENT) {
 199                         // Something is seriously wrong here. If we can access the directory with tinc.conf in it, we should certainly be able to stat() an existing file.
 200                         fprintf(stderr, "ERROR: cannot read %s: %s\n", fname, strerror(errno));
 201                         fprintf(stderr, "Please correct this error.\n");
 202                         return 1;
 203                 }
 204         } else {
 205                 FILE *f = fopen(fname, "r");
 206                 if(!f) {
 207                         fprintf(stderr, "ERROR: could not open %s: %s\n", fname, strerror(errno));
 208                         return 1;
 209                 }
 210                 rsa_priv = rsa_read_pem_private_key(f);
 211                 fclose(f);
 212                 if(!rsa_priv) {
 213                         fprintf(stderr, "ERROR: No key or unusable key found in %s.\n", fname);
 214                         fprintf(stderr, "You can generate a new RSA key with:\n\n");
 215                         print_tinc_cmd(argv0, "generate-rsa-keys");
 216                         return 1;
 217                 }
 218
 219 #if !defined(HAVE_MINGW) && !defined(HAVE_CYGWIN)
 220                 if(st.st_mode & 077) {
 221                         fprintf(stderr, "WARNING: unsafe file permissions on %s.\n", fname);
 222                         if(st.st_uid != uid) {
 223                                 fprintf(stderr, "You are not running %s as the same uid as %s.\n", argv0, fname);
 224                         } else if(ask_fix()) {
 225                                 if(chmod(fname, st.st_mode & ~077))
 226                                         fprintf(stderr, "ERROR: could not change permissions of %s: %s\n", fname, strerror(errno));
 227                                 else
 228                                         fprintf(stderr, "Fixed permissions of %s.\n", fname);
 229                         }
 230                 }
 231 #endif
 232         }
 233 #endif
 234
 235         ecdsa_t *ecdsa_priv = NULL;
 236         snprintf(fname, sizeof fname, "%s/ed25519_key.priv", confbase);
 237
 238         if(stat(fname, &st)) {
 239                 if(errno != ENOENT) {
 240                         // Something is seriously wrong here. If we can access the directory with tinc.conf in it, we should certainly be able to stat() an existing file.
 241                         fprintf(stderr, "ERROR: cannot read %s: %s\n", fname, strerror(errno));
 242                         fprintf(stderr, "Please correct this error.\n");
 243                         return 1;
 244                 }
 245         } else {
 246                 FILE *f = fopen(fname, "r");
 247                 if(!f) {
 248                         fprintf(stderr, "ERROR: could not open %s: %s\n", fname, strerror(errno));
 249                         return 1;
 250                 }
 251                 ecdsa_priv = ecdsa_read_pem_private_key(f);
 252                 fclose(f);
 253                 if(!ecdsa_priv) {
 254                         fprintf(stderr, "ERROR: No key or unusable key found in %s.\n", fname);
 255                         fprintf(stderr, "You can generate a new Ed25519 key with:\n\n");
 256                         print_tinc_cmd(argv0, "generate-ed25519-keys");
 257                         return 1;
 258                 }
 259
 260 #if !defined(HAVE_MINGW) && !defined(HAVE_CYGWIN)
 261                 if(st.st_mode & 077) {
 262                         fprintf(stderr, "WARNING: unsafe file permissions on %s.\n", fname);
 263                         if(st.st_uid != uid) {
 264                                 fprintf(stderr, "You are not running %s as the same uid as %s.\n", argv0, fname);
 265                         } else if(ask_fix()) {
 266                                 if(chmod(fname, st.st_mode & ~077))
 267                                         fprintf(stderr, "ERROR: could not change permissions of %s: %s\n", fname, strerror(errno));
 268                                 else
 269                                         fprintf(stderr, "Fixed permissions of %s.\n", fname);
 270                         }
 271                 }
 272 #endif
 273         }
 274
 275 #ifdef DISABLE_LEGACY
 276         if(!ecdsa_priv) {
 277                 fprintf(stderr, "ERROR: No Ed25519 private key found.\n");
 278 #else
 279         if(!rsa_priv && !ecdsa_priv) {
 280                 fprintf(stderr, "ERROR: Neither RSA or Ed25519 private key found.\n");
 281 #endif
 282                 fprintf(stderr, "You can generate new keys with:\n\n");
 283                 print_tinc_cmd(argv0, "generate-keys");
 284                 return 1;
 285         }
 286
 287         // Check for public keys.
 288         // TODO: use RSAPublicKeyFile variable if present.
 289
 290         snprintf(fname, sizeof fname, "%s/hosts/%s", confbase, name);
 291         if(access(fname, R_OK))
 292                 fprintf(stderr, "WARNING: cannot read %s\n", fname);
 293
 294         FILE *f;
 295
 296 #ifndef DISABLE_LEGACY
 297         rsa_t *rsa_pub = NULL;
 298
 299         f = fopen(fname, "r");
 300         if(f)
 301                 rsa_pub = rsa_read_pem_public_key(f);
 302         fclose(f);
 303
 304         if(rsa_priv) {
 305                 if(!rsa_pub) {
 306                         fprintf(stderr, "WARNING: No (usable) public RSA key found.\n");
 307                         if(ask_fix()) {
 308                                 FILE *f = fopen(fname, "a");
 309                                 if(f) {
 310                                         if(rsa_write_pem_public_key(rsa_priv, f))
 311                                                 fprintf(stderr, "Wrote RSA public key to %s.\n", fname);
 312                                         else
 313                                                 fprintf(stderr, "ERROR: could not write RSA public key to %s.\n", fname);
 314                                         fclose(f);
 315                                 } else {
 316                                         fprintf(stderr, "ERROR: could not append to %s: %s\n", fname, strerror(errno));
 317                                 }
 318                         }
 319                 } else {
 320                         // TODO: suggest remedies
 321                         size_t len = rsa_size(rsa_priv);
 322                         if(len != rsa_size(rsa_pub)) {
 323                                 fprintf(stderr, "ERROR: public and private RSA keys do not match.\n");
 324                                 return 1;
 325                         }
 326                         char buf1[len], buf2[len], buf3[len];
 327                         randomize(buf1, sizeof buf1);
 328                         buf1[0] &= 0x7f;
 329                         memset(buf2, 0, sizeof buf2);
 330                         memset(buf3, 0, sizeof buf2);
 331                         if(!rsa_public_encrypt(rsa_pub, buf1, sizeof buf1, buf2)) {
 332                                 fprintf(stderr, "ERROR: public RSA key does not work.\n");
 333                                 return 1;
 334                         }
 335                         if(!rsa_private_decrypt(rsa_priv, buf2, sizeof buf2, buf3)) {
 336                                 fprintf(stderr, "ERROR: private RSA key does not work.\n");
 337                                 return 1;
 338                         }
 339                         if(memcmp(buf1, buf3, sizeof buf1)) {
 340                                 fprintf(stderr, "ERROR: public and private RSA keys do not match.\n");
 341                                 return 1;
 342                         }
 343                 }
 344         } else {
 345                 if(rsa_pub)
 346                         fprintf(stderr, "WARNING: A public RSA key was found but no private key is known.\n");
 347         }
 348 #endif
 349
 350         ecdsa_t *ecdsa_pub = NULL;
 351
 352         f = fopen(fname, "r");
 353         if(f) {
 354                 ecdsa_pub = get_pubkey(f);
 355                 if(!f) {
 356                         rewind(f);
 357                         ecdsa_pub = ecdsa_read_pem_public_key(f);
 358                 }
 359         }
 360         fclose(f);
 361
 362         if(ecdsa_priv) {
 363                 if(!ecdsa_pub) {
 364                         fprintf(stderr, "WARNING: No (usable) public Ed25519 key found.\n");
 365                         if(ask_fix()) {
 366                                 FILE *f = fopen(fname, "a");
 367                                 if(f) {
 368                                         if(ecdsa_write_pem_public_key(ecdsa_priv, f))
 369                                                 fprintf(stderr, "Wrote Ed25519 public key to %s.\n", fname);
 370                                         else
 371                                                 fprintf(stderr, "ERROR: could not write Ed25519 public key to %s.\n", fname);
 372                                         fclose(f);
 373                                 } else {
 374                                         fprintf(stderr, "ERROR: could not append to %s: %s\n", fname, strerror(errno));
 375                                 }
 376                         }
 377                 } else {
 378                         // TODO: suggest remedies
 379                         char *key1 = ecdsa_get_base64_public_key(ecdsa_pub);
 380                         if(!key1) {
 381                                 fprintf(stderr, "ERROR: public Ed25519 key does not work.\n");
 382                                 return 1;
 383                         }
 384                         char *key2 = ecdsa_get_base64_public_key(ecdsa_priv);
 385                         if(!key2) {
 386                                 free(key1);
 387                                 fprintf(stderr, "ERROR: private Ed25519 key does not work.\n");
 388                                 return 1;
 389                         }
 390                         int result = strcmp(key1, key2);
 391                         free(key1);
 392                         free(key2);
 393                         if(result) {
 394                                 fprintf(stderr, "ERROR: public and private Ed25519 keys do not match.\n");
 395                                 return 1;
 396                         }
 397                 }
 398         } else {
 399                 if(ecdsa_pub)
 400                         fprintf(stderr, "WARNING: A public Ed25519 key was found but no private key is known.\n");
 401         }
 402
 403         // Check whether scripts are executable
 404
 405         struct dirent *ent;
 406         DIR *dir = opendir(confbase);
 407         if(!dir) {
 408                 fprintf(stderr, "ERROR: cannot read directory %s: %s\n", confbase, strerror(errno));
 409                 return 1;
 410         }
 411
 412         while((ent = readdir(dir))) {
 413                 if(strtailcmp(ent->d_name, "-up") && strtailcmp(ent->d_name, "-down"))
 414                         continue;
 415
 416                 strncpy(fname, ent->d_name, sizeof fname);
 417                 char *dash = strrchr(fname, '-');
 418                 if(!dash)
 419                         continue;
 420                 *dash = 0;
 421
 422                 if(strcmp(fname, "tinc") && strcmp(fname, "host") && strcmp(fname, "subnet")) {
 423                         static bool explained = false;
 424                         fprintf(stderr, "WARNING: Unknown script %s" SLASH "%s found.\n", confbase, ent->d_name);
 425                         if(!explained) {
 426                                 fprintf(stderr, "The only scripts in %s executed by tinc are:\n", confbase);
 427                                 fprintf(stderr, "tinc-up, tinc-down, host-up, host-down, subnet-up and subnet-down.\n");
 428                                 explained = true;
 429                         }
 430                         continue;
 431                 }
 432
 433                 snprintf(fname, sizeof fname, "%s" SLASH "%s", confbase, ent->d_name);
 434                 if(access(fname, R_OK | X_OK)) {
 435                         if(errno != EACCES) {
 436                                 fprintf(stderr, "ERROR: cannot access %s: %s\n", fname, strerror(errno));
 437                                 continue;
 438                         }
 439                         fprintf(stderr, "WARNING: cannot read and execute %s: %s\n", fname, strerror(errno));
 440                         if(ask_fix()) {
 441                                 if(chmod(fname, 0755))
 442                                         fprintf(stderr, "ERROR: cannot change permissions on %s: %s\n", fname, strerror(errno));
 443                         }
 444                 }
 445         }
 446         closedir(dir);
 447
 448         snprintf(dname, sizeof dname, "%s" SLASH "hosts", confbase);
 449         dir = opendir(dname);
 450         if(!dir) {
 451                 fprintf(stderr, "ERROR: cannot read directory %s: %s\n", dname, strerror(errno));
 452                 return 1;
 453         }
 454
 455         while((ent = readdir(dir))) {
 456                 if(strtailcmp(ent->d_name, "-up") && strtailcmp(ent->d_name, "-down"))
 457                         continue;
 458
 459                 strncpy(fname, ent->d_name, sizeof fname);
 460                 char *dash = strrchr(fname, '-');
 461                 if(!dash)
 462                         continue;
 463                 *dash = 0;
 464
 465                 snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, ent->d_name);
 466                 if(access(fname, R_OK | X_OK)) {
 467                         if(errno != EACCES) {
 468                                 fprintf(stderr, "ERROR: cannot access %s: %s\n", fname, strerror(errno));
 469                                 continue;
 470                         }
 471                         fprintf(stderr, "WARNING: cannot read and execute %s: %s\n", fname, strerror(errno));
 472                         if(ask_fix()) {
 473                                 if(chmod(fname, 0755))
 474                                         fprintf(stderr, "ERROR: cannot change permissions on %s: %s\n", fname, strerror(errno));
 475                         }
 476                 }
 477         }
 478         closedir(dir);
 479
 480         // Check for obsolete / unsafe / unknown configuration variables.
 481
 482         check_conffile(tinc_conf, true);
 483
 484         dir = opendir(dname);
 485         if(dir) {
 486                 while((ent = readdir(dir))) {
 487                         if(!check_id(ent->d_name))
 488                                 continue;
 489
 490                         snprintf(fname, sizeof fname, "%s" SLASH "hosts" SLASH "%s", confbase, ent->d_name);
 491                         check_conffile(fname, false);
 492                 }
 493                 closedir(dir);
 494         }
 495
 496         return 0;
 497 }
 498