pkcs11-display.c

读写Smart卡加解密接口的程序

  { CKA_VALUE_BITS        , "CKA_VALUE_BITS       ", print_generic, NULL },
  { CKA_VALUE_LEN         , "CKA_VALUE_LEN        ", print_generic, NULL },
  { CKA_EXTRACTABLE       , "CKA_EXTRACTABLE      ", print_boolean, NULL },
  { CKA_LOCAL             , "CKA_LOCAL            ", print_boolean, NULL },
  { CKA_NEVER_EXTRACTABLE , "CKA_NEVER_EXTRACTABLE", print_boolean, NULL },
  { CKA_ALWAYS_SENSITIVE  , "CKA_ALWAYS_SENSITIVE ", print_boolean, NULL },
  { CKA_KEY_GEN_MECHANISM , "CKA_KEY_GEN_MECHANISM", print_boolean, NULL },
  { CKA_MODIFIABLE        , "CKA_MODIFIABLE       ", print_boolean, NULL },
  { CKA_EC_PARAMS         , "CKA_EC_PARAMS        ", print_generic, NULL },
  { CKA_EC_POINT          , "CKA_EC_POINT         ", print_generic, NULL },
  { CKA_SECONDARY_AUTH    , "CKA_SECONDARY_AUTH   ", print_generic, NULL },
  { CKA_AUTH_PIN_FLAGS    , "CKA_AUTH_PIN_FLAGS   ", print_generic, NULL },
  { CKA_HW_FEATURE_TYPE   , "CKA_HW_FEATURE_TYPE  ", print_generic, NULL },
  { CKA_RESET_ON_INIT     , "CKA_RESET_ON_INIT    ", print_generic, NULL },
  { CKA_HAS_RESET         , "CKA_HAS_RESET        ", print_generic, NULL }
};

CK_ULONG ck_attribute_num = sizeof(ck_attribute_specs)/sizeof(type_spec);


const char *lookup_enum_spec(enum_spec *spec, CK_ULONG value)
{
  CK_ULONG i;
  for(i = 0; i < spec->size; i++) {
    if(spec->specs[i].type == value) {
      return spec->specs[i].name;
    }
  }
  return NULL;
}

const char *lookup_enum(CK_LONG type, CK_ULONG value)
{
  CK_ULONG i;
  for(i = 0; ck_types[i].type < ( sizeof(ck_types) / sizeof(enum_spec) ) ; i++) {
    if(ck_types[i].type == type) {
      return lookup_enum_spec(&(ck_types[i]), value);
    }
  }
  return NULL;
}

void show_error( FILE *f, char *str, CK_RV rc )
{
  fprintf(f, "%s returned:  %ld %s", str, rc, lookup_enum ( RV_T, rc ));
  fprintf(f, "\n");
}

void print_ck_info(FILE *f, CK_INFO *info)
{
  fprintf(f, "      cryptokiVersion:         %d.%d\n",    info->cryptokiVersion.major, info->cryptokiVersion.minor );
  fprintf(f, "      manufacturerID:         '%32.32s'\n",  info->manufacturerID );
  fprintf(f, "      flags:                   %0lx\n",     info->flags );
  fprintf(f, "      libraryDescription:     '%32.32s'\n",  info->libraryDescription );
  fprintf(f, "      libraryVersion:          %d.%d\n",    info->libraryVersion.major, info->libraryVersion.minor );
}

void print_slot_list(FILE *f, CK_SLOT_ID_PTR pSlotList, CK_ULONG ulCount)
{
  CK_ULONG          i;
  if(pSlotList) {
    for (i = 0; i < ulCount; i++) {
      fprintf(f, "Slot %ld\n", pSlotList[i]);
    }
  } else {
    fprintf(f, "Count is %ld\n", ulCount);
  }
}

void print_slot_info(FILE *f, CK_SLOT_INFO *info)
{
  int            i;
  enum_specs ck_flags[3] = {
    { CKF_TOKEN_PRESENT    , "CKF_TOKEN_PRESENT                " },
    { CKF_REMOVABLE_DEVICE , "CKF_REMOVABLE_DEVICE             " },
    { CKF_HW_SLOT          , "CKF_HW_SLOT                      " },
  };

  fprintf(f, "      slotDescription:        '%32.32s'\n",  info->slotDescription );
  fprintf(f, "                              '%32.32s'\n",  info->slotDescription+32 );
  fprintf(f, "      manufacturerID:         '%32.32s'\n",  info->manufacturerID );
  fprintf(f, "      hardwareVersion:         %d.%d\n",    info->hardwareVersion.major, info->hardwareVersion.minor );
  fprintf(f, "      firmwareVersion:         %d.%d\n",    info->firmwareVersion.major, info->firmwareVersion.minor );
  fprintf(f, "      flags:                   %0lx\n",     info->flags );
  for(i = 0; i < 3; i++) {
    if(info->flags & ck_flags[i].type) {
      fprintf(f, "        %s\n", ck_flags[i].name);
    }
  }
}

