/mandos/trunk : revision 393

1

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

1

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

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 <https://www.fukt.bsnet.se/~belorn/> and

23

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

22

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

24

23

*/

25

24

26

25

#define _GNU_SOURCE /* getline() */

33

32

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

34

33

sigaction, sigemptyset(),

35

34

sigaction(), sigaddset(), SIGINT,

36

SIGQUIT, SIGHUP, SIGTERM */

35

SIGQUIT, SIGHUP, SIGTERM,

36

raise() */

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

stdout, getopt_long */

44

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

43

getopt_long */

44

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

45

EFAULT, EFBIG, EIO, ENOSPC, EINTR

46

*/

45

47

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

46

48

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

47

49

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

50

52

argp_parse(), error_t,

51

53

ARGP_KEY_ARG, ARGP_KEY_END,

52

54

ARGP_ERR_UNKNOWN */

55

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

56

EX_UNAVAILABLE, EX_IOERR, EX_OK */

53

57

54

58

volatile sig_atomic_t quit_now = 0;

59

int signal_received;

55

60

bool debug = false;

56

61

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

57

62

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

58

63

59

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

64

static void termination_handler(int signum){

65

if(quit_now){

66

return;

67

}

60

68

quit_now = 1;

69

signal_received = signum;

61

70

}

62

71

63

72

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

106

115

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

107

116

if(ret == ARGP_ERR_UNKNOWN){

108

117

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

109

return EXIT_FAILURE;

118

return EX_SOFTWARE;

110

119

}

111

120

}

112

121

118

127

}

119

128

120

129

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

130

int e = errno;

121

131

perror("tcgetattr");

122

return EXIT_FAILURE;

132

switch(e){

133

case EBADF:

134

case ENOTTY:

135

return EX_UNAVAILABLE;

136

default:

137

return EX_OSERR;

138

}

123

139

}

124

140

125

141

sigemptyset(&new_action.sa_mask);

126

sigaddset(&new_action.sa_mask, SIGINT);

127

sigaddset(&new_action.sa_mask, SIGHUP);

128

sigaddset(&new_action.sa_mask, SIGTERM);

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

*/

129

161

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

130

162

if(ret == -1){

131

163

perror("sigaction");

132

return EXIT_FAILURE;

164

return EX_OSERR;

133

165

}

134

166

if(old_action.sa_handler != SIG_IGN){

135

167

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

136

168

if(ret == -1){

137

169

perror("sigaction");

138

return EXIT_FAILURE;

170

return EX_OSERR;

139

171

}

140

172

}

141

173

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

142

174

if(ret == -1){

143

175

perror("sigaction");

144

return EXIT_FAILURE;

176

return EX_OSERR;

145

177

}

146

178

if(old_action.sa_handler != SIG_IGN){

147

179

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

148

180

if(ret == -1){

149

181

perror("sigaction");

150

return EXIT_FAILURE;

182

return EX_OSERR;

151

183

}

152

184

}

153

185

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

154

186

if(ret == -1){

155

187

perror("sigaction");

156

return EXIT_FAILURE;

188

return EX_OSERR;

157

189

}

158

190

if(old_action.sa_handler != SIG_IGN){

159

191

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

160

192

if(ret == -1){

161

193

perror("sigaction");

162

return EXIT_FAILURE;

194

return EX_OSERR;

163

195

}

164

196

}

165

197

169

201

}

170

202

171

203

t_new = t_old;

172

t_new.c_lflag &= ~ECHO;

204

t_new.c_lflag &= ~(tcflag_t)ECHO;

173

205

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

206

int e = errno;

174

207

perror("tcsetattr-echo");

175

return EXIT_FAILURE;

208

switch(e){

209

case EBADF:

210

case ENOTTY:

211

return EX_UNAVAILABLE;

212

case EINVAL:

213

default:

214

return EX_OSERR;

215

}

176

216

}

177

217

178

218

if(debug){

179

219

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

180

220

}

194

234

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

195

235

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

196

236

const char *const prompt

197

= "Enter passphrase to unlock the disk";

237

= "Enter passphrase to unlock the disk";

198

238

if(cryptsource == NULL){

199

239

if(crypttarget == NULL){

200

240

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

216

256

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

217

257

n = (size_t)ret;

218

258

/* Strip final newline */

219

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

259

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

220

260

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

221

261

n--;

222

262

}

224

264

while(written < n){

225

265

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

226

266

if(ret < 0){

267

int e = errno;

227

268

perror("write");

228

status = EXIT_FAILURE;

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

}

229

283

break;

230

284

}

231

285

written += (size_t)ret;

232

286

}

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

}

233

301

break;

234

302

}

235

303

if(ret < 0){

304

int e = errno;

236

305

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

237

306

perror("getline");

238

status = EXIT_FAILURE;

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

}

239

316

break;

240

317

}

241

318

}

242

319

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

243

320

read from stdin */

244

321

fputc('\n', stderr);

245

if(debug and quit_now == 0){

322

if(debug and not quit_now){

246

323

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

247

324

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

248

325

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

258

335

perror("tcsetattr+echo");

259

336

}

260

337

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

261

348

if(debug){

262

349

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

263

350

status);

264

351

}

265

if(status == EXIT_SUCCESS){

352

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

266

353

fputc('\n', stderr);

267

354

}

268

355