/mandos/release

« back to all changes in this revision

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

• browse files at revision 237.7.320
• compare with another revision
• download diff
• download tarball
• view history from revision 237.7.320

• reverse the comparison (237.7.320 to 237.7.771)
• stop comparing with revision 237.7.771

Show diffs side-by-side

added

removed

plugins.d/mandos-client.c

9

9

 * "browse_callback", and parts of "main".

10

10

 * 

11

11

 * Everything else is

12

 

 * Copyright © 2008-2020 Teddy Hogeborn

13

 

 * Copyright © 2008-2020 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

 

12

 * Copyright © 2008-2015 Teddy Hogeborn

 

13

 * Copyright © 2008-2015 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

23

21

 * WITHOUT ANY WARRANTY; without even the implied warranty of

24

22

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

25

23

 * General Public License for more details.

26

24

 * 

27

25

 * You should have received a copy of the GNU General Public License

28

 

 * along with Mandos.  If not, see <http://www.gnu.org/licenses/>.

 

26

 * along with this program.  If not, see

 

27

 * <http://www.gnu.org/licenses/>.

29

28

 * 

30

29

 * Contact the authors at <mandos@recompile.se>.

31

30

 */

47

46

#include <stdlib.h>             /* free(), EXIT_SUCCESS, srand(),

48

47

                                   strtof(), abort() */

49

48

#include <stdbool.h>            /* bool, false, true */

50

 

#include <string.h>             /* strcmp(), strlen(), strerror(),

51

 

                                   asprintf(), strncpy(), strsignal()

52

 

                                */

 

49

#include <string.h>             /* memset(), strcmp(), strlen(),

 

50

                                   strerror(), asprintf(), strcpy() */

53

51

#include <sys/ioctl.h>          /* ioctl */

54

52

#include <sys/types.h>          /* socket(), inet_pton(), sockaddr,

55

53

                                   sockaddr_in6, PF_INET6,

59

57

#include <sys/socket.h>         /* socket(), struct sockaddr_in6,

60

58

                                   inet_pton(), connect(),

61

59

                                   getnameinfo() */

62

 

#include <fcntl.h>              /* open(), unlinkat(), AT_REMOVEDIR */

 

60

#include <fcntl.h>              /* open(), unlinkat() */

63

61

#include <dirent.h>             /* opendir(), struct dirent, readdir()

64

62

                                 */

65

63

#include <inttypes.h>           /* PRIu16, PRIdMAX, intmax_t,

66

64

                                   strtoimax() */

67

 

#include <errno.h>              /* perror(), errno, EINTR, EINVAL,

68

 

                                   EAI_SYSTEM, ENETUNREACH,

69

 

                                   EHOSTUNREACH, ECONNREFUSED, EPROTO,

70

 

                                   EIO, ENOENT, ENXIO, ENOMEM, EISDIR,

71

 

                                   ENOTEMPTY,

 

65

#include <errno.h>              /* perror(), errno,

72

66

                                   program_invocation_short_name */

73

67

#include <time.h>               /* nanosleep(), time(), sleep() */

74

68

#include <net/if.h>             /* ioctl, ifreq, SIOCGIFFLAGS, IFF_UP,

123

117

                                   gnutls_*

124

118

                                   init_gnutls_session(),

125

119

                                   GNUTLS_* */

126

 

#if GNUTLS_VERSION_NUMBER < 0x030600

127

120

#include <gnutls/openpgp.h>

128

121

                         /* gnutls_certificate_set_openpgp_key_file(),

129

122

                            GNUTLS_OPENPGP_FMT_BASE64 */

130

 

#elif GNUTLS_VERSION_NUMBER >= 0x030606

131

 

#include <gnutls/x509.h>        /* gnutls_pkcs_encrypt_flags_t,

132

 

                                 GNUTLS_PKCS_PLAIN,

133

 

                                 GNUTLS_PKCS_NULL_PASSWORD */

134

 

#endif

135

123

 

136

124

/* GPGME */

137

125

#include <gpgme.h>              /* All GPGME types, constants and

145

133

#define PATHDIR "/conf/conf.d/mandos"

146

134

#define SECKEY "seckey.txt"

147

135

#define PUBKEY "pubkey.txt"

148

 

#define TLS_PRIVKEY "tls-privkey.pem"

149

 

#define TLS_PUBKEY "tls-pubkey.pem"

150

136

#define HOOKDIR "/lib/mandos/network-hooks.d"

151

137

 

152

138

bool debug = false;

280

266

  return true;

281

267

}

282

268

 

283

 

/* Set effective uid to 0, return errno */

284

 

__attribute__((warn_unused_result))

285

 

int raise_privileges(void){

286

 

  int old_errno = errno;

287

 

  int ret = 0;

288

 

  if(seteuid(0) == -1){

289

 

    ret = errno;

290

 

  }

291

 

  errno = old_errno;

292

 

  return ret;

293

 

}

294

 

 

295

 

/* Set effective and real user ID to 0.  Return errno. */

296

 

__attribute__((warn_unused_result))

297

 

int raise_privileges_permanently(void){

298

 

  int old_errno = errno;

299

 

  int ret = raise_privileges();

300

 

  if(ret != 0){

301

 

    errno = old_errno;

302

 

    return ret;

303

 

  }

304

 

  if(setuid(0) == -1){

305

 

    ret = errno;

306

 

  }

307

 

  errno = old_errno;

308

 

  return ret;

309

 

}

310

 

 

311

 

/* Set effective user ID to unprivileged saved user ID */

312

 

__attribute__((warn_unused_result))

313

 

int lower_privileges(void){

314

 

  int old_errno = errno;

315

 

  int ret = 0;

316

 

  if(seteuid(uid) == -1){

317

 

    ret = errno;

318

 

  }

319

 

  errno = old_errno;

320

 

  return ret;

321

 

}

322

 

 

323

 

/* Lower privileges permanently */

324

 

__attribute__((warn_unused_result))

325

 

int lower_privileges_permanently(void){

326

 

  int old_errno = errno;

327

 

  int ret = 0;

328

 

  if(setuid(uid) == -1){

329

 

    ret = errno;

330

 

  }

331

 

  errno = old_errno;

332

 

  return ret;

333

 

}

334

 

 

335

269

/* 

336

270

 * Initialize GPGME.

337

271

 */

357

291

      return false;

358

292

    }

359

293

    

360

 

    /* Workaround for systems without a real-time clock; see also

361

 

       Debian bug #894495: <https://bugs.debian.org/894495> */

