xref: /openssh-portable/ssh-sk-client.c (revision 31d8d231)
1 /* $OpenBSD: ssh-sk-client.c,v 1.9 2021/04/03 06:18:41 djm Exp $ */
2 /*
3  * Copyright (c) 2019 Google LLC
4  *
5  * Permission to use, copy, modify, and distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
10  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
11  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
12  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
13  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
14  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
15  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
16  */
17 
18 #include "includes.h"
19 
20 #include <sys/types.h>
21 #include <sys/socket.h>
22 #include <sys/wait.h>
23 
24 #include <fcntl.h>
25 #include <limits.h>
26 #include <errno.h>
27 #include <signal.h>
28 #include <stdarg.h>
29 #include <stdio.h>
30 #include <stdlib.h>
31 #include <string.h>
32 #include <unistd.h>
33 
34 #include "log.h"
35 #include "ssherr.h"
36 #include "sshbuf.h"
37 #include "sshkey.h"
38 #include "msg.h"
39 #include "digest.h"
40 #include "pathnames.h"
41 #include "ssh-sk.h"
42 #include "misc.h"
43 
44 /* #define DEBUG_SK 1 */
45 
46 static int
start_helper(int * fdp,pid_t * pidp,void (** osigchldp)(int))47 start_helper(int *fdp, pid_t *pidp, void (**osigchldp)(int))
48 {
49 	void (*osigchld)(int);
50 	int oerrno, pair[2];
51 	pid_t pid;
52 	char *helper, *verbosity = NULL;
53 
54 	*fdp = -1;
55 	*pidp = 0;
56 	*osigchldp = SIG_DFL;
57 
58 	helper = getenv("SSH_SK_HELPER");
59 	if (helper == NULL || strlen(helper) == 0)
60 		helper = _PATH_SSH_SK_HELPER;
61 	if (access(helper, X_OK) != 0) {
62 		oerrno = errno;
63 		error_f("helper \"%s\" unusable: %s", helper, strerror(errno));
64 		errno = oerrno;
65 		return SSH_ERR_SYSTEM_ERROR;
66 	}
67 #ifdef DEBUG_SK
68 	verbosity = "-vvv";
69 #endif
70 
71 	/* Start helper */
72 	if (socketpair(AF_UNIX, SOCK_STREAM, 0, pair) == -1) {
73 		error("socketpair: %s", strerror(errno));
74 		return SSH_ERR_SYSTEM_ERROR;
75 	}
76 	osigchld = ssh_signal(SIGCHLD, SIG_DFL);
77 	if ((pid = fork()) == -1) {
78 		oerrno = errno;
79 		error("fork: %s", strerror(errno));
80 		close(pair[0]);
81 		close(pair[1]);
82 		ssh_signal(SIGCHLD, osigchld);
83 		errno = oerrno;
84 		return SSH_ERR_SYSTEM_ERROR;
85 	}
86 	if (pid == 0) {
87 		if ((dup2(pair[1], STDIN_FILENO) == -1) ||
88 		    (dup2(pair[1], STDOUT_FILENO) == -1)) {
89 			error_f("dup2: %s", strerror(errno));
90 			_exit(1);
91 		}
92 		close(pair[0]);
93 		close(pair[1]);
94 		closefrom(STDERR_FILENO + 1);
95 		debug_f("starting %s %s", helper,
96 		    verbosity == NULL ? "" : verbosity);
97 		execlp(helper, helper, verbosity, (char *)NULL);
98 		error_f("execlp: %s", strerror(errno));
99 		_exit(1);
100 	}
101 	close(pair[1]);
102 
103 	/* success */
104 	debug3_f("started pid=%ld", (long)pid);
105 	*fdp = pair[0];
106 	*pidp = pid;
107 	*osigchldp = osigchld;
108 	return 0;
109 }
110 
111 static int
reap_helper(pid_t pid)112 reap_helper(pid_t pid)
113 {
114 	int status, oerrno;
115 
116 	debug3_f("pid=%ld", (long)pid);
117 
118 	errno = 0;
119 	while (waitpid(pid, &status, 0) == -1) {
120 		if (errno == EINTR) {
121 			errno = 0;
122 			continue;
123 		}
124 		oerrno = errno;
125 		error_f("waitpid: %s", strerror(errno));
126 		errno = oerrno;
127 		return SSH_ERR_SYSTEM_ERROR;
128 	}
129 	if (!WIFEXITED(status)) {
130 		error_f("helper exited abnormally");
131 		return SSH_ERR_AGENT_FAILURE;
132 	} else if (WEXITSTATUS(status) != 0) {
133 		error_f("helper exited with non-zero exit status");
134 		return SSH_ERR_AGENT_FAILURE;
135 	}
136 	return 0;
137 }
138 
139 static int
client_converse(struct sshbuf * msg,struct sshbuf ** respp,u_int type)140 client_converse(struct sshbuf *msg, struct sshbuf **respp, u_int type)
141 {
142 	int oerrno, fd, r2, ll, r = SSH_ERR_INTERNAL_ERROR;
143 	u_int rtype, rerr;
144 	pid_t pid;
145 	u_char version;
146 	void (*osigchld)(int);
147 	struct sshbuf *req = NULL, *resp = NULL;
148 	*respp = NULL;
149 
150 	if ((r = start_helper(&fd, &pid, &osigchld)) != 0)
151 		return r;
152 
153 	if ((req = sshbuf_new()) == NULL || (resp = sshbuf_new()) == NULL) {
154 		r = SSH_ERR_ALLOC_FAIL;
155 		goto out;
156 	}
157 	/* Request preamble: type, log_on_stderr, log_level */
158 	ll = log_level_get();
159 	if ((r = sshbuf_put_u32(req, type)) != 0 ||
160 	    (r = sshbuf_put_u8(req, log_is_on_stderr() != 0)) != 0 ||
161 	    (r = sshbuf_put_u32(req, ll < 0 ? 0 : ll)) != 0 ||
162 	    (r = sshbuf_putb(req, msg)) != 0) {
163 		error_fr(r, "compose");
164 		goto out;
165 	}
166 	if ((r = ssh_msg_send(fd, SSH_SK_HELPER_VERSION, req)) != 0) {
167 		error_fr(r, "send");
168 		goto out;
169 	}
170 	if ((r = ssh_msg_recv(fd, resp)) != 0) {
171 		error_fr(r, "receive");
172 		goto out;
173 	}
174 	if ((r = sshbuf_get_u8(resp, &version)) != 0) {
175 		error_fr(r, "parse version");
176 		goto out;
177 	}
178 	if (version != SSH_SK_HELPER_VERSION) {
179 		error_f("unsupported version: got %u, expected %u",
180 		    version, SSH_SK_HELPER_VERSION);
181 		r = SSH_ERR_INVALID_FORMAT;
182 		goto out;
183 	}
184 	if ((r = sshbuf_get_u32(resp, &rtype)) != 0) {
185 		error_fr(r, "parse message type");
186 		goto out;
187 	}
188 	if (rtype == SSH_SK_HELPER_ERROR) {
189 		if ((r = sshbuf_get_u32(resp, &rerr)) != 0) {
190 			error_fr(r, "parse");
191 			goto out;
192 		}
193 		debug_f("helper returned error -%u", rerr);
194 		/* OpenSSH error values are negative; encoded as -err on wire */
195 		if (rerr == 0 || rerr >= INT_MAX)
196 			r = SSH_ERR_INTERNAL_ERROR;
197 		else
198 			r = -(int)rerr;
199 		goto out;
200 	} else if (rtype != type) {
201 		error_f("helper returned incorrect message type %u, "
202 		    "expecting %u", rtype, type);
203 		r = SSH_ERR_INTERNAL_ERROR;
204 		goto out;
205 	}
206 	/* success */
207 	r = 0;
208  out:
209 	oerrno = errno;
210 	close(fd);
211 	if ((r2 = reap_helper(pid)) != 0) {
212 		if (r == 0) {
213 			r = r2;
214 			oerrno = errno;
215 		}
216 	}
217 	if (r == 0) {
218 		*respp = resp;
219 		resp = NULL;
220 	}
221 	sshbuf_free(req);
222 	sshbuf_free(resp);
223 	ssh_signal(SIGCHLD, osigchld);
224 	errno = oerrno;
225 	return r;
226 
227 }
228 
229 int
sshsk_sign(const char * provider,struct sshkey * key,u_char ** sigp,size_t * lenp,const u_char * data,size_t datalen,u_int compat,const char * pin)230 sshsk_sign(const char *provider, struct sshkey *key,
231     u_char **sigp, size_t *lenp, const u_char *data, size_t datalen,
232     u_int compat, const char *pin)
233 {
234 	int oerrno, r = SSH_ERR_INTERNAL_ERROR;
235 	char *fp = NULL;
236 	struct sshbuf *kbuf = NULL, *req = NULL, *resp = NULL;
237 
238 	*sigp = NULL;
239 	*lenp = 0;
240 
241 #ifndef ENABLE_SK
242 	return SSH_ERR_KEY_TYPE_UNKNOWN;
243 #endif
244 
245 	if ((kbuf = sshbuf_new()) == NULL ||
246 	    (req = sshbuf_new()) == NULL) {
247 		r = SSH_ERR_ALLOC_FAIL;
248 		goto out;
249 	}
250 
251 	if ((r = sshkey_private_serialize(key, kbuf)) != 0) {
252 		error_fr(r, "encode key");
253 		goto out;
254 	}
255 	if ((r = sshbuf_put_stringb(req, kbuf)) != 0 ||
256 	    (r = sshbuf_put_cstring(req, provider)) != 0 ||
257 	    (r = sshbuf_put_string(req, data, datalen)) != 0 ||
258 	    (r = sshbuf_put_cstring(req, NULL)) != 0 || /* alg */
259 	    (r = sshbuf_put_u32(req, compat)) != 0 ||
260 	    (r = sshbuf_put_cstring(req, pin)) != 0) {
261 		error_fr(r, "compose");
262 		goto out;
263 	}
264 
265 	if ((fp = sshkey_fingerprint(key, SSH_FP_HASH_DEFAULT,
266 	    SSH_FP_DEFAULT)) == NULL) {
267 		error_f("sshkey_fingerprint failed");
268 		r = SSH_ERR_ALLOC_FAIL;
269 		goto out;
270 	}
271 	if ((r = client_converse(req, &resp, SSH_SK_HELPER_SIGN)) != 0)
272 		goto out;
273 
274 	if ((r = sshbuf_get_string(resp, sigp, lenp)) != 0) {
275 		error_fr(r, "parse signature");
276 		r = SSH_ERR_INVALID_FORMAT;
277 		goto out;
278 	}
279 	if (sshbuf_len(resp) != 0) {
280 		error_f("trailing data in response");
281 		r = SSH_ERR_INVALID_FORMAT;
282 		goto out;
283 	}
284 	/* success */
285 	r = 0;
286  out:
287 	oerrno = errno;
288 	if (r != 0) {
289 		freezero(*sigp, *lenp);
290 		*sigp = NULL;
291 		*lenp = 0;
292 	}
293 	sshbuf_free(kbuf);
294 	sshbuf_free(req);
295 	sshbuf_free(resp);
296 	errno = oerrno;
297 	return r;
298 }
299 
300 int
sshsk_enroll(int type,const char * provider_path,const char * device,const char * application,const char * userid,uint8_t flags,const char * pin,struct sshbuf * challenge_buf,struct sshkey ** keyp,struct sshbuf * attest)301 sshsk_enroll(int type, const char *provider_path, const char *device,
302     const char *application, const char *userid, uint8_t flags,
303     const char *pin, struct sshbuf *challenge_buf,
304     struct sshkey **keyp, struct sshbuf *attest)
305 {
306 	int oerrno, r = SSH_ERR_INTERNAL_ERROR;
307 	struct sshbuf *kbuf = NULL, *abuf = NULL, *req = NULL, *resp = NULL;
308 	struct sshkey *key = NULL;
309 
310 	*keyp = NULL;
311 	if (attest != NULL)
312 		sshbuf_reset(attest);
313 
314 #ifndef ENABLE_SK
315 	return SSH_ERR_KEY_TYPE_UNKNOWN;
316 #endif
317 
318 	if (type < 0)
319 		return SSH_ERR_INVALID_ARGUMENT;
320 
321 	if ((abuf = sshbuf_new()) == NULL ||
322 	    (kbuf = sshbuf_new()) == NULL ||
323 	    (req = sshbuf_new()) == NULL) {
324 		r = SSH_ERR_ALLOC_FAIL;
325 		goto out;
326 	}
327 
328 	if ((r = sshbuf_put_u32(req, (u_int)type)) != 0 ||
329 	    (r = sshbuf_put_cstring(req, provider_path)) != 0 ||
330 	    (r = sshbuf_put_cstring(req, device)) != 0 ||
331 	    (r = sshbuf_put_cstring(req, application)) != 0 ||
332 	    (r = sshbuf_put_cstring(req, userid)) != 0 ||
333 	    (r = sshbuf_put_u8(req, flags)) != 0 ||
334 	    (r = sshbuf_put_cstring(req, pin)) != 0 ||
335 	    (r = sshbuf_put_stringb(req, challenge_buf)) != 0) {
336 		error_fr(r, "compose");
337 		goto out;
338 	}
339 
340 	if ((r = client_converse(req, &resp, SSH_SK_HELPER_ENROLL)) != 0)
341 		goto out;
342 
343 	if ((r = sshbuf_get_stringb(resp, kbuf)) != 0 ||
344 	    (r = sshbuf_get_stringb(resp, abuf)) != 0) {
345 		error_fr(r, "parse");
346 		r = SSH_ERR_INVALID_FORMAT;
347 		goto out;
348 	}
349 	if (sshbuf_len(resp) != 0) {
350 		error_f("trailing data in response");
351 		r = SSH_ERR_INVALID_FORMAT;
352 		goto out;
353 	}
354 	if ((r = sshkey_private_deserialize(kbuf, &key)) != 0) {
355 		error_fr(r, "encode");
356 		goto out;
357 	}
358 	if (attest != NULL && (r = sshbuf_putb(attest, abuf)) != 0) {
359 		error_fr(r, "encode attestation information");
360 		goto out;
361 	}
362 
363 	/* success */
364 	r = 0;
365 	*keyp = key;
366 	key = NULL;
367  out:
368 	oerrno = errno;
369 	sshkey_free(key);
370 	sshbuf_free(kbuf);
371 	sshbuf_free(abuf);
372 	sshbuf_free(req);
373 	sshbuf_free(resp);
374 	errno = oerrno;
375 	return r;
376 }
377 
378 int
sshsk_load_resident(const char * provider_path,const char * device,const char * pin,struct sshkey *** keysp,size_t * nkeysp)379 sshsk_load_resident(const char *provider_path, const char *device,
380     const char *pin, struct sshkey ***keysp, size_t *nkeysp)
381 {
382 	int oerrno, r = SSH_ERR_INTERNAL_ERROR;
383 	struct sshbuf *kbuf = NULL, *req = NULL, *resp = NULL;
384 	struct sshkey *key = NULL, **keys = NULL, **tmp;
385 	size_t i, nkeys = 0;
386 
387 	*keysp = NULL;
388 	*nkeysp = 0;
389 
390 	if ((resp = sshbuf_new()) == NULL ||
391 	    (kbuf = sshbuf_new()) == NULL ||
392 	    (req = sshbuf_new()) == NULL) {
393 		r = SSH_ERR_ALLOC_FAIL;
394 		goto out;
395 	}
396 
397 	if ((r = sshbuf_put_cstring(req, provider_path)) != 0 ||
398 	    (r = sshbuf_put_cstring(req, device)) != 0 ||
399 	    (r = sshbuf_put_cstring(req, pin)) != 0) {
400 		error_fr(r, "compose");
401 		goto out;
402 	}
403 
404 	if ((r = client_converse(req, &resp, SSH_SK_HELPER_LOAD_RESIDENT)) != 0)
405 		goto out;
406 
407 	while (sshbuf_len(resp) != 0) {
408 		/* key, comment */
409 		if ((r = sshbuf_get_stringb(resp, kbuf)) != 0 ||
410 		    (r = sshbuf_get_cstring(resp, NULL, NULL)) != 0) {
411 			error_fr(r, "parse signature");
412 			r = SSH_ERR_INVALID_FORMAT;
413 			goto out;
414 		}
415 		if ((r = sshkey_private_deserialize(kbuf, &key)) != 0) {
416 			error_fr(r, "decode key");
417 			goto out;
418 		}
419 		if ((tmp = recallocarray(keys, nkeys, nkeys + 1,
420 		    sizeof(*keys))) == NULL) {
421 			error_f("recallocarray keys failed");
422 			goto out;
423 		}
424 		debug_f("keys[%zu]: %s %s", nkeys, sshkey_type(key),
425 		    key->sk_application);
426 		keys = tmp;
427 		keys[nkeys++] = key;
428 		key = NULL;
429 	}
430 
431 	/* success */
432 	r = 0;
433 	*keysp = keys;
434 	*nkeysp = nkeys;
435 	keys = NULL;
436 	nkeys = 0;
437  out:
438 	oerrno = errno;
439 	for (i = 0; i < nkeys; i++)
440 		sshkey_free(keys[i]);
441 	free(keys);
442 	sshkey_free(key);
443 	sshbuf_free(kbuf);
444 	sshbuf_free(req);
445 	sshbuf_free(resp);
446 	errno = oerrno;
447 	return r;
448 }
449