void print_token_info(FILE *f, CK_TOKEN_INFO *info)
{
  int            i;
  enum_specs ck_flags[18] = {
    { CKF_RNG                          , "CKF_RNG                          " },
    { CKF_WRITE_PROTECTED              , "CKF_WRITE_PROTECTED              " },
    { CKF_LOGIN_REQUIRED               , "CKF_LOGIN_REQUIRED               " },
    { CKF_USER_PIN_INITIALIZED         , "CKF_USER_PIN_INITIALIZED         " },
    { CKF_RESTORE_KEY_NOT_NEEDED       , "CKF_RESTORE_KEY_NOT_NEEDED       " },
    { CKF_CLOCK_ON_TOKEN               , "CKF_CLOCK_ON_TOKEN               " },
    { CKF_PROTECTED_AUTHENTICATION_PATH, "CKF_PROTECTED_AUTHENTICATION_PATH" },
    { CKF_DUAL_CRYPTO_OPERATIONS       , "CKF_DUAL_CRYPTO_OPERATIONS       " },
    { CKF_TOKEN_INITIALIZED            , "CKF_TOKEN_INITIALIZED            " },
    { CKF_SECONDARY_AUTHENTICATION     , "CKF_SECONDARY_AUTHENTICATION     " },
    { CKF_USER_PIN_COUNT_LOW           , "CKF_USER_PIN_COUNT_LOW           " },
    { CKF_USER_PIN_FINAL_TRY           , "CKF_USER_PIN_FINAL_TRY           " },
    { CKF_USER_PIN_LOCKED              , "CKF_USER_PIN_LOCKED              " },
    { CKF_USER_PIN_TO_BE_CHANGED       , "CKF_USER_PIN_TO_BE_CHANGED       " },
    { CKF_SO_PIN_COUNT_LOW             , "CKF_SO_PIN_COUNT_LOW             " },
    { CKF_SO_PIN_FINAL_TRY             , "CKF_SO_PIN_FINAL_TRY             " },
    { CKF_SO_PIN_LOCKED                , "CKF_SO_PIN_LOCKED                " },
    { CKF_SO_PIN_TO_BE_CHANGED         , "CKF_SO_PIN_TO_BE_CHANGED         " }
  };

  fprintf(f, "      label:                  '%32.32s'\n",  info->label );
  fprintf(f, "      manufacturerID:         '%32.32s'\n",  info->manufacturerID );
  fprintf(f, "      model:                  '%16.16s'\n",  info->model );
  fprintf(f, "      serialNumber:           '%16.16s'\n",  info->serialNumber );
  fprintf(f, "      ulMaxSessionCount:       %ld\n",       info->ulMaxSessionCount );
  fprintf(f, "      ulSessionCount:          %ld\n",       info->ulSessionCount );
  fprintf(f, "      ulMaxRwSessionCount:     %ld\n",       info->ulMaxRwSessionCount );
  fprintf(f, "      ulRwSessionCount:        %ld\n",       info->ulRwSessionCount );
  fprintf(f, "      ulMaxPinLen:             %ld\n",       info->ulMaxPinLen );
  fprintf(f, "      ulMinPinLen:             %ld\n",       info->ulMinPinLen );
  fprintf(f, "      ulTotalPublicMemory:     %ld\n",       info->ulTotalPublicMemory );
  fprintf(f, "      ulFreePublicMemory:      %ld\n",       info->ulFreePublicMemory );
  fprintf(f, "      ulTotalPrivateMemory:    %ld\n",       info->ulTotalPrivateMemory );
  fprintf(f, "      ulFreePrivateMemory:     %ld\n",       info->ulFreePrivateMemory );
  fprintf(f, "      hardwareVersion:         %d.%d\n",     info->hardwareVersion.major, info->hardwareVersion.minor );
  fprintf(f, "      firmwareVersion:         %d.%d\n",     info->firmwareVersion.major, info->firmwareVersion.minor );
  fprintf(f, "      time:                   '%16.16s'\n",  info->utcTime );
  fprintf(f, "      flags:                   %0lx\n",      info->flags );
  for(i = 0; i < 8; i++) {
    if(info->flags & ck_flags[i].type) {
      fprintf(f, "        %s\n", ck_flags[i].name);
    }
  }
}

void print_mech_list(FILE *f, CK_MECHANISM_TYPE_PTR pMechanismList,
		     CK_ULONG ulMechCount)
{
  CK_ULONG          imech;
  if(pMechanismList) {
    for (imech = 0; imech < ulMechCount; imech++) {
      const char *name = lookup_enum(MEC_T, pMechanismList[imech]);
      if (name) {
	fprintf(f, "%30s \n", name);
      } else {
	fprintf(f, " Unknown Mechanism (%08lx)  \n", pMechanismList[imech]);
      }
    }
  } else {
    fprintf(f, "Count is %ld\n", ulMechCount);
  }
}