362

 

    do {

363

 

      {

364

 

        time_t currtime = time(NULL);

365

 

        if(currtime != (time_t)-1){

366

 

          struct tm tm;

367

 

          if(gmtime_r(&currtime, &tm) == NULL) {

368

 

            perror_plus("gmtime_r");

369

 

            break;

370

 

          }

371

 

          if(tm.tm_year != 70 or tm.tm_mon != 0){

372

 

            break;

373

 

          }

374

 

          if(debug){

375

 

            fprintf_plus(stderr, "System clock is January 1970");

376

 

          }

377

 

        } else {

378

 

          if(debug){

379

 

            fprintf_plus(stderr, "System clock is invalid");

380

 

          }

381

 

        }

382

 

      }

383

 

      struct stat keystat;

384

 

      ret = fstat(fd, &keystat);

385

 

      if(ret != 0){

386

 

        perror_plus("fstat");

387

 

        break;

388

 

      }

389

 

      ret = raise_privileges();

390

 

      if(ret != 0){

391

 

        errno = ret;

392

 

        perror_plus("Failed to raise privileges");

393

 

        break;

394

 

      }

395

 

      if(debug){

396

 

        fprintf_plus(stderr,

397

 

                     "Setting system clock to key file mtime");

398

 

      }

399

 

      if(clock_settime(CLOCK_REALTIME, &keystat.st_mtim) != 0){

400

 

        perror_plus("clock_settime");

401

 

      }

402

 

      ret = lower_privileges();

403

 

      if(ret != 0){

404

 

        errno = ret;

405

 

        perror_plus("Failed to lower privileges");

406

 

      }

407

 

    } while(false);

408

 

 

409

294

    rc = gpgme_data_new_from_fd(&pgp_data, fd);

410

295

    if(rc != GPG_ERR_NO_ERROR){

411

296

      fprintf_plus(stderr, "bad gpgme_data_new_from_fd: %s: %s\n",

419

304

                   gpgme_strsource(rc), gpgme_strerror(rc));

420

305

      return false;

421

306

    }

422

 

    {

423

 

      gpgme_import_result_t import_result

424

 

        = gpgme_op_import_result(mc->ctx);

425

 

      if((import_result->imported < 1

426

 

          or import_result->not_imported > 0)

427

 

         and import_result->unchanged == 0){

428

 

        fprintf_plus(stderr, "bad gpgme_op_import_results:\n");

429

 

        fprintf_plus(stderr,

430

 

                     "The total number of considered keys: %d\n",

431

 

                     import_result->considered);

432

 

        fprintf_plus(stderr,

433

 

                     "The number of keys without user ID: %d\n",

434

 

                     import_result->no_user_id);

435

 

        fprintf_plus(stderr,

436

 

                     "The total number of imported keys: %d\n",

437

 

                     import_result->imported);

438

 

        fprintf_plus(stderr, "The number of imported RSA keys: %d\n",

439

 

                     import_result->imported_rsa);

440

 

        fprintf_plus(stderr, "The number of unchanged keys: %d\n",

441

 

                     import_result->unchanged);

442

 

        fprintf_plus(stderr, "The number of new user IDs: %d\n",

443

 

                     import_result->new_user_ids);

444

 

        fprintf_plus(stderr, "The number of new sub keys: %d\n",

445

 

                     import_result->new_sub_keys);

446

 

        fprintf_plus(stderr, "The number of new signatures: %d\n",

447

 

                     import_result->new_signatures);

448

 

        fprintf_plus(stderr, "The number of new revocations: %d\n",

449

 

                     import_result->new_revocations);

450

 

        fprintf_plus(stderr,

451

 

                     "The total number of secret keys read: %d\n",

452

 

                     import_result->secret_read);

453

 

        fprintf_plus(stderr,

454

 

                     "The number of imported secret keys: %d\n",

455

 

                     import_result->secret_imported);

456

 

        fprintf_plus(stderr,

457

 

                     "The number of unchanged secret keys: %d\n",

458

 

                     import_result->secret_unchanged);

459

 

        fprintf_plus(stderr, "The number of keys not imported: %d\n",

460

 

                     import_result->not_imported);

461

 

        for(gpgme_import_status_t import_status

462

 

              = import_result->imports;

463

 

            import_status != NULL;

464

 

            import_status = import_status->next){

465

 

          fprintf_plus(stderr, "Import status for key: %s\n",

466

 

                       import_status->fpr);

467

 

          if(import_status->result != GPG_ERR_NO_ERROR){

468

 

            fprintf_plus(stderr, "Import result: %s: %s\n",

469

 

                         gpgme_strsource(import_status->result),

470

 

                         gpgme_strerror(import_status->result));

471

 

          }

472

 

          fprintf_plus(stderr, "Key status:\n");

473

 

          fprintf_plus(stderr,

474

 

                       import_status->status & GPGME_IMPORT_NEW

475

 

                       ? "The key was new.\n"

476

 

                       : "The key was not new.\n");

477

 

          fprintf_plus(stderr,

478

 

                       import_status->status & GPGME_IMPORT_UID

479

 

                       ? "The key contained new user IDs.\n"

480

 

                       : "The key did not contain new user IDs.\n");

481

 

          fprintf_plus(stderr,

482

 

                       import_status->status & GPGME_IMPORT_SIG

483

 

                       ? "The key contained new signatures.\n"

484

 

                       : "The key did not contain new signatures.\n");

485

 

          fprintf_plus(stderr,

486

 

                       import_status->status & GPGME_IMPORT_SUBKEY

487

 

                       ? "The key contained new sub keys.\n"

488

 

                       : "The key did not contain new sub keys.\n");

489

 

          fprintf_plus(stderr,

490

 

                       import_status->status & GPGME_IMPORT_SECRET

491

 

                       ? "The key contained a secret key.\n"

492

 

                       : "The key did not contain a secret key.\n");

493

 

        }

494

 

        return false;

495

 

      }

496

 

    }

497

307

    

498

 

    ret = close(fd);

 

308

    ret = (int)TEMP_FAILURE_RETRY(close(fd));

499

309

    if(ret == -1){

500

310

      perror_plus("close");

501

311

    }

540

350

  /* Create new GPGME "context" */

541

351

  rc = gpgme_new(&(mc->ctx));

542

352

  if(rc != GPG_ERR_NO_ERROR){

543

 

    fprintf_plus(stderr, "bad gpgme_new: %s: %s\n",

544

 

                 gpgme_strsource(rc), gpgme_strerror(rc));

 

353

    fprintf_plus(stderr, "Mandos plugin mandos-client: "

 

354

                 "bad gpgme_new: %s: %s\n", gpgme_strsource(rc),

 

355

                 gpgme_strerror(rc));

545

356

    return false;

546

357

  }

547

358

  

583

394

  /* Create new empty GPGME data buffer for the plaintext */

584

395

  rc = gpgme_data_new(&dh_plain);

585

