/* This program provides examples of how to use the MDS and CSSM services of
   CDSA.  It follows the descriptions and code fragments from the "Intel
   Common Data Security Architecture Application Developer's Guide".
 */

#include <cssm.h>	     /* Basic include file for all CSSM headers */
#include <cssmtype.h>	     /* Operating system dependent declarations */
#include <cssmerr.h>	     /* CDSA CSSM Error codes */
#include <cssmapi.h>	     /* CDSA API prototypes */
#include <mds.h>	     /* MDS API prototypes & declarations */
#include <mds_util_api.h>    /* MDSUTIL API prototypes & declarations */
#include <mds_util_helper.h> /* MDSUTIL helper API prototypes & declarations */
#include <stdio.h>	     /* UNIX 'Standard I/O' Definitions */
#include <stdlib.h>	     /* General utility definitions */
#include <string.h>	     /* String handling function definitions */

static char strbuf[1024];

/* Prototype for routine to print CDSA errors */
void Print_CDSA_Error(CSSM_RETURN Error_Code);

/*
 * GUIDToStr -	Converts a Globally Unique Id (GUID) to a printable string
 *
 * Returns:	A pointer to the printable string.
 *
 * Parameters:	pGUID - A pointer to a GUID
 */
static const char *GUIDToStr(const CSSM_GUID *pGUID)
{
  sprintf( strbuf, "{%08x-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x}",
           pGUID->Data1,
           pGUID->Data2, pGUID->Data3,
           pGUID->Data4[0], pGUID->Data4[1],
           pGUID->Data4[2], pGUID->Data4[3], pGUID->Data4[4],
           pGUID->Data4[5], pGUID->Data4[6], pGUID->Data4[7] );

  return strbuf;
}

/*
 * ServiceTypeToStr - Converts a CSSM_SERVICE_TYPE to a printable string
 *
 * Returns:	A pointer to the printable string.
 *
 * Parameters:	ServiceType - a CSSM_SERVICE_TYPE to convert
 */
static const char *ServiceTypeToStr(CSSM_SERVICE_TYPE ServiceType)
{
  switch (ServiceType) {
  case CSSM_SERVICE_CSSM:
        return "CSSM_SERVICE_CSSM";
  case CSSM_SERVICE_CSP:
        return "CSSM_SERVICE_CSP";
  case CSSM_SERVICE_DL:
        return "CSSM_SERVICE_DL";
  case CSSM_SERVICE_CL:
        return "CSSM_SERVICE_CL";
  case CSSM_SERVICE_TP:
        return "CSSM_SERVICE_TP";
  case CSSM_SERVICE_AC:
        return "CSSM_SERVICE_AC";
  }

  sprintf(strbuf, "unknown CSSM_SERVICE_TYPE 0x%x", ServiceType);

  return strbuf;
}

/*
 * Decode_Context_Type - Prints the string value of a Context Type
 *
 * Returns:	None (void)
 *
 * Parameters:	pCapability - a CSSM_CONTEXT_PTR.
 */
void Decode_Context_Type(pCapability)
  CSSM_CONTEXT_PTR pCapability;
{
  switch (pCapability->ContextType)
  {
    case CSSM_ALGCLASS_CUSTOM :
    {
      printf("        Context Type: CSSM_ALGCLASS_CUSTOM\n");
    }
    break;
    case CSSM_ALGCLASS_SIGNATURE :
    {
      printf("        Context Type: CSSM_ALGCLASS_SIGNATURE\n");
    }
    break;
    case CSSM_ALGCLASS_SYMMETRIC :
    {
      printf("        Context Type: CSSM_ALGCLASS_SYMMETRIC\n");
    }
    break;
    case CSSM_ALGCLASS_DIGEST :
    {
      printf("        Context Type: CSSM_ALGCLASS_DIGEST\n");
    }
    break;
    case CSSM_ALGCLASS_RANDOMGEN :
    {
      printf("        Context Type: CSSM_ALGCLASS_RANDOMGEN\n");
    }
    break;
    case CSSM_ALGCLASS_UNIQUEGEN :
    {
      printf("        Context Type: CSSM_ALGCLASS_UNIQUEGEN\n");
    }
    break;
    case CSSM_ALGCLASS_MAC :
    {
      printf("        Context Type: CSSM_ALGCLASS_MAC\n");
    }
    break;
    case CSSM_ALGCLASS_ASYMMETRIC :
    {
      printf("        Context Type: CSSM_ALGCLASS_ASYMMETRIC\n");
    }
    break;
    case CSSM_ALGCLASS_KEYGEN :
    {
      printf("        Context Type: CSSM_ALGCLASS_KEYGEN\n");
    }
    break;
    case CSSM_ALGCLASS_DERIVEKEY :
    {
      printf("        Context Type: CSSM_ALGCLASS_DERIVEKEY\n");
    }
    break;
    default :
    {
      printf( "        Unknown Context Type: %x\n",
	      pCapability->ContextType );
    }
  }
}

