/mandos/trunk : revision 347

1

/* -*- coding: utf-8; mode: c; mode: orgtbl -*- */

1

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

2

/*

3

* Password-prompt - Read a password from the terminal and print it

4

*

19

* along with this program. If not, see

20

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

21

*

22

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

22

* Contact the authors at <https://www.fukt.bsnet.se/~belorn/> and

23

* <https://www.fukt.bsnet.se/~teddy/>.

23

24

*/

24

25

26

#define _GNU_SOURCE /* getline() */

32

33

#include <signal.h> /* sig_atomic_t, raise(), struct

33

34

sigaction, sigemptyset(),

34

35

sigaction(), sigaddset(), SIGINT,

35

SIGQUIT, SIGHUP, SIGTERM,

36

raise() */

36

SIGQUIT, SIGHUP, SIGTERM */

37

#include <stddef.h> /* NULL, size_t, ssize_t */

38

#include <sys/types.h> /* ssize_t */

39

#include <stdlib.h> /* EXIT_SUCCESS, EXIT_FAILURE,

40

getopt_long, getenv() */

41

#include <stdio.h> /* fprintf(), stderr, getline(),

42

stdin, feof(), perror(), fputc(),

43

getopt_long */

44

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

45

EFAULT, EFBIG, EIO, ENOSPC, EINTR

46

*/

43

stdout, getopt_long */

44

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

47

45

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

48

46

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

49

47

#include <string.h> /* strlen, rindex, strncmp, strcmp */

52

50

argp_parse(), error_t,

53

51

ARGP_KEY_ARG, ARGP_KEY_END,

54

52

ARGP_ERR_UNKNOWN */

55

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

56

EX_UNAVAILABLE, EX_IOERR, EX_OK */

57

53

58

54

volatile sig_atomic_t quit_now = 0;

59

int signal_received;

60

55

bool debug = false;

61

56

const char *argp_program_version = "password-prompt " VERSION;

62

57

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

63

58

64

static void termination_handler(int signum){

65

if(quit_now){

66

return;

67

}

59

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

68

60

quit_now = 1;

69

signal_received = signum;

70

61

}

71

62

72

63

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

115

106

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

116

107

if(ret == ARGP_ERR_UNKNOWN){

117

108

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

118

return EX_SOFTWARE;

109

return EXIT_FAILURE;

119

110

}

120

111

}

121

112

127

118

}

128

119

129

120

if(tcgetattr(STDIN_FILENO, &t_old) != 0){

130

int e = errno;

131

121

perror("tcgetattr");

132

switch(e){

133

case EBADF:

134

case ENOTTY:

135

return EX_UNAVAILABLE;

136

default:

137

return EX_OSERR;

138

}

122

return EXIT_FAILURE;

139

123

}

140

124

141

125

sigemptyset(&new_action.sa_mask);

142

ret = sigaddset(&new_action.sa_mask, SIGINT);

143

if(ret == -1){

144

perror("sigaddset");

145

return EX_OSERR;

146

}

147

ret = sigaddset(&new_action.sa_mask, SIGHUP);

148

if(ret == -1){

149

perror("sigaddset");

150

return EX_OSERR;

151

}

152

ret = sigaddset(&new_action.sa_mask, SIGTERM);

153

if(ret == -1){

154

perror("sigaddset");

155

return EX_OSERR;

156

}

157

/* Need to check if the handler is SIG_IGN before handling:

158

| [[info:libc:Initial Signal Actions]] |

159

| [[info:libc:Basic Signal Handling]] |

160

*/

126

sigaddset(&new_action.sa_mask, SIGINT);

127

sigaddset(&new_action.sa_mask, SIGHUP);

128

sigaddset(&new_action.sa_mask, SIGTERM);

161

129

ret = sigaction(SIGINT, NULL, &old_action);

162

130

if(ret == -1){

163

131

perror("sigaction");

164

return EX_OSERR;

132

return EXIT_FAILURE;

165

133

}

166

134

if(old_action.sa_handler != SIG_IGN){

167

135

ret = sigaction(SIGINT, &new_action, NULL);

168

136

if(ret == -1){

169

137

perror("sigaction");

170

return EX_OSERR;

138

return EXIT_FAILURE;

171

139

}

172

140

}

173

141

ret = sigaction(SIGHUP, NULL, &old_action);

174

142

if(ret == -1){

175

143

perror("sigaction");

176

return EX_OSERR;

144

return EXIT_FAILURE;

177

145

}

178

146

