/mandos/release : revision 101

56

#include <argp.h> /* struct argp_option, struct

57

argp_state, struct argp,

58

argp_parse(), ARGP_ERR_UNKNOWN,

59

ARGP_KEY_END, ARGP_KEY_ARG,

60

error_t */

59

ARGP_KEY_END, ARGP_KEY_ARG, error_t */

61

60

#include <signal.h> /* struct sigaction, sigemptyset(),

62

61

sigaddset(), sigaction(),

63

62

sigprocmask(), SIG_BLOCK, SIGCHLD,

65

64

#include <errno.h> /* errno, EBADF */

66

65

67

66

#define BUFFER_SIZE 256

68

69

#define PDIR "/lib/mandos/plugins.d"

70

#define AFILE "/conf/conf.d/mandos/plugin-runner.conf"

67

#define ARGFILE "/conf/conf.d/mandos/plugin-runner.conf"

71

68

72

69

const char *argp_program_version = "plugin-runner 1.0";

73

70

const char *argp_program_bug_address = "<mandos@fukt.bsnet.se>";

74

71

75

struct plugin;

72

struct process;

73

74

typedef struct process{

75

pid_t pid;

76

int fd;

77

char *buffer;

78

size_t buffer_size;

79

size_t buffer_length;

80

bool eof;

81

bool completed;

82

int status;

83

struct process *next;

84

} process;

76

85

77

86

typedef struct plugin{

78

87

char *name; /* can be NULL or any plugin name */

81

90

char **environ;

82

91

int envc;

83

92

bool disabled;

84

85

/* Variables used for running processes*/

86

pid_t pid;

87

int fd;

88

char *buffer;

89

size_t buffer_size;

90

size_t buffer_length;

91

bool eof;

92

volatile bool completed;

93

volatile int status;

94

93

struct plugin *next;

95

94

} plugin;

96

95

97

static plugin *plugin_list = NULL;

98

99

/* Gets a existing plugin based on name,

100

or if none is found, creates a new one */

101

static plugin *getplugin(char *name){

102

/* Check for exiting plugin with that name */

103

for (plugin *p = plugin_list; p != NULL; p = p->next){

96

static plugin *getplugin(char *name, plugin **plugin_list){

97

for (plugin *p = *plugin_list; p != NULL; p = p->next){

104

98

if ((p->name == name)

105

99

or (p->name and name and (strcmp(p->name, name) == 0))){

106

100

return p;

118

112

return NULL;

119

113

}

120

114

}

121

115

122

116

*new_plugin = (plugin) { .name = copy_name,

123

117

.argc = 1,

118

.envc = 0,

124

119

.disabled = false,

125

.next = plugin_list };

120

.next = *plugin_list };

126

121

127

122

new_plugin->argv = malloc(sizeof(char *) * 2);

128

123

if (new_plugin->argv == NULL){

141

136

return NULL;

142

137

}

143

138

new_plugin->environ[0] = NULL;

144

145

139

/* Append the new plugin to the list */

146

plugin_list = new_plugin;

140

*plugin_list = new_plugin;

147

141

return new_plugin;

148

142

}

149

143

186

180

return add_to_char_array(def, &(p->environ), &(p->envc));

187

181

}

188

182

183

189

184

/*

190

185

* Based on the example in the GNU LibC manual chapter 13.13 "File

191

186

* Descriptor Flags".

202

197

return fcntl(fd, F_SETFD, ret | FD_CLOEXEC);

203

198

}

204

199

200

process *process_list = NULL;

205

201

206

/* Mark processes as completed when they exit, and save their exit

202

/* Mark a process as completed when it exits, and save its exit

207

203

status. */

208

204

