scard.c

   1 /* $OpenBSD: scard.c,v 1.35 2006/08/03 03:34:42 deraadt Exp $ */
   2 /*
   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
  26 #include "includes.h"
  27 #if defined(SMARTCARD) && defined(USE_SECTOK)
  28
  29 #include <sys/types.h>
  30
  31 #include <sectok.h>
  32 #include <string.h>
  33
  34 #include <openssl/evp.h>
  35
  36 #include "xmalloc.h"
  37 #include "key.h"
  38 #include "log.h"
  39 #include "misc.h"
  40 #include "scard.h"
  41
  42 #if OPENSSL_VERSION_NUMBER < 0x00907000L
  43 #define USE_ENGINE
  44 #define RSA_get_default_method RSA_get_default_openssl_method
  45 #else
  46 #endif
  47
  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
  53 #endif
  54
  55 #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
  63 u_char DEFAUT0[] = {0xad, 0x9f, 0x61, 0xfe, 0xfa, 0x20, 0xce, 0x63};
  64
  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 */
  69
  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);
  73
  74 /* interface to libsectok */
  75
  76 static int
  77 sc_open(void)
  78 {
  79         int sw;
  80
  81         if (sc_fd >= 0)
  82                 return sc_fd;
  83
  84         sc_fd = sectok_friendly_open(sc_reader_id, STONOWAIT, &sw);
  85         if (sc_fd < 0) {
  86                 error("sectok_open failed: %s", sectok_get_sw(sw));
  87                 return SCARD_ERROR_FAIL;
  88         }
  89         if (! sectok_cardpresent(sc_fd)) {
  90                 debug("smartcard in reader %s not present, skipping",
  91                     sc_reader_id);
  92                 sc_close();
  93                 return SCARD_ERROR_NOCARD;
  94         }
  95         if (sectok_reset(sc_fd, 0, NULL, &sw) <= 0) {
  96                 error("sectok_reset failed: %s", sectok_get_sw(sw));
  97                 sc_fd = -1;
  98                 return SCARD_ERROR_FAIL;
  99         }
 100         if ((cla = cyberflex_inq_class(sc_fd)) < 0)
 101                 cla = 0;
 102
 103         debug("sc_open ok %d", sc_fd);
 104         return sc_fd;
 105 }
 106
 107 static int
 108 sc_enable_applet(void)
 109 {
 110         static u_char aid[] = {0xfc, 0x53, 0x73, 0x68, 0x2e, 0x62, 0x69, 0x6e};
 111         int sw = 0;
 112
 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));
 117                 sc_close();
 118                 return -1;
 119         }
 120         return 0;
 121 }
 122
 123 static int
 124 sc_init(void)
 125 {
 126         int status;
 127
 128         status = sc_open();
 129         if (status == SCARD_ERROR_NOCARD) {
 130                 return SCARD_ERROR_NOCARD;
 131         }
 132         if (status < 0) {
 133                 error("sc_open failed");
 134                 return status;
 135         }
 136         if (sc_enable_applet() < 0) {
 137                 error("sc_enable_applet failed");
 138                 return SCARD_ERROR_APPLET;
 139         }
 140         return 0;
 141 }
 142
 143 static int
 144 sc_read_pubkey(Key * k)
 145 {
 146         u_char buf[2], *n;
 147         char *p;
 148         int len, sw, status = -1;
 149
 150         len = sw = 0;
 151         n = NULL;
 152
 153         if (sc_fd < 0) {
 154                 if (sc_init() < 0)
 155                         goto err;
 156         }
 157
 158         /* get key size */
 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));
 163                 goto err;
 164         }
 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);
 172
 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         }
 178         if (!sectok_swOK(sw)) {
 179                 error("could not obtain public key: %s", sectok_get_sw(sw));
 180                 goto err;
 181         }
 182
 183         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");
 187                 goto err;
 188         }
 189
 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");
 193                 goto err;
 194         }
 195
 196         status = 0;
 197         p = key_fingerprint(k, SSH_FP_MD5, SSH_FP_HEX);
 198         debug("fingerprint %u %s", key_size(k), p);
 199         xfree(p);
 200
 201 err:
 202         if (n != NULL)
 203                 xfree(n);
 204         sc_close();
 205         return status;
 206 }
 207
 208 /* private key operations */
 209
 210 static int
 211 sc_private_decrypt(int flen, u_char *from, u_char *to, RSA *rsa,
 212     int padding)
 213 {
 214         u_char *padded = NULL;
 215         int sw, len, olen, status = -1;
 216
 217         debug("sc_private_decrypt called");
 218
 219         olen = len = sw = 0;
 220         if (sc_fd < 0) {
 221                 status = sc_init();
 222                 if (status < 0)
 223                         goto err;
 224         }
 225         if (padding != RSA_PKCS1_PADDING)
 226                 goto err;
 227
 228         len = BN_num_bytes(rsa->n);
 229         padded = xmalloc(len);
 230
 231         sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
 232
 233         if (sw == 0x6982) {
 234                 if (try_AUT0() < 0)
 235                         goto err;
 236                 sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, from, len, padded, &sw);
 237         }
 238         if (!sectok_swOK(sw)) {
 239                 error("sc_private_decrypt: INS_DECRYPT failed: %s",
 240                     sectok_get_sw(sw));
 241                 goto err;
 242         }
 243         olen = RSA_padding_check_PKCS1_type_2(to, len, padded + 1, len - 1,
 244             len);
 245 err:
 246         if (padded)
 247                 xfree(padded);
 248         sc_close();
 249         return (olen >= 0 ? olen : status);
 250 }
 251
 252 static int
 253 sc_private_encrypt(int flen, u_char *from, u_char *to, RSA *rsa,
 254     int padding)
 255 {
 256         u_char *padded = NULL;
 257         int sw, len, status = -1;
 258
 259         len = sw = 0;
 260         if (sc_fd < 0) {
 261                 status = sc_init();
 262                 if (status < 0)
 263                         goto err;
 264         }
 265         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
 272         if (RSA_padding_add_PKCS1_type_1(padded, len, (u_char *)from, flen) <= 0) {
 273                 error("RSA_padding_add_PKCS1_type_1 failed");
 274                 goto err;
 275         }
 276         sectok_apdu(sc_fd, CLA_SSH, INS_DECRYPT, 0, 0, len, padded, len, to, &sw);
 277         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         }
 282         if (!sectok_swOK(sw)) {
 283                 error("sc_private_encrypt: INS_DECRYPT failed: %s",
 284                     sectok_get_sw(sw));
 285                 goto err;
 286         }
 287 err:
 288         if (padded)
 289                 xfree(padded);
 290         sc_close();
 291         return (len >= 0 ? len : status);
 292 }
 293
 294 /* called on free */
 295
 296 static int (*orig_finish)(RSA *rsa) = NULL;
 297
 298 static int
 299 sc_finish(RSA *rsa)
 300 {
 301         if (orig_finish)
 302                 orig_finish(rsa);
 303         sc_close();
 304         return 1;
 305 }
 306
 307 /* engine for overloading private key operations */
 308
 309 static RSA_METHOD *
 310 sc_get_rsa_method(void)
 311 {
 312         static RSA_METHOD smart_rsa;
 313         const RSA_METHOD *def = RSA_get_default_method();
 314
 315         /* use the OpenSSL version */
 316         memcpy(&smart_rsa, def, sizeof(smart_rsa));
 317
 318         smart_rsa.name          = "sectok";
 319
 320         /* overload */
 321         smart_rsa.rsa_priv_enc  = sc_private_encrypt;
 322         smart_rsa.rsa_priv_dec  = sc_private_decrypt;
 323
 324         /* save original */
 325         orig_finish             = def->finish;
 326         smart_rsa.finish        = sc_finish;
 327
 328         return &smart_rsa;
 329 }
 330
 331 #ifdef USE_ENGINE
 332 static ENGINE *
 333 sc_get_engine(void)
 334 {
 335         static ENGINE *smart_engine = NULL;
 336
 337         if ((smart_engine = ENGINE_new()) == NULL)
 338                 fatal("ENGINE_new failed");
 339
 340         ENGINE_set_id(smart_engine, "sectok");
 341         ENGINE_set_name(smart_engine, "libsectok");
 342
 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);
 348
 349         return smart_engine;
 350 }
 351 #endif
 352
 353 void
 354 sc_close(void)
 355 {
 356         if (sc_fd >= 0) {
 357                 sectok_close(sc_fd);
 358                 sc_fd = -1;
 359         }
 360 }
 361
 362 Key **
 363 sc_get_keys(const char *id, const char *pin)
 364 {
 365         Key *k, *n, **keys;
 366         int status, nkeys = 2;
 367
 368         if (sc_reader_id != NULL)
 369                 xfree(sc_reader_id);
 370         sc_reader_id = xstrdup(id);
 371
 372         if (sc_pin != NULL)
 373                 xfree(sc_pin);
 374         sc_pin = (pin == NULL) ? NULL : xstrdup(pin);
 375
 376         k = key_new(KEY_RSA);
 377         if (k == NULL) {
 378                 return NULL;
 379         }
 380         status = sc_read_pubkey(k);
 381         if (status == SCARD_ERROR_NOCARD) {
 382                 key_free(k);
 383                 return NULL;
 384         }
 385         if (status < 0) {
 386                 error("sc_read_pubkey failed");
 387                 key_free(k);
 388                 return NULL;
 389         }
 390         keys = xcalloc((nkeys+1), sizeof(Key *));
 391
 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;
 410 }
 411
 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
 422 static void
 423 sc_mk_digest(const char *pin, u_char *digest)
 424 {
 425         const EVP_MD *evp_md = EVP_sha1();
 426         EVP_MD_CTX md;
 427
 428         EVP_DigestInit(&md, evp_md);
 429         EVP_DigestUpdate(&md, pin, strlen(pin));
 430         EVP_DigestFinal(&md, digest, NULL);
 431 }
 432
 433 static int
 434 get_AUT0(u_char *aut0)
 435 {
 436         char *pass;
 437
 438         pass = read_passphrase("Enter passphrase for smartcard: ", RP_ALLOW_STDIN);
 439         if (pass == NULL)
 440                 return -1;
 441         if (!strcmp(pass, "-")) {
 442                 memcpy(aut0, DEFAUT0, sizeof DEFAUT0);
 443                 return 0;
 444         }
 445         sc_mk_digest(pass, aut0);
 446         memset(pass, 0, strlen(pass));
 447         xfree(pass);
 448         return 0;
 449 }
 450
 451 static int
 452 try_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
 477 int
 478 sc_put_key(Key *prv, const char *id)
 479 {
 480         u_char *elements[NUM_RSA_KEY_ELEMENTS];
 481         u_char key_fid[2];
 482         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);
 496         fd = sectok_friendly_open(id, STONOWAIT, &sw);
 497         if (fd < 0) {
 498                 error("sectok_open failed: %s", sectok_get_sw(sw));
 499                 goto done;
 500         }
 501         if (! sectok_cardpresent(fd)) {
 502                 error("smartcard in reader %s not present", id);
 503                 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) {
 518                         memset(AUT0, 0, sizeof(DEFAUT0));
 519                         error("smartcard passphrase incorrect");
 520                         goto done;
 521                 }
 522         }
 523         memset(AUT0, 0, sizeof(DEFAUT0));
 524         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;
 533         logit("cyberflex_load_rsa_priv done");
 534         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;
 543         logit("cyberflex_load_rsa_pub done");
 544         status = 0;
 545
 546 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));
 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 }
 561
 562 char *
 563 sc_get_key_label(Key *key)
 564 {
 565         return xstrdup("smartcard key");
 566 }
 567
 568 #endif /* SMARTCARD && USE_SECTOK */