Head

GCC Code Coverage Report

Directory:	./		Exec	Total	Coverage
File:	usr.bin/ssh/lib/../readpass.c	Lines:	15	84	17.9 %
Date:	2017-11-07	Branches:	6	68	8.8 %


/* $OpenBSD: readpass.c,v 1.51 2015/12/11 00:20:04 mmcc Exp $ */
/*
 * Copyright (c) 2001 Markus Friedl.  All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/wait.h>

#include <errno.h>
#include <fcntl.h>
#include <paths.h>
#include <readpassphrase.h>
#include <signal.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>

#include "xmalloc.h"
#include "misc.h"
#include "pathnames.h"
#include "log.h"
#include "ssh.h"
#include "uidswap.h"

static char *
ssh_askpass(char *askpass, const char *msg)
{
	pid_t pid, ret;
	size_t len;
	char *pass;
	int p[2], status;
	char buf[1024];
	void (*osigchld)(int);

	if (fflush(stdout) != 0)
		error("ssh_askpass: fflush: %s", strerror(errno));
	if (askpass == NULL)
		fatal("internal error: askpass undefined");
	if (pipe(p) < 0) {
		error("ssh_askpass: pipe: %s", strerror(errno));
		return NULL;
	}
	osigchld = signal(SIGCHLD, SIG_DFL);
	if ((pid = fork()) < 0) {
		error("ssh_askpass: fork: %s", strerror(errno));
		signal(SIGCHLD, osigchld);
		return NULL;
	}
	if (pid == 0) {
		permanently_drop_suid(getuid());
		close(p[0]);
		if (dup2(p[1], STDOUT_FILENO) < 0)
			fatal("ssh_askpass: dup2: %s", strerror(errno));
		execlp(askpass, askpass, msg, (char *)NULL);
		fatal("ssh_askpass: exec(%s): %s", askpass, strerror(errno));
	}
	close(p[1]);

	len = 0;
	do {
		ssize_t r = read(p[0], buf + len, sizeof(buf) - 1 - len);

		if (r == -1 && errno == EINTR)
			continue;
		if (r <= 0)
			break;
		len += r;
	} while (sizeof(buf) - 1 - len > 0);
	buf[len] = '\0';

	close(p[0]);
	while ((ret = waitpid(pid, &status, 0)) < 0)
		if (errno != EINTR)
			break;
	signal(SIGCHLD, osigchld);
	if (ret == -1 || !WIFEXITED(status) || WEXITSTATUS(status) != 0) {
		explicit_bzero(buf, sizeof(buf));
		return NULL;
	}

	buf[strcspn(buf, "\r\n")] = '\0';
	pass = xstrdup(buf);
	explicit_bzero(buf, sizeof(buf));
	return pass;
}

/*
 * Reads a passphrase from /dev/tty with echo turned off/on.  Returns the
 * passphrase (allocated with xmalloc).  Exits if EOF is encountered. If
 * RP_ALLOW_STDIN is set, the passphrase will be read from stdin if no
 * tty is available
 */
char *
read_passphrase(const char *prompt, int flags)
{
	char *askpass = NULL, *ret, buf[1024];
	int rppflags, use_askpass = 0, ttyfd;

	rppflags = (flags & RP_ECHO) ? RPP_ECHO_ON : RPP_ECHO_OFF;
	if (flags & RP_USE_ASKPASS)
		use_askpass = 1;
	else if (flags & RP_ALLOW_STDIN) {
		if (!isatty(STDIN_FILENO)) {
			debug("read_passphrase: stdin is not a tty");
			use_askpass = 1;
		}
	} else {
		rppflags |= RPP_REQUIRE_TTY;
		ttyfd = open(_PATH_TTY, O_RDWR);
		if (ttyfd >= 0)
			close(ttyfd);
		else {
			debug("read_passphrase: can't open %s: %s", _PATH_TTY,
			    strerror(errno));
			use_askpass = 1;
		}
	}

	if ((flags & RP_USE_ASKPASS) && getenv("DISPLAY") == NULL)
		return (flags & RP_ALLOW_EOF) ? NULL : xstrdup("");

	if (use_askpass && getenv("DISPLAY")) {
		if (getenv(SSH_ASKPASS_ENV))
			askpass = getenv(SSH_ASKPASS_ENV);
		else
			askpass = _PATH_SSH_ASKPASS_DEFAULT;
		if ((ret = ssh_askpass(askpass, prompt)) == NULL)
			if (!(flags & RP_ALLOW_EOF))
				return xstrdup("");
		return ret;
	}

	if (readpassphrase(prompt, buf, sizeof buf, rppflags) == NULL) {
		if (flags & RP_ALLOW_EOF)
			return NULL;
		return xstrdup("");
	}

	ret = xstrdup(buf);
	explicit_bzero(buf, sizeof(buf));
	return ret;
}

