/mandos/release : revision 237.7.312

9

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

10

*

11

* Everything else is

12

13

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

13

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,

272

266

return true;

273

267

}

274

268

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

327

269

/*

328

270

* Initialize GPGME.

329

271

*/

349

291

return false;

350

292

}

351

293

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

402

294

rc = gpgme_data_new_from_fd(&pgp_data, fd);

403

295

if(rc != GPG_ERR_NO_ERROR){

404

296

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

412

304

gpgme_strsource(rc), gpgme_strerror(rc));

413

305

return false;

414

306

}

415

{

416

gpgme_import_result_t import_result

417

= gpgme_op_import_result(mc->ctx);

418

if((import_result->imported < 1

419

or import_result->not_imported > 0)

420

and import_result->unchanged == 0){

421

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

422

fprintf_plus(stderr,

423

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

424

import_result->considered);

425

fprintf_plus(stderr,

426

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

427

import_result->no_user_id);

428

fprintf_plus(stderr,

429

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

430

import_result->imported);

431

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

432

import_result->imported_rsa);

433

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

434

import_result->unchanged);

435

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

436

import_result->new_user_ids);

437

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

438

import_result->new_sub_keys);

439

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

440

import_result->new_signatures);

441

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

442

import_result->new_revocations);

443

fprintf_plus(stderr,

444

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

445

import_result->secret_read);

446

fprintf_plus(stderr,

447

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

448

import_result->secret_imported);

449

fprintf_plus(stderr,

450

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

451

import_result->secret_unchanged);

452

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

453

import_result->not_imported);

454

for(gpgme_import_status_t import_status

455

= import_result->imports;

456

import_status != NULL;

457

import_status = import_status->next){

458

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

459

import_status->fpr);

460

if(import_status->result != GPG_ERR_NO_ERROR){

461

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

462

gpgme_strsource(import_status->result),

463

gpgme_strerror(import_status->result));

464

}

465

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

466

fprintf_plus(stderr,

467

import_status->status & GPGME_IMPORT_NEW

468

? "The key was new.\n"

469

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

470

fprintf_plus(stderr,

471

import_status->status & GPGME_IMPORT_UID

472

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

473

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

474

fprintf_plus(stderr,

475

import_status->status & GPGME_IMPORT_SIG

476

? "The key contained new signatures.\n"

477

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

478

fprintf_plus(stderr,

479

import_status->status & GPGME_IMPORT_SUBKEY

480

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

481

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

482

fprintf_plus(stderr,

483

import_status->status & GPGME_IMPORT_SECRET

484

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

485

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

486

}

487

return false;

488

}

489

}

490

307

491

ret = close(fd);

308

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

492

309

if(ret == -1){

493

310

perror_plus("close");

494

311

}

533

350

/* Create new GPGME "context" */

534

351

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

535

352

if(rc != GPG_ERR_NO_ERROR){

536

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

537

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));

538

356

return false;

539

357

}

540

358

576

394

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

577

395

rc = gpgme_data_new(&dh_plain);

578

396

if(rc != GPG_ERR_NO_ERROR){

579

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",

580

399

gpgme_strsource(rc), gpgme_strerror(rc));

581

400

gpgme_data_release(dh_crypto);

582

401

return -1;

595

414

if(result == NULL){

596

415

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

597

416

} else {

598

if(result->unsupported_algorithm != NULL) {

599

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

600

result->unsupported_algorithm);

601

}

602

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

603

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);

604

421

if(result->file_name != NULL){

605

422

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

606

423

}

607

608

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

609

r = r->next){

424

gpgme_recipient_t recipient;

425

recipient = result->recipients;

426

while(recipient != NULL){

610

427

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

611

gpgme_pubkey_algo_name(r->pubkey_algo));

612

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);

613

431

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

614

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

432

recipient->status == GPG_ERR_NO_SECKEY

433

? "No" : "Yes");

434

recipient = recipient->next;

615

435

}

616

436

}

617

437

}

693

513

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

694

514

}

695

515

696

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

516

__attribute__((nonnull, warn_unused_result))

697

517

static int init_gnutls_global(const char *pubkeyfilename,

698

518

const char *seckeyfilename,

699

519

const char *dhparamsfilename,

705

525

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

706

526

}

707

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

708

535

if(debug){

709

536

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

710

537

* - GnuTLS manual

718

545

if(ret != GNUTLS_E_SUCCESS){

719

546

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

720

547

safer_gnutls_strerror(ret));

548

gnutls_global_deinit();

721

549

return -1;

722

550

}