396

  if(rc != GPG_ERR_NO_ERROR){

586

 

    fprintf_plus(stderr, "bad gpgme_data_new: %s: %s\n",

 

397

    fprintf_plus(stderr, "Mandos plugin mandos-client: "

 

398

                 "bad gpgme_data_new: %s: %s\n",

587

399

                 gpgme_strsource(rc), gpgme_strerror(rc));

588

400

    gpgme_data_release(dh_crypto);

589

401

    return -1;

602

414

      if(result == NULL){

603

415

        fprintf_plus(stderr, "gpgme_op_decrypt_result failed\n");

604

416

      } else {

605

 

        if(result->unsupported_algorithm != NULL) {

606

 

          fprintf_plus(stderr, "Unsupported algorithm: %s\n",

607

 

                       result->unsupported_algorithm);

608

 

        }

609

 

        fprintf_plus(stderr, "Wrong key usage: %s\n",

610

 

                     result->wrong_key_usage ? "Yes" : "No");

 

417

        fprintf_plus(stderr, "Unsupported algorithm: %s\n",

 

418

                     result->unsupported_algorithm);

 

419

        fprintf_plus(stderr, "Wrong key usage: %u\n",

 

420

                     result->wrong_key_usage);

611

421

        if(result->file_name != NULL){

612

422

          fprintf_plus(stderr, "File name: %s\n", result->file_name);

613

423

        }

614

 

 

615

 

        for(gpgme_recipient_t r = result->recipients; r != NULL;

616

 

            r = r->next){

 

424

        gpgme_recipient_t recipient;

 

425

        recipient = result->recipients;

 

426

        while(recipient != NULL){

617

427

          fprintf_plus(stderr, "Public key algorithm: %s\n",

618

 

                       gpgme_pubkey_algo_name(r->pubkey_algo));

619

 

          fprintf_plus(stderr, "Key ID: %s\n", r->keyid);

 

428

                       gpgme_pubkey_algo_name

 

429

                       (recipient->pubkey_algo));

 

430

          fprintf_plus(stderr, "Key ID: %s\n", recipient->keyid);

620

431

          fprintf_plus(stderr, "Secret key available: %s\n",

621

 

                       r->status == GPG_ERR_NO_SECKEY ? "No" : "Yes");

 

432

                       recipient->status == GPG_ERR_NO_SECKEY

 

433

                       ? "No" : "Yes");

 

434

          recipient = recipient->next;

622

435

        }

623

436

      }

624

437

    }

700

513

  fprintf_plus(stderr, "GnuTLS: %s", string);

701

514

}

702

515

 

703

 

__attribute__((nonnull(1, 2, 4), warn_unused_result))

 

516

__attribute__((nonnull, warn_unused_result))

704

517

static int init_gnutls_global(const char *pubkeyfilename,

705

518

                              const char *seckeyfilename,

706

519

                              const char *dhparamsfilename,

707

520

                              mandos_context *mc){

708

521

  int ret;

 

522

  unsigned int uret;

709

523

  

710

524

  if(debug){

711

525

    fprintf_plus(stderr, "Initializing GnuTLS\n");

712

526

  }

713

527

  

 

528

  ret = gnutls_global_init();

 

529

  if(ret != GNUTLS_E_SUCCESS){

 

530

    fprintf_plus(stderr, "GnuTLS global_init: %s\n",

 

531

                 safer_gnutls_strerror(ret));

 

532

    return -1;

 

533

  }

 

534

  

714

535

  if(debug){

715

536

    /* "Use a log level over 10 to enable all debugging options."

716

537

     * - GnuTLS manual

724

545

  if(ret != GNUTLS_E_SUCCESS){

725

546

    fprintf_plus(stderr, "GnuTLS memory error: %s\n",

726

547

                 safer_gnutls_strerror(ret));

 

548

    gnutls_global_deinit();

727

549

    return -1;

728

550

  }

729

551

  

730

552

  if(debug){

731

 

    fprintf_plus(stderr, "Attempting to use public key %s and"

732

 

                 " private key %s as GnuTLS credentials\n",

 

553

    fprintf_plus(stderr, "Attempting to use OpenPGP public key %s and"

 

554

                 " secret key %s as GnuTLS credentials\n",

733

555

                 pubkeyfilename,

734

556

                 seckeyfilename);

735

557

  }

736

558

  

737

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

738

 

  ret = gnutls_certificate_set_rawpk_key_file

739

 

    (mc->cred, pubkeyfilename, seckeyfilename,

740

 

     GNUTLS_X509_FMT_PEM,       /* format */

741

 

     NULL,                      /* pass */

742

 

     /* key_usage */

743

 

     GNUTLS_KEY_DIGITAL_SIGNATURE | GNUTLS_KEY_KEY_ENCIPHERMENT,

744

 

     NULL,                      /* names */

745

 

     0,                         /* names_length */

746

 

     /* privkey_flags */

747

 

     GNUTLS_PKCS_PLAIN | GNUTLS_PKCS_NULL_PASSWORD,

748

 

     0);                        /* pkcs11_flags */

749

 

#elif GNUTLS_VERSION_NUMBER < 0x030600

750

559

  ret = gnutls_certificate_set_openpgp_key_file

751

560

    (mc->cred, pubkeyfilename, seckeyfilename,

752

561

     GNUTLS_OPENPGP_FMT_BASE64);

753

 

#else

754

 

#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"

755

 

#endif

756

562

  if(ret != GNUTLS_E_SUCCESS){

757

563

    fprintf_plus(stderr,

758

 

                 "Error[%d] while reading the key pair ('%s',"

 

564

                 "Error[%d] while reading the OpenPGP key pair ('%s',"

759

565

                 " '%s')\n", ret, pubkeyfilename, seckeyfilename);

760

566

    fprintf_plus(stderr, "The GnuTLS error is: %s\n",

761

567

                 safer_gnutls_strerror(ret));

809

615

        }

810

616

        params.size += (unsigned int)bytes_read;

811

617

      }

812

 

      ret = close(dhpfile);

813

 

      if(ret == -1){

814

 

        perror_plus("close");

815

 

      }

816

618

      if(params.data == NULL){

817

619

        dhparamsfilename = NULL;

818

620

      }

827

629

                     safer_gnutls_strerror(ret));

828

630

        dhparamsfilename = NULL;

829

631

      }

830

 

      free(params.data);

831

632

    } while(false);

832

633

  }

833

634

  if(dhparamsfilename == NULL){

834

635

    if(mc->dh_bits == 0){

835

 

#if GNUTLS_VERSION_NUMBER < 0x030600

836

636

      /* Find out the optimal number of DH bits */

837

637

      /* Try to read the private key file */

838

638

      gnutls_datum_t buffer = { .data = NULL, .size = 0 };

918

718

          }

919

719

        }

920

720

      }

921

 

      unsigned int uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);

 

721

      uret = gnutls_sec_param_to_pk_bits(GNUTLS_PK_DH, sec_param);

922

722

      if(uret != 0){

923

723

        mc->dh_bits = uret;

924

724

        if(debug){

936

736

                     safer_gnutls_strerror(ret));

937

737

        goto globalfail;

938

738

      }

939

 

#endif

940

 

    } else {                    /* dh_bits != 0 */

941

 

      if(debug){

942

 

        fprintf_plus(stderr, "DH bits explicitly set to %u\n",

943

 

                     mc->dh_bits);

944

 

      }

945

 

      ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);

