gnupg/scd/sc-investigate.c

/* sc-investigate.c - A tool to look around on smartcards.
 *	Copyright (C) 2003 Free Software Foundation, Inc.
 *
 * This file is part of GnuPG.
 *
 * GnuPG is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * GnuPG is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA
 */

#include <config.h>

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <ctype.h>
#include <unistd.h>
#ifdef USE_GNU_PTH
# include <pth.h>
#endif

#ifdef HAVE_READLINE_READLINE_H
#include <readline/readline.h>
#include <readline/history.h>
#endif

#define JNLIB_NEED_LOG_LOGV
#include "scdaemon.h"
#include <gcrypt.h>

#include "apdu.h" /* for open_reader */
#include "atr.h"
#include "app-common.h"
#include "iso7816.h"

#define _(a) (a)

#define CONTROL_D ('D' - 'A' + 1)


enum cmd_and_opt_values 
{ 
  oInteractive    = 'i',
  oVerbose	  = 'v',
  oQuiet          = 'q',
  oReaderPort     = 500,
  octapiDriver,

  oDebug,
  oDebugAll,

  oDisableCCID,


  oGenRandom,

aTest };


static ARGPARSE_OPTS opts[] = {
  
  { 301, NULL, 0, "@Options:\n " },

  { oInteractive, "interactive", 0, "start in interactive explorer mode"},
  { oQuiet,       "quiet", 0, "quiet" },
  { oVerbose, "verbose",   0, "verbose" },
  { oReaderPort, "reader-port", 2, "|N|connect to reader at port N"},
  { octapiDriver, "ctapi-driver", 2, "NAME|use NAME as ctAPI driver"},
  { oDisableCCID, "disable-ccid", 0,
#ifdef HAVE_LIBUSB
                                    "do not use the internal CCID driver"
#else
                                    "@"
#endif
  },
  { oDebug,	"debug"     ,4|16, "set debugging flags"},
  { oDebugAll, "debug-all" ,0, "enable full debugging"},
  { oGenRandom, "gen-random", 4, "|N|generate N bytes of random"},
  {0}
};

#ifndef HAVE_OPENSC
#ifdef USE_GNU_PTH
/* Pth wrapper function definitions. */
GCRY_THREAD_OPTION_PTH_IMPL;
#endif /*USE_GNU_PTH*/
#endif /*!HAVE_OPENSC*/

static void interactive_shell (int slot);
static void dump_other_cards (int slot);

static const char *
my_strusage (int level)
{
  const char *p;
  switch (level)
    {
    case 11: p = "sc-investigate (GnuPG)";
      break;
    case 13: p = VERSION; break;
    case 17: p = PRINTABLE_OS_NAME; break;
    case 19: p = _("Please report bugs to <" PACKAGE_BUGREPORT ">.\n");
      break;
    case 1:
    case 40: p =  _("Usage: sc-investigate [options] (-h for help)\n");
      break;
    case 41: p =  _("Syntax: sc-investigate [options] [args]]\n"
                    "Have a look at smartcards\n");
    break;
    
    default: p = NULL;
    }
  return p;
}

/* Used by gcry for logging */
static void
my_gcry_logger (void *dummy, int level, const char *fmt, va_list arg_ptr)
{
  /* translate the log levels */
  switch (level)
    {
    case GCRY_LOG_CONT: level = JNLIB_LOG_CONT; break;
    case GCRY_LOG_INFO: level = JNLIB_LOG_INFO; break;
    case GCRY_LOG_WARN: level = JNLIB_LOG_WARN; break;
    case GCRY_LOG_ERROR:level = JNLIB_LOG_ERROR; break;
    case GCRY_LOG_FATAL:level = JNLIB_LOG_FATAL; break;
    case GCRY_LOG_BUG:  level = JNLIB_LOG_BUG; break;
    case GCRY_LOG_DEBUG:level = JNLIB_LOG_DEBUG; break;
    default:            level = JNLIB_LOG_ERROR; break;  
    }
  log_logv (level, fmt, arg_ptr);
}


