blob: 06e6d4a4caef74b8584f77ceb4e264aad060f85d [file] [log] [blame]
Damien Millerd4a8b7e1999-10-27 13:42:43 +10001/*
Damien Miller95def091999-11-25 00:26:21 +11002 * Author: Tatu Ylonen <ylo@cs.hut.fi>
Damien Miller95def091999-11-25 00:26:21 +11003 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
4 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11005 * Functions for connecting the local authentication agent.
Damien Miller4af51302000-04-16 11:18:38 +10006 *
Damien Millere4340be2000-09-16 13:29:08 +11007 * As far as I am concerned, the code I have written for this software
8 * can be used freely for any purpose. Any derived versions of this
9 * software must be clearly marked as such, and if the derived work is
10 * incompatible with the protocol description in the RFC file, it must be
11 * called by a name other than "ssh" or "Secure Shell".
Damien Millerad833b32000-08-23 10:46:23 +100012 *
Damien Millere4340be2000-09-16 13:29:08 +110013 * SSH2 implementation,
14 * Copyright (c) 2000 Markus Friedl. All rights reserved.
15 *
16 * Redistribution and use in source and binary forms, with or without
17 * modification, are permitted provided that the following conditions
18 * are met:
19 * 1. Redistributions of source code must retain the above copyright
20 * notice, this list of conditions and the following disclaimer.
21 * 2. Redistributions in binary form must reproduce the above copyright
22 * notice, this list of conditions and the following disclaimer in the
23 * documentation and/or other materials provided with the distribution.
24 *
25 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR
26 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
27 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
28 * IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
29 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
30 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
31 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
32 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
33 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
34 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
Damien Miller95def091999-11-25 00:26:21 +110035 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100036
37#include "includes.h"
Damien Miller574c41f2006-03-15 11:40:10 +110038RCSID("$OpenBSD: authfd.c,v 1.67 2006/02/20 16:36:14 stevesk Exp $");
39
40#include <sys/types.h>
41#include <sys/un.h>
Ben Lindstrom226cfa02001-01-22 05:34:40 +000042
43#include <openssl/evp.h>
Damien Millerd4a8b7e1999-10-27 13:42:43 +100044
45#include "ssh.h"
46#include "rsa.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100047#include "buffer.h"
48#include "bufaux.h"
49#include "xmalloc.h"
50#include "getput.h"
Damien Miller994cf142000-07-21 10:19:44 +100051#include "key.h"
52#include "authfd.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000053#include "cipher.h"
Damien Miller994cf142000-07-21 10:19:44 +100054#include "kex.h"
Damien Miller62cee002000-09-23 17:15:56 +110055#include "compat.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000056#include "log.h"
57#include "atomicio.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100058
Damien Miller789e95d2002-09-12 09:52:46 +100059static int agent_present = 0;
60
Damien Miller37023962000-07-11 17:31:38 +100061/* helper */
Damien Miller942da032000-08-18 13:59:06 +100062int decode_reply(int type);
Damien Miller37023962000-07-11 17:31:38 +100063
Damien Miller874d77b2000-10-14 16:23:11 +110064/* macro to check for "agent failure" message */
65#define agent_failed(x) \
Ben Lindstromc9a26362001-08-15 23:04:50 +000066 ((x == SSH_AGENT_FAILURE) || (x == SSH_COM_AGENT2_FAILURE) || \
Ben Lindstromcb72e4f2002-06-21 00:41:51 +000067 (x == SSH2_AGENT_FAILURE))
Damien Miller874d77b2000-10-14 16:23:11 +110068
Damien Miller789e95d2002-09-12 09:52:46 +100069int
70ssh_agent_present(void)
71{
72 int authfd;
73
74 if (agent_present)
75 return 1;
76 if ((authfd = ssh_get_authentication_socket()) == -1)
77 return 0;
78 else {
79 ssh_close_authentication_socket(authfd);
80 return 1;
81 }
82}
83
Damien Millerd4a8b7e1999-10-27 13:42:43 +100084/* Returns the number of the authentication fd, or -1 if there is none. */
85
86int
Ben Lindstrom46c16222000-12-22 01:43:59 +000087ssh_get_authentication_socket(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +100088{
Damien Miller95def091999-11-25 00:26:21 +110089 const char *authsocket;
Ben Lindstromb1d822c2001-09-20 01:03:31 +000090 int sock;
Damien Miller95def091999-11-25 00:26:21 +110091 struct sockaddr_un sunaddr;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100092
Damien Miller95def091999-11-25 00:26:21 +110093 authsocket = getenv(SSH_AUTHSOCKET_ENV_NAME);
94 if (!authsocket)
95 return -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +100096
Damien Miller95def091999-11-25 00:26:21 +110097 sunaddr.sun_family = AF_UNIX;
98 strlcpy(sunaddr.sun_path, authsocket, sizeof(sunaddr.sun_path));
Damien Miller10f6f6b1999-11-17 17:29:08 +110099
Damien Miller95def091999-11-25 00:26:21 +1100100 sock = socket(AF_UNIX, SOCK_STREAM, 0);
101 if (sock < 0)
102 return -1;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000103
Damien Miller95def091999-11-25 00:26:21 +1100104 /* close on exec */
105 if (fcntl(sock, F_SETFD, 1) == -1) {
106 close(sock);
107 return -1;
108 }
Ben Lindstromb1d822c2001-09-20 01:03:31 +0000109 if (connect(sock, (struct sockaddr *) &sunaddr, sizeof sunaddr) < 0) {
Damien Miller95def091999-11-25 00:26:21 +1100110 close(sock);
111 return -1;
112 }
Damien Miller789e95d2002-09-12 09:52:46 +1000113 agent_present = 1;
Damien Miller95def091999-11-25 00:26:21 +1100114 return sock;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000115}
116
Ben Lindstrombba81212001-06-25 05:01:22 +0000117static int
Damien Millerad833b32000-08-23 10:46:23 +1000118ssh_request_reply(AuthenticationConnection *auth, Buffer *request, Buffer *reply)
Damien Miller942da032000-08-18 13:59:06 +1000119{
Damien Millereccb9de2005-06-17 12:59:34 +1000120 u_int l, len;
Damien Miller942da032000-08-18 13:59:06 +1000121 char buf[1024];
122
123 /* Get the length of the message, and format it in the buffer. */
124 len = buffer_len(request);
125 PUT_32BIT(buf, len);
126
127 /* Send the length and then the packet to the agent. */
Darren Tucker9f63f222003-07-03 13:46:56 +1000128 if (atomicio(vwrite, auth->fd, buf, 4) != 4 ||
129 atomicio(vwrite, auth->fd, buffer_ptr(request),
Damien Miller942da032000-08-18 13:59:06 +1000130 buffer_len(request)) != buffer_len(request)) {
131 error("Error writing to authentication socket.");
132 return 0;
133 }
134 /*
135 * Wait for response from the agent. First read the length of the
136 * response packet.
137 */
Darren Tuckerfe6649d2004-08-13 21:19:37 +1000138 if (atomicio(read, auth->fd, buf, 4) != 4) {
139 error("Error reading response length from authentication socket.");
140 return 0;
Damien Miller942da032000-08-18 13:59:06 +1000141 }
142
143 /* Extract the length, and check it for sanity. */
144 len = GET_32BIT(buf);
145 if (len > 256 * 1024)
Darren Tuckerc0815c92003-09-22 21:05:50 +1000146 fatal("Authentication response too long: %u", len);
Damien Miller942da032000-08-18 13:59:06 +1000147
148 /* Read the rest of the response in to the buffer. */
149 buffer_clear(reply);
150 while (len > 0) {
151 l = len;
152 if (l > sizeof(buf))
153 l = sizeof(buf);
Damien Millerb253cc42005-05-26 12:23:44 +1000154 if (atomicio(read, auth->fd, buf, l) != l) {
Damien Miller942da032000-08-18 13:59:06 +1000155 error("Error reading response from authentication socket.");
156 return 0;
157 }
Ben Lindstrom6398a0e2002-06-25 23:22:54 +0000158 buffer_append(reply, buf, l);
Damien Miller942da032000-08-18 13:59:06 +1000159 len -= l;
160 }
161 return 1;
162}
163
Damien Miller5428f641999-11-25 11:54:57 +1100164/*
165 * Closes the agent socket if it should be closed (depends on how it was
166 * obtained). The argument must have been returned by
167 * ssh_get_authentication_socket().
168 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000169
Damien Miller4af51302000-04-16 11:18:38 +1000170void
Damien Miller95def091999-11-25 00:26:21 +1100171ssh_close_authentication_socket(int sock)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000172{
Damien Miller95def091999-11-25 00:26:21 +1100173 if (getenv(SSH_AUTHSOCKET_ENV_NAME))
174 close(sock);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000175}
176
Damien Miller5428f641999-11-25 11:54:57 +1100177/*
178 * Opens and connects a private socket for communication with the
179 * authentication agent. Returns the file descriptor (which must be
180 * shut down and closed by the caller when no longer needed).
181 * Returns NULL if an error occurred and the connection could not be
182 * opened.
183 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000184
Damien Miller95def091999-11-25 00:26:21 +1100185AuthenticationConnection *
Ben Lindstrom46c16222000-12-22 01:43:59 +0000186ssh_get_authentication_connection(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000187{
Damien Miller95def091999-11-25 00:26:21 +1100188 AuthenticationConnection *auth;
189 int sock;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000190
Damien Miller95def091999-11-25 00:26:21 +1100191 sock = ssh_get_authentication_socket();
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000192
Damien Miller5428f641999-11-25 11:54:57 +1100193 /*
194 * Fail if we couldn't obtain a connection. This happens if we
195 * exited due to a timeout.
196 */
Damien Miller95def091999-11-25 00:26:21 +1100197 if (sock < 0)
198 return NULL;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000199
Damien Miller95def091999-11-25 00:26:21 +1100200 auth = xmalloc(sizeof(*auth));
201 auth->fd = sock;
Damien Miller95def091999-11-25 00:26:21 +1100202 buffer_init(&auth->identities);
203 auth->howmany = 0;
204
205 return auth;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000206}
207
Damien Miller5428f641999-11-25 11:54:57 +1100208/*
209 * Closes the connection to the authentication agent and frees any associated
210 * memory.
211 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000212
Damien Miller4af51302000-04-16 11:18:38 +1000213void
Damien Millerad833b32000-08-23 10:46:23 +1000214ssh_close_authentication_connection(AuthenticationConnection *auth)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000215{
Damien Millerad833b32000-08-23 10:46:23 +1000216 buffer_free(&auth->identities);
217 close(auth->fd);
218 xfree(auth);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000219}
220
Ben Lindstrom2f717042002-06-06 21:52:03 +0000221/* Lock/unlock agent */
222int
223ssh_lock_agent(AuthenticationConnection *auth, int lock, const char *password)
224{
225 int type;
226 Buffer msg;
227
228 buffer_init(&msg);
229 buffer_put_char(&msg, lock ? SSH_AGENTC_LOCK : SSH_AGENTC_UNLOCK);
230 buffer_put_cstring(&msg, password);
231
232 if (ssh_request_reply(auth, &msg, &msg) == 0) {
233 buffer_free(&msg);
234 return 0;
235 }
236 type = buffer_get_char(&msg);
237 buffer_free(&msg);
238 return decode_reply(type);
239}
240
Damien Miller5428f641999-11-25 11:54:57 +1100241/*
242 * Returns the first authentication identity held by the agent.
Damien Miller5428f641999-11-25 11:54:57 +1100243 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000244
Damien Miller0bc1bd82000-11-13 22:57:25 +1100245int
246ssh_get_num_identities(AuthenticationConnection *auth, int version)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000247{
Damien Millerad833b32000-08-23 10:46:23 +1000248 int type, code1 = 0, code2 = 0;
Damien Miller942da032000-08-18 13:59:06 +1000249 Buffer request;
Damien Millerad833b32000-08-23 10:46:23 +1000250
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000251 switch (version) {
Damien Millerad833b32000-08-23 10:46:23 +1000252 case 1:
253 code1 = SSH_AGENTC_REQUEST_RSA_IDENTITIES;
254 code2 = SSH_AGENT_RSA_IDENTITIES_ANSWER;
255 break;
256 case 2:
257 code1 = SSH2_AGENTC_REQUEST_IDENTITIES;
258 code2 = SSH2_AGENT_IDENTITIES_ANSWER;
259 break;
260 default:
Damien Miller0bc1bd82000-11-13 22:57:25 +1100261 return 0;
Damien Millerad833b32000-08-23 10:46:23 +1000262 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000263
Damien Miller5428f641999-11-25 11:54:57 +1100264 /*
265 * Send a message to the agent requesting for a list of the
266 * identities it can represent.
267 */
Damien Miller942da032000-08-18 13:59:06 +1000268 buffer_init(&request);
Damien Millerad833b32000-08-23 10:46:23 +1000269 buffer_put_char(&request, code1);
Damien Miller942da032000-08-18 13:59:06 +1000270
271 buffer_clear(&auth->identities);
272 if (ssh_request_reply(auth, &request, &auth->identities) == 0) {
273 buffer_free(&request);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100274 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000275 }
Damien Miller942da032000-08-18 13:59:06 +1000276 buffer_free(&request);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000277
Damien Miller95def091999-11-25 00:26:21 +1100278 /* Get message type, and verify that we got a proper answer. */
Damien Miller942da032000-08-18 13:59:06 +1000279 type = buffer_get_char(&auth->identities);
Damien Miller874d77b2000-10-14 16:23:11 +1100280 if (agent_failed(type)) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100281 return 0;
Damien Millerad833b32000-08-23 10:46:23 +1000282 } else if (type != code2) {
Damien Miller942da032000-08-18 13:59:06 +1000283 fatal("Bad authentication reply message type: %d", type);
Damien Millerad833b32000-08-23 10:46:23 +1000284 }
Damien Miller95def091999-11-25 00:26:21 +1100285
286 /* Get the number of entries in the response and check it for sanity. */
287 auth->howmany = buffer_get_int(&auth->identities);
Darren Tuckerc0815c92003-09-22 21:05:50 +1000288 if ((u_int)auth->howmany > 1024)
Ben Lindstrom6df8ef42001-03-05 07:47:23 +0000289 fatal("Too many identities in authentication reply: %d",
Damien Miller942da032000-08-18 13:59:06 +1000290 auth->howmany);
Damien Miller95def091999-11-25 00:26:21 +1100291
Damien Miller0bc1bd82000-11-13 22:57:25 +1100292 return auth->howmany;
293}
294
295Key *
296ssh_get_first_identity(AuthenticationConnection *auth, char **comment, int version)
297{
298 /* get number of identities and return the first entry (if any). */
299 if (ssh_get_num_identities(auth, version) > 0)
300 return ssh_get_next_identity(auth, comment, version);
301 return NULL;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000302}
303
Damien Millerad833b32000-08-23 10:46:23 +1000304Key *
305ssh_get_next_identity(AuthenticationConnection *auth, char **comment, int version)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000306{
Damien Millereccb9de2005-06-17 12:59:34 +1000307 int keybits;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000308 u_int bits;
309 u_char *blob;
310 u_int blen;
Damien Millerad833b32000-08-23 10:46:23 +1000311 Key *key = NULL;
Damien Miller7e8e8201999-11-16 13:37:16 +1100312
Damien Miller95def091999-11-25 00:26:21 +1100313 /* Return failure if no more entries. */
314 if (auth->howmany <= 0)
Damien Millerad833b32000-08-23 10:46:23 +1000315 return NULL;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000316
Damien Miller5428f641999-11-25 11:54:57 +1100317 /*
318 * Get the next entry from the packet. These will abort with a fatal
319 * error if the packet is too short or contains corrupt data.
320 */
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000321 switch (version) {
Damien Millerad833b32000-08-23 10:46:23 +1000322 case 1:
Damien Miller0bc1bd82000-11-13 22:57:25 +1100323 key = key_new(KEY_RSA1);
Damien Millerad833b32000-08-23 10:46:23 +1000324 bits = buffer_get_int(&auth->identities);
325 buffer_get_bignum(&auth->identities, key->rsa->e);
326 buffer_get_bignum(&auth->identities, key->rsa->n);
327 *comment = buffer_get_string(&auth->identities, NULL);
Damien Millereccb9de2005-06-17 12:59:34 +1000328 keybits = BN_num_bits(key->rsa->n);
329 if (keybits < 0 || bits != (u_int)keybits)
Damien Miller996acd22003-04-09 20:59:48 +1000330 logit("Warning: identity keysize mismatch: actual %d, announced %u",
Damien Millerad833b32000-08-23 10:46:23 +1000331 BN_num_bits(key->rsa->n), bits);
332 break;
333 case 2:
334 blob = buffer_get_string(&auth->identities, &blen);
335 *comment = buffer_get_string(&auth->identities, NULL);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100336 key = key_from_blob(blob, blen);
Damien Millerad833b32000-08-23 10:46:23 +1000337 xfree(blob);
338 break;
339 default:
340 return NULL;
341 break;
342 }
Damien Miller95def091999-11-25 00:26:21 +1100343 /* Decrement the number of remaining entries. */
344 auth->howmany--;
Damien Millerad833b32000-08-23 10:46:23 +1000345 return key;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000346}
347
Damien Miller5428f641999-11-25 11:54:57 +1100348/*
349 * Generates a random challenge, sends it to the agent, and waits for
350 * response from the agent. Returns true (non-zero) if the agent gave the
351 * correct answer, zero otherwise. Response type selects the style of
352 * response desired, with 0 corresponding to protocol version 1.0 (no longer
353 * supported) and 1 corresponding to protocol version 1.1.
354 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000355
356int
357ssh_decrypt_challenge(AuthenticationConnection *auth,
Damien Millerad833b32000-08-23 10:46:23 +1000358 Key* key, BIGNUM *challenge,
Ben Lindstrom46c16222000-12-22 01:43:59 +0000359 u_char session_id[16],
360 u_int response_type,
361 u_char response[16])
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000362{
Damien Miller95def091999-11-25 00:26:21 +1100363 Buffer buffer;
Damien Miller942da032000-08-18 13:59:06 +1000364 int success = 0;
365 int i;
366 int type;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000367
Damien Miller0bc1bd82000-11-13 22:57:25 +1100368 if (key->type != KEY_RSA1)
Damien Millerad833b32000-08-23 10:46:23 +1000369 return 0;
370 if (response_type == 0) {
Damien Miller996acd22003-04-09 20:59:48 +1000371 logit("Compatibility with ssh protocol version 1.0 no longer supported.");
Damien Millerad833b32000-08-23 10:46:23 +1000372 return 0;
373 }
Damien Miller95def091999-11-25 00:26:21 +1100374 buffer_init(&buffer);
Damien Miller942da032000-08-18 13:59:06 +1000375 buffer_put_char(&buffer, SSH_AGENTC_RSA_CHALLENGE);
Damien Millerad833b32000-08-23 10:46:23 +1000376 buffer_put_int(&buffer, BN_num_bits(key->rsa->n));
377 buffer_put_bignum(&buffer, key->rsa->e);
378 buffer_put_bignum(&buffer, key->rsa->n);
Damien Miller95def091999-11-25 00:26:21 +1100379 buffer_put_bignum(&buffer, challenge);
Damien Miller4a8ed542002-01-22 23:33:31 +1100380 buffer_append(&buffer, session_id, 16);
Damien Miller95def091999-11-25 00:26:21 +1100381 buffer_put_int(&buffer, response_type);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000382
Damien Miller942da032000-08-18 13:59:06 +1000383 if (ssh_request_reply(auth, &buffer, &buffer) == 0) {
Damien Miller95def091999-11-25 00:26:21 +1100384 buffer_free(&buffer);
385 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000386 }
Damien Miller942da032000-08-18 13:59:06 +1000387 type = buffer_get_char(&buffer);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000388
Damien Miller874d77b2000-10-14 16:23:11 +1100389 if (agent_failed(type)) {
Damien Miller996acd22003-04-09 20:59:48 +1000390 logit("Agent admitted failure to authenticate using the key.");
Damien Miller942da032000-08-18 13:59:06 +1000391 } else if (type != SSH_AGENT_RSA_RESPONSE) {
392 fatal("Bad authentication response: %d", type);
393 } else {
394 success = 1;
395 /*
396 * Get the response from the packet. This will abort with a
397 * fatal error if the packet is corrupt.
398 */
399 for (i = 0; i < 16; i++)
400 response[i] = buffer_get_char(&buffer);
Damien Miller95def091999-11-25 00:26:21 +1100401 }
Damien Miller95def091999-11-25 00:26:21 +1100402 buffer_free(&buffer);
Damien Miller942da032000-08-18 13:59:06 +1000403 return success;
Damien Miller95def091999-11-25 00:26:21 +1100404}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000405
Damien Millerad833b32000-08-23 10:46:23 +1000406/* ask agent to sign data, returns -1 on error, 0 on success */
407int
408ssh_agent_sign(AuthenticationConnection *auth,
409 Key *key,
Ben Lindstrom90fd8142002-02-26 18:09:42 +0000410 u_char **sigp, u_int *lenp,
411 u_char *data, u_int datalen)
Damien Millerad833b32000-08-23 10:46:23 +1000412{
Damien Miller62cee002000-09-23 17:15:56 +1100413 extern int datafellows;
Damien Millerad833b32000-08-23 10:46:23 +1000414 Buffer msg;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000415 u_char *blob;
416 u_int blen;
Damien Miller62cee002000-09-23 17:15:56 +1100417 int type, flags = 0;
Damien Millerad833b32000-08-23 10:46:23 +1000418 int ret = -1;
419
Damien Miller0bc1bd82000-11-13 22:57:25 +1100420 if (key_to_blob(key, &blob, &blen) == 0)
Damien Millerad833b32000-08-23 10:46:23 +1000421 return -1;
422
Damien Miller62cee002000-09-23 17:15:56 +1100423 if (datafellows & SSH_BUG_SIGBLOB)
424 flags = SSH_AGENT_OLD_SIGNATURE;
425
Damien Millerad833b32000-08-23 10:46:23 +1000426 buffer_init(&msg);
427 buffer_put_char(&msg, SSH2_AGENTC_SIGN_REQUEST);
428 buffer_put_string(&msg, blob, blen);
429 buffer_put_string(&msg, data, datalen);
Damien Miller62cee002000-09-23 17:15:56 +1100430 buffer_put_int(&msg, flags);
Damien Millerad833b32000-08-23 10:46:23 +1000431 xfree(blob);
432
433 if (ssh_request_reply(auth, &msg, &msg) == 0) {
434 buffer_free(&msg);
435 return -1;
436 }
437 type = buffer_get_char(&msg);
Damien Miller874d77b2000-10-14 16:23:11 +1100438 if (agent_failed(type)) {
Damien Miller996acd22003-04-09 20:59:48 +1000439 logit("Agent admitted failure to sign using the key.");
Damien Millerad833b32000-08-23 10:46:23 +1000440 } else if (type != SSH2_AGENT_SIGN_RESPONSE) {
441 fatal("Bad authentication response: %d", type);
442 } else {
443 ret = 0;
444 *sigp = buffer_get_string(&msg, lenp);
445 }
446 buffer_free(&msg);
447 return ret;
448}
449
Damien Miller994cf142000-07-21 10:19:44 +1000450/* Encode key for a message to the agent. */
451
Ben Lindstrombba81212001-06-25 05:01:22 +0000452static void
Damien Miller0bc1bd82000-11-13 22:57:25 +1100453ssh_encode_identity_rsa1(Buffer *b, RSA *key, const char *comment)
Damien Miller994cf142000-07-21 10:19:44 +1000454{
Damien Miller994cf142000-07-21 10:19:44 +1000455 buffer_put_int(b, BN_num_bits(key->n));
456 buffer_put_bignum(b, key->n);
457 buffer_put_bignum(b, key->e);
458 buffer_put_bignum(b, key->d);
459 /* To keep within the protocol: p < q for ssh. in SSL p > q */
460 buffer_put_bignum(b, key->iqmp); /* ssh key->u */
461 buffer_put_bignum(b, key->q); /* ssh key->p, SSL key->q */
462 buffer_put_bignum(b, key->p); /* ssh key->q, SSL key->p */
Ben Lindstrom664408d2001-06-09 01:42:01 +0000463 buffer_put_cstring(b, comment);
Damien Miller994cf142000-07-21 10:19:44 +1000464}
465
Ben Lindstrombba81212001-06-25 05:01:22 +0000466static void
Damien Miller0bc1bd82000-11-13 22:57:25 +1100467ssh_encode_identity_ssh2(Buffer *b, Key *key, const char *comment)
Damien Miller994cf142000-07-21 10:19:44 +1000468{
Damien Miller0bc1bd82000-11-13 22:57:25 +1100469 buffer_put_cstring(b, key_ssh_name(key));
Ben Lindstrom1c37c6a2001-12-06 18:00:18 +0000470 switch (key->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100471 case KEY_RSA:
472 buffer_put_bignum2(b, key->rsa->n);
473 buffer_put_bignum2(b, key->rsa->e);
474 buffer_put_bignum2(b, key->rsa->d);
475 buffer_put_bignum2(b, key->rsa->iqmp);
476 buffer_put_bignum2(b, key->rsa->p);
477 buffer_put_bignum2(b, key->rsa->q);
478 break;
479 case KEY_DSA:
480 buffer_put_bignum2(b, key->dsa->p);
481 buffer_put_bignum2(b, key->dsa->q);
482 buffer_put_bignum2(b, key->dsa->g);
483 buffer_put_bignum2(b, key->dsa->pub_key);
484 buffer_put_bignum2(b, key->dsa->priv_key);
485 break;
486 }
487 buffer_put_cstring(b, comment);
Damien Miller994cf142000-07-21 10:19:44 +1000488}
489
Damien Miller5428f641999-11-25 11:54:57 +1100490/*
491 * Adds an identity to the authentication server. This call is not meant to
492 * be used by normal applications.
493 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000494
Damien Miller4af51302000-04-16 11:18:38 +1000495int
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000496ssh_add_identity_constrained(AuthenticationConnection *auth, Key *key,
Damien Miller6c711792003-01-24 11:36:23 +1100497 const char *comment, u_int life, u_int confirm)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000498{
Damien Millerad833b32000-08-23 10:46:23 +1000499 Buffer msg;
Damien Miller6c711792003-01-24 11:36:23 +1100500 int type, constrained = (life || confirm);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000501
Damien Millerad833b32000-08-23 10:46:23 +1000502 buffer_init(&msg);
Damien Miller994cf142000-07-21 10:19:44 +1000503
504 switch (key->type) {
Damien Miller0bc1bd82000-11-13 22:57:25 +1100505 case KEY_RSA1:
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000506 type = constrained ?
507 SSH_AGENTC_ADD_RSA_ID_CONSTRAINED :
508 SSH_AGENTC_ADD_RSA_IDENTITY;
509 buffer_put_char(&msg, type);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100510 ssh_encode_identity_rsa1(&msg, key->rsa, comment);
Damien Miller994cf142000-07-21 10:19:44 +1000511 break;
Damien Miller0bc1bd82000-11-13 22:57:25 +1100512 case KEY_RSA:
Damien Miller994cf142000-07-21 10:19:44 +1000513 case KEY_DSA:
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000514 type = constrained ?
515 SSH2_AGENTC_ADD_ID_CONSTRAINED :
516 SSH2_AGENTC_ADD_IDENTITY;
517 buffer_put_char(&msg, type);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100518 ssh_encode_identity_ssh2(&msg, key, comment);
Damien Miller994cf142000-07-21 10:19:44 +1000519 break;
520 default:
Damien Millerad833b32000-08-23 10:46:23 +1000521 buffer_free(&msg);
Damien Miller994cf142000-07-21 10:19:44 +1000522 return 0;
523 break;
524 }
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000525 if (constrained) {
526 if (life != 0) {
527 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_LIFETIME);
528 buffer_put_int(&msg, life);
529 }
Damien Miller6c711792003-01-24 11:36:23 +1100530 if (confirm != 0)
531 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_CONFIRM);
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000532 }
Damien Millerad833b32000-08-23 10:46:23 +1000533 if (ssh_request_reply(auth, &msg, &msg) == 0) {
534 buffer_free(&msg);
Damien Miller95def091999-11-25 00:26:21 +1100535 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000536 }
Damien Millerad833b32000-08-23 10:46:23 +1000537 type = buffer_get_char(&msg);
538 buffer_free(&msg);
Damien Miller942da032000-08-18 13:59:06 +1000539 return decode_reply(type);
Damien Miller95def091999-11-25 00:26:21 +1100540}
541
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000542int
543ssh_add_identity(AuthenticationConnection *auth, Key *key, const char *comment)
544{
Damien Miller6c711792003-01-24 11:36:23 +1100545 return ssh_add_identity_constrained(auth, key, comment, 0, 0);
Ben Lindstrom2b266b72002-06-21 00:08:39 +0000546}
547
Damien Miller5428f641999-11-25 11:54:57 +1100548/*
549 * Removes an identity from the authentication server. This call is not
550 * meant to be used by normal applications.
551 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000552
Damien Miller4af51302000-04-16 11:18:38 +1000553int
Damien Millerad833b32000-08-23 10:46:23 +1000554ssh_remove_identity(AuthenticationConnection *auth, Key *key)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000555{
Damien Millerad833b32000-08-23 10:46:23 +1000556 Buffer msg;
Damien Miller942da032000-08-18 13:59:06 +1000557 int type;
Ben Lindstrom46c16222000-12-22 01:43:59 +0000558 u_char *blob;
559 u_int blen;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000560
Damien Millerad833b32000-08-23 10:46:23 +1000561 buffer_init(&msg);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000562
Damien Miller0bc1bd82000-11-13 22:57:25 +1100563 if (key->type == KEY_RSA1) {
Damien Millerad833b32000-08-23 10:46:23 +1000564 buffer_put_char(&msg, SSH_AGENTC_REMOVE_RSA_IDENTITY);
565 buffer_put_int(&msg, BN_num_bits(key->rsa->n));
566 buffer_put_bignum(&msg, key->rsa->e);
567 buffer_put_bignum(&msg, key->rsa->n);
Damien Miller0bc1bd82000-11-13 22:57:25 +1100568 } else if (key->type == KEY_DSA || key->type == KEY_RSA) {
569 key_to_blob(key, &blob, &blen);
Damien Millerad833b32000-08-23 10:46:23 +1000570 buffer_put_char(&msg, SSH2_AGENTC_REMOVE_IDENTITY);
571 buffer_put_string(&msg, blob, blen);
572 xfree(blob);
573 } else {
574 buffer_free(&msg);
Damien Miller95def091999-11-25 00:26:21 +1100575 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000576 }
Damien Millerad833b32000-08-23 10:46:23 +1000577 if (ssh_request_reply(auth, &msg, &msg) == 0) {
578 buffer_free(&msg);
579 return 0;
580 }
581 type = buffer_get_char(&msg);
582 buffer_free(&msg);
Damien Miller942da032000-08-18 13:59:06 +1000583 return decode_reply(type);
Damien Miller95def091999-11-25 00:26:21 +1100584}
585
Ben Lindstrom036a6b22001-07-04 03:50:02 +0000586int
Damien Millera8e06ce2003-11-21 23:48:55 +1100587ssh_update_card(AuthenticationConnection *auth, int add,
Damien Millerd94f20d2003-06-11 22:06:33 +1000588 const char *reader_id, const char *pin, u_int life, u_int confirm)
Ben Lindstrom036a6b22001-07-04 03:50:02 +0000589{
590 Buffer msg;
Damien Millerd94f20d2003-06-11 22:06:33 +1000591 int type, constrained = (life || confirm);
592
593 if (add) {
594 type = constrained ?
595 SSH_AGENTC_ADD_SMARTCARD_KEY_CONSTRAINED :
596 SSH_AGENTC_ADD_SMARTCARD_KEY;
597 } else
598 type = SSH_AGENTC_REMOVE_SMARTCARD_KEY;
Ben Lindstrom036a6b22001-07-04 03:50:02 +0000599
600 buffer_init(&msg);
Damien Millerd94f20d2003-06-11 22:06:33 +1000601 buffer_put_char(&msg, type);
Ben Lindstromf7db3bb2001-08-06 21:35:51 +0000602 buffer_put_cstring(&msg, reader_id);
Ben Lindstromba72d302002-03-22 03:51:06 +0000603 buffer_put_cstring(&msg, pin);
Damien Miller787b2ec2003-11-21 23:56:47 +1100604
Damien Millerd94f20d2003-06-11 22:06:33 +1000605 if (constrained) {
606 if (life != 0) {
607 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_LIFETIME);
608 buffer_put_int(&msg, life);
609 }
610 if (confirm != 0)
611 buffer_put_char(&msg, SSH_AGENT_CONSTRAIN_CONFIRM);
612 }
613
Ben Lindstrom036a6b22001-07-04 03:50:02 +0000614 if (ssh_request_reply(auth, &msg, &msg) == 0) {
615 buffer_free(&msg);
616 return 0;
617 }
618 type = buffer_get_char(&msg);
619 buffer_free(&msg);
620 return decode_reply(type);
621}
622
Damien Miller5428f641999-11-25 11:54:57 +1100623/*
624 * Removes all identities from the agent. This call is not meant to be used
625 * by normal applications.
626 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000627
Damien Miller4af51302000-04-16 11:18:38 +1000628int
Damien Millerad833b32000-08-23 10:46:23 +1000629ssh_remove_all_identities(AuthenticationConnection *auth, int version)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000630{
Damien Millerad833b32000-08-23 10:46:23 +1000631 Buffer msg;
Damien Miller942da032000-08-18 13:59:06 +1000632 int type;
Damien Millerad833b32000-08-23 10:46:23 +1000633 int code = (version==1) ?
634 SSH_AGENTC_REMOVE_ALL_RSA_IDENTITIES :
635 SSH2_AGENTC_REMOVE_ALL_IDENTITIES;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000636
Damien Millerad833b32000-08-23 10:46:23 +1000637 buffer_init(&msg);
638 buffer_put_char(&msg, code);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000639
Damien Millerad833b32000-08-23 10:46:23 +1000640 if (ssh_request_reply(auth, &msg, &msg) == 0) {
641 buffer_free(&msg);
Damien Miller95def091999-11-25 00:26:21 +1100642 return 0;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000643 }
Damien Millerad833b32000-08-23 10:46:23 +1000644 type = buffer_get_char(&msg);
645 buffer_free(&msg);
Damien Miller942da032000-08-18 13:59:06 +1000646 return decode_reply(type);
647}
648
Kevin Stevesef4eea92001-02-05 12:42:17 +0000649int
Damien Miller942da032000-08-18 13:59:06 +1000650decode_reply(int type)
651{
Damien Miller95def091999-11-25 00:26:21 +1100652 switch (type) {
653 case SSH_AGENT_FAILURE:
Damien Miller874d77b2000-10-14 16:23:11 +1100654 case SSH_COM_AGENT2_FAILURE:
Ben Lindstromc9a26362001-08-15 23:04:50 +0000655 case SSH2_AGENT_FAILURE:
Damien Miller996acd22003-04-09 20:59:48 +1000656 logit("SSH_AGENT_FAILURE");
Damien Miller95def091999-11-25 00:26:21 +1100657 return 0;
658 case SSH_AGENT_SUCCESS:
Damien Miller95def091999-11-25 00:26:21 +1100659 return 1;
660 default:
Damien Miller37023962000-07-11 17:31:38 +1000661 fatal("Bad response from authentication agent: %d", type);
Damien Miller95def091999-11-25 00:26:21 +1100662 }
663 /* NOTREACHED */
664 return 0;
665}