946

 

      if(ret != GNUTLS_E_SUCCESS){

947

 

        fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"

948

 

                     " bits): %s\n", mc->dh_bits,

949

 

                     safer_gnutls_strerror(ret));

950

 

        goto globalfail;

951

 

      }

952

 

      gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);

 

739

    } else if(debug){

 

740

      fprintf_plus(stderr, "DH bits explicitly set to %u\n",

 

741

                   mc->dh_bits);

 

742

    }

 

743

    ret = gnutls_dh_params_generate2(mc->dh_params, mc->dh_bits);

 

744

    if(ret != GNUTLS_E_SUCCESS){

 

745

      fprintf_plus(stderr, "Error in GnuTLS prime generation (%u"

 

746

                   " bits): %s\n", mc->dh_bits,

 

747

                   safer_gnutls_strerror(ret));

 

748

      goto globalfail;

953

749

    }

954

750

  }

 

751

  gnutls_certificate_set_dh_params(mc->cred, mc->dh_params);

955

752

  

956

753

  return 0;

957

754

  

958

755

 globalfail:

959

756

  

960

757

  gnutls_certificate_free_credentials(mc->cred);

 

758

  gnutls_global_deinit();

961

759

  gnutls_dh_params_deinit(mc->dh_params);

962

760

  return -1;

963

761

}

968

766

  int ret;

969

767

  /* GnuTLS session creation */

970

768

  do {

971

 

    ret = gnutls_init(session, (GNUTLS_SERVER

972

 

#if GNUTLS_VERSION_NUMBER >= 0x030506

973

 

                                | GNUTLS_NO_TICKETS

974

 

#endif

975

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

976

 

                                | GNUTLS_ENABLE_RAWPK

977

 

#endif

978

 

                                ));

 

769

    ret = gnutls_init(session, GNUTLS_SERVER);

979

770

    if(quit_now){

980

771

      return -1;

981

772

    }

1029

820

static void empty_log(__attribute__((unused)) AvahiLogLevel level,

1030

821

                      __attribute__((unused)) const char *txt){}

1031

822

 

 

823

/* Set effective uid to 0, return errno */

 

824

__attribute__((warn_unused_result))

 

825

error_t raise_privileges(void){

 

826

  error_t old_errno = errno;

 

827

  error_t ret_errno = 0;

 

828

  if(seteuid(0) == -1){

 

829

    ret_errno = errno;

 

830

  }

 

831

  errno = old_errno;

 

832

  return ret_errno;

 

833

}

 

834

 

 

835

/* Set effective and real user ID to 0.  Return errno. */

 

836

__attribute__((warn_unused_result))

 

837

error_t raise_privileges_permanently(void){

 

838

  error_t old_errno = errno;

 

839

  error_t ret_errno = raise_privileges();

 

840

  if(ret_errno != 0){

 

841

    errno = old_errno;

 

842

    return ret_errno;

 

843

  }

 

844

  if(setuid(0) == -1){

 

845

    ret_errno = errno;

 

846

  }

 

847

  errno = old_errno;

 

848

  return ret_errno;

 

849

}

 

850

 

 

851

/* Set effective user ID to unprivileged saved user ID */

 

852

__attribute__((warn_unused_result))

 

853

error_t lower_privileges(void){

 

854

  error_t old_errno = errno;

 

855

  error_t ret_errno = 0;

 

856

  if(seteuid(uid) == -1){

 

857

    ret_errno = errno;

 

858

  }

 

859

  errno = old_errno;

 

860

  return ret_errno;

 

861

}

 

862

 

 

863

/* Lower privileges permanently */

 

864

__attribute__((warn_unused_result))

 

865

error_t lower_privileges_permanently(void){

 

866

  error_t old_errno = errno;

 

867

  error_t ret_errno = 0;

 

868

  if(setuid(uid) == -1){

 

869

    ret_errno = errno;

 

870

  }

 

871

  errno = old_errno;

 

872

  return ret_errno;

 

873

}

 

874

 

1032

875

/* Helper function to add_local_route() and delete_local_route() */

1033

876

__attribute__((nonnull, warn_unused_result))

1034

877

static bool add_delete_local_route(const bool add,

1073

916

      ret = setgid(0);

1074

917

      if(ret == -1){

1075

918

        perror_plus("setgid");

1076

 

        close(devnull);

1077

919

        _exit(EX_NOPERM);

1078

920

      }

1079

921

      /* Reset supplementary groups */

1081

923

      ret = setgroups(0, NULL);

1082

924

      if(ret == -1){

1083

925

        perror_plus("setgroups");

1084

 

        close(devnull);

1085

926

        _exit(EX_NOPERM);

1086

927

      }

1087

928

    }

1088

929

    ret = dup2(devnull, STDIN_FILENO);

1089

930

    if(ret == -1){

1090

931

      perror_plus("dup2(devnull, STDIN_FILENO)");

1091

 

      close(devnull);

1092

932

      _exit(EX_OSERR);

1093

933

    }

1094

 

    ret = close(devnull);

 

934

    ret = (int)TEMP_FAILURE_RETRY(close(devnull));

1095

935

    if(ret == -1){

1096

936

      perror_plus("close");

 

937

      _exit(EX_OSERR);

1097

938

    }

1098

939

    ret = dup2(STDERR_FILENO, STDOUT_FILENO);

1099

940

    if(ret == -1){

1113

954

                                                   helper, O_RDONLY));

1114

955

    if(helper_fd == -1){

1115

956

      perror_plus("openat");

1116

 

      close(helperdir_fd);

1117

957

      _exit(EX_UNAVAILABLE);

1118

958

    }

1119

 

    close(helperdir_fd);

 

959

    TEMP_FAILURE_RETRY(close(helperdir_fd));

1120

960

#ifdef __GNUC__

1121

961

#pragma GCC diagnostic push

1122

962

#pragma GCC diagnostic ignored "-Wcast-qual"

1134

974

  }

1135

975

  if(pid == -1){

1136

976

    perror_plus("fork");

1137

 

    close(devnull);

1138

977

    return false;

1139

978

  }

1140

 

  ret = close(devnull);

1141

 

  if(ret == -1){

1142

 

    perror_plus("close");

1143

 

  }

1144

979

  int status;

1145

980

  pid_t pret = -1;

1146

981

  errno = 0;

1246

1081

    bool match = false;

1247