int
main (int argc, char **argv )
{
  ARGPARSE_ARGS pargs;
  int slot, rc;
  const char *reader_port = NULL;
  unsigned long gen_random = 0;
  int interactive = 0;

  set_strusage (my_strusage);
  gcry_control (GCRYCTL_SUSPEND_SECMEM_WARN);
  log_set_prefix ("sc-investigate", 1); 

  /* Try to auto set the character set.  */
  set_native_charset (NULL); 

  /* Libgcrypt requires us to register the threading model first.  We
     can't use pth at all if we are using OpenSC becuase OpenSC uses
     ptreads.  Note that this will also do the pth_init. */
#ifndef HAVE_OPENSC
#ifdef USE_GNU_PTH
  rc = gcry_control (GCRYCTL_SET_THREAD_CBS, &gcry_threads_pth);
  if (rc)
    {
      log_fatal ("can't register GNU Pth with Libgcrypt: %s\n",
                 gpg_strerror (rc));
    }
#endif /*USE_GNU_PTH*/
#endif /*!HAVE_OPENSC*/

  /* Check that the libraries are suitable.  Do it here because
     the option parsing may need services of the library */
  if (!gcry_check_version (NEED_LIBGCRYPT_VERSION) )
    {
      log_fatal( _("libgcrypt is too old (need %s, have %s)\n"),
                 NEED_LIBGCRYPT_VERSION, gcry_check_version (NULL) );
    }


  gcry_set_log_handler (my_gcry_logger, NULL);
  /* FIXME? gcry_control (GCRYCTL_USE_SECURE_RNDPOOL);*/

  pargs.argc = &argc;
  pargs.argv = &argv;
  pargs.flags=  1;  /* do not remove the args */
  while (arg_parse (&pargs, opts) )
    {
      switch (pargs.r_opt)
        {
        case oVerbose: opt.verbose++; break;
        case oQuiet: opt.quiet++; break;
        case oDebug: opt.debug |= pargs.r.ret_ulong; break;
        case oDebugAll: opt.debug = ~0; break;
        case oReaderPort: reader_port = pargs.r.ret_str; break;
        case octapiDriver: opt.ctapi_driver = pargs.r.ret_str; break;
        case oDisableCCID: opt.disable_ccid = 1; break;
        case oGenRandom: gen_random = pargs.r.ret_ulong; break;
        case oInteractive: interactive = 1; break;
        default : pargs.err = 2; break;
	}
    }
  if (log_get_errorcount(0))
    exit(2);

  if (opt.verbose < 2)
    opt.verbose = 2; /* Hack to let select_openpgp print some info. */

  if (argc)
    usage (1);

  slot = apdu_open_reader (reader_port);
  if (slot == -1)
    exit (1);
  
  if (!gen_random && !opt.quiet)
    {
      rc = atr_dump (slot, stdout); 
      if (rc)
        log_error ("can't dump ATR: %s\n", gpg_strerror (rc));
    }

  if (interactive)
    interactive_shell (slot);
  else
    {
      struct app_ctx_s appbuf;

      /* Fixme: We better use app.c directly. */
      memset (&appbuf, 0, sizeof appbuf);
      appbuf.slot = slot;
      rc = app_select_openpgp (&appbuf);
      if (rc)
        {
          if (!opt.quiet)
            log_info ("selecting openpgp failed: %s\n", gpg_strerror (rc));
          memset (&appbuf, 0, sizeof appbuf);
          appbuf.slot = slot;
          rc = app_select_dinsig (&appbuf);
          if (rc)
            {
              if (!opt.quiet)
                log_info ("selecting dinsig failed: %s\n", gpg_strerror (rc));
              dump_other_cards (slot);
            }
          else
            {
              appbuf.initialized = 1;
              log_info ("dinsig application selected\n");
            }
        }
      else
        {
          appbuf.initialized = 1;
          log_info ("openpgp application selected\n");

          if (gen_random)
            {
              size_t nbytes;
              unsigned char *buffer;
          
              buffer = xmalloc (4096);
              do 
                {
                  nbytes = gen_random > 4096? 4096 : gen_random;
                  rc = app_get_challenge (&appbuf, nbytes, buffer);
                  if (rc)
                    log_error ("app_get_challenge failed: %s\n",gpg_strerror (rc));
                  else
                    {
                      if (fwrite (buffer, nbytes, 1, stdout) != 1)
                        log_error ("writing to stdout failed: %s\n",
                                   strerror (errno));
                      gen_random -= nbytes;
                    }
                }
              while (gen_random && !log_get_errorcount (0));
              xfree (buffer);
            }
        }
    }
  
  return log_get_errorcount (0)? 2:0;
}



