/mandos/trunk : revision 485

1

/* -*- coding: utf-8 -*- */

2

/*

3

* Plymouth - Read a password from Plymouth and output it

4

*

5

6

7

*

8

* This program is free software: you can redistribute it and/or

9

* modify it under the terms of the GNU General Public License as

10

* published by the Free Software Foundation, either version 3 of the

11

* License, or (at your option) any later version.

12

*

13

* This program is distributed in the hope that it will be useful, but

14

* WITHOUT ANY WARRANTY; without even the implied warranty of

15

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

16

* General Public License for more details.

17

*

18

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

19

* along with this program. If not, see

20

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

21

*

22

* Contact the authors at <mandos@fukt.bsnet.se>.

23

*/

24

1

25

#define _GNU_SOURCE /* asprintf(), TEMP_FAILURE_RETRY() */

2

26

#include <signal.h> /* sig_atomic_t, struct sigaction,

3

27

sigemptyset(), sigaddset(), SIGINT,

6

30

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

7

31

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

8

32

#include <iso646.h> /* and, or, not*/

9

#include <sys/types.h> /* size_t, ssize_t, pid_t, struct dirent,

10

waitpid() */

33

#include <sys/types.h> /* size_t, ssize_t, pid_t, struct

34

dirent, waitpid() */

11

35

#include <sys/wait.h> /* waitpid() */

12

36

#include <stddef.h> /* NULL */

13

37

#include <string.h> /* strchr(), memcmp() */

14

#include <stdio.h> /* asprintf(), perror(), fopen(), fscanf() */

15

#include <unistd.h> /* close(), readlink(), read(), fork()

16

setsid(), chdir(), dup2()

38

#include <stdio.h> /* asprintf(), perror(), fopen(),

39

fscanf(), vasprintf(), fprintf(),

40

vfprintf() */

41

#include <unistd.h> /* close(), readlink(), read(),

42

fork(), setsid(), chdir(), dup2(),

17

43

STDERR_FILENO, execv(), access() */

18

44

#include <stdlib.h> /* free(), EXIT_FAILURE, realloc(),

19

45

EXIT_SUCCESS, malloc(), _exit(),

21

47

#include <dirent.h> /* scandir(), alphasort() */

22

48

#include <inttypes.h> /* intmax_t, strtoumax(), SCNuMAX */

23

49

#include <sys/stat.h> /* struct stat, lstat() */

24

#include <sysexits.h> /* EX_OSERR */

50

#include <sysexits.h> /* EX_OSERR, EX_UNAVAILABLE */

25

51

#include <error.h> /* error() */

26

52

#include <errno.h> /* TEMP_FAILURE_RETRY */

27

#include <stdarg.h>

53

#include <argz.h> /* argz_count(), argz_extract() */

54

#include <stdarg.h> /* va_list, va_start(), ... */

28

55

29

56

sig_atomic_t interrupted_by_signal = 0;

30

57

const char plymouth_pid[] = "/dev/.initramfs/plymouth.pid";

31

58

const char plymouth_path[] = "/bin/plymouth";

32

59

const char plymouthd_path[] = "/sbin/plymouthd";

33