1082

    {

1248

1083

      char *interface = NULL;

1249

 

      while((interface = argz_next(mc->interfaces,

1250

 

                                   mc->interfaces_size,

1251

 

                                   interface))){

 

1084

      while((interface=argz_next(mc->interfaces, mc->interfaces_size,

 

1085

                                 interface))){

1252

1086

        if(if_nametoindex(interface) == (unsigned int)if_index){

1253

1087

          match = true;

1254

1088

          break;

1296

1130

    goto mandos_end;

1297

1131

  }

1298

1132

  

 

1133

  memset(&to, 0, sizeof(to));

1299

1134

  if(af == AF_INET6){

1300

 

    struct sockaddr_in6 *to6 = (struct sockaddr_in6 *)&to;

1301

 

    *to6 = (struct sockaddr_in6){ .sin6_family = (sa_family_t)af };

1302

 

    ret = inet_pton(af, ip, &to6->sin6_addr);

 

1135

    ((struct sockaddr_in6 *)&to)->sin6_family = (sa_family_t)af;

 

1136

    ret = inet_pton(af, ip, &((struct sockaddr_in6 *)&to)->sin6_addr);

1303

1137

  } else {                      /* IPv4 */

1304

 

    struct sockaddr_in *to4 = (struct sockaddr_in *)&to;

1305

 

    *to4 = (struct sockaddr_in){ .sin_family = (sa_family_t)af };

1306

 

    ret = inet_pton(af, ip, &to4->sin_addr);

 

1138

    ((struct sockaddr_in *)&to)->sin_family = (sa_family_t)af;

 

1139

    ret = inet_pton(af, ip, &((struct sockaddr_in *)&to)->sin_addr);

1307

1140

  }

1308

1141

  if(ret < 0 ){

1309

1142

    int e = errno;

1388

1221

                    sizeof(struct sockaddr_in));

1389

1222

    }

1390

1223

    if(ret < 0){

1391

 

      if(((errno == ENETUNREACH) or (errno == EHOSTUNREACH))

 

1224

      if(errno == ENETUNREACH

1392

1225

         and if_index != AVAHI_IF_UNSPEC

1393

1226

         and connect_to == NULL

1394

1227

         and not route_added and

1407

1240

           with an explicit route added with the server's address.

1408

1241

           

1409

1242

           Avahi bug reference:

1410

 

           https://lists.freedesktop.org/archives/avahi/2010-February/001833.html

 

1243

           http://lists.freedesktop.org/archives/avahi/2010-February/001833.html

1411

1244

           https://bugs.debian.org/587961

1412

1245

        */

1413

1246

        if(debug){

1593

1426

                                               &decrypted_buffer, mc);

1594

1427

    if(decrypted_buffer_size >= 0){

1595

1428

      

1596

 

      clearerr(stdout);

1597

1429

      written = 0;

1598

1430

      while(written < (size_t) decrypted_buffer_size){

1599

1431

        if(quit_now){

1615

1447

        }

1616

1448

        written += (size_t)ret;

1617

1449

      }

1618

 

      ret = fflush(stdout);

1619

 

      if(ret != 0){

1620

 

        int e = errno;

1621

 

        if(debug){

1622

 

          fprintf_plus(stderr, "Error writing encrypted data: %s\n",

1623

 

                       strerror(errno));

1624

 

        }

1625

 

        errno = e;

1626

 

        goto mandos_end;

1627

 

      }

1628

1450

      retval = 0;

1629

1451

    }

1630

1452

  }

1643

1465

    free(decrypted_buffer);

1644

1466

    free(buffer);

1645

1467

    if(tcp_sd >= 0){

1646

 

      ret = close(tcp_sd);

 

1468

      ret = (int)TEMP_FAILURE_RETRY(close(tcp_sd));

1647

1469

    }

1648

1470

    if(ret == -1){

1649

1471

      if(e == 0){

1661

1483

  return retval;

1662

1484

}

1663

1485

 

 

1486

__attribute__((nonnull))

1664

1487

static void resolve_callback(AvahiSServiceResolver *r,

1665

1488

                             AvahiIfIndex interface,

1666

1489

                             AvahiProtocol proto,

1803

1626

__attribute__((nonnull, warn_unused_result))

1804

1627

bool get_flags(const char *ifname, struct ifreq *ifr){

1805

1628

  int ret;

1806

 

  int old_errno;

 

1629

  error_t ret_errno;

1807

1630

  

1808

1631

  int s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_IP);

1809

1632

  if(s < 0){

1810

 

    old_errno = errno;

 

1633

    ret_errno = errno;

1811

1634

    perror_plus("socket");

1812

 

    errno = old_errno;

 

1635

    errno = ret_errno;

1813

1636

    return false;

1814

1637

  }

1815

 

  strncpy(ifr->ifr_name, ifname, IF_NAMESIZE);

1816

 

  ifr->ifr_name[IF_NAMESIZE-1] = '\0'; /* NUL terminate */

 

1638

  strcpy(ifr->ifr_name, ifname);

1817

1639

  ret = ioctl(s, SIOCGIFFLAGS, ifr);

1818

1640

  if(ret == -1){

1819

1641

    if(debug){

1820

 

      old_errno = errno;

 

1642

      ret_errno = errno;

1821

1643

      perror_plus("ioctl SIOCGIFFLAGS");

1822

 

      errno = old_errno;

1823

 

    }

1824

 

    if((close(s) == -1) and debug){

1825

 

      old_errno = errno;

1826

 

      perror_plus("close");

1827

 

      errno = old_errno;

 

1644

      errno = ret_errno;

1828

1645

    }

1829

1646

    return false;

1830

1647

  }

1831

 

  if((close(s) == -1) and debug){

1832

 

    old_errno = errno;

1833

 

    perror_plus("close");

1834

 

    errno = old_errno;

1835

 

  }

1836

1648

  return true;

1837

1649

}

1838

1650

 

2099

1911

      return;

2100

1912

    }

2101

1913

  }

2102

 

  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));

2103

 

  if(devnull == -1){

2104

 

    perror_plus("open(\"/dev/null\", O_RDONLY)");

2105

 

    return;

2106

 

  }

 

1914

#ifdef __GLIBC__

 

1915

#if __GLIBC_PREREQ(2, 15)

2107

1916

  int numhooks = scandirat(hookdir_fd, ".", &direntries,

2108

1917

                           runnable_hook, alphasort);

 

1918

#else  /* not __GLIBC_PREREQ(2, 15) */

 

1919

  int numhooks = scandir(hookdir, &direntries, runnable_hook,

 

1920

                         alphasort);

 

1921

#endif  /* not __GLIBC_PREREQ(2, 15) */

 

1922

#else   /* not __GLIBC__ */

 

1923

  int numhooks = scandir(hookdir, &direntries, runnable_hook,

 

1924

                         alphasort);

 

1925

#endif  /* not __GLIBC__ */

2109

1926

  if(numhooks == -1){

2110

1927

    perror_plus("scandir");

2111

 

    close(devnull);

2112

1928

    return;

2113

1929

  }

2114

1930

  struct dirent *direntry;

2115

1931

  int ret;

 

1932

  int devnull = (int)TEMP_FAILURE_RETRY(open("/dev/null", O_RDONLY));

 

1933

  if(devnull == -1){

 

1934

    perror_plus("open(\"/dev/null\", O_RDONLY)");

 

1935

    return;

 

1936

  }

2116

1937

  for(int i = 0; i < numhooks; i++){

2117

1938

    direntry = direntries[i];

2118

1939

    if(debug){

2189

2010

        perror_plus("openat");

2190

2011

        _exit(EXIT_FAILURE);

2191

2012

      }

2192

 

      if(close(hookdir_fd) == -1){

 

2013

      if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){

2193

2014

        perror_plus("close");

2194

2015

        _exit(EXIT_FAILURE);

2195

2016

      }

2198

2019

        perror_plus("dup2(devnull, STDIN_FILENO)");

2199

2020

        _exit(EX_OSERR);

2200

2021

      }

2201

 

      ret = close(devnull);

 

2022

      ret = (int)TEMP_FAILURE_RETRY(close(devnull));

2202

2023

      if(ret == -1){

2203

2024

        perror_plus("close");

2204

2025

        _exit(EX_OSERR);

2253

2074

    free(direntry);

2254

2075

  }

2255

2076

  free(direntries);

2256

 

  if(close(hookdir_fd) == -1){

 

2077

  if((int)TEMP_FAILURE_RETRY(close(hookdir_fd)) == -1){

2257

2078

    perror_plus("close");

2258

2079

  } else {

2259

2080

    hookdir_fd = -1;

2262

2083

}

2263

2084

 

2264

2085

__attribute__((nonnull, warn_unused_result))

2265

 

int bring_up_interface(const char *const interface,

2266

 

                       const float delay){

2267

 

  int old_errno = errno;

 

2086

error_t bring_up_interface(const char *const interface,

 

2087

                           const float delay){

 

2088

  error_t old_errno = errno;

2268

2089

  int ret;

2269

2090

  struct ifreq network;

2270

2091

  unsigned int if_index = if_nametoindex(interface);

2280

2101

  }

2281

2102

  

2282

2103

  if(not interface_is_up(interface)){

2283

 

    int ret_errno = 0;

2284

 

    int ioctl_errno = 0;

 

2104

    error_t ret_errno = 0, ioctl_errno = 0;

2285

2105

    if(not get_flags(interface, &network)){

2286

2106

      ret_errno = errno;

2287

2107

      fprintf_plus(stderr, "Failed to get flags for interface "

2300

2120

    }

2301

2121

    

2302

2122

    if(quit_now){

2303

 

      ret = close(sd);

 

2123

      ret = (int)TEMP_FAILURE_RETRY(close(sd));

2304

2124

      if(ret == -1){

2305

2125

        perror_plus("close");

2306

2126

      }

2356

2176

    }

2357

2177

    

2358

2178

    /* Close the socket */

2359

 

    ret = close(sd);

 

2179

    ret = (int)TEMP_FAILURE_RETRY(close(sd));

2360

2180

    if(ret == -1){

2361

2181

      perror_plus("close");

2362

2182

    }

2374

2194

  

2375

2195

  /* Sleep checking until interface is running.

2376

2196

     Check every 0.25s, up to total time of delay */

2377

 

  for(int i = 0; i < delay * 4; i++){

 

2197

  for(int i=0; i < delay * 4; i++){

2378

2198

    if(interface_is_running(interface)){

2379

2199

      break;

2380

2200

    }

2390

2210

}

2391

2211

 

2392

2212

__attribute__((nonnull, warn_unused_result))

2393

 

int take_down_interface(const char *const interface){

2394

 

  int old_errno = errno;

 

2213

error_t take_down_interface(const char *const interface){

 

2214

  error_t old_errno = errno;

2395

2215

  struct ifreq network;

2396

2216

  unsigned int if_index = if_nametoindex(interface);

2397

2217

  if(if_index == 0){

2400

2220

    return ENXIO;

2401

2221

  }

2402

2222

  if(interface_is_up(interface)){

2403

 

    int ret_errno = 0;

2404

 

    int ioctl_errno = 0;

 

2223

    error_t ret_errno = 0, ioctl_errno = 0;

2405

2224

    if(not get_flags(interface, &network) and debug){

2406

2225

      ret_errno = errno;

2407

2226

      fprintf_plus(stderr, "Failed to get flags for interface "

2445

2264

    }

2446

2265

    

2447

2266

    /* Close the socket */

2448

 

    int ret = close(sd);

 

2267

    int ret = (int)TEMP_FAILURE_RETRY(close(sd));

2449

2268

    if(ret == -1){

2450

2269

      perror_plus("close");

2451

2270

    }

2467

2286

 

2468

2287

int main(int argc, char *argv[]){

2469

2288

  mandos_context mc = { .server = NULL, .dh_bits = 0,

2470

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

2471

 

                        .priority = "SECURE128:!CTYPE-X.509"

2472

 

                        ":+CTYPE-RAWPK:!RSA:!VERS-ALL:+VERS-TLS1.3"

2473

 

                        ":%PROFILE_ULTRA",

2474

 

#elif GNUTLS_VERSION_NUMBER < 0x030600

2475

 

                        .priority = "SECURE256:!CTYPE-X.509"

2476

 

                        ":+CTYPE-OPENPGP:!RSA:+SIGN-DSA-SHA256",

2477

 

#else

2478

 

#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"

2479

 

#endif

2480

 

                        .current_server = NULL, .interfaces = NULL,

2481

 

                        .interfaces_size = 0 };

 

2289

                        .priority = "SECURE256:!CTYPE-X.509:"

 

2290

                        "+CTYPE-OPENPGP:!RSA", .current_server = NULL,

 

2291

                        .interfaces = NULL, .interfaces_size = 0 };

2482

2292

  AvahiSServiceBrowser *sb = NULL;

2483

2293

  error_t ret_errno;

2484

2294

  int ret;

2493

2303

  AvahiIfIndex if_index = AVAHI_IF_UNSPEC;

2494

2304

  const char *seckey = PATHDIR "/" SECKEY;

2495

2305

  const char *pubkey = PATHDIR "/" PUBKEY;

2496

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

2497

 

  const char *tls_privkey = PATHDIR "/" TLS_PRIVKEY;

2498

 

  const char *tls_pubkey = PATHDIR "/" TLS_PUBKEY;

2499

 

#endif

2500

2306

  const char *dh_params_file = NULL;

2501

2307

  char *interfaces_hooks = NULL;

2502

2308

  

2550

2356

      { .name = "pubkey", .key = 'p',

2551

2357

        .arg = "FILE",

2552

2358

        .doc = "OpenPGP public key file base name",

2553

 

        .group = 1 },

2554

 

      { .name = "tls-privkey", .key = 't',

2555

 

        .arg = "FILE",

2556

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

2557

 

        .doc = "TLS private key file base name",

2558

 

#else

2559

 

        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",

2560

 

#endif

2561

 

        .group = 1 },

2562

 

      { .name = "tls-pubkey", .key = 'T',

2563

 

        .arg = "FILE",

2564

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

2565

 

        .doc = "TLS public key file base name",

2566

 

#else

2567

 

        .doc = "Dummy; ignored (requires GnuTLS 3.6.6)",

2568

 

#endif

2569

 

        .group = 1 },

 

2359

        .group = 2 },

2570

2360

      { .name = "dh-bits", .key = 129,

2571

2361

        .arg = "BITS",

2572

2362

        .doc = "Bit length of the prime number used in the"

2628

2418

      case 'p':                 /* --pubkey */

2629

2419

        pubkey = arg;

2630

2420

        break;

2631

 

      case 't':                 /* --tls-privkey */

2632

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

2633

 

        tls_privkey = arg;

2634

 

#endif

2635

 

        break;

2636

 

      case 'T':                 /* --tls-pubkey */

2637

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

2638

 

        tls_pubkey = arg;

2639

 

#endif

2640

 

        break;

2641

2421

      case 129:                 /* --dh-bits */

2642

2422

        errno = 0;

2643

2423

        tmpmax = strtoimax(arg, &tmp, 10);

2678

2458

        argp_state_help(state, state->out_stream,

2679

2459

                        (ARGP_HELP_STD_HELP | ARGP_HELP_EXIT_ERR)

2680

2460

                        & ~(unsigned int)ARGP_HELP_EXIT_OK);

2681

 

        __builtin_unreachable();

2682

2461

      case -3:                  /* --usage */

2683

2462

        argp_state_help(state, state->out_stream,

2684

2463

                        ARGP_HELP_USAGE | ARGP_HELP_EXIT_ERR);

2685

 

        __builtin_unreachable();

2686

2464

      case 'V':                 /* --version */

2687

2465

        fprintf_plus(state->out_stream, "%s\n", argp_program_version);

2688

2466

        exit(argp_err_exit_status);

2697

2475

                         .args_doc = "",

2698

2476

                         .doc = "Mandos client -- Get and decrypt"

2699

2477

                         " passwords from a Mandos server" };

2700

 

    ret_errno = argp_parse(&argp, argc, argv,

2701

 

                           ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);

2702

 

    switch(ret_errno){

 

2478

    ret = argp_parse(&argp, argc, argv,

 

2479

                     ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);

 

2480

    switch(ret){

2703

2481

    case 0:

2704

2482

      break;

2705

2483

    case ENOMEM:

2706

2484

    default:

2707

 

      errno = ret_errno;

 

2485

      errno = ret;

2708

2486

      perror_plus("argp_parse");

2709

2487

      exitcode = EX_OSERR;

2710

2488

      goto end;

2716

2494

  

2717

2495

  {

2718

2496

    /* Work around Debian bug #633582:

2719

 

       <https://bugs.debian.org/633582> */

 

2497

       <http://bugs.debian.org/633582> */

2720

2498

    

2721

2499

    /* Re-raise privileges */

2722

 

    ret = raise_privileges();

2723

 

    if(ret != 0){

2724

 

      errno = ret;

 

2500

    ret_errno = raise_privileges();

 

2501

    if(ret_errno != 0){

 

2502

      errno = ret_errno;

2725

2503

      perror_plus("Failed to raise privileges");

2726

2504

    } else {

2727

2505

      struct stat st;

2743

2521

              }

2744

2522

            }

2745

2523

          }

2746

 

          close(seckey_fd);

 

2524

          TEMP_FAILURE_RETRY(close(seckey_fd));

2747

2525

        }

2748

2526

      }

2749

2527

      

2764

2542

              }

2765

2543

            }

2766

2544

          }

2767

 

          close(pubkey_fd);

 

2545

          TEMP_FAILURE_RETRY(close(pubkey_fd));

2768

2546

        }

2769

2547

      }

2770

2548

      

2771

 

      if(dh_params_file != NULL

2772

 

         and strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){

 

2549

      if(strcmp(dh_params_file, PATHDIR "/dhparams.pem" ) == 0){

2773

2550

        int dhparams_fd = open(dh_params_file, O_RDONLY);

2774

2551

        if(dhparams_fd == -1){

2775

2552

          perror_plus("open");

2786

2563

              }

2787

2564

            }

2788

2565

          }

2789

 

          close(dhparams_fd);

 

2566

          TEMP_FAILURE_RETRY(close(dhparams_fd));

2790

2567

        }

2791

2568

      }

2792

2569

      

2793

2570

      /* Lower privileges */

2794

 

      ret = lower_privileges();

2795

 

      if(ret != 0){

2796

 

        errno = ret;

 

2571

      ret_errno = lower_privileges();

 

2572

      if(ret_errno != 0){

 

2573

        errno = ret_errno;

2797

2574

        perror_plus("Failed to lower privileges");

2798

2575

      }

2799

2576

    }

2999

2776

    goto end;

3000

2777

  }

3001

2778

  

3002

 

#if GNUTLS_VERSION_NUMBER >= 0x030606

3003

 

  ret = init_gnutls_global(tls_pubkey, tls_privkey, dh_params_file, &mc);

3004

 

#elif GNUTLS_VERSION_NUMBER < 0x030600

3005

2779

  ret = init_gnutls_global(pubkey, seckey, dh_params_file, &mc);

3006

 

#else

3007

 

#error "Needs GnuTLS 3.6.6 or later, or before 3.6.0"

3008

 

#endif

3009

2780

  if(ret == -1){

3010

2781

    fprintf_plus(stderr, "init_gnutls_global failed\n");

3011

2782

    exitcode = EX_UNAVAILABLE;

3133

2904

    

3134

2905

    /* Allocate a new server */

3135

2906

    mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),

3136

 

                                 &config, NULL, NULL, &ret);

 

