/mandos/trunk

« back to all changes in this revision

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

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

• reverse the comparison (938 to 951)
• stop comparing with revision 951

Show diffs side-by-side

added

removed

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

 

 

327

275

/* 

328

276

 * Initialize GPGME.

329

277

 */

349

297

      return false;

350

298

    }

351

299

    

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

300

    rc = gpgme_data_new_from_fd(&pgp_data, fd);

403

301

    if(rc != GPG_ERR_NO_ERROR){

404

302

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

412

310

                   gpgme_strsource(rc), gpgme_strerror(rc));

413

311

      return false;

414

312

    }

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

313

    

491

314

    ret = close(fd);

492

315

    if(ret == -1){

533

356

  /* Create new GPGME "context" */

534

357

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

535

358

  if(rc != GPG_ERR_NO_ERROR){

536

 

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

537

 

                 gpgme_strsource(rc), gpgme_strerror(rc));

 

359

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

 

360

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

 

361

                 gpgme_strerror(rc));

538

362

    return false;

539

363

  }

540

364

  

576

400

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

577

401

  rc = gpgme_data_new(&dh_plain);

578

402

  if(rc != GPG_ERR_NO_ERROR){

579

 

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

 

403

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

 

404

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

580

405

                 gpgme_strsource(rc), gpgme_strerror(rc));

581

406

    gpgme_data_release(dh_crypto);

582

407

    return -1;

595

420

      if(result == NULL){

596

421

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

597

422

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

 

423

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

 

424

                     result->unsupported_algorithm);

 

425

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

 

426

                     result->wrong_key_usage);

604

427

        if(result->file_name != NULL){

605

428

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

606

429

        }

607

 

 

608

 

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

609

 

            r = r->next){

 

430

        gpgme_recipient_t recipient;

 

431

        recipient = result->recipients;

 

432

        while(recipient != NULL){

610

433

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

 

434

                       gpgme_pubkey_algo_name

 

435

                       (recipient->pubkey_algo));

 

436

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

613

437

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

614

 

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

 

438

                       recipient->status == GPG_ERR_NO_SECKEY

 

439

                       ? "No" : "Yes");

 

440

          recipient = recipient->next;

615

441

        }

616

442

      }

617

443

    }

787

613

        }

788

614

        params.size += (unsigned int)bytes_read;

789

615

      }

790

 

      ret = close(dhpfile);

791

 

      if(ret == -1){

792

 

        perror_plus("close");

793

 

      }

794

616

      if(params.data == NULL){

795

617

        dhparamsfilename = NULL;

796

618

      }

996

818

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

997

819

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

998

820

 

 

821

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

 

822

__attribute__((warn_unused_result))

 

823

int raise_privileges(void){

 

824

  int old_errno = errno;

 

825

  int ret = 0;

 

826

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

 

827

    ret = errno;

 

828

  }

 

829

  errno = old_errno;

 

830

  return ret;

 

831

}

 

832

 

 

833

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

 

834

__attribute__((warn_unused_result))

 

835

int raise_privileges_permanently(void){

 

836

  int old_errno = errno;

 

837

  int ret = raise_privileges();

 

838

  if(ret != 0){

 

839

    errno = old_errno;

 

840

    return ret;

 

841

  }

 

842

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

 

843

    ret = errno;

 

844

  }

 

845

  errno = old_errno;

 

846

  return ret;

 

847

}

 

848

 

 

849

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

 

850

__attribute__((warn_unused_result))

 

851

int lower_privileges(void){

 

852

  int old_errno = errno;

 

853

  int ret = 0;

 

854

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

 

855

    ret = errno;

 

856

  }

 

857

  errno = old_errno;

 

858

  return ret;

 

859

}

 

860

 

 

861

/* Lower privileges permanently */

 

862

__attribute__((warn_unused_result))

 

863

int lower_privileges_permanently(void){

 

864

  int old_errno = errno;

 

865

  int ret = 0;

 

866

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

 

867

    ret = errno;

 

868

  }

 

869

  errno = old_errno;

 

870

  return ret;

 

871

}

 

872

 

999

873

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

1000

874

__attribute__((nonnull, warn_unused_result))

1001

875

static bool add_delete_local_route(const bool add,

1781

1655

      perror_plus("ioctl SIOCGIFFLAGS");

1782

1656

      errno = old_errno;

1783

1657

    }

1784

 

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

1785

 

      old_errno = errno;

1786

 

      perror_plus("close");

1787

 

      errno = old_errno;

1788

 

    }

1789

1658

    return false;

1790

1659

  }

1791

 

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

1792

 

    old_errno = errno;

1793

 

    perror_plus("close");

1794

 

    errno = old_errno;

1795

 

  }

1796

1660

  return true;

1797

1661

}

1798

1662

 

• Older »

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