723

551

787

615

}

788

616

params.size += (unsigned int)bytes_read;

789

617

}

790

ret = close(dhpfile);

791

if(ret == -1){

792

perror_plus("close");

793

}

794

618

if(params.data == NULL){

795

619

dhparamsfilename = NULL;

796

620

}

805

629

safer_gnutls_strerror(ret));

806

630

dhparamsfilename = NULL;

807

631

}

808

free(params.data);

809

632

} while(false);

810

633

}

811

634

if(dhparamsfilename == NULL){

932

755

globalfail:

933

756

934

757

gnutls_certificate_free_credentials(mc->cred);

758

gnutls_global_deinit();

935

759

gnutls_dh_params_deinit(mc->dh_params);

936

760

return -1;

937

761

}

996

820

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

997

821

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

998

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

999

875

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

1000

876

__attribute__((nonnull, warn_unused_result))

1001

877

static bool add_delete_local_route(const bool add,

1055

931

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

1056

932

_exit(EX_OSERR);

1057

933

}

1058

ret = close(devnull);

934

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

1059

935

if(ret == -1){

1060

936

perror_plus("close");

1061

937

_exit(EX_OSERR);

1078

954

helper, O_RDONLY));

1079

955

if(helper_fd == -1){

1080

956

perror_plus("openat");

1081

close(helperdir_fd);

1082

957

_exit(EX_UNAVAILABLE);

1083

958

}

1084

close(helperdir_fd);

959

TEMP_FAILURE_RETRY(close(helperdir_fd));

1085

960

#ifdef __GNUC__

1086

961

#pragma GCC diagnostic push

1087

962

#pragma GCC diagnostic ignored "-Wcast-qual"

1206

1081

bool match = false;

1207

1082

{

1208

1083

char *interface = NULL;

1209

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

1210

mc->interfaces_size,

1211

interface))){

1084

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

1085

interface))){

1212

1086

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

1213

1087

match = true;

1214

1088

break;

1256

1130

goto mandos_end;

1257

1131

}

1258

1132

1133

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

1259

1134

if(af == AF_INET6){

1260

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

1261

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

1262

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);

1263

1137

} else { /* IPv4 */

1264

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

1265

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

1266

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);

1267

1140

}

1268

1141

if(ret < 0 ){

1269

1142

int e = errno;

1348

1221

sizeof(struct sockaddr_in));

1349

1222

}

1350

1223

if(ret < 0){

1351

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

1224

if(errno == ENETUNREACH

1352

1225

and if_index != AVAHI_IF_UNSPEC

1353

1226

and connect_to == NULL

1354

1227

and not route_added and

1367

1240

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

1368

1241

1369

1242

Avahi bug reference:

1370

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

1243

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

1371

1244

https://bugs.debian.org/587961

1372

1245

*/

1373

1246

if(debug){

1553

1426

&decrypted_buffer, mc);

1554

1427

if(decrypted_buffer_size >= 0){

1555

1428

1556

clearerr(stdout);

1557

1429

written = 0;

1558

1430

while(written < (size_t) decrypted_buffer_size){

1559

1431

if(quit_now){

1575

1447

}

1576

1448

written += (size_t)ret;

1577

1449

}

1578

ret = fflush(stdout);

1579

if(ret != 0){

1580

int e = errno;

1581

if(debug){

1582

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

1583

strerror(errno));

1584

}

1585

errno = e;

1586

goto mandos_end;

1587

}

1588

1450

retval = 0;

1589

1451

}

1590

1452

}

1603

1465

free(decrypted_buffer);

1604

1466

free(buffer);

1605

1467

if(tcp_sd >= 0){

1606

ret = close(tcp_sd);

1468

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

1607

1469

}

1608

1470

