/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: 2018-08-19 01:35:11 UTC
  • Revision ID: teddy@recompile.se-20180819013511-cku25q9yeub3dnr0
Adapt to changes in cryptsetup; use "cryptroot-unlock" program

* Makefile (install-client-nokey): Also install new script files
  "mandos-to-cryptroot-unlock" and "initramfs-tools-script-stop".
* debian/mandos-client.dirs: Add
  "usr/share/initramfs-tools/scripts/local-premount".
* initramfs-tools-hook: Also copy "mandos-to-cryptroot-unlock".
* initramfs-tools-script: Only modify keyscript setting in cryptroot
  file if the file exists, otherwise start
  "mandos-to-cryptroot-unlock" in background.
* initramfs-tools-script-stop: New script to make sure plugin-runner
  has stopped before continuing.
* mandos-to-cryptroot-unlock: New script to run plugin-runner and feed
  any password it gets into the "cryptroot-unlock" program.

Show diffs side-by-side

added added

removed removed

Lines of Context:
plugins.d/mandos-client.c
272
272
  return true;
273
273
}
274
274
 
 
275
/* Set effective uid to 0, return errno */
 
276
__attribute__((warn_unused_result))
 
277
int raise_privileges(void){
 
278
  int old_errno = errno;
 
279
  int ret = 0;
 
280
  if(seteuid(0) == -1){
 
281
    ret = errno;
 
282
  }
 
283
  errno = old_errno;
 
284
  return ret;
 
285
}
 
286
 
 
287
/* Set effective and real user ID to 0.  Return errno. */
 
288
__attribute__((warn_unused_result))
 
289
int raise_privileges_permanently(void){
 
290
  int old_errno = errno;
 
291
  int ret = raise_privileges();
 
292
  if(ret != 0){
 
293
    errno = old_errno;
 
294
    return ret;
 
295
  }
 
296
  if(setuid(0) == -1){
 
297
    ret = errno;
 
298
  }
 
299
  errno = old_errno;
 
300
  return ret;
 
301
}
 
302
 
 
303
/* Set effective user ID to unprivileged saved user ID */
 
304
__attribute__((warn_unused_result))
 
305
int lower_privileges(void){
 
306
  int old_errno = errno;
 
307
  int ret = 0;
 
308
  if(seteuid(uid) == -1){
 
309
    ret = errno;
 
310
  }
 
311
  errno = old_errno;
 
312
  return ret;
 
313
}
 
314
 
 
315
/* Lower privileges permanently */
 
316
__attribute__((warn_unused_result))
 
317
int lower_privileges_permanently(void){
 
318
  int old_errno = errno;
 
319
  int ret = 0;
 
320
  if(setuid(uid) == -1){
 
321
    ret = errno;
 
322
  }
 
323
  errno = old_errno;
 
324
  return ret;
 
325
}
 
326
 
275
327
/* 
276
328
 * Initialize GPGME.
277
329
 */
297
349
      return false;
298
350
    }
299
351
    
 
352
    /* Workaround for systems without a real-time clock; see also
 
353
       Debian bug #894495: <https://bugs.debian.org/894495> */
 
354
    do {
 
355
      {
 
356
        time_t currtime = time(NULL);
 
357
        if(currtime != (time_t)-1){
 
358
          struct tm tm;
 
359
          if(gmtime_r(&currtime, &tm) == NULL) {
 
360
            perror_plus("gmtime_r");
 
361
            break;
 
362
          }
 
363
          if(tm.tm_year != 70 or tm.tm_mon != 0){
 
364
            break;
 
365
          }
 
366
          if(debug){
 
367
            fprintf_plus(stderr, "System clock is January 1970");
 
368
          }
 
369
        } else {
 
370
          if(debug){
 
371
            fprintf_plus(stderr, "System clock is invalid");
 
372
          }
 
373
        }
 
374
      }
 
375
      struct stat keystat;
 
376
      ret = fstat(fd, &keystat);
 
377
      if(ret != 0){
 
378
        perror_plus("fstat");
 
379
        break;
 
380
      }
 
381
      ret = raise_privileges();
 
382
      if(ret != 0){
 
383
        errno = ret;
 
384
        perror_plus("Failed to raise privileges");
 
385
        break;
 
386
      }
 
387
      if(debug){
 
388
        fprintf_plus(stderr,
 
389
                     "Setting system clock to key file mtime");
 
390
      }
 
391
      time_t keytime = keystat.st_mtim.tv_sec;
 
392
      if(stime(&keytime) != 0){
 
393
        perror_plus("stime");
 
394
      }
 
395
      ret = lower_privileges();
 
396
      if(ret != 0){
 
397
        errno = ret;
 
398
        perror_plus("Failed to lower privileges");
 
399
      }
 
400
    } while(false);
 