if(old_action.sa_handler != SIG_IGN){

179

147

ret = sigaction(SIGHUP, &new_action, NULL);

180

148

if(ret == -1){

181

149

perror("sigaction");

182

return EX_OSERR;

150

return EXIT_FAILURE;

183

151

}

184

152

}

185

153

ret = sigaction(SIGTERM, NULL, &old_action);

186

154

if(ret == -1){

187

155

perror("sigaction");

188

return EX_OSERR;

156

return EXIT_FAILURE;

189

157

}

190

158

if(old_action.sa_handler != SIG_IGN){

191

159

ret = sigaction(SIGTERM, &new_action, NULL);

192

160

if(ret == -1){

193

161

perror("sigaction");

194

return EX_OSERR;

162

return EXIT_FAILURE;

195

163

}

196

164

}

197

165

201

169

}

202

170

203

171

t_new = t_old;

204

t_new.c_lflag &= ~(tcflag_t)ECHO;

172

t_new.c_lflag &= ~ECHO;

205

173

if(tcsetattr(STDIN_FILENO, TCSAFLUSH, &t_new) != 0){

206

int e = errno;

207

174

perror("tcsetattr-echo");

208

switch(e){

209

case EBADF:

210

case ENOTTY:

211

return EX_UNAVAILABLE;

212

case EINVAL:

213

default:

214

return EX_OSERR;

215

}

175

return EXIT_FAILURE;

216

176

}

217

177

218

178

if(debug){

219

179

fprintf(stderr, "Waiting for input from stdin \n");

220

180

}

234

194

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

235

195

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

236

196

const char *const prompt

237

= "Enter passphrase to unlock the disk";

197

= "Enter passphrase to unlock the disk";

238

198

if(cryptsource == NULL){

239

199

if(crypttarget == NULL){

240

200

fprintf(stderr, "%s: ", prompt);

256

216

/* Make n = data size instead of allocated buffer size */

257

217

n = (size_t)ret;

258

218

/* Strip final newline */

259

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

219

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

260

220

buffer[n-1] = '\0'; /* not strictly necessary */

261

221

n--;

262

222

}

264

224

while(written < n){

265

225

ret = write(STDOUT_FILENO, buffer + written, n - written);

266

226

if(ret < 0){

267

int e = errno;

268

227

perror("write");

269

switch(e){

270

case EBADF:

271

case EFAULT:

272

case EINVAL:

273

case EFBIG:

274

case EIO:

275

case ENOSPC:

276

default:

277

status = EX_IOERR;

278

break;

279

case EINTR:

280

status = EXIT_FAILURE;

281

break;

282

}

228

status = EXIT_FAILURE;

283

229

break;

284

230

}

285

231

written += (size_t)ret;

286

232

}

287

ret = close(STDOUT_FILENO);

288

if(ret == -1){

289

int e = errno;

290

perror("close");

291

switch(e){

292

case EBADF:

293

status = EX_OSFILE;

294

break;

295

case EIO:

296

default:

297

status = EX_IOERR;

298

break;

299

}

300

}

301

233

break;

302

234

}

303

235

if(ret < 0){

304

int e = errno;

305

236

if(errno != EINTR and not feof(stdin)){

306

237

perror("getline");

307

switch(e){

308

case EBADF:

309

status = EX_UNAVAILABLE;

310

case EIO:

311

case EINVAL:

312

default:

313

status = EX_IOERR;

314

break;

315

}

238

status = EXIT_FAILURE;

316

239

break;

317

240

}

318

241

}

319

242

/* if(ret == 0), then the only sensible thing to do is to retry to

320

243

read from stdin */

321

244

fputc('\n', stderr);

322

if(debug and not quit_now){

245

if(debug and quit_now == 0){

323

246

/* If quit_now is nonzero, we were interrupted by a signal, and

324

247

will print that later, so no need to show this too. */

325

248

fprintf(stderr, "getline() returned 0, retrying.\n");

335

258

perror("tcsetattr+echo");

336

259

}

337

260

338

if(quit_now){

339

sigemptyset(&old_action.sa_mask);

340

old_action.sa_handler = SIG_DFL;

341

ret = sigaction(signal_received, &old_action, NULL);

342

if(ret == -1){

343

perror("sigaction");

344

}

345

raise(signal_received);

346

}

347

348

261

if(debug){

349

262

fprintf(stderr, "%s is exiting with status %d\n", argv[0],

350

263

status);

351

264

}

352

if(status == EXIT_SUCCESS or status == EX_OK){

265

if(status == EXIT_SUCCESS){

353

266

fputc('\n', stderr);

354

267

}

355

268