void print_mech_info(FILE *f, CK_MECHANISM_TYPE type,
		     CK_MECHANISM_INFO_PTR minfo)
{
  const char *name = lookup_enum(MEC_T, type);
  CK_ULONG known_flags = CKF_HW|CKF_ENCRYPT|CKF_DECRYPT|CKF_DIGEST|
    CKF_SIGN|CKF_SIGN_RECOVER|CKF_VERIFY|CKF_VERIFY_RECOVER|
    CKF_GENERATE|CKF_GENERATE_KEY_PAIR|CKF_WRAP|CKF_UNWRAP|
    CKF_DERIVE;
    
#if 0
  if (name) {
    fprintf(f, "%30s ", name);
  } else {
    fprintf(f, " Unknown Mechanism (%08lx)  ", type);
  }
  fprintf(f, "min:%6lu  max:%6lu  flags:0x%08lX  \n",
	  minfo->ulMinKeySize, minfo->ulMaxKeySize, minfo->flags);
  printf("  flags:  %s%s%s%s%s%s%s%s%s%s%s%s%s%s\n",
#else
  if (name) {
    fprintf(f, "%s : ", name);
  } else {
    fprintf(f, "Unknown Mechanism (%08lx) : ", type);
  }
  fprintf(f, "min:%lu max:%lu flags:0x%lX ",
	  minfo->ulMinKeySize, minfo->ulMaxKeySize, minfo->flags);
  printf("( %s%s%s%s%s%s%s%s%s%s%s%s%s%s)\n",
#endif
	 (minfo->flags & CKF_HW)                ? "Hardware " : "",
	 (minfo->flags & CKF_ENCRYPT)           ? "Encrypt "  : "",
	 (minfo->flags & CKF_DECRYPT)           ? "Decrypt "  : "",
	 (minfo->flags & CKF_DIGEST)            ? "Digest "   : "",
	 (minfo->flags & CKF_SIGN)              ? "Sign "     : "",
	 (minfo->flags & CKF_SIGN_RECOVER)      ? "SigRecov " : "",
	 (minfo->flags & CKF_VERIFY)            ? "Verify "   : "",
	 (minfo->flags & CKF_VERIFY_RECOVER)    ? "VerRecov " : "",
	 (minfo->flags & CKF_GENERATE)          ? "Generate " : "",
	 (minfo->flags & CKF_GENERATE_KEY_PAIR) ? "KeyPair "  : "",
	 (minfo->flags & CKF_WRAP)              ? "Wrap "     : "",
	 (minfo->flags & CKF_UNWRAP)            ? "Unwrap "   : "",
	 (minfo->flags & CKF_DERIVE)            ? "Derive "   : "",
	 (minfo->flags & ~known_flags)          ? "Unknown "  : "");
}

void print_attribute_list(FILE *f, CK_ATTRIBUTE_PTR pTemplate,
			  CK_ULONG  ulCount)
{
  CK_ULONG j, k;
  for(j = 0; j < ulCount ; j++) {
    for(k = 0; k < ck_attribute_num; k++) {
      if(ck_attribute_specs[k].type == pTemplate[j].type) {
	fprintf(f, "    %s ", ck_attribute_specs[k].name);
	if(pTemplate[j].pValue) {
	  ck_attribute_specs[k].display
	    (f, pTemplate[j].type, pTemplate[j].pValue,
	     pTemplate[j].ulValueLen,
	     ck_attribute_specs[k].arg);
	} else {
	  fprintf(f, "has size %ld\n", pTemplate[j].ulValueLen); 
	}
	k = ck_attribute_num;
      }
    }
  }
}

void print_attribute_list_req(FILE *f, CK_ATTRIBUTE_PTR pTemplate,
			      CK_ULONG  ulCount)
{
  CK_ULONG j, k;
  for(j = 0; j < ulCount ; j++) {
    for(k = 0; k < ck_attribute_num; k++) {
      if(ck_attribute_specs[k].type == pTemplate[j].type) {
	fprintf(f, "    %s ", ck_attribute_specs[k].name);
	fprintf(f, "requested with %ld buffer\n", pTemplate[j].ulValueLen); 
	k = ck_attribute_num;
      }
    }
  }
}

void print_session_info(FILE *f, CK_SESSION_INFO *info)
{
  int            i;
  enum_specs ck_flags[2] = {
    { CKF_RW_SESSION     , "CKF_RW_SESSION                   " },
    { CKF_SERIAL_SESSION , "CKF_SERIAL_SESSION               " }
  };

  fprintf(f, "      slotID:                  %ld\n",       info->slotID );
  fprintf(f, "      state:                  '%32.32s'\n",  lookup_enum(STA_T, info->state));
  fprintf(f, "      flags:                   %0lx\n",     info->flags );
  for(i = 0; i < 2; i++) {
    if(info->flags & ck_flags[i].type) {
      fprintf(f, "        %s\n", ck_flags[i].name);
    }
  }
  fprintf(f, "      ulDeviceError:           %0lx\n",     info->ulDeviceError );
}