void
send_status_info (CTRL ctrl, const char *keyword, ...)
{
  /* DUMMY */
}



/* Dump BUFFER of length NBYTES in a nicely human readable format. */ 
static void
dump_buffer (const unsigned char *buffer, size_t nbytes)
{
  int i;

  while (nbytes)
    {
      for (i=0; i < 16 && i < nbytes; i++)
        printf ("%02X%s ", buffer[i], i==8? " ":"");
      for (; i < 16; i++)
        printf ("  %s ", i==8? " ":"");
      putchar (' ');
      putchar (' ');
      for (i=0; i < 16 && i < nbytes; i++)
        if (isprint (buffer[i]))
          putchar (buffer[i]);
        else
          putchar ('.');
      nbytes -= i;
      buffer += i;
      for (; i < 16; i++)
        putchar (' ');
      putchar ('\n');
    }
}


static void
dump_or_store_buffer (const char *arg,
                      const unsigned char *buffer, size_t nbytes)
{
  const char *s = strchr (arg, '>');
  int append;
  FILE *fp;

  if (!s)
    {
      dump_buffer (buffer, nbytes);
      return;
    }
  if ((append = (*++s == '>')))
    s++;
  fp = fopen (s, append? "ab":"wb");
  if (!fp)
    {
      log_error ("failed to create `%s': %s\n", s, strerror (errno));
      return;
    }
  if (nbytes && fwrite (buffer, nbytes, 1, fp) != 1)
      log_error ("failed to write to `%s': %s\n", s, strerror (errno));
  if (fclose (fp))
      log_error ("failed to close `%s': %s\n", s, strerror (errno));
}


/* Convert STRING into a a newly allocated buffer and return the
   length of the buffer in R_LENGTH.  Detect xx:xx:xx... sequence and
   unhexify that one. */
static unsigned char *
pin_to_buffer (const char *string, size_t *r_length)
{
  unsigned char *buffer = xmalloc (strlen (string)+1);
  const char *s;
  size_t n;

  for (s=string, n=0; *s; s += 3)
    {
      if (hexdigitp (s) && hexdigitp (s+1) && (s[2]==':'||!s[2]))
        {
          buffer[n++] = xtoi_2 (s);
          if (!s[2])
            break;
        }
      else
        {
          memcpy (buffer, string, strlen (string));
          *r_length = strlen (string);
          return buffer;
        }
    }
  *r_length = n;
  return buffer;
}


static char *
my_read_line (int use_readline, char *prompt)
{
  static char buf[256];

#ifdef HAVE_READLINE
  if (use_readline)
    {
      char *line = readline (prompt);
      if (line)
        trim_spaces (line);
      if (line && strlen (line) > 2 )
        add_history (line);
      return line;
    }
#endif
  /* Either we don't have readline or we are not running
     interactively */
#ifndef HAVE_READLINE
  printf ("%s", prompt );
#endif
  fflush(stdout);
  if (!fgets(buf, sizeof(buf), stdin))
    return NULL;
  if (!strlen(buf))
    return NULL;
  if (buf[strlen (buf)-1] == '\n')
    buf[strlen (buf)-1] = 0;
  trim_spaces (buf);
  return buf;
}