/*
 * Decode_Algorithm_Type - Prints the string value of an Algorithm Type
 *
 * Returns:	None (void)
 *
 * Parameters:	pCapability - a CSSM_CONTEXT_PTR.
 */
void Decode_Algorithm_Type(pCapability)
  CSSM_CONTEXT_PTR pCapability;
{
  switch (pCapability->AlgorithmType)
  {
    case CSSM_ALGID_CUSTOM :
    {
      printf("        Algorithm Type: CSSM_ALGID_CUSTOM\n");
    }
    break;
    case CSSM_ALGID_DH :
    {
      printf("        Algorithm Type: CSSM_ALGID_DH\n");
    }
    break;
    case CSSM_ALGID_PH :
    {
      printf("        Algorithm Type: CSSM_ALGID_PH\n");
    }
    break;
    case CSSM_ALGID_KEA :
    {
      printf("        Algorithm Type: CSSM_ALGID_KEA\n");
    }
    break;
    case CSSM_ALGID_MD2 :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD2\n");
    }
    break;
    case CSSM_ALGID_MD4 :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD4\n");
    }
    break;
    case CSSM_ALGID_MD5 :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD5\n");
    }
    break;
    case CSSM_ALGID_SHA1 :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHA1\n");
    }
    break;
    case CSSM_ALGID_NHASH :
    {
      printf("        Algorithm Type: CSSM_ALGID_NHASH\n");
    }
    break;
    case CSSM_ALGID_HAVAL :
    {
      printf("        Algorithm Type: CSSM_ALGID_HAVAL\n");
    }
    break;
    case CSSM_ALGID_RIPEMD :
    {
      printf("        Algorithm Type: CSSM_ALGID_RIPEMD\n");
    }
    break;
    case CSSM_ALGID_IBCHASH :
    {
      printf("        Algorithm Type: CSSM_ALGID_IBCHASH\n");
    }
    break;
    case CSSM_ALGID_RIPEMAC :
    {
      printf("        Algorithm Type: CSSM_ALGID_RIPEMAC\n");
    }
    break;
    case CSSM_ALGID_DES :
    {
      printf("        Algorithm Type: CSSM_ALGID_DES\n");
    }
    break;
    case CSSM_ALGID_DESX :
    {
      printf("        Algorithm Type: CSSM_ALGID_DESX\n");
    }
    break;
    case CSSM_ALGID_RDES :
    {
      printf("        Algorithm Type: CSSM_ALGID_RDES\n");
    }
    break;
    case CSSM_ALGID_3DES_3KEY_EDE :
    {
      printf("        Algorithm Type: CSSM_ALGID_3DES_3KEY_EDE/CSSM_ALGID_3DES_3KEY\n");
    }
    break;
    case CSSM_ALGID_3DES_2KEY_EDE :
    {
      printf("        Algorithm Type: CSSM_ALGID_3DES_2KEY_EDE/CSSM_ALGID_3DES_2KEY\n");
    }
    break;
    case CSSM_ALGID_3DES_1KEY_EEE :
    {
      printf("        Algorithm Type: CSSM_ALGID_3DES_1KEY_EEE\n");
    }
    break;
    case CSSM_ALGID_3DES_3KEY_EEE :
    {
      printf("        Algorithm Type: CSSM_ALGID_3DES_3KEY_EEE\n");
    }
    break;
    case CSSM_ALGID_3DES_2KEY_EEE :
    {
      printf("        Algorithm Type: CSSM_ALGID_3DES_2KEY_EEE\n");
    }
    break;
    case CSSM_ALGID_IDEA :
    {
      printf("        Algorithm Type: CSSM_ALGID_IDEA\n");
    }
    break;
    case CSSM_ALGID_RC2 :
    {
      printf("        Algorithm Type: CSSM_ALGID_RC2\n");
    }
    break;
    case CSSM_ALGID_RC4 :
    {
      printf("        Algorithm Type: CSSM_ALGID_RC4\n");
    }
    break;
    case CSSM_ALGID_RC5 :
    {
      printf("        Algorithm Type: CSSM_ALGID_RC5\n");
    }
    break;
    case CSSM_ALGID_SEAL :
    {
      printf("        Algorithm Type: CSSM_ALGID_SEAL\n");
    }
    break;
    case CSSM_ALGID_CAST :
    {
      printf("        Algorithm Type: CSSM_ALGID_CAST\n");
    }
    break;
    case CSSM_ALGID_BLOWFISH :
    {
      printf("        Algorithm Type: CSSM_ALGID_BLOWFISH\n");
    }
    break;
    case CSSM_ALGID_SKIPJACK :
    {
      printf("        Algorithm Type: CSSM_ALGID_SKIPJACK\n");
    }
    break;
    case CSSM_ALGID_LUCIFER :
    {
      printf("        Algorithm Type: CSSM_ALGID_LUCIFER\n");
    }
    break;
    case CSSM_ALGID_MADRYGA :
    {
      printf("        Algorithm Type: CSSM_ALGID_MADRYGA\n");
    }
    break;
    case CSSM_ALGID_FEAL :
    {
      printf("        Algorithm Type: CSSM_ALGID_FEAL\n");
    }
    break;
    case CSSM_ALGID_REDOC :
    {
      printf("        Algorithm Type: CSSM_ALGID_REDOC\n");
    }
    break;
    case CSSM_ALGID_REDOC3 :
    {
      printf("        Algorithm Type: CSSM_ALGID_REDOC3\n");
    }
    break;
    case CSSM_ALGID_LOKI :
    {
      printf("        Algorithm Type: CSSM_ALGID_LOKI\n");
    }
    break;
    case CSSM_ALGID_KHUFU :
    {
      printf("        Algorithm Type: CSSM_ALGID_KHUFU\n");
    }
    break;
    case CSSM_ALGID_KHAFRE :
    {
      printf("        Algorithm Type: CSSM_ALGID_KHAFRE\n");
    }
    break;
    case CSSM_ALGID_MMB :
    {
      printf("        Algorithm Type: CSSM_ALGID_MMB\n");
    }
    break;
    case CSSM_ALGID_GOST :
    {
      printf("        Algorithm Type: CSSM_ALGID_GOST\n");
    }
    break;
    case CSSM_ALGID_SAFER :
    {
      printf("        Algorithm Type: CSSM_ALGID_SAFER\n");
    }
    break;
    case CSSM_ALGID_CRAB :
    {
      printf("        Algorithm Type: CSSM_ALGID_CRAB\n");
    }
    break;
    case CSSM_ALGID_RSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_RSA\n");
    }
    break;
    case CSSM_ALGID_DSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_DSA\n");
    }
    break;
    case CSSM_ALGID_MD5WithRSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD5WithRSA\n");
    }
    break;
    case CSSM_ALGID_MD2WithRSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD2WithRSA\n");
    }
    break;
    case CSSM_ALGID_ElGamal :
    {
      printf("        Algorithm Type: CSSM_ALGID_ElGamal\n");
    }
    break;
    case CSSM_ALGID_MD2Random :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD2Random\n");
    }
    break;
    case CSSM_ALGID_MD5Random :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD5Random\n");
    }
    break;
    case CSSM_ALGID_SHARandom :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHARandom\n");
    }
    break;
    case CSSM_ALGID_DESRandom :
    {
      printf("        Algorithm Type: CSSM_ALGID_DESRandom\n");
    }
    break;
    case CSSM_ALGID_SHA1WithRSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHA1WithRSA\n");
    }
    break;
    case CSSM_ALGID_CDMF :
    {
      printf("        Algorithm Type: CSSM_ALGID_CDMF\n");
    }
    break;
    case CSSM_ALGID_CAST3 :
    {
      printf("        Algorithm Type: CSSM_ALGID_CAST3\n");
    }
    break;
    case CSSM_ALGID_CAST5 :
    {
      printf("        Algorithm Type: CSSM_ALGID_CAST5\n");
    }
    break;
    case CSSM_ALGID_GenericSecret :
    {
      printf("        Algorithm Type: CSSM_ALGID_GenericSecret\n");
    }
    break;
    case CSSM_ALGID_ConcatBaseAndKey :
    {
      printf("        Algorithm Type: CSSM_ALGID_ConcatBaseAndKey\n");
    }
    break;
    case CSSM_ALGID_ConcatKeyAndBase :
    {
      printf("        Algorithm Type: CSSM_ALGID_ConcatKeyAndBase\n");
    }
    break;
    case CSSM_ALGID_ConcatBaseAndData :
    {
      printf("        Algorithm Type: CSSM_ALGID_ConcatBaseAndData\n");
    }
    break;
    case CSSM_ALGID_ConcatDataAndBase :
    {
      printf("        Algorithm Type: CSSM_ALGID_ConcatDataAndBase\n");
    }
    break;
    case CSSM_ALGID_XORBaseAndData :
    {
      printf("        Algorithm Type: CSSM_ALGID_XORBaseAndData\n");
    }
    break;
    case CSSM_ALGID_ExtractFromKey :
    {
      printf("        Algorithm Type: CSSM_ALGID_ExtractFromKey\n");
    }
    break;
    case CSSM_ALGID_SSL3PreMasterGen :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3PreMasterGen\n");
    }
    break;
    case CSSM_ALGID_SSL3MasterDerive :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3MasterDerive\n");
    }
    break;
    case CSSM_ALGID_SSL3KeyAndMacDerive :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3KeyAndMacDerive\n");
    }
    break;
    case CSSM_ALGID_SSL3MD5_MAC :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3MD5_MAC\n");
    }
    break;
    case CSSM_ALGID_SSL3SHA1_MAC :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3SHA1_MAC\n");
    }
    break;
    case CSSM_ALGID_PKCS5_PBKDF1_MD5 :
    {
      printf("        Algorithm Type: CSSM_ALGID_PKCS5_PBKDF1_MD5\n");
    }
    break;
    case CSSM_ALGID_PKCS5_PBKDF1_MD2 :
    {
      printf("        Algorithm Type: CSSM_ALGID_PKCS5_PBKDF1_MD2\n");
    }
    break;
    case CSSM_ALGID_PKCS5_PBKDF1_SHA1 :
    {
      printf("        Algorithm Type: CSSM_ALGID_PKCS5_PBKDF1_SHA1\n");
    }
    break;
    case CSSM_ALGID_WrapLynks :
    {
      printf("        Algorithm Type: CSSM_ALGID_WrapLynks\n");
    }
    break;
    case CSSM_ALGID_WrapSET_OAEP :
    {
      printf("        Algorithm Type: CSSM_ALGID_WrapSET_OAEP\n");
    }
    break;
    case CSSM_ALGID_BATON :
    {
      printf("        Algorithm Type: CSSM_ALGID_BATON\n");
    }
    break;
    case CSSM_ALGID_ECDSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECDSA\n");
    }
    break;
    case CSSM_ALGID_MAYFLY :
    {
      printf("        Algorithm Type: CSSM_ALGID_MAYFLY\n");
    }
    break;
    case CSSM_ALGID_JUNIPER :
    {
      printf("        Algorithm Type: CSSM_ALGID_JUNIPER\n");
    }
    break;
    case CSSM_ALGID_FASTHASH :
    {
      printf("        Algorithm Type: CSSM_ALGID_FASTHASH\n");
    }
    break;
    case CSSM_ALGID_3DES :
    {
      printf("        Algorithm Type: CSSM_ALGID_3DES\n");
    }
    break;
    case CSSM_ALGID_SSL3MD5 :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3MD5\n");
    }
    break;
    case CSSM_ALGID_SSL3SHA1 :
    {
      printf("        Algorithm Type: CSSM_ALGID_SSL3SHA1\n");
    }
    break;
    case CSSM_ALGID_FortezzaTimestamp :
    {
      printf("        Algorithm Type: CSSM_ALGID_FortezzaTimestamp\n");
    }
    break;
    case CSSM_ALGID_SHA1WithDSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHA1WithDSA\n");
    }
    break;
    case CSSM_ALGID_SHA1WithECDSA :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHA1WithECDSA\n");
    }
    break;
    case CSSM_ALGID_DSA_BSAFE :
    {
      printf("        Algorithm Type: CSSM_ALGID_DSA_BSAFE\n");
    }
    break;
    case CSSM_ALGID_ECDH :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECDH\n");
    }
    break;
    case CSSM_ALGID_ECMQV :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECMQV\n");
    }
    break;
    case CSSM_ALGID_PKCS12_SHA1_PBE :
    {
      printf("        Algorithm Type: CSSM_ALGID_PKCS12_SHA1_PBE\n");
    }
    break;
    case CSSM_ALGID_ECNRA :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECNRA\n");
    }
    break;
    case CSSM_ALGID_SHA1WithECNRA :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHA1WithECNRA\n");
    }
    break;
    case CSSM_ALGID_ECES :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECES\n");
    }
    break;
    case CSSM_ALGID_ECAES :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECAES\n");
    }
    break;
    case CSSM_ALGID_SHA1HMAC :
    {
      printf("        Algorithm Type: CSSM_ALGID_SHA1HMAC\n");
    }
    break;
    case CSSM_ALGID_FIPS186Random :
    {
      printf("        Algorithm Type: CSSM_ALGID_FIPS186Random\n");
    }
    break;
    case CSSM_ALGID_ECC :
    {
      printf("        Algorithm Type: CSSM_ALGID_ECC\n");
    }
    break;
    case CSSM_ALGID_MQV :
    {
      printf("        Algorithm Type: CSSM_ALGID_MQV\n");
    }
    break;
    case CSSM_ALGID_NRA :
    {
      printf("        Algorithm Type: CSSM_ALGID_NRA\n");
    }
    break;
    case CSSM_ALGID_IntelPlatformRandom :
    {
      printf("        Algorithm Type: CSSM_ALGID_IntelPlatformRandom\n");
    }
    break;
    case CSSM_ALGID_UTC :
    {
      printf("        Algorithm Type: CSSM_ALGID_UTC\n");
    }
    break;
    case CSSM_ALGID_HAVAL3 :
    {
      printf("        Algorithm Type: CSSM_ALGID_HAVAL3\n");
    }
    break;
    case CSSM_ALGID_HAVAL4 :
    {
      printf("        Algorithm Type: CSSM_ALGID_HAVAL4\n");
    }
    break;
    case CSSM_ALGID_HAVAL5 :
    {
      printf("        Algorithm Type: CSSM_ALGID_HAVAL5\n");
    }
    break;
    case CSSM_ALGID_TIGER :
    {
      printf("        Algorithm Type: CSSM_ALGID_TIGER\n");
    }
    break;
    case CSSM_ALGID_MD5HMAC :
    {
      printf("        Algorithm Type: CSSM_ALGID_MD5HMAC\n");
    }
    break;
    case CSSM_ALGID_PKCS5_PBKDF2 :
    {
      printf("        Algorithm Type: CSSM_ALGID_PKCS5_PBKDF2\n");
    }
    break;
    case CSSM_ALGID_RUNNING_COUNTER :
    {
      printf("        Algorithm Type: CSSM_ALGID_RUNNING_COUNTER\n");
    }
    break;
    default :
    {
      printf( "        Unknown Algorithm Type: %x\n",
	      pCapability->AlgorithmType );
    }
  }
}

