blob: a2d28cba18789137e2962bf52c9f7ac14f93aacf [file] [log] [blame]
Damien Millerd7834352006-08-05 12:39:39 +10001/* $OpenBSD: scard.c,v 1.35 2006/08/03 03:34:42 deraadt Exp $ */
Ben Lindstrom3133dbb2001-07-04 05:35:00 +00002/*
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
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000026#include "includes.h"
Ben Lindstroma42694f2002-04-05 16:11:45 +000027#if defined(SMARTCARD) && defined(USE_SECTOK)
Ben Lindstrom818659a2002-03-22 03:38:35 +000028
Damien Millerd7834352006-08-05 12:39:39 +100029#include <sys/types.h>
Damien Miller7c6e4b02006-08-05 09:33:15 +100030
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000031#include <sectok.h>
Damien Miller7c6e4b02006-08-05 09:33:15 +100032#include <string.h>
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000033
Damien Millerd7834352006-08-05 12:39:39 +100034#include <openssl/evp.h>
35
36#include "xmalloc.h"
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000037#include "key.h"
38#include "log.h"
Darren Tuckere608ca22004-05-13 16:15:47 +100039#include "misc.h"
Ben Lindstrom266ec632002-03-22 03:47:38 +000040#include "scard.h"
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000041
Ben Lindstrom0936a5b2002-03-26 03:17:42 +000042#if OPENSSL_VERSION_NUMBER < 0x00907000L
43#define USE_ENGINE
44#define RSA_get_default_method RSA_get_default_openssl_method
45#else
Ben Lindstrom0b675b12002-03-22 03:28:11 +000046#endif
Ben Lindstrom0936a5b2002-03-26 03:17:42 +000047
48#ifdef USE_ENGINE
49#include <openssl/engine.h>
50#define sc_get_rsa sc_get_engine
51#else
52#define sc_get_rsa sc_get_rsa_method
Ben Lindstrom0b675b12002-03-22 03:28:11 +000053#endif
54
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000055#define CLA_SSH 0x05
56#define INS_DECRYPT 0x10
57#define INS_GET_KEYLENGTH 0x20
58#define INS_GET_PUBKEY 0x30
59#define INS_GET_RESPONSE 0xc0
60
61#define MAX_BUF_SIZE 256
62
Ben Lindstrom266ec632002-03-22 03:47:38 +000063u_char DEFAUT0[] = {0xad, 0x9f, 0x61, 0xfe, 0xfa, 0x20, 0xce, 0x63};
64
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000065static int sc_fd = -1;
Ben Lindstromf7db3bb2001-08-06 21:35:51 +000066static char *sc_reader_id = NULL;
Ben Lindstrom266ec632002-03-22 03:47:38 +000067static char *sc_pin = NULL;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000068static int cla = 0x00; /* class */
69
Ben Lindstrom266ec632002-03-22 03:47:38 +000070static void sc_mk_digest(const char *pin, u_char *digest);
71static int get_AUT0(u_char *aut0);
Ben Lindstrom43a5e2f2002-03-27 17:33:17 +000072static int try_AUT0(void);
Ben Lindstrom266ec632002-03-22 03:47:38 +000073
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000074/* interface to libsectok */
75
Damien Miller9f0f5c62001-12-21 14:45:46 +110076static int
Damien Miller694be4b2001-07-14 12:13:26 +100077sc_open(void)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000078{
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000079 int sw;
80
81 if (sc_fd >= 0)
82 return sc_fd;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000083
Ben Lindstromf7db3bb2001-08-06 21:35:51 +000084 sc_fd = sectok_friendly_open(sc_reader_id, STONOWAIT, &sw);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000085 if (sc_fd < 0) {
Damien Miller694be4b2001-07-14 12:13:26 +100086 error("sectok_open failed: %s", sectok_get_sw(sw));
Ben Lindstrom30b00be2001-08-06 21:22:10 +000087 return SCARD_ERROR_FAIL;
88 }
89 if (! sectok_cardpresent(sc_fd)) {
Ben Lindstromf7db3bb2001-08-06 21:35:51 +000090 debug("smartcard in reader %s not present, skipping",
91 sc_reader_id);
Ben Lindstrom3ab1dfa2001-08-06 21:33:44 +000092 sc_close();
Ben Lindstrom30b00be2001-08-06 21:22:10 +000093 return SCARD_ERROR_NOCARD;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000094 }
Ben Lindstrom60df8e42001-08-06 21:10:52 +000095 if (sectok_reset(sc_fd, 0, NULL, &sw) <= 0) {
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000096 error("sectok_reset failed: %s", sectok_get_sw(sw));
97 sc_fd = -1;
Ben Lindstrom30b00be2001-08-06 21:22:10 +000098 return SCARD_ERROR_FAIL;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000099 }
Ben Lindstrom60df8e42001-08-06 21:10:52 +0000100 if ((cla = cyberflex_inq_class(sc_fd)) < 0)
101 cla = 0;
Damien Miller694be4b2001-07-14 12:13:26 +1000102
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000103 debug("sc_open ok %d", sc_fd);
104 return sc_fd;
105}
106
Damien Miller9f0f5c62001-12-21 14:45:46 +1100107static int
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000108sc_enable_applet(void)
109{
Ben Lindstrom60df8e42001-08-06 21:10:52 +0000110 static u_char aid[] = {0xfc, 0x53, 0x73, 0x68, 0x2e, 0x62, 0x69, 0x6e};
111 int sw = 0;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000112
Ben Lindstrom60df8e42001-08-06 21:10:52 +0000113 /* select applet id */
114 sectok_apdu(sc_fd, cla, 0xa4, 0x04, 0, sizeof aid, aid, 0, NULL, &sw);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000115 if (!sectok_swOK(sw)) {
116 error("sectok_apdu failed: %s", sectok_get_sw(sw));
Damien Miller694be4b2001-07-14 12:13:26 +1000117 sc_close();
118 return -1;
119 }
120 return 0;
121}
122
Damien Miller9f0f5c62001-12-21 14:45:46 +1100123static int
Damien Miller694be4b2001-07-14 12:13:26 +1000124sc_init(void)
125{
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000126 int status;
127
128 status = sc_open();
129 if (status == SCARD_ERROR_NOCARD) {
130 return SCARD_ERROR_NOCARD;
131 }
Damien Miller4dec5d72006-08-05 11:38:40 +1000132 if (status < 0) {
Damien Miller694be4b2001-07-14 12:13:26 +1000133 error("sc_open failed");
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000134 return status;
Damien Miller694be4b2001-07-14 12:13:26 +1000135 }
136 if (sc_enable_applet() < 0) {
137 error("sc_enable_applet failed");
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000138 return SCARD_ERROR_APPLET;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000139 }
140 return 0;
141}
142
Damien Miller9f0f5c62001-12-21 14:45:46 +1100143static int
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000144sc_read_pubkey(Key * k)
145{
146 u_char buf[2], *n;
147 char *p;
Ben Lindstroma2fec902001-09-18 05:45:44 +0000148 int len, sw, status = -1;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000149
150 len = sw = 0;
Damien Miller3ff36d62001-09-28 19:51:54 +1000151 n = NULL;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000152
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000153 if (sc_fd < 0) {
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000154 if (sc_init() < 0)
Ben Lindstroma2fec902001-09-18 05:45:44 +0000155 goto err;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000156 }
Damien Miller694be4b2001-07-14 12:13:26 +1000157
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000158 /* get key size */
159 sectok_apdu(sc_fd, CLA_SSH, INS_GET_KEYLENGTH, 0, 0, 0, NULL,
Damien Miller9f0f5c62001-12-21 14:45:46 +1100160 sizeof(buf), buf, &sw);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000161 if (!sectok_swOK(sw)) {
162 error("could not obtain key length: %s", sectok_get_sw(sw));
Ben Lindstroma2fec902001-09-18 05:45:44 +0000163 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000164 }
165 len = (buf[0] << 8) | buf[1];
166 len /= 8;
167 debug("INS_GET_KEYLENGTH: len %d sw %s", len, sectok_get_sw(sw));
168
169 n = xmalloc(len);
170 /* get n */
171 sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw);
Ben Lindstrom43a5e2f2002-03-27 17:33:17 +0000172
173 if (sw == 0x6982) {
174 if (try_AUT0() < 0)
175 goto err;
176 sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw);
177 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000178 if (!sectok_swOK(sw)) {
179 error("could not obtain public key: %s", sectok_get_sw(sw));
Ben Lindstroma2fec902001-09-18 05:45:44 +0000180 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000181 }
Ben Lindstroma2fec902001-09-18 05:45:44 +0000182
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000183 debug("INS_GET_KEYLENGTH: sw %s", sectok_get_sw(sw));
184
185 if (BN_bin2bn(n, len, k->rsa->n) == NULL) {
186 error("c_read_pubkey: BN_bin2bn failed");
Ben Lindstroma2fec902001-09-18 05:45:44 +0000187 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000188 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000189
190 /* currently the java applet just stores 'n' */
191 if (!BN_set_word(k->rsa->e, 35)) {
192 error("c_read_pubkey: BN_set_word(e, 35) failed");
Ben Lindstroma2fec902001-09-18 05:45:44 +0000193 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000194 }
195
Ben Lindstroma2fec902001-09-18 05:45:44 +0000196 status = 0;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000197 p = key_fingerprint(k, SSH_FP_MD5, SSH_FP_HEX);
Ben Lindstrom5c385522002-06-23 21:23:20 +0000198 debug("fingerprint %u %s", key_size(k), p);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000199 xfree(p);
200
Ben Lindstroma2fec902001-09-18 05:45:44 +0000201err:
202 if (n != NULL)
203 xfree(n);
204 sc_close();
205 return status;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000206}
207
208/* private key operations */
209
210static int
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000211sc_private_decrypt(int flen, u_char *from, u_char *to, RSA *rsa,
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000212 int padding)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000213{
214 u_char *padded = NULL;
Ben Lindstroma2fec902001-09-18 05:45:44 +0000215 int sw, len, olen, status = -1;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000216
217 debug("sc_private_decrypt called");
218
219 olen = len = sw = 0;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000220 if (sc_fd < 0) {
221 status = sc_init();
Damien Miller4dec5d72006-08-05 11:38:40 +1000222 if (status < 0)
Damien Miller694be4b2001-07-14 12:13:26 +1000223 goto err;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000224 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000225 if (padding != RSA_PKCS1_PADDING)
226 goto err;
227
228 len = BN_num_bytes(rsa->n);
229 padded = xmalloc(len);
230
Ben Lindstrom266ec632002-03-22 03:47:38 +0000231 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
232
233 if (sw == 0x6982) {
Ben Lindstromc2c6cbc2002-03-26 02:44:44 +0000234 if (try_AUT0() < 0)
235 goto err;
Ben Lindstrom266ec632002-03-22 03:47:38 +0000236 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
237 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000238 if (!sectok_swOK(sw)) {
239 error("sc_private_decrypt: INS_DECRYPT failed: %s",
240 sectok_get_sw(sw));
241 goto err;
242 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000243 olen = RSA_padding_check_PKCS1_type_2(to, len, padded + 1, len - 1,
244 len);
245err:
246 if (padded)
247 xfree(padded);
Ben Lindstroma2fec902001-09-18 05:45:44 +0000248 sc_close();
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000249 return (olen >= 0 ? olen : status);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000250}
251
252static int
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000253sc_private_encrypt(int flen, u_char *from, u_char *to, RSA *rsa,
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000254 int padding)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000255{
256 u_char *padded = NULL;
Ben Lindstroma2fec902001-09-18 05:45:44 +0000257 int sw, len, status = -1;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000258
259 len = sw = 0;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000260 if (sc_fd < 0) {
261 status = sc_init();
Damien Miller4dec5d72006-08-05 11:38:40 +1000262 if (status < 0)
Damien Miller694be4b2001-07-14 12:13:26 +1000263 goto err;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000264 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000265 if (padding != RSA_PKCS1_PADDING)
266 goto err;
267
268 debug("sc_private_encrypt called");
269 len = BN_num_bytes(rsa->n);
270 padded = xmalloc(len);
271
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000272 if (RSA_padding_add_PKCS1_type_1(padded, len, (u_char *)from, flen) <= 0) {
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000273 error("RSA_padding_add_PKCS1_type_1 failed");
274 goto err;
275 }
Ben Lindstrom266ec632002-03-22 03:47:38 +0000276 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
Ben Lindstromc2c6cbc2002-03-26 02:44:44 +0000277 if (sw == 0x6982) {
278 if (try_AUT0() < 0)
279 goto err;
280 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
281 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000282 if (!sectok_swOK(sw)) {
Ben Lindstromc2c6cbc2002-03-26 02:44:44 +0000283 error("sc_private_encrypt: INS_DECRYPT failed: %s",
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000284 sectok_get_sw(sw));
285 goto err;
286 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000287err:
288 if (padded)
289 xfree(padded);
Ben Lindstroma2fec902001-09-18 05:45:44 +0000290 sc_close();
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000291 return (len >= 0 ? len : status);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000292}
293
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +0000294/* called on free */
295
296static int (*orig_finish)(RSA *rsa) = NULL;
297
298static int
299sc_finish(RSA *rsa)
300{
301 if (orig_finish)
302 orig_finish(rsa);
303 sc_close();
304 return 1;
305}
306
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000307/* engine for overloading private key operations */
308
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000309static RSA_METHOD *
310sc_get_rsa_method(void)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000311{
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000312 static RSA_METHOD smart_rsa;
313 const RSA_METHOD *def = RSA_get_default_method();
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000314
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000315 /* use the OpenSSL version */
316 memcpy(&smart_rsa, def, sizeof(smart_rsa));
317
318 smart_rsa.name = "sectok";
319
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000320 /* overload */
321 smart_rsa.rsa_priv_enc = sc_private_encrypt;
322 smart_rsa.rsa_priv_dec = sc_private_decrypt;
323
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +0000324 /* save original */
325 orig_finish = def->finish;
326 smart_rsa.finish = sc_finish;
327
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000328 return &smart_rsa;
329}
330
331#ifdef USE_ENGINE
332static ENGINE *
333sc_get_engine(void)
334{
335 static ENGINE *smart_engine = NULL;
336
Damien Millerda755162002-01-22 23:09:22 +1100337 if ((smart_engine = ENGINE_new()) == NULL)
338 fatal("ENGINE_new failed");
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000339
340 ENGINE_set_id(smart_engine, "sectok");
341 ENGINE_set_name(smart_engine, "libsectok");
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000342
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000343 ENGINE_set_RSA(smart_engine, sc_get_rsa_method());
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000344 ENGINE_set_DSA(smart_engine, DSA_get_default_openssl_method());
345 ENGINE_set_DH(smart_engine, DH_get_default_openssl_method());
346 ENGINE_set_RAND(smart_engine, RAND_SSLeay());
347 ENGINE_set_BN_mod_exp(smart_engine, BN_mod_exp);
348
349 return smart_engine;
350}
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000351#endif
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000352
Damien Miller694be4b2001-07-14 12:13:26 +1000353void
354sc_close(void)
355{
356 if (sc_fd >= 0) {
357 sectok_close(sc_fd);
358 sc_fd = -1;
359 }
360}
361
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000362Key **
363sc_get_keys(const char *id, const char *pin)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000364{
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000365 Key *k, *n, **keys;
366 int status, nkeys = 2;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000367
Ben Lindstromf7db3bb2001-08-06 21:35:51 +0000368 if (sc_reader_id != NULL)
369 xfree(sc_reader_id);
370 sc_reader_id = xstrdup(id);
371
Ben Lindstrom266ec632002-03-22 03:47:38 +0000372 if (sc_pin != NULL)
373 xfree(sc_pin);
374 sc_pin = (pin == NULL) ? NULL : xstrdup(pin);
375
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000376 k = key_new(KEY_RSA);
377 if (k == NULL) {
378 return NULL;
379 }
Ben Lindstrom94baf302001-08-06 21:25:38 +0000380 status = sc_read_pubkey(k);
381 if (status == SCARD_ERROR_NOCARD) {
382 key_free(k);
383 return NULL;
384 }
Damien Miller4dec5d72006-08-05 11:38:40 +1000385 if (status < 0) {
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000386 error("sc_read_pubkey failed");
387 key_free(k);
388 return NULL;
389 }
Damien Miller07d86be2006-03-26 14:19:21 +1100390 keys = xcalloc((nkeys+1), sizeof(Key *));
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000391
392 n = key_new(KEY_RSA1);
393 BN_copy(n->rsa->n, k->rsa->n);
394 BN_copy(n->rsa->e, k->rsa->e);
395 RSA_set_method(n->rsa, sc_get_rsa());
396 n->flags |= KEY_FLAG_EXT;
397 keys[0] = n;
398
399 n = key_new(KEY_RSA);
400 BN_copy(n->rsa->n, k->rsa->n);
401 BN_copy(n->rsa->e, k->rsa->e);
402 RSA_set_method(n->rsa, sc_get_rsa());
403 n->flags |= KEY_FLAG_EXT;
404 keys[1] = n;
405
406 keys[2] = NULL;
407
408 key_free(k);
409 return keys;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000410}
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000411
412#define NUM_RSA_KEY_ELEMENTS 5+1
413#define COPY_RSA_KEY(x, i) \
414 do { \
415 len = BN_num_bytes(prv->rsa->x); \
416 elements[i] = xmalloc(len); \
417 debug("#bytes %d", len); \
418 if (BN_bn2bin(prv->rsa->x, elements[i]) < 0) \
419 goto done; \
420 } while (0)
421
Ben Lindstrom266ec632002-03-22 03:47:38 +0000422static void
423sc_mk_digest(const char *pin, u_char *digest)
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000424{
425 const EVP_MD *evp_md = EVP_sha1();
426 EVP_MD_CTX md;
Ben Lindstrom266ec632002-03-22 03:47:38 +0000427
428 EVP_DigestInit(&md, evp_md);
429 EVP_DigestUpdate(&md, pin, strlen(pin));
430 EVP_DigestFinal(&md, digest, NULL);
431}
432
433static int
434get_AUT0(u_char *aut0)
435{
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000436 char *pass;
437
438 pass = read_passphrase("Enter passphrase for smartcard: ", RP_ALLOW_STDIN);
439 if (pass == NULL)
440 return -1;
Ben Lindstrom266ec632002-03-22 03:47:38 +0000441 if (!strcmp(pass, "-")) {
442 memcpy(aut0, DEFAUT0, sizeof DEFAUT0);
443 return 0;
444 }
445 sc_mk_digest(pass, aut0);
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000446 memset(pass, 0, strlen(pass));
447 xfree(pass);
448 return 0;
449}
450
Ben Lindstrom43a5e2f2002-03-27 17:33:17 +0000451static int
452try_AUT0(void)
453{
454 u_char aut0[EVP_MAX_MD_SIZE];
455
456 /* permission denied; try PIN if provided */
457 if (sc_pin && strlen(sc_pin) > 0) {
458 sc_mk_digest(sc_pin, aut0);
459 if (cyberflex_verify_AUT0(sc_fd, cla, aut0, 8) < 0) {
460 error("smartcard passphrase incorrect");
461 return (-1);
462 }
463 } else {
464 /* try default AUT0 key */
465 if (cyberflex_verify_AUT0(sc_fd, cla, DEFAUT0, 8) < 0) {
466 /* default AUT0 key failed; prompt for passphrase */
467 if (get_AUT0(aut0) < 0 ||
468 cyberflex_verify_AUT0(sc_fd, cla, aut0, 8) < 0) {
469 error("smartcard passphrase incorrect");
470 return (-1);
471 }
472 }
473 }
474 return (0);
475}
476
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000477int
478sc_put_key(Key *prv, const char *id)
479{
480 u_char *elements[NUM_RSA_KEY_ELEMENTS];
481 u_char key_fid[2];
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000482 u_char AUT0[EVP_MAX_MD_SIZE];
483 int len, status = -1, i, fd = -1, ret;
484 int sw = 0, cla = 0x00;
485
486 for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
487 elements[i] = NULL;
488
489 COPY_RSA_KEY(q, 0);
490 COPY_RSA_KEY(p, 1);
491 COPY_RSA_KEY(iqmp, 2);
492 COPY_RSA_KEY(dmq1, 3);
493 COPY_RSA_KEY(dmp1, 4);
494 COPY_RSA_KEY(n, 5);
495 len = BN_num_bytes(prv->rsa->n);
Ben Lindstrom818659a2002-03-22 03:38:35 +0000496 fd = sectok_friendly_open(id, STONOWAIT, &sw);
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000497 if (fd < 0) {
498 error("sectok_open failed: %s", sectok_get_sw(sw));
499 goto done;
500 }
501 if (! sectok_cardpresent(fd)) {
Ben Lindstrom818659a2002-03-22 03:38:35 +0000502 error("smartcard in reader %s not present", id);
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000503 goto done;
504 }
505 ret = sectok_reset(fd, 0, NULL, &sw);
506 if (ret <= 0) {
507 error("sectok_reset failed: %s", sectok_get_sw(sw));
508 goto done;
509 }
510 if ((cla = cyberflex_inq_class(fd)) < 0) {
511 error("cyberflex_inq_class failed");
512 goto done;
513 }
514 memcpy(AUT0, DEFAUT0, sizeof(DEFAUT0));
515 if (cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(DEFAUT0)) < 0) {
516 if (get_AUT0(AUT0) < 0 ||
517 cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(DEFAUT0)) < 0) {
Ben Lindstrom266ec632002-03-22 03:47:38 +0000518 memset(AUT0, 0, sizeof(DEFAUT0));
519 error("smartcard passphrase incorrect");
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000520 goto done;
521 }
522 }
Ben Lindstrom266ec632002-03-22 03:47:38 +0000523 memset(AUT0, 0, sizeof(DEFAUT0));
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000524 key_fid[0] = 0x00;
525 key_fid[1] = 0x12;
526 if (cyberflex_load_rsa_priv(fd, cla, key_fid, 5, 8*len, elements,
527 &sw) < 0) {
528 error("cyberflex_load_rsa_priv failed: %s", sectok_get_sw(sw));
529 goto done;
530 }
531 if (!sectok_swOK(sw))
532 goto done;
Damien Miller996acd22003-04-09 20:59:48 +1000533 logit("cyberflex_load_rsa_priv done");
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000534 key_fid[0] = 0x73;
535 key_fid[1] = 0x68;
536 if (cyberflex_load_rsa_pub(fd, cla, key_fid, len, elements[5],
537 &sw) < 0) {
538 error("cyberflex_load_rsa_pub failed: %s", sectok_get_sw(sw));
539 goto done;
540 }
541 if (!sectok_swOK(sw))
542 goto done;
Damien Miller996acd22003-04-09 20:59:48 +1000543 logit("cyberflex_load_rsa_pub done");
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000544 status = 0;
545
546done:
547 memset(elements[0], '\0', BN_num_bytes(prv->rsa->q));
548 memset(elements[1], '\0', BN_num_bytes(prv->rsa->p));
549 memset(elements[2], '\0', BN_num_bytes(prv->rsa->iqmp));
550 memset(elements[3], '\0', BN_num_bytes(prv->rsa->dmq1));
551 memset(elements[4], '\0', BN_num_bytes(prv->rsa->dmp1));
552 memset(elements[5], '\0', BN_num_bytes(prv->rsa->n));
553
554 for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
555 if (elements[i])
556 xfree(elements[i]);
557 if (fd != -1)
558 sectok_close(fd);
559 return (status);
560}
Damien Miller56a0bb02003-06-18 20:28:40 +1000561
562char *
563sc_get_key_label(Key *key)
564{
565 return xstrdup("smartcard key");
566}
567
Ben Lindstroma42694f2002-04-05 16:11:45 +0000568#endif /* SMARTCARD && USE_SECTOK */