/* Run a shell for interactive exploration of the card. */
static void
interactive_shell (int slot)
{
  enum cmdids
    {
      cmdNOP = 0,
      cmdQUIT, cmdHELP,
      cmdSELECT,
      cmdCHDIR,
      cmdLS,
      cmdAPP,
      cmdREAD,
      cmdREADREC,
      cmdREADSHORTREC,
      cmdDEBUG,
      cmdVERIFY,
      cmdCHANGEREF,
      cmdREADPK,

      cmdINVCMD
    };
  static struct 
  {
    const char *name;
    enum cmdids id;
    const char *desc;
  } cmds[] = {
    { "quit"   , cmdQUIT  , "quit this menu" },
    { "q"      , cmdQUIT  , NULL   },
    { "help"   , cmdHELP  , "show this help" },
    { "?"      , cmdHELP  , NULL   },
    { "debug"  , cmdDEBUG, "set debugging flags" },
    { "select" , cmdSELECT, "select file (EF)" },
    { "s"      , cmdSELECT, NULL },
    { "chdir"  , cmdCHDIR, "change directory (select DF)"},
    { "cd"     , cmdCHDIR,  NULL },
    { "ls"     , cmdLS,    "list directory (some cards only)"},
    { "app"    , cmdAPP,   "select application"},
    { "read"   , cmdREAD,  "read binary" },
    { "rb"     , cmdREAD,  NULL },
    { "readrec", cmdREADREC,  "read record(s)" },
    { "rr"     , cmdREADREC,  NULL },
    { "rsr"    , cmdREADSHORTREC,  "readshortrec RECNO SHORT_EF" },
    { "verify" , cmdVERIFY, "verify CHVNO PIN" },
    { "ver"    , cmdVERIFY, NULL },
    { "changeref", cmdCHANGEREF, "change reference data" },
    { "readpk",    cmdREADPK,    "read a public key" },
    { NULL, cmdINVCMD } 
  };
  enum cmdids cmd = cmdNOP;
  int use_readline = isatty (fileno(stdin));
  char *line;
  gpg_error_t err = 0;
  unsigned char *result = NULL;
  size_t resultlen;

#ifdef HAVE_READLINE
  if (use_readline)
    using_history ();
#endif

  for (;;)
    {
      int arg_number;
      const char *arg_string = "";
      const char *arg_next = "";
      char *p;
      int i;
      
      if (err)
        printf ("command failed: %s\n", gpg_strerror (err));
      err = 0;
      xfree (result);
      result = NULL;

      printf ("\n");
      do
        {
          line = my_read_line (use_readline, "cmd> ");
	}
      while ( line && *line == '#' );

      arg_number = 0; 
      if (!line || *line == CONTROL_D)
        cmd = cmdQUIT; 
      else if (!*line)
        cmd = cmdNOP;
      else {
        if ((p=strchr (line,' ')))
          {
            char *endp;

            *p++ = 0;
            trim_spaces (line);
            trim_spaces (p);
            arg_number = strtol (p, &endp, 0);
            arg_string = p;
            if (endp != p)
              {
                arg_next = endp;
                while ( spacep (arg_next) )
                  arg_next++;
              }
          }

        for (i=0; cmds[i].name; i++ )
          if (!ascii_strcasecmp (line, cmds[i].name ))
            break;
        
        cmd = cmds[i].id;
      }
      
      switch (cmd)
        {
        case cmdHELP:
          for (i=0; cmds[i].name; i++ )
            if (cmds[i].desc)
              printf("%-10s %s\n", cmds[i].name, _(cmds[i].desc) );
          break;

        case cmdQUIT:
          goto leave;

        case cmdNOP:
          break;

        case cmdDEBUG:
          if (!*arg_string)
            opt.debug = opt.debug? 0 : 2048;
          else
            opt.debug = arg_number;
          break;

        case cmdSELECT:
          err = iso7816_select_file (slot, arg_number, 0, NULL, NULL);
          break;

        case cmdCHDIR:
          err = iso7816_select_file (slot, arg_number, 1, NULL, NULL);
          break;

        case cmdLS:
          err = iso7816_list_directory (slot, 1, &result, &resultlen);
          if (!err || gpg_err_code (err) == GPG_ERR_ENOENT)
            err = iso7816_list_directory (slot, 0, &result, &resultlen);
          /* FIXME: Do something with RESULT. */
          break;

        case cmdAPP:
          {
            app_t app;

            app = select_application (NULL, slot, *arg_string? arg_string:NULL);
            if (app)
              {
                char *sn;

                app_get_serial_and_stamp (app, &sn, NULL);
                log_info ("application `%s' ready; sn=%s\n",
                          app->apptype?app->apptype:"?", sn? sn:"[none]");
                release_application (app);
              }
          }
          break;

        case cmdREAD:
          err = iso7816_read_binary (slot, 0, 0, &result, &resultlen);
          if (!err)
            dump_or_store_buffer (arg_string, result, resultlen);
          break;

        case cmdREADREC:
          if (*arg_string == '*' && (!arg_string[1] || arg_string[1] == ' '))
            {
              /* Fixme: Can't write to a file yet. */
              for (i=1, err=0; !err; i++)
                {
                  xfree (result); result = NULL;
                  err = iso7816_read_record (slot, i, 1, 0,
                                             &result, &resultlen);
                  if (!err)
                    dump_buffer (result, resultlen);
                }
              if (gpg_err_code (err) == GPG_ERR_NOT_FOUND)
                err = 0;
            }
          else
            {
              err = iso7816_read_record (slot, arg_number, 1, 0,
                                         &result, &resultlen);
              if (!err)
                dump_or_store_buffer (arg_string, result, resultlen);
            }
          break;

        case cmdREADSHORTREC:
          {
            int short_ef;

            short_ef = strtol (arg_next, NULL, 0);
            
            if (short_ef < 1 || short_ef > 254)
              printf ("error: short EF must be between 1 and 254\n");
            else
              {
                err = iso7816_read_record (slot, arg_number, 1, short_ef,
                                           &result, &resultlen);
                if (!err)
                  dump_or_store_buffer (arg_string, result, resultlen);
              }
          }
          break;

        case cmdVERIFY:
          if (arg_number < 0 || arg_number > 255 || (arg_number & 127) > 31)
            printf ("error: invalid CHVNO\n");
          else 
            {
              unsigned char *pin;
              size_t pinlen;

              pin = pin_to_buffer (arg_next, &pinlen);
              err = iso7816_verify (slot, arg_number, pin, pinlen);
              xfree (pin);
            }
            break;

        case cmdCHANGEREF:
          {
            const char *newpin = arg_next;
            
            while ( *newpin && !spacep (newpin) )
              newpin++;
            while ( spacep (newpin) )
              newpin++;

            if (arg_number < 0 || arg_number > 255 || (arg_number & 127) > 31)
              printf ("error: invalid CHVNO\n");
            else if (!*arg_next || !*newpin || newpin == arg_next)
              printf ("usage: changeref CHVNO OLDPIN NEWPIN\n");
            else
              {
                char *oldpin = xstrdup (arg_next);
                unsigned char *oldpin_buf, *newpin_buf;
                size_t oldpin_len, newpin_len;

                for (p=oldpin; *p && !spacep (p); p++ )
                  ;
                *p = 0;
                oldpin_buf = pin_to_buffer (oldpin, &oldpin_len);
                newpin_buf = pin_to_buffer (newpin, &newpin_len);

                err = iso7816_change_reference_data (slot, arg_number,
                                                     oldpin_buf, oldpin_len,
                                                     newpin_buf, newpin_len);

                xfree (newpin_buf);
                xfree (oldpin_buf);
                xfree (oldpin);
              }
          }
          break;

        case cmdREADPK:
          if (arg_number < 1 || arg_number > 255)
            printf ("usage: readpk CRTBYTE1\n");
          else
            {
              unsigned char crt[2];
            
              crt[0] = arg_number;
              crt[1] = 0;
              err = iso7816_read_public_key(slot, crt, 2,
                                            &result, &resultlen);
              if (!err) 
                dump_or_store_buffer (arg_string, result, resultlen);
            }
            break;


        case cmdINVCMD:
        default:
          printf ("\n");
          printf ("Invalid command  (try \"help\")\n");
          break;
        } /* End command switch. */
    } /* End of main menu loop. */

 leave:
  ;
}



