1 /* $OpenBSD: scard.c,v 1.35 2006/08/03 03:34:42 deraadt Exp $ */
3 * Copyright (c) 2001 Markus Friedl. All rights reserved.
5 * Redistribution and use in source and binary forms, with or without
6 * modification, are permitted provided that the following conditions
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.
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.
27 #if defined(SMARTCARD) && defined(USE_SECTOK)
29 #include <sys/types.h>
34 #include <openssl/evp.h>
42 #if OPENSSL_VERSION_NUMBER < 0x00907000L
44 #define RSA_get_default_method RSA_get_default_openssl_method
49 #include <openssl/engine.h>
50 #define sc_get_rsa sc_get_engine
52 #define sc_get_rsa sc_get_rsa_method
56 #define INS_DECRYPT 0x10
57 #define INS_GET_KEYLENGTH 0x20
58 #define INS_GET_PUBKEY 0x30
59 #define INS_GET_RESPONSE 0xc0
61 #define MAX_BUF_SIZE 256
63 u_char DEFAUT0[] = {0xad, 0x9f, 0x61, 0xfe, 0xfa, 0x20, 0xce, 0x63};
65 static int sc_fd = -1;
66 static char *sc_reader_id = NULL;
67 static char *sc_pin = NULL;
68 static int cla = 0x00; /* class */
70 static void sc_mk_digest(const char *pin, u_char *digest);
71 static int get_AUT0(u_char *aut0);
72 static int try_AUT0(void);
74 /* interface to libsectok */
84 sc_fd = sectok_friendly_open(sc_reader_id, STONOWAIT, &sw);
86 error("sectok_open failed: %s", sectok_get_sw(sw));
87 return SCARD_ERROR_FAIL;
89 if (! sectok_cardpresent(sc_fd)) {
90 debug("smartcard in reader %s not present, skipping",
93 return SCARD_ERROR_NOCARD;
95 if (sectok_reset(sc_fd, 0, NULL, &sw) <= 0) {
96 error("sectok_reset failed: %s", sectok_get_sw(sw));
98 return SCARD_ERROR_FAIL;
100 if ((cla = cyberflex_inq_class(sc_fd)) < 0)
103 debug("sc_open ok %d", sc_fd);
108 sc_enable_applet(void)
110 static u_char aid[] = {0xfc, 0x53, 0x73, 0x68, 0x2e, 0x62, 0x69, 0x6e};
113 /* select applet id */
114 sectok_apdu(sc_fd, cla, 0xa4, 0x04, 0, sizeof aid, aid, 0, NULL, &sw);
115 if (!sectok_swOK(sw)) {
116 error("sectok_apdu failed: %s", sectok_get_sw(sw));
129 if (status == SCARD_ERROR_NOCARD) {
130 return SCARD_ERROR_NOCARD;
133 error("sc_open failed");
136 if (sc_enable_applet() < 0) {
137 error("sc_enable_applet failed");
138 return SCARD_ERROR_APPLET;
144 sc_read_pubkey(Key * k)
148 int len, sw, status = -1;
159 sectok_apdu(sc_fd, CLA_SSH, INS_GET_KEYLENGTH, 0, 0, 0, NULL,
160 sizeof(buf), buf, &sw);
161 if (!sectok_swOK(sw)) {
162 error("could not obtain key length: %s", sectok_get_sw(sw));
165 len = (buf[0] << 8) | buf[1];
167 debug("INS_GET_KEYLENGTH: len %d sw %s", len, sectok_get_sw(sw));
171 sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw);
176 sectok_apdu(sc_fd, CLA_SSH, INS_GET_PUBKEY, 0, 0, 0, NULL, len, n, &sw);
178 if (!sectok_swOK(sw)) {
179 error("could not obtain public key: %s", sectok_get_sw(sw));
183 debug("INS_GET_KEYLENGTH: sw %s", sectok_get_sw(sw));
185 if (BN_bin2bn(n, len, k->rsa->n) == NULL) {
186 error("c_read_pubkey: BN_bin2bn failed");
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");
197 p = key_fingerprint(k, SSH_FP_MD5, SSH_FP_HEX);
198 debug("fingerprint %u %s", key_size(k), p);
208 /* private key operations */
211 sc_private_decrypt(int flen, u_char *from, u_char *to, RSA *rsa,
214 u_char *padded = NULL;
215 int sw, len, olen, status = -1;
217 debug("sc_private_decrypt called");
225 if (padding != RSA_PKCS1_PADDING)
228 len = BN_num_bytes(rsa->n);
229 padded = xmalloc(len);
231 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
236 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
238 if (!sectok_swOK(sw)) {
239 error("sc_private_decrypt: INS_DECRYPT failed: %s",
243 olen = RSA_padding_check_PKCS1_type_2(to, len, padded + 1, len - 1,
249 return (olen >= 0 ? olen : status);
253 sc_private_encrypt(int flen, u_char *from, u_char *to, RSA *rsa,
256 u_char *padded = NULL;
257 int sw, len, status = -1;
265 if (padding != RSA_PKCS1_PADDING)
268 debug("sc_private_encrypt called");
269 len = BN_num_bytes(rsa->n);
270 padded = xmalloc(len);
272 if (RSA_padding_add_PKCS1_type_1(padded, len, (u_char *)from, flen) <= 0) {
273 error("RSA_padding_add_PKCS1_type_1 failed");
276 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
280 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
282 if (!sectok_swOK(sw)) {
283 error("sc_private_encrypt: INS_DECRYPT failed: %s",
291 return (len >= 0 ? len : status);
296 static int (*orig_finish)(RSA *rsa) = NULL;
307 /* engine for overloading private key operations */
310 sc_get_rsa_method(void)
312 static RSA_METHOD smart_rsa;
313 const RSA_METHOD *def = RSA_get_default_method();
315 /* use the OpenSSL version */
316 memcpy(&smart_rsa, def, sizeof(smart_rsa));
318 smart_rsa.name = "sectok";
321 smart_rsa.rsa_priv_enc = sc_private_encrypt;
322 smart_rsa.rsa_priv_dec = sc_private_decrypt;
325 orig_finish = def->finish;
326 smart_rsa.finish = sc_finish;
335 static ENGINE *smart_engine = NULL;
337 if ((smart_engine = ENGINE_new()) == NULL)
338 fatal("ENGINE_new failed");
340 ENGINE_set_id(smart_engine, "sectok");
341 ENGINE_set_name(smart_engine, "libsectok");
343 ENGINE_set_RSA(smart_engine, sc_get_rsa_method());
344 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);
363 sc_get_keys(const char *id, const char *pin)
366 int status, nkeys = 2;
368 if (sc_reader_id != NULL)
370 sc_reader_id = xstrdup(id);
374 sc_pin = (pin == NULL) ? NULL : xstrdup(pin);
376 k = key_new(KEY_RSA);
380 status = sc_read_pubkey(k);
381 if (status == SCARD_ERROR_NOCARD) {
386 error("sc_read_pubkey failed");
390 keys = xcalloc((nkeys+1), sizeof(Key *));
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;
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;
412 #define NUM_RSA_KEY_ELEMENTS 5+1
413 #define COPY_RSA_KEY(x, i) \
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) \
423 sc_mk_digest(const char *pin, u_char *digest)
425 const EVP_MD *evp_md = EVP_sha1();
428 EVP_DigestInit(&md, evp_md);
429 EVP_DigestUpdate(&md, pin, strlen(pin));
430 EVP_DigestFinal(&md, digest, NULL);
434 get_AUT0(u_char *aut0)
438 pass = read_passphrase("Enter passphrase for smartcard: ", RP_ALLOW_STDIN);
441 if (!strcmp(pass, "-")) {
442 memcpy(aut0, DEFAUT0, sizeof DEFAUT0);
445 sc_mk_digest(pass, aut0);
446 memset(pass, 0, strlen(pass));
454 u_char aut0[EVP_MAX_MD_SIZE];
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");
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");
478 sc_put_key(Key *prv, const char *id)
480 u_char *elements[NUM_RSA_KEY_ELEMENTS];
482 u_char AUT0[EVP_MAX_MD_SIZE];
483 int len, status = -1, i, fd = -1, ret;
484 int sw = 0, cla = 0x00;
486 for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
491 COPY_RSA_KEY(iqmp, 2);
492 COPY_RSA_KEY(dmq1, 3);
493 COPY_RSA_KEY(dmp1, 4);
495 len = BN_num_bytes(prv->rsa->n);
496 fd = sectok_friendly_open(id, STONOWAIT, &sw);
498 error("sectok_open failed: %s", sectok_get_sw(sw));
501 if (! sectok_cardpresent(fd)) {
502 error("smartcard in reader %s not present", id);
505 ret = sectok_reset(fd, 0, NULL, &sw);
507 error("sectok_reset failed: %s", sectok_get_sw(sw));
510 if ((cla = cyberflex_inq_class(fd)) < 0) {
511 error("cyberflex_inq_class failed");
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) {
518 memset(AUT0, 0, sizeof(DEFAUT0));
519 error("smartcard passphrase incorrect");
523 memset(AUT0, 0, sizeof(DEFAUT0));
526 if (cyberflex_load_rsa_priv(fd, cla, key_fid, 5, 8*len, elements,
528 error("cyberflex_load_rsa_priv failed: %s", sectok_get_sw(sw));
531 if (!sectok_swOK(sw))
533 logit("cyberflex_load_rsa_priv done");
536 if (cyberflex_load_rsa_pub(fd, cla, key_fid, len, elements[5],
538 error("cyberflex_load_rsa_pub failed: %s", sectok_get_sw(sw));
541 if (!sectok_swOK(sw))
543 logit("cyberflex_load_rsa_pub done");
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));
554 for (i = 0; i < NUM_RSA_KEY_ELEMENTS; i++)
563 sc_get_key_label(Key *key)
565 return xstrdup("smartcard key");
568 #endif /* SMARTCARD && USE_SECTOK */