if(ret == -1){

1609

1471

if(e == 0){

1621

1483

return retval;

1622

1484

}

1623

1485

1486

__attribute__((nonnull))

1624

1487

static void resolve_callback(AvahiSServiceResolver *r,

1625

1488

AvahiIfIndex interface,

1626

1489

AvahiProtocol proto,

1763

1626

__attribute__((nonnull, warn_unused_result))

1764

1627

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

1765

1628

int ret;

1766

int old_errno;

1629

error_t ret_errno;

1767

1630

1768

1631

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

1769

1632

if(s < 0){

1770

old_errno = errno;

1633

ret_errno = errno;

1771

1634

perror_plus("socket");

1772

errno = old_errno;

1635

errno = ret_errno;

1773

1636

return false;

1774

1637

}

1775

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

1776

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

1638

strcpy(ifr->ifr_name, ifname);

1777

1639

ret = ioctl(s, SIOCGIFFLAGS, ifr);

1778

1640

if(ret == -1){

1779

1641

if(debug){

1780

old_errno = errno;

1642

ret_errno = errno;

1781

1643

perror_plus("ioctl SIOCGIFFLAGS");

1782

errno = old_errno;

1783

}

1784

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

1785

old_errno = errno;

1786

perror_plus("close");

1787

errno = old_errno;

1644

errno = ret_errno;

1788

1645

}

1789

1646

return false;

1790

1647

}

1791

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

1792

old_errno = errno;

1793

perror_plus("close");

1794

errno = old_errno;

1795

}

1796

1648

return true;

1797

1649

}

1798

1650

2059

1911

return;

2060

1912

}

2061

1913

}

2062

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

2063

if(devnull == -1){

2064

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

2065

return;

2066

}

1914

#ifdef __GLIBC__

1915

#if __GLIBC_PREREQ(2, 15)

2067

1916

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

2068

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__ */

2069

1926

if(numhooks == -1){

2070

1927

perror_plus("scandir");

2071

close(devnull);

2072

1928

return;

2073

1929

}

2074

1930

struct dirent *direntry;

2075

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

}

2076

1937

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

2077

1938

direntry = direntries[i];

2078

1939

if(debug){

2149

2010

perror_plus("openat");

2150

2011

_exit(EXIT_FAILURE);

2151

2012

}

2152

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

2013

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

2153

2014

perror_plus("close");

2154

2015

_exit(EXIT_FAILURE);

2155

2016

}

2158

2019

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

2159

2020

_exit(EX_OSERR);

2160

2021

}

2161

ret = close(devnull);

2022

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

2162

2023

if(ret == -1){

2163

2024

perror_plus("close");

2164

2025

_exit(EX_OSERR);

2213

2074

free(direntry);

2214

2075

}

2215

2076

free(direntries);

2216

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

2077

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

2217

2078

perror_plus("close");

2218

2079

} else {

2219

2080

hookdir_fd = -1;

2222

2083

}

2223

2084

2224

2085

__attribute__((nonnull, warn_unused_result))

2225

int bring_up_interface(const char *const interface,

2226

const float delay){

2227

int old_errno = errno;

2086

error_t bring_up_interface(const char *const interface,

2087

const float delay){

2088

error_t old_errno = errno;

2228

2089

int ret;

2229

2090

struct ifreq network;

2230

2091

unsigned int if_index = if_nametoindex(interface);

2240

2101

}

2241

2102

2242

2103

if(not interface_is_up(interface)){

2243

int ret_errno = 0;

2244

int ioctl_errno = 0;

2104

error_t ret_errno = 0, ioctl_errno = 0;

2245

2105

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

2246

2106

ret_errno = errno;

2247

2107

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

2260

2120

}

2261

2121

2262

2122

if(quit_now){

2263

ret = close(sd);

2123

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

2264

2124

if(ret == -1){

2265

2125

perror_plus("close");

2266

2126

}

2316

2176

}

2317

2177

2318

2178

/* Close the socket */

2319

ret = close(sd);

2179

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

2320

2180

if(ret == -1){

2321

2181

perror_plus("close");

2322

2182

}

2334

2194

2335

2195

/* Sleep checking until interface is running.

2336

2196

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

2337

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

2197

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

2338

2198

if(interface_is_running(interface)){

2339

2199

break;

2340

2200

}

2350

2210

}

2351

2211

2352

2212

__attribute__((nonnull, warn_unused_result))

2353

int take_down_interface(const char *const interface){

2354

int old_errno = errno;

2213

error_t take_down_interface(const char *const interface){

2214

error_t old_errno = errno;

2355

2215

struct ifreq network;

2356

2216

unsigned int if_index = if_nametoindex(interface);

2357

2217

if(if_index == 0){

2360

2220

return ENXIO;

2361

2221

}

2362

2222

if(interface_is_up(interface)){

2363

int ret_errno = 0;

2364

int ioctl_errno = 0;

2223

error_t ret_errno = 0, ioctl_errno = 0;

2365

2224

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

2366

2225

ret_errno = errno;

2367

2226

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

2405

2264

}

2406

2265

2407

2266

/* Close the socket */

2408

int ret = close(sd);

2267

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

2409

2268

if(ret == -1){

2410

2269

perror_plus("close");

2411

2270

}

2427

2286

2428

2287

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

2429

2288

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

2430

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

2431

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

2432

.current_server = NULL, .interfaces = NULL,

2433

.interfaces_size = 0 };