int
ask_permission(const char *fmt, ...)
{
	va_list args;
	char *p, prompt[1024];
	int allowed = 0;

	va_start(args, fmt);
	vsnprintf(prompt, sizeof(prompt), fmt, args);
	va_end(args);

	p = read_passphrase(prompt, RP_USE_ASKPASS|RP_ALLOW_EOF);
	if (p != NULL) {
		/*
		 * Accept empty responses and responses consisting
		 * of the word "yes" as affirmative.
		 */
		if (*p == '\0' || *p == '\n' ||
		    strcasecmp(p, "yes") == 0)
			allowed = 1;
		free(p);
	}

	return (allowed);
}


Generated by: GCOVR (Version 3.3)

Line	Branch	Exec	Source
1			/* $OpenBSD: readpass.c,v 1.51 2015/12/11 00:20:04 mmcc Exp $ */
2			/*
3			* Copyright (c) 2001 Markus Friedl. All rights reserved.
4			*
5			* Redistribution and use in source and binary forms, with or without
6			* modification, are permitted provided that the following conditions
7			* are met:
8			* 1. Redistributions of source code must retain the above copyright
9			* notice, this list of conditions and the following disclaimer.
10			* 2. Redistributions in binary form must reproduce the above copyright
11			* notice, this list of conditions and the following disclaimer in the
12			* documentation and/or other materials provided with the distribution.
13			*
14			* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
15			* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
16			* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
17			* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
18			* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
19			* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
20			* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
21			* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
22			* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
23			* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
24			*/
25
26			#include <sys/types.h>
27			#include <sys/wait.h>
28
29			#include <errno.h>
30			#include <fcntl.h>
31			#include <paths.h>
32			#include <readpassphrase.h>
33			#include <signal.h>
34			#include <stdarg.h>
35			#include <stdio.h>
36			#include <stdlib.h>
37			#include <string.h>
38			#include <unistd.h>
39
40			#include "xmalloc.h"
41			#include "misc.h"
42			#include "pathnames.h"
43			#include "log.h"
44			#include "ssh.h"
45			#include "uidswap.h"
46
47			static char *
48			ssh_askpass(char askpass, const char msg)
49			{
50			pid_t pid, ret;
51			size_t len;
52			char *pass;
53			int p[2], status;
54			char buf[1024];
55			void (*osigchld)(int);
56
57			if (fflush(stdout) != 0)
58			error("ssh_askpass: fflush: %s", strerror(errno));
59			if (askpass == NULL)
60			fatal("internal error: askpass undefined");
61			if (pipe(p) < 0) {
62			error("ssh_askpass: pipe: %s", strerror(errno));
63			return NULL;
64			}
65			osigchld = signal(SIGCHLD, SIG_DFL);
66			if ((pid = fork()) < 0) {
67			error("ssh_askpass: fork: %s", strerror(errno));
68			signal(SIGCHLD, osigchld);
69			return NULL;
70			}
71			if (pid == 0) {
72			permanently_drop_suid(getuid());
73			close(p[0]);
74			if (dup2(p[1], STDOUT_FILENO) < 0)
75			fatal("ssh_askpass: dup2: %s", strerror(errno));
76			execlp(askpass, askpass, msg, (char *)NULL);
77			fatal("ssh_askpass: exec(%s): %s", askpass, strerror(errno));
78			}
79			close(p[1]);
80
81			len = 0;
82			do {
83			ssize_t r = read(p[0], buf + len, sizeof(buf) - 1 - len);
84
85			if (r == -1 && errno == EINTR)
86			continue;
87			if (r <= 0)
88			break;
89			len += r;
90			} while (sizeof(buf) - 1 - len > 0);
91			buf[len] = '\0';
92
93			close(p[0]);
94			while ((ret = waitpid(pid, &status, 0)) < 0)
95			if (errno != EINTR)
96			break;
97			signal(SIGCHLD, osigchld);
98			if (ret == -1 \|\| !WIFEXITED(status) \|\| WEXITSTATUS(status) != 0) {
99			explicit_bzero(buf, sizeof(buf));
100			return NULL;
101			}
102
103			buf[strcspn(buf, "\r\n")] = '\0';
104			pass = xstrdup(buf);
105			explicit_bzero(buf, sizeof(buf));
106			return pass;
107			}
108
109			/*
110			* Reads a passphrase from /dev/tty with echo turned off/on. Returns the
111			* passphrase (allocated with xmalloc). Exits if EOF is encountered. If
112			* RP_ALLOW_STDIN is set, the passphrase will be read from stdin if no
113			* tty is available
114			*/
115			char *
116			read_passphrase(const char *prompt, int flags)
117			{
118		4	char askpass = NULL, ret, buf[1024];
119			int rppflags, use_askpass = 0, ttyfd;
120
121		2	rppflags = (flags & RP_ECHO) ? RPP_ECHO_ON : RPP_ECHO_OFF;
122	✗✓	2	if (flags & RP_USE_ASKPASS)
123			use_askpass = 1;
124	✗✓	2	else if (flags & RP_ALLOW_STDIN) {
125			if (!isatty(STDIN_FILENO)) {
126			debug("read_passphrase: stdin is not a tty");
127			use_askpass = 1;
128			}
129			} else {
130		2	rppflags \|= RPP_REQUIRE_TTY;
131		2	ttyfd = open(_PATH_TTY, O_RDWR);
132	✓✗	2	if (ttyfd >= 0)
133		2	close(ttyfd);
134			else {
135			debug("read_passphrase: can't open %s: %s", _PATH_TTY,
136			strerror(errno));
137			use_askpass = 1;
138			}
139			}
140
141	✗✓✗✗	2	if ((flags & RP_USE_ASKPASS) && getenv("DISPLAY") == NULL)
142			return (flags & RP_ALLOW_EOF) ? NULL : xstrdup("");
143
144	✗✓✗✗	2	if (use_askpass && getenv("DISPLAY")) {
145			if (getenv(SSH_ASKPASS_ENV))
146			askpass = getenv(SSH_ASKPASS_ENV);
147			else
148			askpass = _PATH_SSH_ASKPASS_DEFAULT;
149			if ((ret = ssh_askpass(askpass, prompt)) == NULL)
150			if (!(flags & RP_ALLOW_EOF))
151			return xstrdup("");
152			return ret;
153			}
154
155	✗✓	2	if (readpassphrase(prompt, buf, sizeof buf, rppflags) == NULL) {
156			if (flags & RP_ALLOW_EOF)
157			return NULL;
158			return xstrdup("");
159			}
160
161		2	ret = xstrdup(buf);
162		2	explicit_bzero(buf, sizeof(buf));
163		2	return ret;
164		2	}
165
166			int
167			ask_permission(const char *fmt, ...)
168			{
169			va_list args;
170			char *p, prompt[1024];
171			int allowed = 0;
172
173			va_start(args, fmt);
174			vsnprintf(prompt, sizeof(prompt), fmt, args);
175			va_end(args);
176
177			p = read_passphrase(prompt, RP_USE_ASKPASS\|RP_ALLOW_EOF);
178			if (p != NULL) {
179			/*
180			* Accept empty responses and responses consisting
181			* of the word "yes" as affirmative.
182			*/
183			if (p == '\0' \|\| p == '\n' \|\|
184			strcasecmp(p, "yes") == 0)
185			allowed = 1;
186			free(p);
187			}
188
189			return (allowed);
190			}