/*
 * Decode_Attribute_Type - Prints the string value of an Attribute Type
 *
 * Returns:	None (void)
 *
 * Parameters:	pAttributes - a CSSM_CONTEXT_ATTRIBUTE_PTR.
 *		iAttribute  - an index into the pAttributes array
 */
void Decode_Attribute_Type(pAttributes,iAttribute)
  CSSM_CONTEXT_ATTRIBUTE_PTR pAttributes;
  uint32 iAttribute;
{
  switch (pAttributes[iAttribute].AttributeType)
  {
    case CSSM_ATTRIBUTE_CUSTOM :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_CUSTOM\n");
    }
    break;
    case CSSM_ATTRIBUTE_DESCRIPTION :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_DESCRIPTION\n");
    }
    break;
    case CSSM_ATTRIBUTE_KEY :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KEY\n");
    }
    break;
    case CSSM_ATTRIBUTE_INIT_VECTOR :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_INIT_VECTOR\n");
    }
    break;
    case CSSM_ATTRIBUTE_SALT :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_SALT\n");
    }
    break;
    case CSSM_ATTRIBUTE_PADDING :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_PADDING\n");
    }
    break;
    case CSSM_ATTRIBUTE_RANDOM :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_RANDOM\n");
    }
    break;
    case CSSM_ATTRIBUTE_SEED :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_SEED\n");
    }
    break;
    case CSSM_ATTRIBUTE_PASSPHRASE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_PASSPHRASE\n");
    }
    break;
    case CSSM_ATTRIBUTE_KEY_LENGTH :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KEY_LENGTH\n");
    }
    break;
    case CSSM_ATTRIBUTE_KEY_LENGTH_RANGE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KEY_LENGTH_RANGE\n");
    }
    break;
    case CSSM_ATTRIBUTE_BLOCK_SIZE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_BLOCK_SIZE\n");
    }
    break;
    case CSSM_ATTRIBUTE_OUTPUT_SIZE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_OUTPUT_SIZE\n");
    }
    break;
    case CSSM_ATTRIBUTE_ROUNDS :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ROUNDS\n");
    }
    break;
    case CSSM_ATTRIBUTE_IV_SIZE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_IV_SIZE\n");
    }
    break;
    case CSSM_ATTRIBUTE_ALG_PARAMS :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ALG_PARAMS\n");
    }
    break;
    case CSSM_ATTRIBUTE_LABEL :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_LABEL\n");
    }
    break;
    case CSSM_ATTRIBUTE_KEY_TYPE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KEY_TYPE\n");
    }
    break;
    case CSSM_ATTRIBUTE_MODE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ALG_MODE\n");
    }
    break;
    case CSSM_ATTRIBUTE_EFFECTIVE_BITS :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_EFFECTIVE_BITS\n");
    }
    break;
    case CSSM_ATTRIBUTE_START_DATE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_START_DATE\n");
    }
    break;
    case CSSM_ATTRIBUTE_END_DATE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_END_DATE\n");
    }
    break;
    case CSSM_ATTRIBUTE_KEYUSAGE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KEYUSAGE\n");
    }
    break;
    case CSSM_ATTRIBUTE_KEYATTR :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KEYATTR\n");
    }
    break;
    case CSSM_ATTRIBUTE_VERSION :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_VERSION\n");
    }
    break;
    case CSSM_ATTRIBUTE_PRIME :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_PRIME\n");
    }
    break;
    case CSSM_ATTRIBUTE_BASE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_BASE\n");
    }
    break;
    case CSSM_ATTRIBUTE_SUBPRIME :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_SUBPRIME\n");
    }
    break;
    case CSSM_ATTRIBUTE_ALG_ID :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ALG_ID\n");
    }
    break;
    case CSSM_ATTRIBUTE_ITERATION_COUNT :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ITERATION_COUNT\n");
    }
    break;
    case CSSM_ATTRIBUTE_ROUNDS_RANGE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ROUNDS_RANGE\n");
    }
    break;
    case CSSM_ATTRIBUTE_CSP_HANDLE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_CSP_HANDLE\n");
    }
    break;
    case CSSM_ATTRIBUTE_DL_DB_HANDLE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_DL_DB_HANDLE\n");
    }
    break;
    case CSSM_ATTRIBUTE_ACCESS_CREDENTIALS :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_ACCESS_CREDENTIALS\n");
    }
    break;
    case CSSM_ATTRIBUTE_PUBLIC_KEY_FORMAT :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_PUBLIC_KEY_FORMAT\n");
    }
    break;
    case CSSM_ATTRIBUTE_PRIVATE_KEY_FORMAT :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_PRIVATE_KEY_FORMAT\n");
    }
    break;
    case CSSM_ATTRIBUTE_SYMMETRIC_KEY_FORMAT :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_SYMMETRIC_KEY_FORMAT\n");
    }
    break;
    case CSSM_ATTRIBUTE_WRAPPED_KEY_FORMAT :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_WRAPPED_KEY_FORMAT\n");
    }
    break;
    case CSSM_ATTRIBUTE_KRPROFILE_LOCAL :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KRPROFILE_LOCAL\n");
    }
    break;
    case CSSM_ATTRIBUTE_KRPROFILE_REMOTE :
    {
      printf("            Attribute Type: CSSM_ATTRIBUTE_KRPROFILE_REMOTE\n");
    }
    break;
    default :
    {
      printf( "            Unknown Attribute Type: %x\n",
	      pAttributes[iAttribute].AttributeType );
    }
  }
}