2289

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

2290

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

2291

.interfaces = NULL, .interfaces_size = 0 };

2434

2292

AvahiSServiceBrowser *sb = NULL;

2435

2293

error_t ret_errno;

2436

2294

int ret;

2617

2475

.args_doc = "",

2618

2476

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

2619

2477

" passwords from a Mandos server" };

2620

ret_errno = argp_parse(&argp, argc, argv,

2621

ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);

2622

switch(ret_errno){

2478

ret = argp_parse(&argp, argc, argv,

2479

ARGP_IN_ORDER | ARGP_NO_HELP, 0, NULL);

2480

switch(ret){

2623

2481

case 0:

2624

2482

break;

2625

2483

case ENOMEM:

2626

2484

default:

2627

errno = ret_errno;

2485

errno = ret;

2628

2486

perror_plus("argp_parse");

2629

2487

exitcode = EX_OSERR;

2630

2488

goto end;

2636

2494

2637

2495

{

2638

2496

/* Work around Debian bug #633582:

2639

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

2497

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

2640

2498

2641

2499

/* Re-raise privileges */

2642

ret = raise_privileges();

2643

if(ret != 0){

2644

errno = ret;

2500

ret_errno = raise_privileges();

2501

if(ret_errno != 0){

2502

errno = ret_errno;

2645

2503

perror_plus("Failed to raise privileges");

2646

2504

} else {

2647

2505

struct stat st;

2663

2521

}

2664

2522

}

2665

2523

}

2666

close(seckey_fd);

2524

TEMP_FAILURE_RETRY(close(seckey_fd));

2667

2525

}

2668

2526

}

2669

2527

2684

2542

}

2685

2543

}

2686

2544

}

2687

close(pubkey_fd);

2688

}

2689

}

2690

2691

if(dh_params_file != NULL

2692

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

2693

int dhparams_fd = open(dh_params_file, O_RDONLY);

2694

if(dhparams_fd == -1){

2695

perror_plus("open");

2696

} else {

2697

ret = (int)TEMP_FAILURE_RETRY(fstat(dhparams_fd, &st));

2698

if(ret == -1){

2699

perror_plus("fstat");

2700

} else {

2701

if(S_ISREG(st.st_mode)

2702

and st.st_uid == 0 and st.st_gid == 0){

2703

ret = fchown(dhparams_fd, uid, gid);

2704

if(ret == -1){

2705

perror_plus("fchown");

2706

}

2707

}

2708

}

2709

close(dhparams_fd);

2545

TEMP_FAILURE_RETRY(close(pubkey_fd));

2710

2546

}

2711

2547

}

2712

2548

2713

2549

/* Lower privileges */

2714

ret = lower_privileges();

2715

if(ret != 0){

2716

errno = ret;

2550

ret_errno = lower_privileges();

2551

if(ret_errno != 0){

2552

errno = ret_errno;

2717

2553

perror_plus("Failed to lower privileges");

2718

2554

}

2719

2555

}

2889

2725

errno = bring_up_interface(interface, delay);

2890

2726

if(not interface_was_up){

2891

2727

if(errno != 0){

2892

fprintf_plus(stderr, "Failed to bring up interface \"%s\":"

2893

" %s\n", interface, strerror(errno));

2728

perror_plus("Failed to bring up interface");

2894

2729

} else {

2895

2730

errno = argz_add(&interfaces_to_take_down,

2896

2731

&interfaces_to_take_down_size,

3047

2882

3048

2883

/* Allocate a new server */

3049

2884

mc.server = avahi_server_new(avahi_simple_poll_get(simple_poll),

3050

&config, NULL, NULL, &ret);

2885

&config, NULL, NULL, &ret_errno);

3051

2886

3052

2887

/* Free the Avahi configuration data */

3053

2888

avahi_server_config_free(&config);

3056

2891

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

3057

2892

if(mc.server == NULL){

3058

2893

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

3059

avahi_strerror(ret));

2894

avahi_strerror(ret_errno));

3060

2895

exitcode = EX_UNAVAILABLE;

3061

2896

goto end;

3062

2897

}

3097

2932

end:

3098

2933

3099

2934

if(debug){

3100

if(signal_received){

3101

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

3102

argv[0], signal_received,

3103

strsignal(signal_received));

3104

} else {

3105

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

3106

}