const char *plymouthd_default_argv[] = {"/sbin/plymouthd", "--mode=boot",

60

const char *plymouthd_default_argv[] = {"/sbin/plymouthd",

61

"--mode=boot",

34

62

"--attach-to-session",

35

"--pid-file=/dev/.initramfs/plymouth.pid",

63

"--pid-file="

64

"/dev/.initramfs/"

65

"plymouth.pid",

36

66

NULL };

37

67

38

68

static void termination_handler(__attribute__((unused))int signum){

42

72

interrupted_by_signal = 1;

43

73

}

44

74

75

/* Function to use when printing errors */

76

void error_plus(int status, int errnum, const char *formatstring,

77

...){

78

va_list ap;

79

char *text;

80

int ret;

81

82

va_start(ap, formatstring);

83

ret = vasprintf(&text, formatstring, ap);

84

if (ret == -1){

85

fprintf(stderr, "Mandos plugin %s: ",

86

program_invocation_short_name);

87

vfprintf(stderr, formatstring, ap);

88

fprintf(stderr, ": ");

89

fprintf(stderr, "%s\n", strerror(errnum));

90

error(status, errno, "vasprintf while printing error");

91

return;

92

}

93

fprintf(stderr, "Mandos plugin ");

94

error(status, errnum, "%s", text);

95

free(text);

96

}

97

45

98

/* Create prompt string */

46

99

char *makeprompt(void){

47

100

int ret = 0;

48

101

char *prompt;

49

102

const char *const cryptsource = getenv("cryptsource");

50

103

const char *const crypttarget = getenv("crypttarget");

51

const char prompt_start[] = "Enter passphrase to unlock the disk";

104

const char prompt_start[] = "Unlocking the disk";

105

const char prompt_end[] = "Enter passphrase";

52

106

53

107

if(cryptsource == NULL){

54

108

if(crypttarget == NULL){

55

ret = asprintf(&prompt, "%s: ", prompt_start);

109

ret = asprintf(&prompt, "%s\n%s", prompt_start, prompt_end);

56

110

} else {

57

ret = asprintf(&prompt, "%s (%s): ", prompt_start,

58

crypttarget);

111

ret = asprintf(&prompt, "%s (%s)\n%s", prompt_start,

112

crypttarget, prompt_end);

59

113

}

60

114

} else {

61

115

if(crypttarget == NULL){

62

ret = asprintf(&prompt, "%s %s: ", prompt_start, cryptsource);

116

ret = asprintf(&prompt, "%s %s\n%s", prompt_start, cryptsource,

117

prompt_end);

63

118

} else {

64

ret = asprintf(&prompt, "%s %s (%s): ", prompt_start,

65

cryptsource, crypttarget);

119

ret = asprintf(&prompt, "%s %s (%s)\n%s", prompt_start,

120

cryptsource, crypttarget, prompt_end);

66

121

}

67

122

}

68

123

if(ret == -1){

79

134

bool become_a_daemon(void){

80

135

int ret = setuid(geteuid());

81

136

if(ret == -1){

82

error(0, errno, "setuid");

137

error_plus(0, errno, "setuid");

83

138

}

84

139

85

140

setsid();

86

141

ret = chdir("/");

87

142

if(ret == -1){

88

error(0, errno, "chdir");

143

error_plus(0, errno, "chdir");

89

144

return false;

90

145

}

91

146

ret = dup2(STDERR_FILENO, STDOUT_FILENO); /* replace our stdout */

92

147

if(ret == -1){

93

error(0, errno, "dup2");

148

error_plus(0, errno, "dup2");

94

149

return false;

95

150

}

96

151

return true;

104

159

pid_t pid;

105

160

pid = fork();

106

161

if(pid == -1){

107

error(0, errno, "fork");

162

error_plus(0, errno, "fork");

108

163

return false;

109

164

}

110

165

if(pid == 0){

114

169

_exit(EX_OSERR);

115

170

}

116

171

}

117

172

118

173

char **new_argv = NULL;

119

char *tmp;

174

char **tmp;

120

175

int i = 0;

121

for (; argv[i]!=(char *)NULL; i++){

176

for (; argv[i]!=NULL; i++){

122

177

tmp = realloc(new_argv, sizeof(const char *) * ((size_t)i + 1));

123

178

if (tmp == NULL){

124

error(0, errno, "realloc");

179

error_plus(0, errno, "realloc");

125

180

free(new_argv);

126

_exit(EXIT_FAILURE);

181

_exit(EX_OSERR);

127

182

}

128

new_argv = (char **)tmp;

183

new_argv = tmp;

129

184

new_argv[i] = strdup(argv[i]);

130

185

}

131

new_argv[i] = (char *) NULL;

186

new_argv[i] = NULL;

132

187

133

188

execv(path, (char *const *)new_argv);

134

error(0, errno, "execv");

189

error_plus(0, errno, "execv");

135

190

_exit(EXIT_FAILURE);

136

191

}

137

192

if(pid_return != NULL){

146

201

return false;

147

202

}

148

203

if(ret == -1){

149

error(0, errno, "waitpid");

204

error_plus(0, errno, "waitpid");

150

205

return false;

151

206

}

152

if(WIFEXITED(status) and WEXITSTATUS(status) == 0){

207

if(WIFEXITED(status) and (WEXITSTATUS(status) == 0)){

153

208

return true;

154

209

}

155

210

return false;

163

218

errno = 0;

164

219

maxvalue = strtoumax(proc_entry->d_name, &tmp, 10);

165

220

166

if(errno != 0 or *tmp != '\0' or maxvalue != (uintmax_t)((pid_t)maxvalue)){

221

if(errno != 0 or *tmp != '\0'

222

or maxvalue != (uintmax_t)((pid_t)maxvalue)){

167

223

return 0;

168

224

}

169

225

}

170

char exe_target[sizeof(plymouth_path)];

226

char exe_target[sizeof(plymouthd_path)];

171

227

char *exe_link;

172

228

ret = asprintf(&exe_link, "/proc/%s/exe", proc_entry->d_name);

173

229

if(ret == -1){

174

error(0, errno, "asprintf");

230

error_plus(0, errno, "asprintf");

175

231

return 0;

176

232

}

177

233

178

234

struct stat exe_stat;

179

235

ret = lstat(exe_link, &exe_stat);

180

236

if(ret == -1){

181

237

free(exe_link);

182

238

if(errno != ENOENT){

183

error(0, errno, "lstat");

239

error_plus(0, errno, "lstat");

184

240

}

185

241

return 0;

186

242

}

191

247

free(exe_link);

192

248

return 0;

193

249

}

194

250

195

251

ssize_t sret = readlink(exe_link, exe_target, sizeof(exe_target));

196

252

free(exe_link);

197

if((sret != (ssize_t)sizeof(plymouth_path)-1) or

198

(memcmp(plymouth_path, exe_target,

199

sizeof(plymouth_path)-1) != 0)){

253

if((sret != (ssize_t)sizeof(plymouthd_path)-1) or

254

(memcmp(plymouthd_path, exe_target,

255

sizeof(plymouthd_path)-1) != 0)){

200

256

return 0;

201

257

}

202

258

return 1;

214

270

fclose(pidfile);

215

271

}

216

272

if(maxvalue == 0){

217

struct dirent **direntries;

273

struct dirent **direntries = NULL;

218

274

ret = scandir("/proc", &direntries, is_plymouth, alphasort);

219

sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);

275

if (ret == -1){

276

error_plus(0, errno, "scandir");

277

}

278

if (ret > 0){

279

ret = sscanf(direntries[0]->d_name, "%" SCNuMAX, &maxvalue);

280

if (ret < 0){

281

error_plus(0, errno, "sscanf");

282

}

283

}

284

/* scandir might preallocate for this variable (man page unclear).

285

even if ret == 0, therefore we need to free it. */

286

free(direntries);

220

287

}

221

288

pid_t pid;

222

289

pid = (pid_t)maxvalue;

236

303

ret = asprintf(&cmdline_filename, "/proc/%" PRIuMAX "/cmdline",

237

304

(uintmax_t)pid);

238

305

if(ret == -1){

239

error(0, errno, "asprintf");

306

error_plus(0, errno, "asprintf");

240

307

return NULL;

241

308

}

242

309

244

311

cl_fd = open(cmdline_filename, O_RDONLY);

245

312

free(cmdline_filename);

246

313

if(cl_fd == -1){

247

error(0, errno, "open");

314

error_plus(0, errno, "open");

248

315

return NULL;

249

316

}

250

317

258

325

if(cmdline_len + blocksize > cmdline_allocated){

259

326

tmp = realloc(cmdline, cmdline_allocated + blocksize);

260

327

if(tmp == NULL){

261

error(0, errno, "realloc");

328

error_plus(0, errno, "realloc");

262

329

free(cmdline);

263

330

close(cl_fd);

264

331

return NULL;

271

338

sret = read(cl_fd, cmdline + cmdline_len,

272

339

cmdline_allocated - cmdline_len);

273

340

if(sret == -1){

274

error(0, errno, "read");

341

error_plus(0, errno, "read");

275

342

free(cmdline);

276

343

close(cl_fd);

277

344

return NULL;

280

347

} while(sret != 0);

281

348

ret = close(cl_fd);

282

349

if(ret == -1){

283

error(0, errno, "close");

350

error_plus(0, errno, "close");

284

351

free(cmdline);

285

352

return NULL;

286

353

}

287

354

288

355

/* we got cmdline and cmdline_len, ignore rest... */

289

const char **argv = NULL;

290

size_t argv_size = 0;

291

for(char *arg = cmdline; arg-cmdline < (ssize_t)cmdline_len;

292

arg = strchr(arg, '\0')+1){

293

tmp = realloc(argv, ((++argv_size)+1)*sizeof(char *));

294

if(tmp == NULL){

295

error(0, errno, "realloc");

296

free(argv);

297

return NULL;

298

}

299

argv = (const char **)tmp;

300

argv[argv_size-1] = arg;

356

char **argv = malloc((argz_count(cmdline, cmdline_len) + 1)

357

* sizeof(char *)); /* Get number of args */

358

if(argv == NULL){

359

error_plus(0, errno, "argv = malloc()");

360

free(cmdline);

361

return NULL;

301

362

}

302

argv[argv_size] = NULL;

303

return argv;

363

argz_extract(cmdline, cmdline_len, argv); /* Create argv */

364

return (const char **)argv;

304

365

}

305

366

306

367

int main(__attribute__((unused))int argc,

314

375

/* test -x /bin/plymouth */

315

376

ret = access(plymouth_path, X_OK);

316

377

if(ret == -1){

317

exit(EXIT_FAILURE);

378

/* Plymouth is probably not installed. Don't print an error

379

message, just exit. */

380

exit(EX_UNAVAILABLE);

318

381

}

319

382

320

383

{ /* Add signal handlers */

321

384

struct sigaction old_action,

322

385

new_action = { .sa_handler = termination_handler,

323

386

.sa_flags = 0 };

324

387

sigemptyset(&new_action.sa_mask);

325

for(int *sig = (int[]){ SIGINT, SIGHUP, SIGTERM, 0 }; *sig != 0; sig++){

388

for(int *sig = (int[]){ SIGINT, SIGHUP, SIGTERM, 0 };

389

*sig != 0; sig++){

326

390

ret = sigaddset(&new_action.sa_mask, *sig);

327

391

if(ret == -1){

328

error(0, errno, "sigaddset");

329

exit(EX_OSERR);

392

error_plus(EX_OSERR, errno, "sigaddset");

330

393

}

331

394

ret = sigaction(*sig, NULL, &old_action);

332

395

if(ret == -1){

333

error(0, errno, "sigaction");

334

exit(EX_OSERR);

396

error_plus(EX_OSERR, errno, "sigaction");

335

397

}

336

398

if(old_action.sa_handler != SIG_IGN){

337

399

ret = sigaction(*sig, &new_action, NULL);

338

400

if(ret == -1){

339

error(0, errno, "sigaction");

340

exit(EX_OSERR);

401

error_plus(EX_OSERR, errno, "sigaction");

341

402

}

342

403

}

343

404

}

344

405

}

345

406

346

407

/* plymouth --ping */

347

408

bret = exec_and_wait(&plymouth_command_pid, plymouth_path,

348

(const char *[]){ (const char *)plymouth_path, (const char *)"--ping", (const char *)NULL},

409

(const char *[])

410

{ plymouth_path, "--ping", NULL },

349

411

true, false);

350

412

if(not bret){

351

413

if(interrupted_by_signal){

352

414

kill_and_wait(plymouth_command_pid);

415

exit(EXIT_FAILURE);

353

416

}

354

exit(EXIT_FAILURE);

417

/* Plymouth is probably not running. Don't print an error

418

message, just exit. */

419

exit(EX_UNAVAILABLE);

355

420

}

356

421

357

422

prompt = makeprompt();

358

423

ret = asprintf(&prompt_arg, "--prompt=%s", prompt);

359

424

free(prompt);

360

425

if(ret == -1){

361

error(0, errno, "asprintf");

362

exit(EXIT_FAILURE);

426

error_plus(EX_OSERR, errno, "asprintf");

363

427

}

364

428

365

429

/* plymouth ask-for-password --prompt="$prompt" */

366

bret = exec_and_wait(&plymouth_command_pid, plymouth_path,

367

(const char *[]){plymouth_path, "ask-for-password", prompt_arg, NULL},

430

bret = exec_and_wait(&plymouth_command_pid,

431

plymouth_path, (const char *[])

432

{ plymouth_path, "ask-for-password",

433

prompt_arg, NULL },

368

434

true, false);

369

435

free(prompt_arg);

370

if(not bret){

371

if(interrupted_by_signal){

372

kill_and_wait(plymouth_command_pid);

373

} else {

374

exit(EXIT_FAILURE);

375

}

376

}

377

378

436

if(bret){

379

437

exit(EXIT_SUCCESS);

380

438

}

439

if(not interrupted_by_signal){

440

/* exec_and_wait failed for some other reason */

441

exit(EXIT_FAILURE);

442

}

443

kill_and_wait(plymouth_command_pid);

381

444

382

const char **plymouthd_argv = NULL;

445

const char **plymouthd_argv;

383

446

pid_t pid = get_pid();

384

447

if(pid == 0){

385

error(0, 0, "plymouthd pid not found");

448

error_plus(0, 0, "plymouthd pid not found");

449

plymouthd_argv = plymouthd_default_argv;

386

450

} else {

387

451

plymouthd_argv = getargv(pid);

388

452

}

389

if(plymouthd_argv == NULL){

390

plymouthd_argv = plymouthd_default_argv;

391

}

392

453

393

bret = exec_and_wait(NULL, plymouth_path,

394

(const char *[]){plymouth_path, "quit", NULL}, false, false);

395

if(not bret){

396

exit(EXIT_FAILURE);

397

}

398

bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv, false, true);

399

if(not bret){

400

exit(EXIT_FAILURE);

401

}

402

exec_and_wait(NULL, plymouth_path,

403

(const char *[]){ plymouth_path, "show-splash", NULL }, false, false);

454

bret = exec_and_wait(NULL, plymouth_path, (const char *[])

455

{ plymouth_path, "quit", NULL },

456

false, false);

457

if(not bret){

458

exit(EXIT_FAILURE);

459

}

460

bret = exec_and_wait(NULL, plymouthd_path, plymouthd_argv,

461

false, true);

462

if(not bret){

463

exit(EXIT_FAILURE);

464

}

465

exec_and_wait(NULL, plymouth_path, (const char *[])

466

{ plymouth_path, "show-splash", NULL },

467

false, false);

404

468

exit(EXIT_FAILURE);

405

469

}