//+--------------------------------------------------------------------------- // // Microsoft Windows // Copyright (C) Microsoft Corporation, 1992 - 1995. // // File: context.c // // Contents: Schannel context management routines. // // Classes: // // Functions: // // History: 09-23-97 jbanes LSA integration stuff. // //---------------------------------------------------------------------------- #include #include #include #include DWORD g_cContext = 0; #if DBG void DumpContexts(void); static void AddContextToList(PSPContext pContext); static void DeleteContextFromList(PSPContext pContext); #endif /************************************************************************ * SPContextCreate * * Create a new SPContext, and initialize it. * * Returns - PSPContext pointer to context object. * \***********************************************************************/ PSPContext SPContextCreate(LPWSTR pszTarget) { PSPContext pContext; SP_BEGIN("SPContextCreate"); pContext = (PSPContext)SPExternalAlloc( sizeof(SPContext)); if(!pContext) { SP_RETURN(NULL); } DebugLog((DEB_TRACE, "Create context:0x%p\n", pContext)); FillMemory(pContext, sizeof(SPContext), 0); pContext->Magic = SP_CONTEXT_MAGIC; pContext->Flags = 0; GenerateRandomThumbprint(&pContext->ContextThumbprint); if(pszTarget) { pContext->pszTarget = SPExternalAlloc((lstrlenW(pszTarget) + 1) * sizeof(WCHAR)); if(pContext->pszTarget == NULL) { SP_LOG_RESULT(SEC_E_INSUFFICIENT_MEMORY); SPExternalFree(pContext); SP_RETURN(NULL); } lstrcpyW(pContext->pszTarget, pszTarget); } pContext->dwRequestedCF = CF_EXPORT; if(SslGlobalStrongEncryptionPermitted) { pContext->dwRequestedCF |= CF_DOMESTIC; } pContext->fCertChainsAllowed = FALSE; g_cContext++; #if DBG //AddContextToList(pContext); #endif SP_RETURN(pContext); } /************************************************************************ * VOID SPContextClean(PSPContext pContext) * * Clean out everything used by the handshake (in case we want * to do another). * \***********************************************************************/ BOOL SPContextClean(PSPContext pContext) { SP_BEGIN("SPContextClean"); if(pContext == NULL || pContext->Magic != SP_CONTEXT_MAGIC) { DebugLog((DEB_WARN, "Attempt to delete invalid context\n")); SP_RETURN(FALSE); } if(pContext->pbEncryptedKey) { SPExternalFree(pContext->pbEncryptedKey); pContext->pbEncryptedKey = NULL; } if(pContext->pbServerKeyExchange) { SPExternalFree(pContext->pbServerKeyExchange); pContext->pbServerKeyExchange = NULL; } if(pContext->pbIssuerList) { SPExternalFree(pContext->pbIssuerList); pContext->pbIssuerList = NULL; } if(pContext->pClientHello) { SPExternalFree(pContext->pClientHello); pContext->pClientHello = NULL; } if((pContext->Flags & CONTEXT_FLAG_FULL_HANDSHAKE) && (pContext->RipeZombie != NULL) && (pContext->RipeZombie->pClientCred != NULL)) { // We've just done a client-side full handshake in which a default // client certificate was selected. This client credential // technically belongs to the cache (so that other contexts can // query the certificate etc) but we want to free up the // application-process hProv now, while we're in the context // of the owning process. PSPCredential pClientCred = pContext->RipeZombie->pClientCred; if(pClientCred->hRemoteProv) { if(!RemoteCryptReleaseContext( pClientCred->hRemoteProv, 0, pClientCred->dwCapiFlags)) { SP_LOG_RESULT(GetLastError()); } pClientCred->hRemoteProv = 0; } } pContext->fExchKey = FALSE; SP_RETURN(TRUE); } /************************************************************************ * VOID SPDeleteContext(PSPContext pContext) * * Delete an existing context object. * \***********************************************************************/ BOOL SPContextDelete(PSPContext pContext) { SP_BEGIN("SPContextDelete"); DebugLog((DEB_TRACE, "Delete context:0x%p\n", pContext)); if(pContext == NULL || pContext->Magic != SP_CONTEXT_MAGIC) { DebugLog((DEB_WARN, "Attempt to delete invalid context\n")); SP_RETURN(FALSE); } // DsysAssert((pContext->pCredGroup->dwFlags & CRED_FLAG_DELETED) == 0); if(pContext->State != SP_STATE_CONNECTED && pContext->State != SP_STATE_SHUTDOWN) { DebugLog((DEB_WARN, "Attempting to delete an incompleted context\n")); // The context is being deleted in the middle of a handshake, // which is curious. This may be caused by the user aborting // an operation, or it may be caused by a reconfiguration of // the remote computer that caused the reconnect attempt to // fail. If it's the latter cause, then the only way to recover // is to request a full handshake next time. We have no way // of knowing which it is, so it's probably best that we kill // the current cache entry. if(pContext->RipeZombie) { pContext->RipeZombie->ZombieJuju = FALSE; } } SPContextClean(pContext); if(pContext->pszTarget) { SPExternalFree(pContext->pszTarget); pContext->pszTarget = NULL; } if(pContext->pszCredentialName) { SPExternalFree(pContext->pszCredentialName); pContext->pszCredentialName = NULL; } // // Delete session keys. // if(pContext->hReadKey) { if(pContext->pReadCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hReadKey, 0); pContext->hReadKey = 0; } } if(pContext->hPendingReadKey) { if(pContext->pPendingCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hPendingReadKey, 0); pContext->hPendingReadKey = 0; } } if(pContext->hWriteKey) { if(pContext->pWriteCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hWriteKey, 0); pContext->hWriteKey = 0; } } if(pContext->hPendingWriteKey) { if(pContext->pPendingCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hPendingWriteKey, 0); pContext->hPendingWriteKey = 0; } } if(pContext->hReadMAC) { if(pContext->pReadCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hReadMAC, 0); pContext->hReadMAC = 0; } } if(pContext->hPendingReadMAC) { if(pContext->pPendingCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hPendingReadMAC, 0); pContext->hPendingReadMAC = 0; } } if(pContext->hWriteMAC) { if(pContext->pWriteCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hWriteMAC, 0); pContext->hWriteMAC = 0; } } if(pContext->hPendingWriteMAC) { if(pContext->pPendingCipherInfo->aiCipher != CALG_SKIPJACK) { SchCryptDestroyKey(pContext->hPendingWriteMAC, 0); pContext->hPendingWriteMAC = 0; } } // // Delete the handshake hashes // if(pContext->hMd5Handshake) { SchCryptDestroyHash(pContext->hMd5Handshake, pContext->RipeZombie->dwCapiFlags); pContext->hMd5Handshake = 0; } if(pContext->hShaHandshake) { SchCryptDestroyHash(pContext->hShaHandshake, pContext->RipeZombie->dwCapiFlags); pContext->hShaHandshake = 0; } SPDereferenceCredential(pContext->pCredGroup); SPCacheDereference(pContext->RipeZombie); #if DBG //DeleteContextFromList(pContext); #endif FillMemory( pContext, sizeof( SPContext ), 0 ); g_cContext--; SPExternalFree( pContext ); SP_RETURN(TRUE); } /************************************************************************ * SPContext SPContextSetCredentials * * Associate a set of credentials with a context. * * Returns - PSPContext pointer to context object. * \***********************************************************************/ SP_STATUS SPContextSetCredentials( PSPContext pContext, PSPCredentialGroup pCred) { DWORD cbThumbprint; BOOL fNewCredentials = FALSE; SP_BEGIN("SPContextSetCredentials"); if(pContext->Magic != SP_CONTEXT_MAGIC) { SP_RETURN(SP_LOG_RESULT(PCT_INT_INTERNAL_ERROR)); } // DsysAssert((pCred->dwFlags & CRED_FLAG_DELETED) == 0); // // Associate the credential group with the context. // if(pCred != pContext->pCredGroup) { if(pContext->pCredGroup) { SPDereferenceCredential(pContext->pCredGroup); } SPReferenceCredential(pCred); pContext->pCredGroup = pCred; fNewCredentials = TRUE; } // // Set the protocol. // if(pContext->State == SP_STATE_NONE) { switch(pCred->grbitProtocol) { case SP_PROT_UNI_CLIENT: case SP_PROT_UNI_SERVER: case SP_PROT_PCT1_CLIENT: case SP_PROT_PCT1_SERVER: case SP_PROT_SSL2_CLIENT: case SP_PROT_SSL2_SERVER: case SP_PROT_SSL3_CLIENT: case SP_PROT_SSL3_SERVER: case SP_PROT_TLS1_CLIENT: case SP_PROT_TLS1_SERVER: pContext->ProtocolHandler = ServerProtocolHandler; pContext->InitiateHello = GenerateHello; break; default: SP_RETURN(SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } } // // If the client application has supplied a new credential, then // attempt to choose a suitable client certificate to send to // the server. // if(fNewCredentials && pContext->State == SSL3_STATE_GEN_SERVER_HELLORESP) { Ssl3CheckForExistingCred(pContext); } // // Allow the "manual cred validation" flag to be set from either // AcquireCredentialsHandle or InitializeSecurityContext. // if(pCred->dwFlags & CRED_FLAG_MANUAL_CRED_VALIDATION) { if((pContext->Flags & CONTEXT_FLAG_MUTUAL_AUTH) == 0) { pContext->Flags |= CONTEXT_FLAG_MANUAL_CRED_VALIDATION; } } SP_RETURN(PCT_ERR_OK); } SP_STATUS ContextInitCiphersFromCache(SPContext *pContext) { PSessCacheItem pZombie; SP_STATUS pctRet; pZombie = pContext->RipeZombie; pContext->pPendingCipherInfo = GetCipherInfo(pZombie->aiCipher, pZombie->dwStrength); pContext->pPendingHashInfo = GetHashInfo(pZombie->aiHash); pContext->pKeyExchInfo = GetKeyExchangeInfo(pZombie->SessExchSpec); pContext->dwPendingCipherSuiteIndex = pZombie->dwCipherSuiteIndex; if(!IsCipherAllowed(pContext, pContext->pPendingCipherInfo, pZombie->fProtocol, pZombie->dwCF)) { pContext->pPendingCipherInfo = NULL; return (SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } // Load the pending hash structure pContext->pPendingHashInfo = GetHashInfo(pZombie->aiHash); if(!IsHashAllowed(pContext, pContext->pPendingHashInfo, pZombie->fProtocol)) { pContext->pPendingHashInfo = NULL; return (SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } // load the exch info structure pContext->pKeyExchInfo = GetKeyExchangeInfo(pZombie->SessExchSpec); if(!IsExchAllowed(pContext, pContext->pKeyExchInfo, pZombie->fProtocol)) { pContext->pKeyExchInfo = NULL; return (SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } // Determine the CSP to use, based on the key exchange algorithm. pctRet = DetermineClientCSP(pContext); if(pctRet != PCT_ERR_OK) { return SP_LOG_RESULT(PCT_ERR_SPECS_MISMATCH); } #if DBG switch(pZombie->fProtocol) { case SP_PROT_PCT1_CLIENT: DebugLog((DEB_TRACE, "Protocol:PCT Client\n")); break; case SP_PROT_PCT1_SERVER: DebugLog((DEB_TRACE, "Protocol:PCT Server\n")); break; case SP_PROT_SSL2_CLIENT: DebugLog((DEB_TRACE, "Protocol:SSL2 Client\n")); break; case SP_PROT_SSL2_SERVER: DebugLog((DEB_TRACE, "Protocol:SSL2 Server\n")); break; case SP_PROT_SSL3_CLIENT: DebugLog((DEB_TRACE, "Protocol:SSL3 Client\n")); break; case SP_PROT_SSL3_SERVER: DebugLog((DEB_TRACE, "Protocol:SSL3 Server\n")); break; case SP_PROT_TLS1_CLIENT: DebugLog((DEB_TRACE, "Protocol:TLS Client\n")); break; case SP_PROT_TLS1_SERVER: DebugLog((DEB_TRACE, "Protocol:TLS Server\n")); break; default: DebugLog((DEB_TRACE, "Protocol:0x%x\n", pZombie->fProtocol)); } DebugLog((DEB_TRACE, "Cipher: %s\n", pContext->pPendingCipherInfo->szName)); DebugLog((DEB_TRACE, "Strength:%d\n", pContext->pPendingCipherInfo->dwStrength)); DebugLog((DEB_TRACE, "Hash: %s\n", pContext->pPendingHashInfo->szName)); DebugLog((DEB_TRACE, "Exchange:%s\n", pContext->pKeyExchInfo->szName)); #endif return PCT_ERR_OK; } SP_STATUS DetermineClientCSP(PSPContext pContext) { PSPCredential pCred = NULL; if(!(pContext->RipeZombie->fProtocol & SP_PROT_CLIENTS)) { return PCT_ERR_OK; } if(pContext->RipeZombie->hMasterProv != 0) { return PCT_ERR_OK; } switch(pContext->pKeyExchInfo->Spec) { case SP_EXCH_RSA_PKCS1: pContext->RipeZombie->hMasterProv = g_hRsaSchannel; break; case SP_EXCH_DH_PKCS3: pContext->RipeZombie->hMasterProv = g_hDhSchannelProv; break; default: DebugLog((DEB_ERROR, "Appropriate Schannel CSP not available!\n")); pContext->RipeZombie->hMasterProv = 0; return SP_LOG_RESULT(PCT_ERR_SPECS_MISMATCH); } return PCT_ERR_OK; } SP_STATUS ContextInitCiphers( SPContext *pContext, BOOL fRead, BOOL fWrite) { SP_BEGIN("ContextInitCiphers"); if((pContext == NULL) || (pContext->RipeZombie == NULL)) { SP_RETURN(SP_LOG_RESULT(PCT_INT_INTERNAL_ERROR)); } pContext->pCipherInfo = pContext->pPendingCipherInfo; if ((NULL == pContext->pCipherInfo) || ((pContext->RipeZombie->fProtocol & pContext->pCipherInfo->fProtocol) == 0)) { SP_RETURN(SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } pContext->pHashInfo = pContext->pPendingHashInfo; if ((NULL == pContext->pHashInfo)|| ((pContext->RipeZombie->fProtocol & pContext->pHashInfo->fProtocol) == 0)) { SP_RETURN(SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } if (NULL == pContext->pKeyExchInfo) { SP_RETURN(SP_LOG_RESULT(PCT_INT_SPECS_MISMATCH)); } if(fRead) { pContext->pReadCipherInfo = pContext->pPendingCipherInfo; pContext->pReadHashInfo = pContext->pPendingHashInfo; } if(fWrite) { pContext->pWriteCipherInfo = pContext->pPendingCipherInfo; pContext->pWriteHashInfo = pContext->pPendingHashInfo; } SP_RETURN(PCT_ERR_OK); } SP_STATUS SPContextDoMapping( PSPContext pContext) { PSessCacheItem pZombie; PSPCredentialGroup pCred; SP_STATUS pctRet; LONG iState; BOOL fSuccess; LONG iMapper; const SCH_MAPPER_DEFAULT_STATE = 0; const SCH_MAPPER_NORMAL_STATE = 1; SP_BEGIN("SPContextDoMapping"); pZombie = pContext->RipeZombie; pCred = pContext->RipeZombie->pServerCred; if(pCred->cMappers) { // Clear "called" flags. for(iMapper = 0; iMapper < pCred->cMappers; iMapper++) { pCred->pahMappers[iMapper]->m_dwFlags &= ~SCH_FLAG_MAPPER_CALLED; } pZombie->phMapper = NULL; for(iState = 0; iState < 2; iState++) { for(iMapper = 0; iMapper < pCred->cMappers; iMapper++) { if(pCred->pahMappers[iMapper]->m_dwFlags & SCH_FLAG_MAPPER_CALLED) { // This mapper has already had its chance. continue; } if(iState == SCH_MAPPER_DEFAULT_STATE) { if(!(pCred->pahMappers[iMapper]->m_dwFlags & SCH_FLAG_DEFAULT_MAPPER)) { continue; } } if((pCred->dwFlags & CRED_FLAG_NO_SYSTEM_MAPPER) && (pCred->pahMappers[iMapper]->m_dwFlags & SCH_FLAG_SYSTEM_MAPPER)) { // Skip the system mapper. DebugLog((DEB_TRACE, "Skip the system mapper\n")); continue; } #if DBG if(pCred->pahMappers[iMapper]->m_dwFlags & SCH_FLAG_SYSTEM_MAPPER) { DebugLog((DEB_TRACE, "Invoke the system mapper\n")); } else { DebugLog((DEB_TRACE, "Invoke the application mapper\n")); } #endif // Invoke mapper. pctRet = SslMapCredential( pCred->pahMappers[iMapper], X509_ASN_CHAIN, pZombie->pRemoteCert, NULL, &pZombie->hLocator); pCred->pahMappers[iMapper]->m_dwFlags |= SCH_FLAG_MAPPER_CALLED; if(NT_SUCCESS(pctRet)) { // Mapping was successful. DebugLog((DEB_TRACE, "Mapping was successful (0x%p)\n", pZombie->hLocator)); SslReferenceMapper(pCred->pahMappers[iMapper]); if(pZombie->phMapper) { SslDereferenceMapper(pZombie->phMapper); } pZombie->phMapper = pCred->pahMappers[iMapper]; pZombie->LocatorStatus = SEC_E_OK; break; } else { // Mapping failed. DebugLog((DEB_TRACE, "Mapping failed (0x%x)\n", pctRet)); pZombie->LocatorStatus = pctRet; } } if(pZombie->phMapper) { break; } } } SP_RETURN(PCT_ERR_OK); } SP_STATUS RemoveDuplicateIssuers( PBYTE pbIssuers, PDWORD pcbIssuers) { DWORD cbIssuers = *pcbIssuers; DWORD cBlob; PCRYPT_DATA_BLOB rgBlob; DWORD cbIssuer; PBYTE pbIssuer; PBYTE pbSource, pbDest; DWORD i, j; if(pbIssuers == NULL || cbIssuers < 2) { return PCT_ERR_OK; } // Count number of issuers. cBlob = 0; pbIssuer = pbIssuers; while(pbIssuer + 1 < pbIssuers + cbIssuers) { cbIssuer = MAKEWORD(pbIssuer[1], pbIssuer[0]); pbIssuer += 2 + cbIssuer; cBlob++; } // Allocate memory for blob list. rgBlob = SPExternalAlloc(cBlob * sizeof(CRYPT_DATA_BLOB)); if(rgBlob == NULL) { return SP_LOG_RESULT(SEC_E_INSUFFICIENT_MEMORY); } // Build blob list. cBlob = 0; pbIssuer = pbIssuers; while(pbIssuer + 1 < pbIssuers + cbIssuers) { cbIssuer = MAKEWORD(pbIssuer[1], pbIssuer[0]); rgBlob[cBlob].cbData = 2 + cbIssuer; rgBlob[cBlob].pbData = pbIssuer; pbIssuer += 2 + cbIssuer; cBlob++; } // Mark duplicates. for(i = 0; i < cBlob; i++) { if(rgBlob[i].pbData == NULL) continue; for(j = i + 1; j < cBlob; j++) { if(rgBlob[j].pbData == NULL) continue; if(rgBlob[i].cbData == rgBlob[j].cbData && memcmp(rgBlob[i].pbData, rgBlob[j].pbData, rgBlob[j].cbData) == 0) { // duplicate found rgBlob[j].pbData = NULL; } } } // Compact list. pbSource = pbIssuers; pbDest = pbIssuers; for(i = 0; i < cBlob; i++) { if(rgBlob[i].pbData) { if(pbDest != pbSource) { MoveMemory(pbDest, pbSource, rgBlob[i].cbData); } pbDest += rgBlob[i].cbData; } pbSource += rgBlob[i].cbData; } *pcbIssuers = (DWORD)(pbDest - pbIssuers); // Free blob list. SPExternalFree(rgBlob); return PCT_ERR_OK; } SP_STATUS SPContextGetIssuers( PSPCredentialGroup pCredGroup) { LONG i; PBYTE pbIssuerList; DWORD cbIssuerList; PBYTE pbIssuer; DWORD cbIssuer; PBYTE pbNew; DWORD Status; LockCredential(pCredGroup); if((pCredGroup->pbTrustedIssuers != NULL) && !(pCredGroup->dwFlags & CRED_FLAG_UPDATE_ISSUER_LIST)) { // Issuer list has already been built. Status = PCT_ERR_OK; goto cleanup; } // Free existing issuer list. if(pCredGroup->pbTrustedIssuers) { LocalFree(pCredGroup->pbTrustedIssuers); pCredGroup->pbTrustedIssuers = NULL; pCredGroup->cbTrustedIssuers = 0; } pCredGroup->dwFlags &= ~CRED_FLAG_UPDATE_ISSUER_LIST; // // Get issuers from application-specified ROOT store. // pbIssuerList = NULL; cbIssuerList = 0; while(pCredGroup->hApplicationRoots) { Status = ExtractIssuerNamesFromStore(pCredGroup->hApplicationRoots, NULL, &cbIssuerList); if(Status != PCT_ERR_OK) { break; } pbIssuerList = LocalAlloc(LPTR, cbIssuerList); if(pbIssuerList == NULL) { break; } Status = ExtractIssuerNamesFromStore(pCredGroup->hApplicationRoots, pbIssuerList, &cbIssuerList); if(Status != PCT_ERR_OK) { LocalFree(pbIssuerList); pbIssuerList = NULL; cbIssuerList = 0; } break; } // // Call each of the mappers in turn, building a large // list of all trusted issuers. // for(i = 0; i < pCredGroup->cMappers; i++) { #if 0 if((pCredGroup->dwFlags & CRED_FLAG_NO_SYSTEM_MAPPER) && (pCredGroup->pahMappers[i]->m_dwFlags & SCH_FLAG_SYSTEM_MAPPER)) { // Skip the system mapper. continue; } #endif Status = SslGetMapperIssuerList(pCredGroup->pahMappers[i], &pbIssuer, &cbIssuer); if(!NT_SUCCESS(Status)) { continue; } if(pbIssuerList == NULL) { pbIssuerList = LocalAlloc(LPTR, cbIssuer); if(pbIssuerList == NULL) { SP_LOG_RESULT(SEC_E_INSUFFICIENT_MEMORY); break; } } else { pbNew = LocalReAlloc(pbIssuerList, cbIssuerList + cbIssuer, LMEM_MOVEABLE); if(pbNew == NULL) { SP_LOG_RESULT(SEC_E_INSUFFICIENT_MEMORY); break; } pbIssuerList = pbNew; } CopyMemory(pbIssuerList + cbIssuerList, pbIssuer, cbIssuer); cbIssuerList += cbIssuer; SPExternalFree(pbIssuer); } // // Remove duplicates from list. // if(pbIssuerList) { Status = RemoveDuplicateIssuers(pbIssuerList, &cbIssuerList); if(!NT_SUCCESS(Status)) { LocalFree(pbIssuerList); goto cleanup; } } pCredGroup->cbTrustedIssuers = cbIssuerList; // do not reverse these lines pCredGroup->pbTrustedIssuers = pbIssuerList; Status = PCT_ERR_OK; cleanup: UnlockCredential(pCredGroup); return Status; } SP_STATUS SPPickClientCertificate( PSPContext pContext, DWORD dwExchSpec) { PSPCredentialGroup pCred; PSPCredential pCurrentCred; SP_STATUS pctRet; DWORD i; pCred = pContext->pCredGroup; if((pCred == NULL) || (pCred->pCredList == NULL)) { return SP_LOG_RESULT(PCT_ERR_SPECS_MISMATCH); } pContext->pActiveClientCred = NULL; pctRet = PCT_ERR_SPECS_MISMATCH; for(i = 0; i < pCred->cCredList; i++) { pCurrentCred = pCred->pCredList + i; if(pCurrentCred->pCert == NULL) { continue; } if(pCurrentCred->pPublicKey == NULL) { continue; } // Does this cert contain the proper key type. if(dwExchSpec != pCurrentCred->dwExchSpec) { continue; // try the next cert. } // Does this cert have the proper encoding type? if(pCurrentCred->pCert->dwCertEncodingType != X509_ASN_ENCODING) { continue; } // WE FOUND ONE pContext->pActiveClientCred = pCurrentCred; pctRet = PCT_ERR_OK; break; } return pctRet; } SP_STATUS SPPickServerCertificate( PSPContext pContext, DWORD dwExchSpec) { PSPCredentialGroup pCred; PSPCredential pCurrentCred; SP_STATUS pctRet; DWORD i; pCred = pContext->RipeZombie->pServerCred; if((pCred == NULL) || (pCred->pCredList == NULL)) { return SP_LOG_RESULT(PCT_ERR_SPECS_MISMATCH); } DsysAssert((pContext->RipeZombie->dwFlags & SP_CACHE_FLAG_READONLY) == 0); #if 0 if(pContext->RipeZombie->dwFlags & SP_CACHE_FLAG_READONLY) { // What in the world causes this case to occur? Anything? // Don't mess with the current credentials. if(pContext->RipeZombie->pActiveServerCred == NULL) { return SP_LOG_RESULT(PCT_ERR_SPECS_MISMATCH); } else { return PCT_ERR_OK; } } #endif pContext->RipeZombie->pActiveServerCred = NULL; pctRet = PCT_ERR_SPECS_MISMATCH; for(i = 0; i < pCred->cCredList; i++) { pCurrentCred = pCred->pCredList + i; if(pCurrentCred->pCert == NULL) { continue; } if(pCurrentCred->pPublicKey == NULL) { continue; } // Does this cert contain the proper key type. if(dwExchSpec != pCurrentCred->dwExchSpec) { continue; // try the next cert. } // Does this cert have the proper encoding type? if(pCurrentCred->pCert->dwCertEncodingType != X509_ASN_ENCODING) { continue; } // WE FOUND ONE pContext->RipeZombie->pActiveServerCred = pCurrentCred; pContext->RipeZombie->CredThumbprint = pCred->CredThumbprint; pContext->RipeZombie->CertThumbprint = pCurrentCred->CertThumbprint; // Set "master" provider handle to current credential's. Note that // SSL3 will sometimes overide this selection in favor of its // ephemeral key pair. pContext->RipeZombie->hMasterProv = pCurrentCred->hProv; pctRet = PCT_ERR_OK; break; } return pctRet; } // This routine is called by the user process. It frees a context // structure that was originally allocated by the LSA process, // and passed over via the SPContextDeserialize routine. BOOL LsaContextDelete(PSPContext pContext) { if(pContext) { if(pContext->hReadKey) { SchCryptDestroyKey(pContext->hReadKey, 0); pContext->hReadKey = 0; } if(pContext->hReadMAC) { SchCryptDestroyKey(pContext->hReadMAC, 0); pContext->hReadMAC = 0; } if(pContext->hWriteKey) { SchCryptDestroyKey(pContext->hWriteKey, 0); pContext->hWriteKey = 0; } if(pContext->hWriteMAC) { SchCryptDestroyKey(pContext->hWriteMAC, 0); pContext->hWriteMAC = 0; } // Close locator if this handle belongs to the system // default certificate mapper. if(pContext->RipeZombie) { if(pContext->RipeZombie->hLocator && pContext->RipeZombie->phMapper) { if(pContext->RipeZombie->phMapper->m_dwFlags & SCH_FLAG_SYSTEM_MAPPER) { NtClose((HANDLE)pContext->RipeZombie->hLocator); pContext->RipeZombie->hLocator = 0; } } if(pContext->RipeZombie->pbServerCertificate) { SPExternalFree(pContext->RipeZombie->pbServerCertificate); pContext->RipeZombie->pbServerCertificate = NULL; } } } return TRUE; } /* * * Misc Utility functions. * */ #if DBG typedef struct _DbgMapCrypto { DWORD C; PSTR psz; } DbgMapCrypto; DbgMapCrypto DbgCryptoNames[] = { {CALG_RC4, "RC4 "}, }; CHAR DbgNameSpace[100]; PSTR DbgAlgNames[] = { "Basic RSA", "RSA with MD2", "RSA with MD5", "RC4 stream"}; #define AlgName(x) ((x < sizeof(DbgAlgNames) / sizeof(PSTR)) ? DbgAlgNames[x] : "Unknown") PSTR DbgGetNameOfCrypto(DWORD x) { int i; for (i = 0; i < sizeof(DbgCryptoNames) / sizeof(DbgMapCrypto) ; i++ ) { if (x == DbgCryptoNames[i].C) { wsprintf(DbgNameSpace, "%s", (DbgCryptoNames[i].psz)); return DbgNameSpace; } } return("Unknown"); } #endif #if 0 PSTR CopyString( PSTR pszString) { PSTR pszNewString; DWORD cchString; cchString = lstrlen(pszString) + 1; pszNewString = (PSTR)SPExternalAlloc(cchString); if (pszNewString) { CopyMemory(pszNewString, pszString, cchString); } return(pszNewString); } #endif #ifdef LTS int __cdecl memcmp ( const void * buf1, const void * buf2, size_t count ) { if (!count) return(0); while ( --count && *(char *)buf1 == *(char *)buf2 ) { buf1 = (char *)buf1 + 1; buf2 = (char *)buf2 + 1; } return( *((unsigned char *)buf1) - *((unsigned char *)buf2) ); } #endif #if DBG typedef struct _CONTEXTLIST { struct _CONTEXTLIST *pNext; PSPContext pContext; } CONTEXTLIST, *PCONTEXTLIST; PCONTEXTLIST g_ContextList = NULL; static void AddContextToList(PSPContext pContext) { PCONTEXTLIST pNew = LocalAlloc(LMEM_FIXED, sizeof(CONTEXTLIST)); pNew->pNext = g_ContextList; pNew->pContext = pContext; g_ContextList = pNew; } static void DeleteContextFromList(PSPContext pContext) { PCONTEXTLIST pItem, pPrevItem; BOOL fFound = FALSE; if(g_ContextList == NULL) { DebugLog((DEB_ERROR, "List is empty!\n")); } else if(g_ContextList->pContext == pContext) { // Delete first item in list g_ContextList = g_ContextList->pNext; fFound = TRUE; } else { pPrevItem = g_ContextList; for(pItem = g_ContextList->pNext; pItem; pItem = pItem->pNext) { if(pItem->pContext == pContext) { pPrevItem->pNext = pItem->pNext; LocalFree(pItem); fFound = TRUE; break; } pPrevItem = pItem; } } if(!fFound) { DebugLog((DEB_ERROR, "Unknown context 0x%p\n", pContext)); } } void DumpContexts(void) { PCONTEXTLIST pItem; DWORD dwCount = 0; SP_BEGIN("DumpContexts"); for(pItem = g_ContextList; pItem; pItem = pItem->pNext) { dwCount++; DebugLog((DEB_TRACE, "Context:%8x, Cache:%8x\n", pItem->pContext, pItem->pContext->RipeZombie)); } if(dwCount != g_cContext) { DebugLog((DEB_ERROR, "Context count discrepancy %d vs. %d\n", dwCount, g_cContext)); } SP_END(); } #endif