2935

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

3107

2936

}

3108

2937

3109

2938

/* Cleanup things */

3120

2949

3121

2950

if(gnutls_initialized){

3122

2951

gnutls_certificate_free_credentials(mc.cred);

2952

gnutls_global_deinit();

3123

2953

gnutls_dh_params_deinit(mc.dh_params);

3124

2954

}

3125

2955

3148

2978

3149

2979

/* Re-raise privileges */

3150

2980

{

3151

ret = raise_privileges();

3152

if(ret != 0){

3153

errno = ret;

2981

ret_errno = raise_privileges();

2982

if(ret_errno != 0){

2983

errno = ret_errno;

3154

2984

perror_plus("Failed to raise privileges");

3155

2985

} else {

3156

2986

3161

2991

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

3162

2992

{

3163

2993

char *interface = NULL;

3164

while((interface = argz_next(interfaces_to_take_down,

3165

interfaces_to_take_down_size,

3166

interface))){

3167

ret = take_down_interface(interface);

3168

if(ret != 0){

3169

errno = ret;

2994

while((interface=argz_next(interfaces_to_take_down,

2995

interfaces_to_take_down_size,

2996

interface))){

2997

ret_errno = take_down_interface(interface);

2998

if(ret_errno != 0){

2999

errno = ret_errno;

3170

3000

perror_plus("Failed to take down interface");

3171

3001

}

3172

3002

}

3177

3007

}

3178

3008

}

3179

3009

3180

ret = lower_privileges_permanently();

3181

if(ret != 0){

3182

errno = ret;

3010

ret_errno = lower_privileges_permanently();

3011

if(ret_errno != 0){

3012

errno = ret_errno;

3183

3013

perror_plus("Failed to lower privileges permanently");

3184

3014

}

3185

3015

}

3187

3017

free(interfaces_to_take_down);

3188

3018

free(interfaces_hooks);

3189

3019

3190

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

3191

uintmax_t level){

3192

struct dirent **direntries = NULL;

3193

int dret;

3194

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

3195

O_RDONLY

3196

| O_NOFOLLOW

3197

| O_DIRECTORY

3198

| O_PATH));

3199

if(dir_fd == -1){

3200

perror_plus("open");

3201

return;

3202

}

3203

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

3204

notdotentries, alphasort);

3205

if(numentries >= 0){

3206

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

3207

if(debug){

3208

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

3209

dirname, direntries[i]->d_name);

3210

}

3211

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

3212

if(dret == -1){

3213

if(errno == EISDIR){

3214

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

3215

AT_REMOVEDIR);

3216

}

3217

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

3218

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

3219

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

3220

/* Recurse only in this special case */

3221

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

3222

dret = 0;

3223

}

3224

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

3225

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

3226

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

3227

}

3228

}

3229

free(direntries[i]);

3230

}

3231

3232

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

3233

free(direntries);

3234

dret = unlinkat(base, dirname, AT_REMOVEDIR);

3235

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

3236

perror_plus("rmdir");

3237

}

3238

} else {

3239

perror_plus("scandirat");

3240

}

3241

close(dir_fd);

3242

}

3243

3244

3020

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

3245

3021

if(tempdir != NULL){

3246

clean_dir_at(-1, tempdir, 0);

3022

struct dirent **direntries = NULL;

3023

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

3024

| O_NOFOLLOW

3025

| O_DIRECTORY

3026

| O_PATH));

3027

if(tempdir_fd == -1){

3028

perror_plus("open");

3029

} else {

3030

#ifdef __GLIBC__

3031

#if __GLIBC_PREREQ(2, 15)

3032

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

3033

notdotentries, alphasort);

3034

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

3035

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

3036

alphasort);

3037

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

3038

#else /* not __GLIBC__ */

3039

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

3040

alphasort);

3041

#endif /* not __GLIBC__ */

3042

if(numentries >= 0){

3043

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

3044

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

3045

if(ret == -1){

3046

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

3047

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

3048

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

3049

}

3050

free(direntries[i]);

3051

}

3052

3053

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

3054

free(direntries);

3055

if(numentries == -1){

3056

perror_plus("scandir");

3057

}

3058

ret = rmdir(tempdir);

3059

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

3060

perror_plus("rmdir");

3061

}

3062

}

3063

TEMP_FAILURE_RETRY(close(tempdir_fd));

3064

}

3247

3065

}

3248

3066

3249

3067

if(quit_now){