If I understand right. You very to check the cert via the Windows store. OK.
This is what I did in fe-secure.c in Postgresql libpq client library
conn->peer holds the server cert.

I used MS Visual Studio 7.0,
wincrypt.h is required for the API.

CA cert is installed in the windows stores

This code is based on one if the examples available on MSDN


**********************************************************************************
#ifdef _CHECK_SSL_CERT
        conn->check_server_cert_status=0;
        if 
(conn->check_server_cert_status|=((strcmp(conn->peer_cn,conn->pghost?conn->pghost:conn->pghostaddr))?_CERT_INVALID_NAME:0))
 {
           char msg_text[]="Имя сервера не соответствует сертификату: %s не 
соответсвует %s";
           char 
*msg_fin=malloc(strlen(msg_text)+strlen(conn->peer_cn)+strlen(conn->pghost?conn->pghost:conn->pghostaddr));
           if (msg_fin) {
             
sprintf(msg_fin,msg_text,conn->peer_cn,conn->pghost?conn->pghost:conn->pghostaddr);
             MessageBox(NULL,msg_fin,"Ошибка в имени 
сервера",MB_OK|MB_ICONERROR);
             free(msg_fin);
           }

           
        }




//Here start chain cert verification
        {

#define ENCODING_TYPE  (PKCS_7_ASN_ENCODING | X509_ASN_ENCODING)




HCERTCHAINENGINE         hChainEngine;
CERT_CHAIN_ENGINE_CONFIG ChainConfig;
PCCERT_CHAIN_CONTEXT     pChainContext;
//PCCERT_CHAIN_CONTEXT     pDupContext;
HCERTSTORE               hCertStore;
PCCERT_CONTEXT           pCertContext = NULL;
CERT_ENHKEY_USAGE        EnhkeyUsage;
CERT_USAGE_MATCH         CertUsage;  
CERT_CHAIN_PARA          ChainPara;
DWORD                    dwFlags=0;
BYTE                     *pszNameString;


size_t cert_buf_size=i2d_X509(conn->peer,NULL);
BYTE *cert_buf=((BYTE*)malloc(cert_buf_size)), *next=cert_buf;


#ifdef _CHECK_CERT_DEBUG
          FILE *check_log=fopen("ssl_check.log","w");

          if (check_log) fprintf(check_log,"Connection started: host=%s 
hostaddr=%s ssl_cn=%s\n",conn->pghost,conn->pghostaddr,conn->peer_cn);
#endif


if (cert_buf) {
   cert_buf_size=i2d_X509(conn->peer,&next);

#ifdef _CHECK_CERT_DEBUG
          if (check_log) fprintf(check_log,"Cert converted\n");
#endif



//---------------------------------------------------------
// Initialize data structures.

if(!(pszNameString=(BYTE *)malloc(256))) 
  conn->check_server_cert_status=~0;
else {
#ifdef _CHECK_CERT_DEBUG
          if (check_log) fprintf(check_log,"Buffer allocated\n");
#endif
EnhkeyUsage.cUsageIdentifier = 0;
EnhkeyUsage.rgpszUsageIdentifier=NULL;
CertUsage.dwType = USAGE_MATCH_TYPE_AND;
CertUsage.Usage  = EnhkeyUsage;
ChainPara.cbSize = sizeof(CERT_CHAIN_PARA);
ChainPara.RequestedUsage=CertUsage;

ChainConfig.cbSize = sizeof(CERT_CHAIN_ENGINE_CONFIG);
ChainConfig.hRestrictedRoot= NULL ;
ChainConfig.hRestrictedTrust= NULL ;
ChainConfig.hRestrictedOther= NULL ;
ChainConfig.cAdditionalStore=0 ;
ChainConfig.rghAdditionalStore = NULL ;
ChainConfig.dwFlags = CERT_CHAIN_CACHE_END_CERT;
ChainConfig.dwUrlRetrievalTimeout= 0 ;
ChainConfig.MaximumCachedCertificates=0 ;
ChainConfig.CycleDetectionModulus = 0;

//---------------------------------------------------------
// Create the nondefault certificate chain engine.

if(!CertCreateCertificateChainEngine(
         &ChainConfig,
         &hChainEngine))
   conn->check_server_cert_status=~0;
else
{
#ifdef _CHECK_CERT_DEBUG
          if (check_log) fprintf(check_log,"Chain created\n");
#endif
// Open the My system store.


if(!(hCertStore=CertOpenStore(CERT_STORE_PROV_SYSTEM,ENCODING_TYPE,NULL,CERT_SYSTEM_STORE_CURRENT_USER,L"Root")))
       conn->check_server_cert_status=~0;
else
{
#ifdef _CHECK_CERT_DEBUG
          if (check_log) fprintf(check_log,"Root store opened\n");
#endif

//-------------------------------------------------------
// Loop through the certificates in the store, 
// and create a chain for each.

  
pCertContext=CertCreateCertificateContext(ENCODING_TYPE,cert_buf,cert_buf_size);


if (pCertContext)
{

#ifdef _CHECK_CERT_DEBUG
          if (check_log) fprintf(check_log,"Cert imported\n");
#endif
//----------------------------------------------------------------
// Build a chain using CertGetCertificateChain
// and the certificate retrieved.

if(CertGetCertificateChain(
    NULL,                  // use the default chain engine
    pCertContext,          // pointer to the end certificate
    NULL,                  // use the default time
    hCertStore,                  // search root store
    &ChainPara,            // use AND logic and enhanced key usage 
                           //  as indicated in the ChainPara 
                           //  data structure
    dwFlags,
    NULL,                  // currently reserved
    &pChainContext))       // return a pointer to the chain created
{

//---------------------------------------------------------------
// Display some of the contents of the chain.

#ifdef _CHECK_CERT_DEBUG
          if (check_log) fprintf(check_log,"Cert chain built\n");
#endif
conn->check_server_cert_status|=(pChainContext->TrustStatus.dwErrorStatus==CERT_TRUST_NO_ERROR)?0:1;

{
           char *msg_text=NULL;

switch(pChainContext->TrustStatus.dwErrorStatus)
{
case CERT_TRUST_IS_NOT_TIME_VALID: 
     msg_text="Сертификат недействителен в данный момент";
     break;
case CERT_TRUST_IS_NOT_TIME_NESTED: 
     msg_text="В цепочке сертификатов время неправильное";
     break;
case CERT_TRUST_IS_REVOKED:
     msg_text="Один из сертифкатов в цепочке был аннулирован";
     break;
case CERT_TRUST_IS_NOT_SIGNATURE_VALID:
     msg_text="Неверная подпись сертификата";
     break;
case CERT_TRUST_IS_NOT_VALID_FOR_USAGE:
     msg_text="Сертификат сервера не одобрен для таких соединений";
     break;
case CERT_TRUST_IS_UNTRUSTED_ROOT:
     msg_text="Корневой сертификат цепочки не является доверенным";
     break;
case CERT_TRUST_REVOCATION_STATUS_UNKNOWN:
     msg_text="Статус аннулирования сертивикатов не выяснен";
     break;
case CERT_TRUST_IS_CYCLIC :
     msg_text="Циклическая зависимость сертификатов";
     break;
case CERT_TRUST_IS_PARTIAL_CHAIN: 
     msg_text="Один из сертификатов в цепочке не является доверенным";
     break;
case CERT_TRUST_CTL_IS_NOT_TIME_VALID: 
     msg_text="Цепочка проверки сертификатов недействительная в данный момент";
     break;
case CERT_TRUST_CTL_IS_NOT_SIGNATURE_VALID: 
     msg_text="Цепочка проверки сертификатов не имеет правильной подписи";
     break;
case CERT_TRUST_CTL_IS_NOT_VALID_FOR_USAGE: 
     msg_text="Цепочка проверки сертификатов не одобрена для такого 
использования";
} // End switch


             if (msg_text) MessageBox(NULL,msg_text,"Ошибка проверкм 
сертификата",MB_OK|MB_ICONERROR);



}
 
//printf("\nInfo status for the chain:\n");
/*
switch(pChainContext->TrustStatus.dwInfoStatus)
{
case 0:
     printf("No information status reported.\n");
     break;
case CERT_TRUST_HAS_EXACT_MATCH_ISSUER :
     printf("An exact match issuer certificate has been found for this 
certificate.\n");
     break;
case CERT_TRUST_HAS_KEY_MATCH_ISSUER: 
    printf("A key match issuer certificate has been found for this 
certificate.\n");
     break;
case CERT_TRUST_HAS_NAME_MATCH_ISSUER: 
    printf("A name match issuer certificate has been found for this 
certificate.\n");
     break;
case CERT_TRUST_IS_SELF_SIGNED:
     printf("This certificate is self-signed.\n");
     break;
case CERT_TRUST_IS_COMPLEX_CHAIN:
     printf("The certificate chain created is a complex chain.\n");
     break;
} // end switch
  */
//--------------------------------------------------------------------
// Free both chains.

CertFreeCertificateChain(pChainContext);
} else {
  conn->check_server_cert_status=~0;
}
} else {
  // Cert was not created from the buffer
  conn->check_server_cert_status=~0;
}

CertCloseStore(hCertStore,CERT_CLOSE_STORE_FORCE_FLAG);
} // End of open store if

//---------------------------------------------------------
// Free the chain engine.

CertFreeCertificateChainEngine(hChainEngine);

// Free memory for pszNameString.

if(pszNameString)
     free(pszNameString);
} // End of chain created if


} //End of allocation if

 if (cert_buf)
  free(cert_buf); //End of cert conversion
} else {
  conn->check_server_cert_status=~0;
}


#ifdef _CHECK_CERT_DEBUG
if (check_log) fclose(check_log);
#endif

        }
//Here ends chain cert verification




        if (conn->check_server_cert_status) {
          close_SSL(conn);
          return PGRES_POLLING_FAILED;
        }
#endif

______________________________________________________________________
OpenSSL Project                                 http://www.openssl.org
User Support Mailing List                    [email protected]
Automated List Manager                           [EMAIL PROTECTED]

Reply via email to