#define		_WIN32_WINNT	0x0500
#include "stdafx.h"
#include <stdio.h>
#include <windows.h>
#include <Wincrypt.h>
#include <cryptuiapi.h>

#pragma comment(lib,"crypt32.lib")
#define MY_ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)

/*
PCCERT_CONTEXT GetSubjectCert(
HCERTSTORE hCertStore,       // the store to search
LPCTSTR pszSearchName)       // the string to match
{

  //********************************************************************
  // Declare variables.
  PCCERT_CONTEXT   pCertContext = NULL;
  BOOL             fFound = FALSE;
  BOOL             fMore = TRUE;
  DWORD            dwSize = 0;
  LPSTR            pszSubjectName;
  LPSTR            pszNameFound;
  CERT_NAME_BLOB   NameBlob;
  
	//********************************************************************
	//  Enumerate the certificates in the store until a match is found.
	while(fMore && !fFound)
	{     
    if(!(pCertContext = CertEnumCertificatesInStore(
	hCertStore,
	pCertContext)))
    {
	// The end of the store has been reached. Get out of the loop.
	fMore=FALSE;
	break;
	}
	NameBlob = pCertContext->pCertInfo->Issuer;
	// Call CertNameToStr to get dwSize, the length of the 
	// CertNameString
	dwSize = CertNameToStr(
	MY_ENCODING_TYPE,        // Encoding type
	&NameBlob,               // the subject from the pCertInfo
	CERT_SIMPLE_NAME_STR,    // Type of string
	NULL,                    // Place to return string.
	// In the first pass, NULL since 
	// space for the name string has not
	// yet been allocated.
	0);                      // Size of the name string 
	if (dwSize<2)        // If the string length returned is 
	// less than 2, the function could not
	// determine a valid name string length.
	// The function failed. 
	{     
	// The call to the function failed. Get out of the loop.
	printf("Error First pass of getting Name String1");
	fMore = FALSE;
	break;
	}           
	// Allocate memory for the subject name string.
	if(!(pszSubjectName = (LPSTR)malloc(dwSize)))
	{  
	// Memory allocation failed. Get out of the loop.
	printf("Error Allocating Memory");
	fMore = FALSE;
	break;
	}   
	//  Make second call to CertNameToStr to get the string.
	dwSize = CertNameToStr(
	MY_ENCODING_TYPE,       // Encoding type
	&NameBlob,              // CERT_NAME_BLOB
	CERT_SIMPLE_NAME_STR,   // Type
	pszSubjectName,         // Place to return string
	dwSize);                // Size of string (chars)
	if(dwSize<2)
	{  
	// If the length returned is less than 2, 
	// the function failed. Get out of the loop.
	printf("Error in second pass.\n");
	fMore = FALSE;
	break;
	}
	pszNameFound = strstr(pszSubjectName,                   
	pszSearchName);
	if(pszNameFound)
	{
	// The string searched for was matched. Get out of the loop.
	printf("Target Certificate %s Found \n", pszNameFound);
	fFound = TRUE;
	break;
	}  // end while  
	free(pszSubjectName);
	if(!fFound)
	{      
	printf("Target Cert Not Found\n");
	CertFreeCertificateContext(pCertContext);
	return NULL;
	}   
	else
    return (pCertContext);   // return the whole context that included
	// the subject name string.
	}       // end of function
	
*/

void MyHandleError(char *s){
    printf("An error occured in running the program.\n");
    printf("%s\n\n",s);
    printf("Program terminating.\n");
    exit(1);
}