2907

                                 &config, NULL, NULL, &ret_errno);

3137

2908

    

3138

2909

    /* Free the Avahi configuration data */

3139

2910

    avahi_server_config_free(&config);

3142

2913

  /* Check if creating the Avahi server object succeeded */

3143

2914

  if(mc.server == NULL){

3144

2915

    fprintf_plus(stderr, "Failed to create Avahi server: %s\n",

3145

 

                 avahi_strerror(ret));

 

2916

                 avahi_strerror(ret_errno));

3146

2917

    exitcode = EX_UNAVAILABLE;

3147

2918

    goto end;

3148

2919

  }

3183

2954

 end:

3184

2955

  

3185

2956

  if(debug){

3186

 

    if(signal_received){

3187

 

      fprintf_plus(stderr, "%s exiting due to signal %d: %s\n",

3188

 

                   argv[0], signal_received,

3189

 

                   strsignal(signal_received));

3190

 

    } else {

3191

 

      fprintf_plus(stderr, "%s exiting\n", argv[0]);

3192

 

    }

 

2957

    fprintf_plus(stderr, "%s exiting\n", argv[0]);

3193

2958

  }

3194

2959

  

3195

2960

  /* Cleanup things */

3206

2971

  

3207

2972

  if(gnutls_initialized){

3208

2973

    gnutls_certificate_free_credentials(mc.cred);

 

2974

    gnutls_global_deinit();

3209

2975

    gnutls_dh_params_deinit(mc.dh_params);

3210

2976

  }

