blob: 9fd3ca1b4ee3bf009e12c7f8b2a4bda83c6a5980 [file] [log] [blame]
Darren Tucker0bc85572006-11-07 23:14:41 +11001/* $OpenBSD: scard.c,v 1.36 2006/11/06 21:25:28 markus 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 Millerded319c2006-09-01 15:38:36 +100032#include <stdarg.h>
Damien Miller7c6e4b02006-08-05 09:33:15 +100033#include <string.h>
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000034
Damien Millerd7834352006-08-05 12:39:39 +100035#include <openssl/evp.h>
36
37#include "xmalloc.h"
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000038#include "key.h"
39#include "log.h"
Darren Tuckere608ca22004-05-13 16:15:47 +100040#include "misc.h"
Ben Lindstrom266ec632002-03-22 03:47:38 +000041#include "scard.h"
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000042
Ben Lindstrom0936a5b2002-03-26 03:17:42 +000043#if OPENSSL_VERSION_NUMBER < 0x00907000L
44#define USE_ENGINE
45#define RSA_get_default_method RSA_get_default_openssl_method
46#else
Ben Lindstrom0b675b12002-03-22 03:28:11 +000047#endif
Ben Lindstrom0936a5b2002-03-26 03:17:42 +000048
49#ifdef USE_ENGINE
50#include <openssl/engine.h>
51#define sc_get_rsa sc_get_engine
52#else
53#define sc_get_rsa sc_get_rsa_method
Ben Lindstrom0b675b12002-03-22 03:28:11 +000054#endif
55
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000056#define CLA_SSH 0x05
57#define INS_DECRYPT 0x10
58#define INS_GET_KEYLENGTH 0x20
59#define INS_GET_PUBKEY 0x30
60#define INS_GET_RESPONSE 0xc0
61
62#define MAX_BUF_SIZE 256
63
Ben Lindstrom266ec632002-03-22 03:47:38 +000064u_char DEFAUT0[] = {0xad, 0x9f, 0x61, 0xfe, 0xfa, 0x20, 0xce, 0x63};
65
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000066static int sc_fd = -1;
Ben Lindstromf7db3bb2001-08-06 21:35:51 +000067static char *sc_reader_id = NULL;
Ben Lindstrom266ec632002-03-22 03:47:38 +000068static char *sc_pin = NULL;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000069static int cla = 0x00; /* class */
70
Ben Lindstrom266ec632002-03-22 03:47:38 +000071static void sc_mk_digest(const char *pin, u_char *digest);
72static int get_AUT0(u_char *aut0);
Ben Lindstrom43a5e2f2002-03-27 17:33:17 +000073static int try_AUT0(void);
Ben Lindstrom266ec632002-03-22 03:47:38 +000074
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000075/* interface to libsectok */
76
Damien Miller9f0f5c62001-12-21 14:45:46 +110077static int
Damien Miller694be4b2001-07-14 12:13:26 +100078sc_open(void)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000079{
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000080 int sw;
81
82 if (sc_fd >= 0)
83 return sc_fd;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000084
Ben Lindstromf7db3bb2001-08-06 21:35:51 +000085 sc_fd = sectok_friendly_open(sc_reader_id, STONOWAIT, &sw);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000086 if (sc_fd < 0) {
Damien Miller694be4b2001-07-14 12:13:26 +100087 error("sectok_open failed: %s", sectok_get_sw(sw));
Ben Lindstrom30b00be2001-08-06 21:22:10 +000088 return SCARD_ERROR_FAIL;
89 }
90 if (! sectok_cardpresent(sc_fd)) {
Ben Lindstromf7db3bb2001-08-06 21:35:51 +000091 debug("smartcard in reader %s not present, skipping",
92 sc_reader_id);
Ben Lindstrom3ab1dfa2001-08-06 21:33:44 +000093 sc_close();
Ben Lindstrom30b00be2001-08-06 21:22:10 +000094 return SCARD_ERROR_NOCARD;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000095 }
Ben Lindstrom60df8e42001-08-06 21:10:52 +000096 if (sectok_reset(sc_fd, 0, NULL, &sw) <= 0) {
Ben Lindstrom3133dbb2001-07-04 05:35:00 +000097 error("sectok_reset failed: %s", sectok_get_sw(sw));
98 sc_fd = -1;
Ben Lindstrom30b00be2001-08-06 21:22:10 +000099 return SCARD_ERROR_FAIL;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000100 }
Ben Lindstrom60df8e42001-08-06 21:10:52 +0000101 if ((cla = cyberflex_inq_class(sc_fd)) < 0)
102 cla = 0;
Damien Miller694be4b2001-07-14 12:13:26 +1000103
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000104 debug("sc_open ok %d", sc_fd);
105 return sc_fd;
106}
107
Damien Miller9f0f5c62001-12-21 14:45:46 +1100108static int
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000109sc_enable_applet(void)
110{
Ben Lindstrom60df8e42001-08-06 21:10:52 +0000111 static u_char aid[] = {0xfc, 0x53, 0x73, 0x68, 0x2e, 0x62, 0x69, 0x6e};
112 int sw = 0;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000113
Ben Lindstrom60df8e42001-08-06 21:10:52 +0000114 /* select applet id */
115 sectok_apdu(sc_fd, cla, 0xa4, 0x04, 0, sizeof aid, aid, 0, NULL, &sw);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000116 if (!sectok_swOK(sw)) {
117 error("sectok_apdu failed: %s", sectok_get_sw(sw));
Damien Miller694be4b2001-07-14 12:13:26 +1000118 sc_close();
119 return -1;
120 }
121 return 0;
122}
123
Damien Miller9f0f5c62001-12-21 14:45:46 +1100124static int
Damien Miller694be4b2001-07-14 12:13:26 +1000125sc_init(void)
126{
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000127 int status;
128
129 status = sc_open();
130 if (status == SCARD_ERROR_NOCARD) {
131 return SCARD_ERROR_NOCARD;
132 }
Damien Miller4dec5d72006-08-05 11:38:40 +1000133 if (status < 0) {
Damien Miller694be4b2001-07-14 12:13:26 +1000134 error("sc_open failed");
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000135 return status;
Damien Miller694be4b2001-07-14 12:13:26 +1000136 }
137 if (sc_enable_applet() < 0) {
138 error("sc_enable_applet failed");
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000139 return SCARD_ERROR_APPLET;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000140 }
141 return 0;
142}
143
Damien Miller9f0f5c62001-12-21 14:45:46 +1100144static int
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000145sc_read_pubkey(Key * k)
146{
147 u_char buf[2], *n;
148 char *p;
Ben Lindstroma2fec902001-09-18 05:45:44 +0000149 int len, sw, status = -1;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000150
151 len = sw = 0;
Damien Miller3ff36d62001-09-28 19:51:54 +1000152 n = NULL;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000153
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000154 if (sc_fd < 0) {
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000155 if (sc_init() < 0)
Ben Lindstroma2fec902001-09-18 05:45:44 +0000156 goto err;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000157 }
Damien Miller694be4b2001-07-14 12:13:26 +1000158
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000159 /* get key size */
160 sectok_apdu(sc_fd, CLA_SSH, INS_GET_KEYLENGTH, 0, 0, 0, NULL,
Damien Miller9f0f5c62001-12-21 14:45:46 +1100161 sizeof(buf), buf, &sw);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000162 if (!sectok_swOK(sw)) {
163 error("could not obtain key length: %s", sectok_get_sw(sw));
Ben Lindstroma2fec902001-09-18 05:45:44 +0000164 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000165 }
166 len = (buf[0] << 8) | buf[1];
167 len /= 8;
168 debug("INS_GET_KEYLENGTH: len %d sw %s", len, sectok_get_sw(sw));
169
170 n = xmalloc(len);
171 /* get n */
172 sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw);
Ben Lindstrom43a5e2f2002-03-27 17:33:17 +0000173
174 if (sw == 0x6982) {
175 if (try_AUT0() < 0)
176 goto err;
177 sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw);
178 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000179 if (!sectok_swOK(sw)) {
180 error("could not obtain public key: %s", sectok_get_sw(sw));
Ben Lindstroma2fec902001-09-18 05:45:44 +0000181 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000182 }
Ben Lindstroma2fec902001-09-18 05:45:44 +0000183
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000184 debug("INS_GET_KEYLENGTH: sw %s", sectok_get_sw(sw));
185
186 if (BN_bin2bn(n, len, k->rsa->n) == NULL) {
187 error("c_read_pubkey: BN_bin2bn failed");
Ben Lindstroma2fec902001-09-18 05:45:44 +0000188 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000189 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000190
191 /* currently the java applet just stores 'n' */
192 if (!BN_set_word(k->rsa->e, 35)) {
193 error("c_read_pubkey: BN_set_word(e, 35) failed");
Ben Lindstroma2fec902001-09-18 05:45:44 +0000194 goto err;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000195 }
196
Ben Lindstroma2fec902001-09-18 05:45:44 +0000197 status = 0;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000198 p = key_fingerprint(k, SSH_FP_MD5, SSH_FP_HEX);
Ben Lindstrom5c385522002-06-23 21:23:20 +0000199 debug("fingerprint %u %s", key_size(k), p);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000200 xfree(p);
201
Ben Lindstroma2fec902001-09-18 05:45:44 +0000202err:
203 if (n != NULL)
204 xfree(n);
205 sc_close();
206 return status;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000207}
208
209/* private key operations */
210
211static int
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000212sc_private_decrypt(int flen, u_char *from, u_char *to, RSA *rsa,
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000213 int padding)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000214{
215 u_char *padded = NULL;
Ben Lindstroma2fec902001-09-18 05:45:44 +0000216 int sw, len, olen, status = -1;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000217
218 debug("sc_private_decrypt called");
219
220 olen = len = sw = 0;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000221 if (sc_fd < 0) {
222 status = sc_init();
Damien Miller4dec5d72006-08-05 11:38:40 +1000223 if (status < 0)
Damien Miller694be4b2001-07-14 12:13:26 +1000224 goto err;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000225 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000226 if (padding != RSA_PKCS1_PADDING)
227 goto err;
228
229 len = BN_num_bytes(rsa->n);
230 padded = xmalloc(len);
231
Ben Lindstrom266ec632002-03-22 03:47:38 +0000232 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
233
234 if (sw == 0x6982) {
Ben Lindstromc2c6cbc2002-03-26 02:44:44 +0000235 if (try_AUT0() < 0)
236 goto err;
Ben Lindstrom266ec632002-03-22 03:47:38 +0000237 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
238 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000239 if (!sectok_swOK(sw)) {
240 error("sc_private_decrypt: INS_DECRYPT failed: %s",
241 sectok_get_sw(sw));
242 goto err;
243 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000244 olen = RSA_padding_check_PKCS1_type_2(to, len, padded + 1, len - 1,
245 len);
246err:
247 if (padded)
248 xfree(padded);
Ben Lindstroma2fec902001-09-18 05:45:44 +0000249 sc_close();
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000250 return (olen >= 0 ? olen : status);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000251}
252
253static int
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000254sc_private_encrypt(int flen, u_char *from, u_char *to, RSA *rsa,
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000255 int padding)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000256{
257 u_char *padded = NULL;
Ben Lindstroma2fec902001-09-18 05:45:44 +0000258 int sw, len, status = -1;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000259
260 len = sw = 0;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000261 if (sc_fd < 0) {
262 status = sc_init();
Damien Miller4dec5d72006-08-05 11:38:40 +1000263 if (status < 0)
Damien Miller694be4b2001-07-14 12:13:26 +1000264 goto err;
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000265 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000266 if (padding != RSA_PKCS1_PADDING)
267 goto err;
268
269 debug("sc_private_encrypt called");
270 len = BN_num_bytes(rsa->n);
271 padded = xmalloc(len);
272
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000273 if (RSA_padding_add_PKCS1_type_1(padded, len, (u_char *)from, flen) <= 0) {
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000274 error("RSA_padding_add_PKCS1_type_1 failed");
275 goto err;
276 }
Ben Lindstrom266ec632002-03-22 03:47:38 +0000277 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
Ben Lindstromc2c6cbc2002-03-26 02:44:44 +0000278 if (sw == 0x6982) {
279 if (try_AUT0() < 0)
280 goto err;
281 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
282 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000283 if (!sectok_swOK(sw)) {
Ben Lindstromc2c6cbc2002-03-26 02:44:44 +0000284 error("sc_private_encrypt: INS_DECRYPT failed: %s",
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000285 sectok_get_sw(sw));
286 goto err;
287 }
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000288err:
289 if (padded)
290 xfree(padded);
Ben Lindstroma2fec902001-09-18 05:45:44 +0000291 sc_close();
Ben Lindstrom30b00be2001-08-06 21:22:10 +0000292 return (len >= 0 ? len : status);
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000293}
294
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +0000295/* called on free */
296
297static int (*orig_finish)(RSA *rsa) = NULL;
298
299static int
300sc_finish(RSA *rsa)
301{
302 if (orig_finish)
303 orig_finish(rsa);
304 sc_close();
305 return 1;
306}
307
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000308/* engine for overloading private key operations */
309
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000310static RSA_METHOD *
311sc_get_rsa_method(void)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000312{
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000313 static RSA_METHOD smart_rsa;
314 const RSA_METHOD *def = RSA_get_default_method();
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000315
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000316 /* use the OpenSSL version */
317 memcpy(&smart_rsa, def, sizeof(smart_rsa));
318
319 smart_rsa.name = "sectok";
320
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000321 /* overload */
322 smart_rsa.rsa_priv_enc = sc_private_encrypt;
323 smart_rsa.rsa_priv_dec = sc_private_decrypt;
324
Ben Lindstroma6c8a8d2001-08-06 21:42:00 +0000325 /* save original */
326 orig_finish = def->finish;
327 smart_rsa.finish = sc_finish;
328
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000329 return &smart_rsa;
330}
331
332#ifdef USE_ENGINE
333static ENGINE *
334sc_get_engine(void)
335{
336 static ENGINE *smart_engine = NULL;
337
Damien Millerda755162002-01-22 23:09:22 +1100338 if ((smart_engine = ENGINE_new()) == NULL)
339 fatal("ENGINE_new failed");
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000340
341 ENGINE_set_id(smart_engine, "sectok");
342 ENGINE_set_name(smart_engine, "libsectok");
Ben Lindstrom0b675b12002-03-22 03:28:11 +0000343
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000344 ENGINE_set_RSA(smart_engine, sc_get_rsa_method());
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000345 ENGINE_set_DSA(smart_engine, DSA_get_default_openssl_method());
346 ENGINE_set_DH(smart_engine, DH_get_default_openssl_method());
347 ENGINE_set_RAND(smart_engine, RAND_SSLeay());
348 ENGINE_set_BN_mod_exp(smart_engine, BN_mod_exp);
349
350 return smart_engine;
351}
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000352#endif
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000353
Damien Miller694be4b2001-07-14 12:13:26 +1000354void
355sc_close(void)
356{
357 if (sc_fd >= 0) {
358 sectok_close(sc_fd);
359 sc_fd = -1;
360 }
361}
362
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000363Key **
364sc_get_keys(const char *id, const char *pin)
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000365{
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000366 Key *k, *n, **keys;
367 int status, nkeys = 2;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000368
Ben Lindstromf7db3bb2001-08-06 21:35:51 +0000369 if (sc_reader_id != NULL)
370 xfree(sc_reader_id);
371 sc_reader_id = xstrdup(id);
372
Ben Lindstrom266ec632002-03-22 03:47:38 +0000373 if (sc_pin != NULL)
374 xfree(sc_pin);
375 sc_pin = (pin == NULL) ? NULL : xstrdup(pin);
376
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000377 k = key_new(KEY_RSA);
378 if (k == NULL) {
379 return NULL;
380 }
Ben Lindstrom94baf302001-08-06 21:25:38 +0000381 status = sc_read_pubkey(k);
382 if (status == SCARD_ERROR_NOCARD) {
383 key_free(k);
384 return NULL;
385 }
Damien Miller4dec5d72006-08-05 11:38:40 +1000386 if (status < 0) {
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000387 error("sc_read_pubkey failed");
388 key_free(k);
389 return NULL;
390 }
Damien Miller07d86be2006-03-26 14:19:21 +1100391 keys = xcalloc((nkeys+1), sizeof(Key *));
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000392
393 n = key_new(KEY_RSA1);
Darren Tucker0bc85572006-11-07 23:14:41 +1100394 if ((BN_copy(n->rsa->n, k->rsa->n) == NULL) ||
395 (BN_copy(n->rsa->e, k->rsa->e) == NULL))
396 fatal("sc_get_keys: BN_copy failed");
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000397 RSA_set_method(n->rsa, sc_get_rsa());
398 n->flags |= KEY_FLAG_EXT;
399 keys[0] = n;
400
401 n = key_new(KEY_RSA);
Darren Tucker0bc85572006-11-07 23:14:41 +1100402 if ((BN_copy(n->rsa->n, k->rsa->n) == NULL) ||
403 (BN_copy(n->rsa->e, k->rsa->e) == NULL))
404 fatal("sc_get_keys: BN_copy failed");
Ben Lindstrom0936a5b2002-03-26 03:17:42 +0000405 RSA_set_method(n->rsa, sc_get_rsa());
406 n->flags |= KEY_FLAG_EXT;
407 keys[1] = n;
408
409 keys[2] = NULL;
410
411 key_free(k);
412 return keys;
Ben Lindstrom3133dbb2001-07-04 05:35:00 +0000413}
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000414
415#define NUM_RSA_KEY_ELEMENTS 5+1
416#define COPY_RSA_KEY(x, i) \
417 do { \
418 len = BN_num_bytes(prv->rsa->x); \
419 elements[i] = xmalloc(len); \
420 debug("#bytes %d", len); \
421 if (BN_bn2bin(prv->rsa->x, elements[i]) < 0) \
422 goto done; \
423 } while (0)
424
Ben Lindstrom266ec632002-03-22 03:47:38 +0000425static void
426sc_mk_digest(const char *pin, u_char *digest)
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000427{
428 const EVP_MD *evp_md = EVP_sha1();
429 EVP_MD_CTX md;
Ben Lindstrom266ec632002-03-22 03:47:38 +0000430
431 EVP_DigestInit(&md, evp_md);
432 EVP_DigestUpdate(&md, pin, strlen(pin));
433 EVP_DigestFinal(&md, digest, NULL);
434}
435
436static int
437get_AUT0(u_char *aut0)
438{
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000439 char *pass;
440
441 pass = read_passphrase("Enter passphrase for smartcard: ", RP_ALLOW_STDIN);
442 if (pass == NULL)
443 return -1;
Ben Lindstrom266ec632002-03-22 03:47:38 +0000444 if (!strcmp(pass, "-")) {
445 memcpy(aut0, DEFAUT0, sizeof DEFAUT0);
446 return 0;
447 }
448 sc_mk_digest(pass, aut0);
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000449 memset(pass, 0, strlen(pass));
450 xfree(pass);
451 return 0;
452}
453
Ben Lindstrom43a5e2f2002-03-27 17:33:17 +0000454static int
455try_AUT0(void)
456{
457 u_char aut0[EVP_MAX_MD_SIZE];
458
459 /* permission denied; try PIN if provided */
460 if (sc_pin && strlen(sc_pin) > 0) {
461 sc_mk_digest(sc_pin, aut0);
462 if (cyberflex_verify_AUT0(sc_fd, cla, aut0, 8) < 0) {
463 error("smartcard passphrase incorrect");
464 return (-1);
465 }
466 } else {
467 /* try default AUT0 key */
468 if (cyberflex_verify_AUT0(sc_fd, cla, DEFAUT0, 8) < 0) {
469 /* default AUT0 key failed; prompt for passphrase */
470 if (get_AUT0(aut0) < 0 ||
471 cyberflex_verify_AUT0(sc_fd, cla, aut0, 8) < 0) {
472 error("smartcard passphrase incorrect");
473 return (-1);
474 }
475 }
476 }
477 return (0);
478}
479
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000480int
481sc_put_key(Key *prv, const char *id)
482{
483 u_char *elements[NUM_RSA_KEY_ELEMENTS];
484 u_char key_fid[2];
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000485 u_char AUT0[EVP_MAX_MD_SIZE];
486 int len, status = -1, i, fd = -1, ret;
487 int sw = 0, cla = 0x00;
488
489 for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
490 elements[i] = NULL;
491
492 COPY_RSA_KEY(q, 0);
493 COPY_RSA_KEY(p, 1);
494 COPY_RSA_KEY(iqmp, 2);
495 COPY_RSA_KEY(dmq1, 3);
496 COPY_RSA_KEY(dmp1, 4);
497 COPY_RSA_KEY(n, 5);
498 len = BN_num_bytes(prv->rsa->n);
Ben Lindstrom818659a2002-03-22 03:38:35 +0000499 fd = sectok_friendly_open(id, STONOWAIT, &sw);
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000500 if (fd < 0) {
501 error("sectok_open failed: %s", sectok_get_sw(sw));
502 goto done;
503 }
504 if (! sectok_cardpresent(fd)) {
Ben Lindstrom818659a2002-03-22 03:38:35 +0000505 error("smartcard in reader %s not present", id);
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000506 goto done;
507 }
508 ret = sectok_reset(fd, 0, NULL, &sw);
509 if (ret <= 0) {
510 error("sectok_reset failed: %s", sectok_get_sw(sw));
511 goto done;
512 }
513 if ((cla = cyberflex_inq_class(fd)) < 0) {
514 error("cyberflex_inq_class failed");
515 goto done;
516 }
517 memcpy(AUT0, DEFAUT0, sizeof(DEFAUT0));
518 if (cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(DEFAUT0)) < 0) {
519 if (get_AUT0(AUT0) < 0 ||
520 cyberflex_verify_AUT0(fd, cla, AUT0, sizeof(DEFAUT0)) < 0) {
Ben Lindstrom266ec632002-03-22 03:47:38 +0000521 memset(AUT0, 0, sizeof(DEFAUT0));
522 error("smartcard passphrase incorrect");
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000523 goto done;
524 }
525 }
Ben Lindstrom266ec632002-03-22 03:47:38 +0000526 memset(AUT0, 0, sizeof(DEFAUT0));
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000527 key_fid[0] = 0x00;
528 key_fid[1] = 0x12;
529 if (cyberflex_load_rsa_priv(fd, cla, key_fid, 5, 8*len, elements,
530 &sw) < 0) {
531 error("cyberflex_load_rsa_priv failed: %s", sectok_get_sw(sw));
532 goto done;
533 }
534 if (!sectok_swOK(sw))
535 goto done;
Damien Miller996acd22003-04-09 20:59:48 +1000536 logit("cyberflex_load_rsa_priv done");
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000537 key_fid[0] = 0x73;
538 key_fid[1] = 0x68;
539 if (cyberflex_load_rsa_pub(fd, cla, key_fid, len, elements[5],
540 &sw) < 0) {
541 error("cyberflex_load_rsa_pub failed: %s", sectok_get_sw(sw));
542 goto done;
543 }
544 if (!sectok_swOK(sw))
545 goto done;
Damien Miller996acd22003-04-09 20:59:48 +1000546 logit("cyberflex_load_rsa_pub done");
Ben Lindstrom70e3ad82002-03-22 03:33:43 +0000547 status = 0;
548
549done:
550 memset(elements[0], '\0', BN_num_bytes(prv->rsa->q));
551 memset(elements[1], '\0', BN_num_bytes(prv->rsa->p));
552 memset(elements[2], '\0', BN_num_bytes(prv->rsa->iqmp));
553 memset(elements[3], '\0', BN_num_bytes(prv->rsa->dmq1));
554 memset(elements[4], '\0', BN_num_bytes(prv->rsa->dmp1));
555 memset(elements[5], '\0', BN_num_bytes(prv->rsa->n));
556
557 for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
558 if (elements[i])
559 xfree(elements[i]);
560 if (fd != -1)
561 sectok_close(fd);
562 return (status);
563}
Damien Miller56a0bb02003-06-18 20:28:40 +1000564
565char *
566sc_get_key_label(Key *key)
567{
568 return xstrdup("smartcard key");
569}
570
Ben Lindstroma42694f2002-04-05 16:11:45 +0000571#endif /* SMARTCARD && USE_SECTOK */