void handle_sigchld(__attribute__((unused)) int sig){

209

while(true){

210

plugin *proc = plugin_list;

211

int status;

212

pid_t pid = waitpid(-1, &status, WNOHANG);

213

if(pid == 0){

214

/* Only still running child processes */

215

break;

216

}

217

if(pid == -1){

218

if (errno != ECHILD){

219

perror("waitpid");

220

}

221

/* No child processes */

222

break;

223

}

224

225

/* A child exited, find it in process_list */

226

while(proc != NULL and proc->pid != pid){

227

proc = proc->next;

228

}

229

if(proc == NULL){

230

/* Process not found in process list */

231

continue;

232

}

233

proc->status = status;

234

proc->completed = true;

235

}

205

process *proc = process_list;

206

int status;

207

pid_t pid = wait(&status);

208

if(pid == -1){

209

perror("wait");

210

return;

211

}

212

while(proc != NULL and proc->pid != pid){

213

proc = proc->next;

214

}

215

if(proc == NULL){

216

/* Process not found in process list */

217

return;

218

}

219

proc->status = status;

220

proc->completed = true;

236

221

}

237

222

238

/* Prints out a password to stdout */

239

223

bool print_out_password(const char *buffer, size_t length){

240

224

ssize_t ret;

241

225

if(length>0 and buffer[length-1] == '\n'){

251

235

return true;

252

236

}

253

237

254

/* Removes and free a plugin from the plugin list */

255

static void free_plugin(plugin *plugin_node){

256

257

for(char **arg = plugin_node->argv; *arg != NULL; arg++){

258

free(*arg);

259

}

260

free(plugin_node->argv);

261

for(char **env = plugin_node->environ; *env != NULL; env++){

262

free(*env);

263

}

264

free(plugin_node->environ);

265

free(plugin_node->buffer);

266

267

/* Removes the plugin from the singly-linked list */

268

if(plugin_node == plugin_list){

269

/* First one - simple */

270

plugin_list = plugin_list->next;

271

} else {

272

/* Second one or later */

273

for(plugin *p = plugin_list; p != NULL; p = p->next){

274

if(p->next == plugin_node){

275

p->next = plugin_node->next;

276

break;

277

}

238

char **add_to_argv(char **argv, int *argc, char *arg){

239

if (argv == NULL){

240

*argc = 1;

241

argv = malloc(sizeof(char*) * 2);

242

if(argv == NULL){

243

return NULL;

278

244

}

279

}

280

281

free(plugin_node);

245

argv[0] = NULL; /* Will be set to argv[0] in main before parsing */

246

argv[1] = NULL;

247

}

248

*argc += 1;

249

argv = realloc(argv, sizeof(char *)

250

* ((unsigned int) *argc + 1));

251

if(argv == NULL){

252

return NULL;

253

}

254

argv[*argc-1] = arg;

255

argv[*argc] = NULL;

256

return argv;

282

257

}

283

258

284

static void free_plugin_list(void){

285

while(plugin_list != NULL){

286

free_plugin(plugin_list);

259

static void free_plugin_list(plugin *plugin_list){

260

for(plugin *next; plugin_list != NULL; plugin_list = next){

261

next = plugin_list->next;

262

for(char **arg = plugin_list->argv; *arg != NULL; arg++){

263

free(*arg);

264

}

265

free(plugin_list->argv);

266

for(char **env = plugin_list->environ; *env != NULL; env++){

267

free(*env);

268

}

269

free(plugin_list->environ);

270

free(plugin_list);

287

271

}

288

272

}

289

273

290

274

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

291

char *plugindir = NULL;

292

char *argfile = NULL;

275

const char *plugindir = "/lib/mandos/plugins.d";

276

const char *argfile = ARGFILE;

293

277

FILE *conffp;

294

278

size_t d_name_len;

295

279

DIR *dir = NULL;

342

326

{ .name = "plugin-dir", .key = 128,

343

327

.arg = "DIRECTORY",

344

328

.doc = "Specify a different plugin directory", .group = 2 },

345

{ .name = "config-file", .key = 129,

346

.arg = "FILE",

347

.doc = "Specify a different configuration file", .group = 2 },

348

{ .name = "userid", .key = 130,

349

.arg = "ID", .flags = 0,

350

.doc = "User ID the plugins will run as", .group = 3 },

351

{ .name = "groupid", .key = 131,

352

.arg = "ID", .flags = 0,

353

.doc = "Group ID the plugins will run as", .group = 3 },

354

{ .name = "debug", .key = 132,

355

.doc = "Debug mode", .group = 4 },

329

{ .name = "userid", .key = 129,

330

.arg = "ID", .flags = 0,

331

.doc = "User ID the plugins will run as", .group = 2 },

332

{ .name = "groupid", .key = 130,

333

.arg = "ID", .flags = 0,

334

.doc = "Group ID the plugins will run as", .group = 2 },

335

{ .name = "debug", .key = 131,

336

.doc = "Debug mode", .group = 3 },

356

337

{ .name = NULL }

357

338

};

358

339

359

error_t parse_opt (int key, char *arg, __attribute__((unused))

360

struct argp_state *state) {

340

error_t parse_opt (int key, char *arg, struct argp_state *state) {

361

341

/* Get the INPUT argument from `argp_parse', which we know is a

362

342

pointer to our plugin list pointer. */

343

plugin **plugins = state->input;

363

344

switch (key) {

364

case 'g': /* --global-options */

345

case 'g':

365

346

if (arg != NULL){

366

347

char *p;

367

348

while((p = strsep(&arg, ",")) != NULL){

368

349

if(p[0] == '\0'){

369

350

continue;

370

351

}

371

if(not add_argument(getplugin(NULL), p)){

352

if(not add_argument(getplugin(NULL, plugins), p)){

372

353

perror("add_argument");

373

354

return ARGP_ERR_UNKNOWN;

374

355

}

375

356

}

376

357

}

377

358

break;

378

case 'e': /* --global-envs */

359

case 'e':

379

360

if(arg == NULL){

380

361

break;

381

362

}

384

365

if(envdef == NULL){

385

366

break;

386

367

}

387

if(not add_environment(getplugin(NULL), envdef)){

368

if(not add_environment(getplugin(NULL, plugins), envdef)){

388

369

perror("add_environment");

389

370

}

390

371

}

391

372

break;

392

case 'o': /* --options-for */

373

case 'o':

393

374

if (arg != NULL){

394

375

char *p_name = strsep(&arg, ":");

395

376

if(p_name[0] == '\0'){

405

386

if(p[0] == '\0'){

406

387

continue;

407

388

}

408

if(not add_argument(getplugin(p_name), p)){

389

if(not add_argument(getplugin(p_name, plugins), p)){

409

390

perror("add_argument");

410

391

return ARGP_ERR_UNKNOWN;

411

392

}

413

394

}

414

395

}

415

396

break;

416

case 'f': /* --envs-for */

397

case 'f':

417

398

if(arg == NULL){

418

399

break;

419

400

}

427

408

break;

428

409

}

429

410

envdef++;

430

if(not add_environment(getplugin(p_name), envdef)){

411

if(not add_environment(getplugin(p_name, plugins), envdef)){

431

412

perror("add_environment");

432

413

}

433

414

}

434

415

break;

435

case 'd': /* --disable */

416

case 'd':

436

417

if (arg != NULL){

437

plugin *p = getplugin(arg);

418

plugin *p = getplugin(arg, plugins);

438

419

if(p == NULL){

439

420

return ARGP_ERR_UNKNOWN;

440

421

}

441

422

p->disabled = true;

442

423

}

443

424

break;

444

case 128: /* --plugin-dir */

445

plugindir = strdup(arg);

446

if(plugindir == NULL){

447

perror("strdup");

448

}

425

case 128:

426

plugindir = arg;

449

427

break;

450

case 129: /* --config-file */

451

argfile = strdup(arg);

452

if(argfile == NULL){

453

perror("strdup");

454

}

455

break;

456

case 130: /* --userid */

428

case 129:

457

429

uid = (uid_t)strtol(arg, NULL, 10);

458

430

break;

459

case 131: /* --groupid */

431

case 130:

460

432

gid = (gid_t)strtol(arg, NULL, 10);

461

433

break;

462

case 132: /* --debug */

434

case 131:

463

435

debug = true;

464

436

break;

465

437

case ARGP_KEY_ARG:

473

445

return 0;

474

446

}

475

447

448

plugin *plugin_list = NULL;

449

476

450

struct argp argp = { .options = options, .parser = parse_opt,

477

451

.args_doc = "[+PLUS_SEPARATED_OPTIONS]",

478

452

.doc = "Mandos plugin runner -- Run plugins" };

479

453

480

ret = argp_parse (&argp, argc, argv, 0, 0, NULL);

454

ret = argp_parse (&argp, argc, argv, 0, 0, &plugin_list);

481

455

if (ret == ARGP_ERR_UNKNOWN){

482

456

fprintf(stderr, "Unknown error while parsing arguments\n");

483

457

exitstatus = EXIT_FAILURE;

484

458

goto fallback;

485

459

}

486

460

487

/* Opens the configfile if aviable */

488

if (argfile == NULL){

489

conffp = fopen(AFILE, "r");

490

} else {

491

conffp = fopen(argfile, "r");

492

}

461

conffp = fopen(argfile, "r");

493

462

if(conffp != NULL){

494

463

char *org_line = NULL;

495

464

char *p, *arg, *new_arg, *line;

498

467

const char whitespace_delims[] = " \r\t\f\v\n";

499

468

const char comment_delim[] = "#";

500

469

501

custom_argc = 1;

502

custom_argv = malloc(sizeof(char*) * 2);

503

if(custom_argv == NULL){

504

perror("malloc");

505

exitstatus = EXIT_FAILURE;

506

goto fallback;

507

}

508

custom_argv[0] = argv[0];

509

custom_argv[1] = NULL;

510

511

/* for each line in the config file, strip whitespace and ignore

512

commented text */

513

470

while(true){

514

471

sret = getline(&org_line, &size, conffp);

515

472

if(sret == -1){

523

480

continue;

524

481

}

525

482

new_arg = strdup(p);

526

if(new_arg == NULL){

527

perror("strdup");

528

exitstatus = EXIT_FAILURE;

529

free(org_line);

530

goto fallback;

531

}

532

533

custom_argc += 1;

534

custom_argv = realloc(custom_argv, sizeof(char *)

535

* ((unsigned int) custom_argc + 1));

536

if(custom_argv == NULL){

537

perror("realloc");

538

exitstatus = EXIT_FAILURE;

539

free(org_line);

540

goto fallback;

541

}

542

custom_argv[custom_argc-1] = new_arg;

543

custom_argv[custom_argc] = NULL;

483

custom_argv = add_to_argv(custom_argv, &custom_argc, new_arg);

484

if (custom_argv == NULL){

485

perror("add_to_argv");

486

exitstatus = EXIT_FAILURE;

487

goto fallback;

488

}

544

489

}

545

490

}

546

491

free(org_line);

553

498

goto fallback;

554

499

}

555

500

}

556

/* If there was any arguments from configuration file,

557

pass them to parser as command arguments */

501

558

502

if(custom_argv != NULL){

559

ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, NULL);

503

custom_argv[0] = argv[0];

504

ret = argp_parse (&argp, custom_argc, custom_argv, 0, 0, &plugin_list);

560

505

if (ret == ARGP_ERR_UNKNOWN){

561

506

fprintf(stderr, "Unknown error while parsing arguments\n");

562

507

exitstatus = EXIT_FAILURE;

577

522

}

578

523

}

579

524

}

580

581

/* Strip permissions down to nobody */

525

582

526

ret = setuid(uid);

583

527

if (ret == -1){

584

528

perror("setuid");

585

}

529

}

530

586

531

setgid(gid);

587

532

if (ret == -1){

588

533

perror("setgid");

589

534

}

590

591

if (plugindir == NULL){

592

dir = opendir(PDIR);

593

} else {

594

dir = opendir(plugindir);

595

}

596

535

536

dir = opendir(plugindir);

597

537

if(dir == NULL){

598

538

perror("Could not open plugin dir");

599

539

exitstatus = EXIT_FAILURE;

614

554

}

615

555

616

556

FD_ZERO(&rfds_all);

617

618

/* Read and execute any executable in the plugin directory*/

557

619

558

while(true){

620

559

dirst = readdir(dir);

621

560

652

591

break;

653

592

}

654

593

}

594

655

595

if(bad_name){

656

596

continue;

657

597

}

598

658

599

for(const char **suf = bad_suffixes; *suf != NULL; suf++){

659

600

size_t suf_len = strlen(*suf);

660

601

if((d_name_len >= suf_len)

687

628

free(filename);

688

629

continue;

689

630

}

690

691

/* Ignore non-executable files */

631

692

632

if (not S_ISREG(st.st_mode) or (access(filename, X_OK) != 0)){

693

633

if(debug){

694

634

fprintf(stderr, "Ignoring plugin dir entry \"%s\""

697

637

free(filename);

698

638

continue;

699

639

}

700

701

plugin *p = getplugin(dirst->d_name);

640

plugin *p = getplugin(dirst->d_name, &plugin_list);

702

641

if(p == NULL){

703

642

perror("getplugin");

704

643

free(filename);

714

653

}

715

654

{

716

655

/* Add global arguments to argument list for this plugin */

717

plugin *g = getplugin(NULL);

656

plugin *g = getplugin(NULL, &plugin_list);

718

657

if(g != NULL){

719

658

for(char **a = g->argv + 1; *a != NULL; a++){

720

659

if(not add_argument(p, *a)){

752

691

exitstatus = EXIT_FAILURE;

753

692

goto fallback;

754

693

}

755

/* Ask OS to automatic close the pipe on exec */

756

694

ret = set_cloexec_flag(pipefd[0]);

757

695

if(ret < 0){

758

696

perror("set_cloexec_flag");

816

754

}

817

755

/* no return */

818

756

}

819

/* Parent process */

820

close(pipefd[1]); /* Close unused write end of pipe */

757

/* parent process */

821

758

free(filename);

822

plugin *new_plugin = getplugin(dirst->d_name);

823

if (new_plugin == NULL){

824

perror("getplugin");

759

close(pipefd[1]); /* close unused write end of pipe */

760

process *new_process = malloc(sizeof(process));

761

if (new_process == NULL){

762

perror("malloc");

825

763

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);

826

764

if(ret < 0){

827

perror("sigprocmask");

765

perror("sigprocmask");

828

766

}

829

767

exitstatus = EXIT_FAILURE;

830

768

goto fallback;

831

769

}

832

770

833

new_plugin->pid = pid;

834

new_plugin->fd = pipefd[0];

835

771

*new_process = (struct process){ .pid = pid,

772

.fd = pipefd[0],

773

.next = process_list };

774

// List handling

775

process_list = new_process;

836

776

/* Unblock SIGCHLD so signal handler can be run if this process

837

777

has already completed */

838

778

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask, NULL);

842

782

goto fallback;

843

783

}

844

784

845

FD_SET(new_plugin->fd, &rfds_all);

785

FD_SET(new_process->fd, &rfds_all);

846

786

847

if (maxfd < new_plugin->fd){

848

maxfd = new_plugin->fd;

787

if (maxfd < new_process->fd){

788

maxfd = new_process->fd;

849

789

}

850

790

851

791

}

852

792

793

free_plugin_list(plugin_list);

794

plugin_list = NULL;

795

853

796

closedir(dir);

854

797

dir = NULL;

855

856

for(plugin *p = plugin_list; p != NULL; p = p->next){

857

if(p->pid != 0){

858

break;

859

}

860

if(p->next == NULL){

861

fprintf(stderr, "No plugin processes started. Incorrect plugin"

862

" directory?\n");

863

free_plugin_list();

864

}

798

799

if (process_list == NULL){

800

fprintf(stderr, "No plugin processes started. Incorrect plugin"

801

" directory?\n");

802

process_list = NULL;

865

803

}

866

867

/* Main loop while running plugins exist */

868

while(plugin_list){

804

while(process_list){

869

805

fd_set rfds = rfds_all;

870

806

int select_ret = select(maxfd+1, &rfds, NULL, NULL, NULL);

871

807

if (select_ret == -1){

875

811

}

876

812

/* OK, now either a process completed, or something can be read

877

813

from one of them */

878

for(plugin *proc = plugin_list; proc != NULL; proc = proc->next){

814

for(process *proc = process_list; proc ; proc = proc->next){

879

815

/* Is this process completely done? */

880

816

if(proc->eof and proc->completed){

881

817

/* Only accept the plugin output if it exited cleanly */

882

818

if(not WIFEXITED(proc->status)

883

819

or WEXITSTATUS(proc->status) != 0){

884

820

/* Bad exit by plugin */

885

886

821

if(debug){

887

822

if(WIFEXITED(proc->status)){

888

823

fprintf(stderr, "Plugin %u exited with status %d\n",

897

832

(unsigned int) (proc->pid));

898

833

}

899

834

}

900

901

835

/* Remove the plugin */

902

836

FD_CLR(proc->fd, &rfds_all);

903

904

837

/* Block signal while modifying process_list */

905

ret = sigprocmask(SIG_BLOCK, &sigchld_action.sa_mask, NULL);

838

ret = sigprocmask (SIG_BLOCK, &sigchld_action.sa_mask, NULL);

906

839

if(ret < 0){

907

840

perror("sigprocmask");

908

841

exitstatus = EXIT_FAILURE;

909

842

goto fallback;

910

843

}

911

free_plugin(proc);

844

/* Delete this process entry from the list */

845

if(process_list == proc){

846

/* First one - simple */

847

process_list = proc->next;

848

} else {

849

/* Second one or later */

850

for(process *p = process_list; p != NULL; p = p->next){

851

if(p->next == proc){

852

p->next = proc->next;

853

break;

854

}

855

}

856

}

912

857

/* We are done modifying process list, so unblock signal */

913

858

ret = sigprocmask (SIG_UNBLOCK, &sigchld_action.sa_mask,

914

859

NULL);

915

860

if(ret < 0){

916

861

perror("sigprocmask");

917

exitstatus = EXIT_FAILURE;

918

goto fallback;

919

}

920

921

if(plugin_list == NULL){

922

break;

923

}

924

continue;

862

}

863

free(proc->buffer);

864

free(proc);

865

/* We deleted this process from the list, so we can't go

866

proc->next. Therefore, start over from the beginning of

867

the process list */

868

break;

925

869

}

926

927

870

/* This process exited nicely, so print its buffer */

928

871

929

bool bret = print_out_password(proc->buffer,

930

proc->buffer_length);

872

bool bret = print_out_password(proc->buffer, proc->buffer_length);

931

873

if(not bret){

932

874

perror("print_out_password");

933

875

exitstatus = EXIT_FAILURE;

934

876

}

935

877

goto fallback;

936

878

}

937

938

879

/* This process has not completed. Does it have any output? */

939

880

if(proc->eof or not FD_ISSET(proc->fd, &rfds)){

940

881

/* This process had nothing to say at this time */

970

911

971

912

fallback:

972

913

973

if(plugin_list == NULL or exitstatus != EXIT_SUCCESS){

974

/* Fallback if all plugins failed, none are found or an error

975

occured */

914

if(process_list == NULL or exitstatus != EXIT_SUCCESS){

915

/* Fallback if all plugins failed, none are found or an error occured */

976

916

bool bret;

977

917

fprintf(stderr, "Going to fallback mode using getpass(3)\n");

978

918

char *passwordbuffer = getpass("Password: ");

991

931

}

992

932

993

933

if(custom_argv != NULL){

994

for(char **arg = custom_argv+1; *arg != NULL; arg++){

934

for(char **arg = custom_argv; *arg != NULL; arg++){

995

935

free(*arg);

996

936

}

997

937

free(custom_argv);

998

938

}

939

free_plugin_list(plugin_list);

999

940

1000

941

if(dir != NULL){

1001

942

closedir(dir);

1002

943

}

1003

944

1004

945

/* Free the process list and kill the processes */

1005

for(plugin *p = plugin_list; p != NULL; p = p->next){

1006

if(p->pid != 0){

1007

close(p->fd);

1008

ret = kill(p->pid, SIGTERM);

1009

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

1010

/* Set-uid proccesses might not get closed */

1011

perror("kill");

1012

}

946

for(process *next; process_list != NULL; process_list = next){

947

next = process_list->next;

948

close(process_list->fd);

949

ret = kill(process_list->pid, SIGTERM);

950

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

951

/* set-uid proccesses migth not get closed */

952

perror("kill");

1013

953

}

954

free(process_list->buffer);

955

free(process_list);

1014

956

}

1015

957

1016

958

/* Wait for any remaining child processes to terminate */

1020

962

if(errno != ECHILD){

1021

963

perror("wait");

1022

964

}

1023

1024

free_plugin_list();

1025

1026

free(plugindir);

1027

free(argfile);

1028

965

1029

966

return exitstatus;

1030

967

}