3211

2977

  

3234

3000

  

3235

3001

  /* Re-raise privileges */

3236

3002

  {

3237

 

    ret = raise_privileges();

3238

 

    if(ret != 0){

3239

 

      errno = ret;

 

3003

    ret_errno = raise_privileges();

 

3004

    if(ret_errno != 0){

 

3005

      errno = ret_errno;

3240

3006

      perror_plus("Failed to raise privileges");

3241

3007

    } else {

3242

3008

      

3247

3013

      /* Take down the network interfaces which were brought up */

3248

3014

      {

3249

3015

        char *interface = NULL;

3250

 

        while((interface = argz_next(interfaces_to_take_down,

3251

 

                                     interfaces_to_take_down_size,

3252

 

                                     interface))){

3253

 

          ret = take_down_interface(interface);

3254

 

          if(ret != 0){

3255

 

            errno = ret;

 

3016

        while((interface=argz_next(interfaces_to_take_down,

 

3017

                                   interfaces_to_take_down_size,

 

3018

                                   interface))){

 

3019

          ret_errno = take_down_interface(interface);

 

3020

          if(ret_errno != 0){

 

3021

            errno = ret_errno;

3256

3022

            perror_plus("Failed to take down interface");

3257

3023

          }

3258

3024

        }

3263

3029

      }

3264

3030

    }

3265

3031

    

3266

 

    ret = lower_privileges_permanently();

3267

 

    if(ret != 0){

3268

 

      errno = ret;

 

3032

    ret_errno = lower_privileges_permanently();

 

3033

    if(ret_errno != 0){

 

3034

      errno = ret_errno;

3269

3035

      perror_plus("Failed to lower privileges permanently");

3270

3036

    }

3271

3037

  }

3273

3039

  free(interfaces_to_take_down);

3274

3040

  free(interfaces_hooks);

3275

3041

  

3276

 

  void clean_dir_at(int base, const char * const dirname,

3277

 

                    uintmax_t level){

3278

 

    struct dirent **direntries = NULL;

3279

 

    int dret;

3280

 

    int dir_fd = (int)TEMP_FAILURE_RETRY(openat(base, dirname,

3281

 

                                                O_RDONLY

3282

 

                                                | O_NOFOLLOW

3283

 

                                                | O_DIRECTORY

3284

 

                                                | O_PATH));

3285

 

    if(dir_fd == -1){

3286

 

      perror_plus("open");

3287

 

      return;

3288

 

    }

3289

 

    int numentries = scandirat(dir_fd, ".", &direntries,

3290

 

                               notdotentries, alphasort);

3291

 

    if(numentries >= 0){

3292

 

      for(int i = 0; i < numentries; i++){

3293

 

        if(debug){

3294

 

          fprintf_plus(stderr, "Unlinking \"%s/%s\"\n",

3295

 

                       dirname, direntries[i]->d_name);

3296

 

        }

3297

 

        dret = unlinkat(dir_fd, direntries[i]->d_name, 0);

3298

 

        if(dret == -1){

3299

 

          if(errno == EISDIR){

3300

 

              dret = unlinkat(dir_fd, direntries[i]->d_name,

3301

 

                              AT_REMOVEDIR);

3302

 

          }         

3303

 

          if((dret == -1) and (errno == ENOTEMPTY)

3304

 

             and (strcmp(direntries[i]->d_name, "private-keys-v1.d")

3305

 

                  == 0) and (level == 0)){

3306

 

            /* Recurse only in this special case */

3307

 

            clean_dir_at(dir_fd, direntries[i]->d_name, level+1);

3308

 

            dret = 0;

3309

 

          }

3310

 

          if((dret == -1) and (errno != ENOENT)){

3311

 

            fprintf_plus(stderr, "unlink(\"%s/%s\"): %s\n", dirname,

3312

 

                         direntries[i]->d_name, strerror(errno));

3313

 

          }

3314

 

        }

3315

 

        free(direntries[i]);

3316

 

      }

3317

 

      

3318

 

      /* need to clean even if 0 because man page doesn't specify */

3319

 

      free(direntries);

3320

 

      dret = unlinkat(base, dirname, AT_REMOVEDIR);

3321

 

      if(dret == -1 and errno != ENOENT){

3322

 

        perror_plus("rmdir");

3323

 

      }

3324

 

    } else {

3325

 

      perror_plus("scandirat");

3326

 

    }

3327

 

    close(dir_fd);

3328

 

  }

3329

 

  

3330

3042

  /* Removes the GPGME temp directory and all files inside */

3331

3043

  if(tempdir != NULL){

3332

 

    clean_dir_at(-1, tempdir, 0);

 

3044

    struct dirent **direntries = NULL;

 

3045

    int tempdir_fd = (int)TEMP_FAILURE_RETRY(open(tempdir, O_RDONLY

 

3046

                                                  | O_NOFOLLOW

 

3047

                                                  | O_DIRECTORY

 

3048

                                                  | O_PATH));

 

3049

    if(tempdir_fd == -1){

 

3050

      perror_plus("open");

 

3051

    } else {

 

3052

#ifdef __GLIBC__

 

3053

#if __GLIBC_PREREQ(2, 15)

 

3054

      int numentries = scandirat(tempdir_fd, ".", &direntries,

 

3055

                                 notdotentries, alphasort);

 

3056

#else  /* not __GLIBC_PREREQ(2, 15) */

 

3057

      int numentries = scandir(tempdir, &direntries, notdotentries,

 

3058

                               alphasort);

 

3059

#endif  /* not __GLIBC_PREREQ(2, 15) */

 

3060

#else   /* not __GLIBC__ */

 

3061

      int numentries = scandir(tempdir, &direntries, notdotentries,

 

3062

                               alphasort);

 

3063

#endif  /* not __GLIBC__ */

 

3064

      if(numentries >= 0){

 

3065

        for(int i = 0; i < numentries; i++){

 

3066

          ret = unlinkat(tempdir_fd, direntries[i]->d_name, 0);

 

3067

          if(ret == -1){

 

3068

            fprintf_plus(stderr, "unlinkat(open(\"%s\", O_RDONLY),"

 

3069

                         " \"%s\", 0): %s\n", tempdir,

 

3070

                         direntries[i]->d_name, strerror(errno));

 

3071

          }

 

3072

          free(direntries[i]);

 

3073

        }

 

3074

        

 

3075

        /* need to clean even if 0 because man page doesn't specify */

 

3076

        free(direntries);

 

3077

        if(numentries == -1){

 

3078

          perror_plus("scandir");

 

3079

        }

 

3080

        ret = rmdir(tempdir);

 

3081

        if(ret == -1 and errno != ENOENT){

 

3082

          perror_plus("rmdir");

 

3083

        }

 

3084

      }

 

3085

      TEMP_FAILURE_RETRY(close(tempdir_fd));

 

3086

    }

3333

3087

  }

3334

3088

  

3335

3089

  if(quit_now){

• Older »

Loggerhead is a web-based interface for Breezy
Version: 2.0.2.dev0