void main(void)
{
	
	//-------------------------------------------------------------------
	// Copyright (c) Microsoft Corporation.  All rights reserved.
	// This program lists all of the certificates in a system certificate
	// store and all of the property identifier numbers of those 
	// certificates. It also demonstrates the use of two
	// UI functions. One, CryptUIDlgSelectCertificateFromStore, 
	// displays the certificates in a store
	// and allows the user to select one of them, 
	// The other, CryptUIDlgViewContext,
	// displays the contents of a single certificate.
	
	//-------------------------------------------------------------------
	// Declare and initialize variables.
	
	HCERTSTORE       hCertStore;        
	PCCERT_CONTEXT   pCertContext=NULL;      
	char pszNameString[256];
	char pszStoreName[256];
	void*            pvData;
	DWORD            cbData;
	DWORD            dwPropId = 0; 
	// Zero must be used on the first
	// call to the function. After that,
	// the last returned property identifier is passed.
	
	//-------------------------------------------------------------------
	//  Begin processing. Get the name of the system certificate store 
	//  to be enumerated. Output here is to stderr so that the program  
	//  can be run from the command line and stdout can be redirected  
	//  to a file.
	
	printf("Please enter the store name:");
	scanf("%s",pszStoreName);
	printf("The store name is %s .\n",pszStoreName);
	
	//-------------------------------------------------------------------
	// Open a system certificate store.
	
	if ( hCertStore = CertOpenSystemStore(
		NULL,
		pszStoreName))
	{
		printf("The %s store has been opened. \n", 
			pszStoreName);
	}
	else
	{
		// If the store was not opened, exit to an error routine.
		MyHandleError("The store was not opened.");
	}
	
	//-------------------------------------------------------------------
	// Use CertEnumCertificatesInStore to get the certificates 
	// from the open store. pCertContext must be reset to
	// NULL to retrieve the first certificate in the store.
	
	// pCertContext = NULL;
	//----------------------------------------	
	while(pCertContext= CertEnumCertificatesInStore(
		hCertStore,
		pCertContext))
	{
		//-------------------------------------------------------------------
		// A certificate was retrieved. Continue.
		//-------------------------------------------------------------------
		//  Display the certificate.
		/*
		if ( CryptUIDlgViewContext(
			CERT_STORE_CERTIFICATE_CONTEXT,
			pCertContext,
			NULL,
			NULL,
			0,
			NULL))
		{
			//     printf("OK\n");
		}
		else
		{
			MyHandleError("UI failed.");
		}
		*/
		getchar();
		if(CertGetNameString(
			pCertContext,
			CERT_NAME_SIMPLE_DISPLAY_TYPE,
			0,
			NULL,
			pszNameString,
			128))
		{
			printf(" %s \n",pszNameString);
		}
		else
			printf("CertGetName failed. \n");
		
		//-------------------------------------------------------------------
		// Loop to find all of the property identifiers for the specified  
		// certificate. The loop continues until 
		// CertEnumCertificateContextProperties returns zero.
	//==============================================================	
		while(dwPropId = CertEnumCertificateContextProperties(
			pCertContext, // The context whose properties are to be 
			dwPropId))    // listed. Number of the last property found.  
			// This must be zero to find the first 
			// property identifier.
		{
			//-------------------------------------------------------------------
			// When the loop is executed, a property identifier has been found.
			// Print the property number.
			
			printf("Property # %d found->", dwPropId);
			
			//-------------------------------------------------------------------
			//  Indicate the kind of property found.
			
			switch(dwPropId)
			{
			case CERT_FRIENDLY_NAME_PROP_ID:
				{
					printf("Friendly name: ");
					break;
				}
			case CERT_SIGNATURE_HASH_PROP_ID:
				{
					printf("Signature hash identifier ");
					break;
				}
			case CERT_KEY_PROV_HANDLE_PROP_ID:
				{
					printf("KEY PROVE HANDLE");
					break;
				}
			case CERT_KEY_PROV_INFO_PROP_ID:
				{
					printf("KEY PROV INFO PROP ID ");
					break;
				}
			case CERT_SHA1_HASH_PROP_ID:
				{
					printf("SHA1 HASH identifier");
					break;
				}
			case CERT_MD5_HASH_PROP_ID:
				{
					printf("md5 hash identifier ");
					break;
				}
			case CERT_KEY_CONTEXT_PROP_ID:
				{
					printf("KEY CONTEXT PROP identifier");
					break;
				}
			case CERT_KEY_SPEC_PROP_ID:
				{
					printf("KEY SPEC PROP identifier");
					break;
				}
			case CERT_ENHKEY_USAGE_PROP_ID:
				{
					printf("ENHKEY USAGE PROP identifier");
					break;
				}
			case CERT_NEXT_UPDATE_LOCATION_PROP_ID:
				{
					printf("NEXT UPDATE LOCATION PROP identifier");
					break;
				}
			case CERT_PVK_FILE_PROP_ID:
				{
					printf("PVK FILE PROP identifier ");
					break;
				}
			case CERT_DESCRIPTION_PROP_ID:
				{
					printf("DESCRIPTION PROP identifier ");
					break;
				}
			case CERT_ACCESS_STATE_PROP_ID:
				{
					printf("ACCESS STATE PROP identifier ");
					break;
				}
			case CERT_SMART_CARD_DATA_PROP_ID:
				{
					printf("SMART_CARD DATA PROP identifier ");
					break;
				}
			case CERT_EFS_PROP_ID:
				{
					printf("EFS PROP identifier ");
					break;
				}
			case CERT_FORTEZZA_DATA_PROP_ID:
				{
					printf("FORTEZZA DATA PROP identifier ");
					break;
				}
			case CERT_ARCHIVED_PROP_ID:
				{
					printf("ARCHIVED PROP identifier ");
					break;
				}
			case CERT_KEY_IDENTIFIER_PROP_ID:
				{
					printf("KEY IDENTIFIER PROP identifier ");
					break;
				}
			case CERT_AUTO_ENROLL_PROP_ID:
				{
					printf("AUTO ENROLL identifier. ");
					break;
				}
			} // End switch
	//==========================================================================		
			//-------------------------------------------------------------------
			// Retrieve information on the property by first getting the size 
			// of the property size. 
			// For details, see CertGetCertificateContextProperty.
	/*	
			if(CertGetCertificateContextProperty(
				pCertContext, 
				dwPropId , 
				NULL, 
				&cbData))
			{
				//  Continue.
			}
			else
			{  
				// If the first call to the function failed,
				// exit to an error routine.
				MyHandleError("Call #1 to GetCertContextProperty failed.");
			}
			//-------------------------------------------------------------------
			// The call succeeded. Use the size to allocate memory 
			// for the property.
			
			if(pvData = (void*)malloc(cbData))
			{
				// Memory is allocated. Continue.
			}
			else
			{
				// If memory allocation failed, exit to an error routine.
				MyHandleError("Memory allocation failed.");
			}
			//----------------------------------------------------------------
			// Allocation succeeded. Retrieve the property data.
			
			if(CertGetCertificateContextProperty(
				pCertContext,
				dwPropId,
				pvData, 
				&cbData))
			{
				// The data has been retrieved. Continue.
			}
			else
			{
				// If error occurred in the second call, 
				// exit to an error routine.
				MyHandleError("Call #2 failed.");
			}
			//---------------------------------------------------------------
			// Show the results.
			
			printf("The Property Content is %d \n", pvData);
			
			//----------------------------------------------------------------
			// Free the certificate context property memory.
		
			free(pvData);
			*/
			printf("\n");
  }  // End inner while
} // End outer while
/*
//-------------------------------------------------------------------
//  Select an new certificate using UI.
if(!(pCertContext = CryptUIDlgSelectCertificateFromStore(
   hCertStore,
   NULL,
   NULL,
   NULL,
   CRYPTUI_SELECT_LOCATION_COLUMN,
   0,
   NULL)))
{
    MyHandleError("Select UI failed." );
}

*/

//-------------------------------------------------------------------
// Clean up.

CertFreeCertificateContext(pCertContext);
CertCloseStore(hCertStore,0);
printf("The function completed successfully. \n");
} // End of main

//-------------------------------------------------------------------
//  This example uses the function MyHandleError, a simple error
//  handling function, to print an error message to  
//  the standard error (stderr) file and exit the program. 
//  For most applications, replace this function with one 
//  that does more extensive error reporting.