401
 
300
402
    rc = gpgme_data_new_from_fd(&pgp_data, fd);
301
403
    if(rc != GPG_ERR_NO_ERROR){
302
404
      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",
502
604
        if(result->file_name != NULL){
503
605
          fprintf_plus(stderr, "File name: %s\n", result->file_name);
504
606
        }
505
 
        gpgme_recipient_t recipient;
506
 
        recipient = result->recipients;
507
 
        while(recipient != NULL){
 
607
 
 
608
        for(gpgme_recipient_t r = result->recipients; r != NULL;
 
609
            r = r->next){
508
610
          fprintf_plus(stderr, "Public key algorithm: %s\n",
509
 
                       gpgme_pubkey_algo_name
510
 
                       (recipient->pubkey_algo));
511
 
          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);
 
611
                       gpgme_pubkey_algo_name(r->pubkey_algo));
 
612
          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);
512
613
          fprintf_plus(stderr, "Secret key available: %s\n",
513
 
                       recipient->status == GPG_ERR_NO_SECKEY
514
 
                       ? "No" : "Yes");
515
 
          recipient = recipient->next;
 
614
                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");
516
615
        }
517
616
      }
518
617
    }
897
996
static void empty_log(__attribute__((unused)) AvahiLogLevel level,
898
997
                      __attribute__((unused)) const char *txt){}
899
998
 
900
 
/* Set effective uid to 0, return errno */
901
 
__attribute__((warn_unused_result))
902
 
int raise_privileges(void){
903
 
  int old_errno = errno;
904
 
  int ret = 0;
905
 
  if(seteuid(0) == -1){
906
 
    ret = errno;
907
 
  }
908
 
  errno = old_errno;
909
 
  return ret;
910
 
}
911
 
 
912
 
/* Set effective and real user ID to 0.  Return errno. */
913
 
__attribute__((warn_unused_result))
914
 
int raise_privileges_permanently(void){
915
 
  int old_errno = errno;
916
 
  int ret = raise_privileges();
917
 
  if(ret != 0){
918
 
    errno = old_errno;
919
 
    return ret;
920
 
  }
921
 
  if(setuid(0) == -1){
922
 
    ret = errno;
923
 
  }
924
 
  errno = old_errno;
925
 
  return ret;
926
 
}
927
 
 
928
 
/* Set effective user ID to unprivileged saved user ID */
929
 
__attribute__((warn_unused_result))
930
 
int lower_privileges(void){
931
 
  int old_errno = errno;
932
 
  int ret = 0;
933
 
  if(seteuid(uid) == -1){
934
 
    ret = errno;
935
 
  }
936
 
  errno = old_errno;
937
 
  return ret;
938
 
}
939
 
 
940
 
/* Lower privileges permanently */
941
 
__attribute__((warn_unused_result))
942
 
int lower_privileges_permanently(void){
943
 
  int old_errno = errno;
944
 
  int ret = 0;
945
 
  if(setuid(uid) == -1){
946
 
    ret = errno;
947
 
  }
948
 
  errno = old_errno;
949
 
  return ret;
950
 
}
951
 
 
952
999
/* Helper function to add_local_route() and delete_local_route() */
953
1000
__attribute__((nonnull, warn_unused_result))
954
1001
static bool add_delete_local_route(const bool add,