/* Figure out whether the current card is a German Geldkarte and print
   what we know about it. */
static int
dump_geldkarte (int slot)
{
  unsigned char *r = NULL;
  size_t rlen;
  const char *t;

  if (iso7816_read_record (slot, 1, 1, 0xbc, &r, &rlen))
    return -1;
  /* We require that the record is at least 24 bytes, the first byte
     is 0x67 and the filler byte is correct. */
  if (rlen < 24 || *r != 0x67 || r[22])
    return -1;
  
  /* The short Bankleitzahl consists of 3 bytes at offset 1.  */
  switch (r[1])
    {
    case 0x21: t = "Oeffentlich-rechtliche oder private Bank"; break;
    case 0x22: t = "Privat- oder Gesch<63>ftsbank"; break;
    case 0x25: t = "Sparkasse"; break;
    case 0x26:
    case 0x29: t = "Genossenschaftsbank"; break;
    default: 
      xfree (r);
      return -1;  /* Probably not a Geldkarte. */
    }

  printf ("KBLZ .....: %02X-%02X%02X (%s)\n", r[1], r[2], r[3], t);
  printf ("Card-No ..: %02X%02X%02X%02X%02X\n", r[4], r[5], r[6], r[7], r[8]);
   
/*   Byte 10 enth<74>lt im linken Halbbyte eine Pr<50>fziffer, die nach dem */
/*   Verfahren 'Luhn formula for computing modulus 10' <20>ber die Ziffern der */
/*   ersten 9 Byte berechnet ist. */
  
/*   Das rechte Halbbyte wird zu 'D' gesetzt.  */
  
/*   F<>r die Berechnung der Luhn-Pr<50>fziffer sind die folgenden Schritte */
/*   durchzuf<75>hren: */
  
/*   Schritt 1:	Mit der rechtesten Ziffer beginnend ist einschlie<69>lich dieser */
/*   Ziffer jede <20>bern<72>chste Ziffer zu verdoppeln (mit 2 multiplizieren). */
  
/*   Schritt 2:	Die einzelnen Ziffern der Produkte aus Schritt 1 und die bei */
/*   diesen Multiplikationen unber<65>hrt gebliebenen Ziffern sind zu addieren. */
  
/*   Schritt 3:	Das Ergebnis der Addition aus Schritt 2 ist von dem auf die */
/*   n<>chst h<>here Zahl mit der Einerstelle 0 aufgerundeten Ergebnis der */
/*   Addition aus Schritt 2 abzuziehen. Wenn das Ergebnis der Addition aus */
/*   Schritt 2 bereits eine Zahl mit der Einerstelle 0 ergibt (z.B. 30, 40, */
/*   usw.), ist die Pr<50>fziffer 0. */
  
/*   Beispiel:	Kartennummer ohne Pr<50>fziffer: 992 839 871 */
  
/*    9   9   2   8   3   9   8   7   1 */
  
/*   x 2     x 2     x 2     x 2     x 2       Schritt 1 */
  
/*   18       4       6      16       2 */
  
/*   1+8 +9  +4  +8  +6  +9 +1+6 +7  +2 = 61   Schritt 2 */
  
/*   70-61 = 9                                 Schritt 3 */
  
/*   Pr<50>fziffer zu 992 839 871 = 9 */


  printf ("Expires at: %02X/%02X\n", r[11], r[10] );
  printf ("Valid from: %02X.%02X.%02X\n", r[14], r[13], r[12]);
  printf ("Country ..: %02X%02X\n", r[15], r[16]);
  printf ("Currency .: %c%c%c\n", isascii (r[17])? r[17]:' ',
          isascii (r[18])? r[18]:' ', isascii (r[19])? r[19]:' ');
  printf ("Cur.-Mult : %s\n", 
          r[20] == 0x01? "0.01":
          r[20] == 0x02? "0.1":
          r[20] == 0x04? "1":
          r[20] == 0x08? "10":
          r[20] == 0x10? "100":
          r[20] == 0x20? "1000": "?");
  printf ("ZKA ChipID: %02X\n", r[21]);
  printf ("OS version: %02X\n", r[23]);

  xfree (r);
  return 0;
} 



/* Try to figure out the type of teh card and dump its contents. */
static void
dump_other_cards (int slot)
{

  if (!dump_geldkarte (slot))
    return; 

}