main (argc, argv)
  int argc;
  char **argv;
{
  CSSM_RETURN		Return_value;
  MDSUTIL_LIST_PTR	pCSPModuleList = NULL;
  static const CSSM_API_MEMORY_FUNCS	MemoryFunctions = { _MDSUTIL_malloc,
							    _MDSUTIL_free,
							    _MDSUTIL_realloc,
							    _MDSUTIL_calloc,
							    NULL };

  printf("\n");
  Return_value = MDSUTIL_Init();
  if (Return_value == CSSM_OK)
  {
  /* Get a list of CSP service provider modules */
    Return_value = MDSUTIL_ListModules( CSSM_SERVICE_CSP,
					CSSM_FALSE,
					&pCSPModuleList );
    if (Return_value != CSSM_OK)
    {
      printf("MDSUTIL_ListModules returned error\n");
      Print_CDSA_Error(Return_value);
    }
  }
  else {
    printf("MDSUTIL_Init returned error\n");
    Print_CDSA_Error(Return_value);
  }
  if (Return_value == CSSM_OK)
  {
    if (pCSPModuleList->NumberItems == 0)
    {
      printf("No CSP modules are available\n");
    }
    else
    {
      CSSM_VERSION version;
      CSSM_PVC_MODE policy = CSSM_PVC_SP;	/* check service providers */
      CSSM_GUID myApplication_guid;

      version.Major = CSSM_MAJOR;
      version.Minor = CSSM_MINOR;
    /* Initialize the CSSM - must be done before calling any other CSSM API. */
      Return_value = CSSM_Init( &version,
				CSSM_PRIVILEGE_SCOPE_NONE,
				NULL,			 /* caller guid */
				CSSM_KEY_HIERARCHY_NONE, /* let CSSM choose hierarchy */
				&policy,		 /* pvc policy  */
				0 );			 /* reserved    */
      if (Return_value != CSSM_OK)
      {
	if (Return_value != CSSMERR_CSSM_PVC_ALREADY_CONFIGURED)
	{
	  printf("Error initializing CSSM\n");
	  Print_CDSA_Error(Return_value);
	}
      }
    }
  }
  if (Return_value == CSSM_OK)
  {
    unsigned int iModule;

  /* For each module, get a list of services */
    for ( iModule = 0;
	  iModule < pCSPModuleList->NumberItems;
	  iModule++ )
    {
      MDSUTIL_MODULE_INFO_PTR pInfo = NULL;

      printf("");
      printf( "Module %d) Name: %s\n",
	      iModule,
	      pCSPModuleList->Items[iModule].Name );
      Return_value = MDSUTIL_GetModuleInfo( &(pCSPModuleList->Items[iModule].SubserviceUid.Guid),
					    CSSM_SERVICE_CSP,
					    pCSPModuleList->Items[iModule].SubserviceUid.SubserviceId,
					    CSSM_USEE_NONE,
					    &pInfo );
      if (Return_value != CSSM_OK)
      {
	printf("Error getting module info\n");
	Print_CDSA_Error(Return_value);
      }
      else
      {	/* For each service, get a list of subservices */
	unsigned int iService,iSubService;

	printf( "Module %d) ModuleGuid: %s\n",
		iModule,
		GUIDToStr(&pInfo->ModuleGuid) );
	printf( "Module %d) Version: %d.%d\n",
		iModule,
		pInfo->Version.Major,pInfo->Version.Minor );
	printf( "Module %d) CompatibleCSSMVersion: %d.%d\n",
		iModule,
		pInfo->CompatibleCSSMVersion.Major,
		pInfo->CompatibleCSSMVersion.Minor );
	printf( "Module %d) Description: %s\n",
		iModule,
		pInfo->Description );
	printf( "Module %d) Vendor: %s\n",
		iModule,
		pInfo->Vendor );
	printf( "Module %d) Flags: 0x%x\n",
		iModule,
		pInfo->Flags );
	printf( "Module %d) ServiceMask: 0x%x\n",
		iModule,
		pInfo->ServiceMask );

	for (iService = 0;
	     iService < pInfo->NumberOfServices;
	     iService++ )
	{
	  MDSUTIL_SERVICE_INFO_PTR pServiceInfo;

	  pServiceInfo = &pInfo->ServiceList[iService];
	  printf( "  Service %d) Description: %s\n",
		  iService,
		  pServiceInfo->Description );
	  printf( "  Service %d) Type: %s\n",
		  iService,
		  ServiceTypeToStr(pServiceInfo->Type) );
	  printf( "  Service %d) Flags: 0x%x\n",
		  iService,
		  pServiceInfo->Flags );
	  for (iSubService = 0;
	       iSubService < pServiceInfo->NumberOfSubServices;
	       iSubService++ )
	  {
	    MDSUTIL_CSPSUBSERVICE_PTR pSubService;
	    MDSUTIL_SUBSERVICE_LIST_PTR pSubService1;
	    unsigned int numCapabilities = 0;
	    CSSM_CONTEXT_PTR capabilityList;
	    unsigned int iCapability;

	    pSubService1 = &pServiceInfo->SubServiceList[iSubService];
	    printf( "    SubService %d) ModuleType: %d\n",
		    iSubService,
		    pSubService1->ModuleType );
	    printf( "    SubService %d) SubServiceId: %d\n",
		    iSubService,
		    pSubService1->SubServiceId );
	    pSubService = (MDSUTIL_CSPSUBSERVICE_PTR) pServiceInfo->SubServiceList[iSubService].SubServiceInfo;
	  /* For each subservice, get a list of capabilities */
	    if (pSubService->CspType == CSSM_CSP_SOFTWARE)
	    {
	      numCapabilities = pSubService->SubServiceInfo.SoftwareCspSubService.NumberOfCapabilities;
	      capabilityList  = pSubService->SubServiceInfo.SoftwareCspSubService.CapabilityList;
	      printf( "    This is a SOFTWARE subservice with %d capabilities\n",
		      numCapabilities );
	    }
	    else if (pSubService->CspType == CSSM_CSP_HARDWARE)
	    {
	      numCapabilities = pSubService->SubServiceInfo.HardwareCspSubService.NumberOfCapabilities;
	      capabilityList  = pSubService->SubServiceInfo.HardwareCspSubService.CapabilityList;
	      printf( "    This is a HARDWARE subservice with %d capabilities\n",
		      numCapabilities );
	    }
	    else
	    {
	      printf("Unknown CSP type\n");
	    }
	    for (iCapability = 0; iCapability < numCapabilities; iCapability++)
	    {
	      CSSM_CONTEXT_PTR pCapability;
	      CSSM_CONTEXT_ATTRIBUTE_PTR pAttributes;
	      uint32 iAttribute;
	      CSSM_MODULE_HANDLE hCSP;

	      pCapability = &capabilityList[iCapability];
	      Decode_Context_Type(pCapability);
	      Decode_Algorithm_Type(pCapability);
	      pAttributes = pCapability->ContextAttributes;
	      for (iAttribute = 0; iAttribute < pCapability->NumberOfAttributes; iAttribute++)
	      {
		Decode_Attribute_Type(pAttributes,iAttribute);
	    /* Find the key size attribute */
		if (pAttributes[iAttribute].AttributeType == CSSM_ATTRIBUTE_KEY_LENGTH)
		{ /* If key size matches, then try to load & attach */
		  if (pAttributes[iAttribute].Attribute.Uint32 == 64)
		  {
		    printf("Attempting module load\n");
		    Return_value = CSSM_ModuleLoad(&pCSPModuleList->Items[iModule].SubserviceUid.Guid,
						   0,
						   NULL,
						   NULL);
		    if (Return_value != CSSM_OK)
		    {
		      printf("Error loading CSP\n");
		      Print_CDSA_Error(Return_value);
		    }
		    printf("Attempting module attach\n");
		    Return_value = CSSM_ModuleAttach(&pCSPModuleList->Items[iModule].SubserviceUid.Guid,
						     &pInfo->CompatibleCSSMVersion,
						     &MemoryFunctions,
						     pSubService->SubServiceId,
						     CSSM_SERVICE_CSP,
						     0,		/* attach flags   */
						     0,		/* KEY_HIERARCHY  */
						     NULL,		/* function table */
						     0,		/* num functions  */
						     NULL,		/* reserved       */
						     &hCSP );
		    if (Return_value != CSSM_OK)
		    {
		      printf("Error attaching CSP\n");
		      Print_CDSA_Error(Return_value);
		    }
		    else
		    {
		    /* You can now generate a key, derive a key, perform
			encryption/decryption, etc.
		     */
		    }
		  }
		}
	      }
	    }
	  }
	}
	  MDSUTIL_FreeModuleInfo(pInfo);
      }
    }
  }
  if (Return_value == CSSM_OK)
  {
    MDSUTIL_FreeModuleList(pCSPModuleList);
    MDSUTIL_Term();
  }
}	/* main */