You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2390 lines
64 KiB
2390 lines
64 KiB
//+-----------------------------------------------------------------------
|
|
//
|
|
// Microsoft Windows
|
|
//
|
|
// Copyright (c) Microsoft Corporation 1992 - 1997
|
|
//
|
|
// File: pkserv.cxx
|
|
//
|
|
// Contents: Server side public key support for Kerberos
|
|
//
|
|
//
|
|
// History: 24-Nov-1997 MikeSw Created
|
|
//
|
|
//------------------------------------------------------------------------
|
|
|
|
#include "kdcsvr.hxx"
|
|
#include <wininet.h> // for SECURITY_FLAG_xxx
|
|
#include <sclogon.h> // ScHelperXXX
|
|
#include <cryptui.h> // for CryptUiXXX
|
|
#include <certca.h> // for CA*XXX
|
|
|
|
#define FILENO FILENO_PKSERV
|
|
//
|
|
// This is the cert store containing the CTL used to verify client certificates
|
|
//
|
|
|
|
HCERTSTORE KdcCertStore = NULL;
|
|
HCRYPTPROV KdcClientProvider = NULL;
|
|
|
|
PCCERT_CONTEXT GlobalKdcCert = NULL;
|
|
HANDLE KdcCertStoreChangeEvent = NULL;
|
|
TimeStamp KdcLastChangeEventTime;
|
|
|
|
RTL_CRITICAL_SECTION KdcGlobalCertCritSect;
|
|
BOOLEAN KdcGlobalCertCritSectInitialized = FALSE;
|
|
|
|
HANDLE KdcCertStoreWait = NULL;
|
|
BOOLEAN KdcPKIInitialized = FALSE;
|
|
|
|
BOOLEAN Kdc3DesSupported = TRUE;
|
|
HANDLE KdcCaNotificationHandle = NULL;
|
|
#define KDC_ROOT_STORE L"ROOT"
|
|
#define KDC_PRIVATE_MY_STORE L"MY"
|
|
|
|
#define MAX_TEMPLATE_NAME_VALUE_SIZE 80 // sizeof (CERT_NAME_VALUE) + wcslen(SmartcardLogon)
|
|
|
|
KERB_OBJECT_ID KdcSignatureAlg[10];
|
|
|
|
|
|
NTSTATUS
|
|
KdcGetKdcCertificate(PCCERT_CONTEXT *KdcCert);
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: VerifyScLogonEku
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments: IN: A certificate context
|
|
//
|
|
// Requires: TRUE is the certificate has a smart card logon EKU; or its template
|
|
// name is DomainController
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOL
|
|
VerifyScLogonEku(
|
|
IN PCCERT_CONTEXT pCertContext,
|
|
IN BOOLEAN KdcCertificate
|
|
)
|
|
{
|
|
BOOL fDCCert=FALSE;
|
|
CERT_EXTENSION *pExtension = NULL;
|
|
DWORD cbSize = 0;
|
|
DWORD dwIndex = 0;
|
|
|
|
PCERT_NAME_VALUE pTemplateName = NULL;
|
|
CERT_ENHKEY_USAGE *pEnhKeyUsage=NULL;
|
|
|
|
if(NULL == (pCertContext->pCertInfo))
|
|
goto Cleanup;
|
|
|
|
|
|
//find the EKU extension
|
|
pExtension =CertFindExtension(szOID_ENHANCED_KEY_USAGE,
|
|
pCertContext->pCertInfo->cExtension,
|
|
pCertContext->pCertInfo->rgExtension);
|
|
|
|
if(pExtension)
|
|
{
|
|
if(CryptDecodeObject(X509_ASN_ENCODING,
|
|
X509_ENHANCED_KEY_USAGE,
|
|
pExtension->Value.pbData,
|
|
pExtension->Value.cbData,
|
|
0,
|
|
NULL,
|
|
&cbSize))
|
|
|
|
{
|
|
pEnhKeyUsage=(CERT_ENHKEY_USAGE *)MIDL_user_allocate(cbSize);
|
|
|
|
if(pEnhKeyUsage)
|
|
{
|
|
if(CryptDecodeObject(X509_ASN_ENCODING,
|
|
X509_ENHANCED_KEY_USAGE,
|
|
pExtension->Value.pbData,
|
|
pExtension->Value.cbData,
|
|
0,
|
|
pEnhKeyUsage,
|
|
&cbSize))
|
|
{
|
|
for(dwIndex=0; dwIndex < pEnhKeyUsage->cUsageIdentifier; dwIndex++)
|
|
{
|
|
if(0 == strcmp(szOID_KP_SMARTCARD_LOGON,
|
|
(pEnhKeyUsage->rgpszUsageIdentifier)[dwIndex]))
|
|
{
|
|
//we find it
|
|
fDCCert=TRUE;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
//check if we have found it via the enhanced key usage extension
|
|
//
|
|
if (( fDCCert ) ||
|
|
(!KdcCertificate && !fDCCert))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
//
|
|
// For DC certificates, its also OK to have the W2K certtype extension in
|
|
// place of the sclogon oid - this doesn't apply to client certificates,
|
|
// however.
|
|
//
|
|
|
|
|
|
//find the V1 template extension
|
|
pExtension =CertFindExtension(szOID_ENROLL_CERTTYPE_EXTENSION,
|
|
pCertContext->pCertInfo->cExtension,
|
|
pCertContext->pCertInfo->rgExtension);
|
|
if(pExtension == NULL)
|
|
goto Cleanup;
|
|
|
|
|
|
cbSize=0;
|
|
|
|
if(!CryptDecodeObject(X509_ASN_ENCODING,
|
|
X509_UNICODE_ANY_STRING,
|
|
pExtension->Value.pbData,
|
|
pExtension->Value.cbData,
|
|
0,
|
|
NULL,
|
|
&cbSize))
|
|
|
|
goto Cleanup;
|
|
|
|
pTemplateName = (CERT_NAME_VALUE *)MIDL_user_allocate(cbSize);
|
|
|
|
if(NULL == pTemplateName)
|
|
goto Cleanup;
|
|
|
|
if(!CryptDecodeObject(X509_ASN_ENCODING,
|
|
X509_UNICODE_ANY_STRING,
|
|
pExtension->Value.pbData,
|
|
pExtension->Value.cbData,
|
|
0,
|
|
pTemplateName,
|
|
&cbSize))
|
|
|
|
goto Cleanup;
|
|
|
|
if(wcscmp((LPWSTR) pTemplateName->Value.pbData, wszCERTTYPE_DC) != 0)
|
|
goto Cleanup;
|
|
|
|
fDCCert=TRUE;
|
|
|
|
|
|
Cleanup:
|
|
|
|
if(pEnhKeyUsage)
|
|
MIDL_user_free(pEnhKeyUsage);
|
|
|
|
if(pTemplateName)
|
|
MIDL_user_free(pTemplateName);
|
|
|
|
return fDCCert;
|
|
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcCheckCertificate
|
|
//
|
|
// Synopsis: a helper routine to verify the certificate. It will check
|
|
// CRLs, CTLs
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
// CertContext - the certificate to check
|
|
// EmbeddedUPNOk - returns TRUE if the certificate can
|
|
// be translated to a user by looking at the
|
|
// subject name.
|
|
// returns FALSE if the certificate must be
|
|
// mapped by looking in the user's mapped certificate
|
|
// ds attribute.
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
KERBERR
|
|
KdcCheckCertificate(
|
|
IN PCCERT_CONTEXT CertContext,
|
|
IN OUT PKERB_EXT_ERROR pExtendedError,
|
|
IN OUT OPTIONAL PCERT_CHAIN_POLICY_STATUS FinalChainStatus,
|
|
IN BOOLEAN KdcCert
|
|
)
|
|
{
|
|
KERBERR KerbErr = KDC_ERR_NONE;
|
|
CERT_CHAIN_PARA ChainParameters = {0};
|
|
LPSTR Usage = (KdcCert ? KERB_PKINIT_KDC_CERT_TYPE : KERB_PKINIT_CLIENT_CERT_TYPE);
|
|
PCCERT_CHAIN_CONTEXT ChainContext = NULL;
|
|
CERT_CHAIN_POLICY_STATUS PolicyStatus ={0};
|
|
|
|
ChainParameters.cbSize = sizeof(CERT_CHAIN_PARA);
|
|
ChainParameters.RequestedUsage.dwType = USAGE_MATCH_TYPE_AND;
|
|
ChainParameters.RequestedUsage.Usage.cUsageIdentifier = 1;
|
|
ChainParameters.RequestedUsage.Usage.rgpszUsageIdentifier = &Usage;
|
|
|
|
|
|
if (!CertGetCertificateChain(
|
|
HCCE_LOCAL_MACHINE,
|
|
CertContext,
|
|
NULL, // evaluate at current time
|
|
NULL, // no additional stores
|
|
&ChainParameters,
|
|
CERT_CHAIN_REVOCATION_CHECK_CHAIN_EXCLUDE_ROOT,
|
|
NULL, // reserved
|
|
&ChainContext
|
|
))
|
|
{
|
|
D_DebugLog((DEB_WARN,"Failed to verify certificate chain: %0x%x\n",GetLastError()));
|
|
KerbErr = KDC_ERR_CLIENT_NOT_TRUSTED;
|
|
goto Cleanup;
|
|
|
|
}
|
|
else
|
|
{
|
|
CERT_CHAIN_POLICY_PARA ChainPolicy;
|
|
ZeroMemory(&ChainPolicy, sizeof(ChainPolicy));
|
|
|
|
ChainPolicy.cbSize = sizeof(ChainPolicy);
|
|
|
|
ZeroMemory(&PolicyStatus, sizeof(PolicyStatus));
|
|
PolicyStatus.cbSize = sizeof(PolicyStatus);
|
|
PolicyStatus.lChainIndex = -1;
|
|
PolicyStatus.lElementIndex = -1;
|
|
|
|
|
|
if (!CertVerifyCertificateChainPolicy(
|
|
CERT_CHAIN_POLICY_NT_AUTH,
|
|
ChainContext,
|
|
&ChainPolicy,
|
|
&PolicyStatus))
|
|
{
|
|
D_DebugLog((DEB_WARN,"CertVerifyCertificateChainPolicy failure: %0x%x\n", GetLastError()));
|
|
KerbErr = KDC_ERR_CLIENT_NOT_TRUSTED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
if( PolicyStatus.dwError != S_OK )
|
|
{
|
|
D_DebugLog((DEB_WARN,"CertVerifyCertificateChainPolicy - Chain Status failure: %0x%x\n",PolicyStatus.dwError));
|
|
KerbErr = KDC_ERR_CLIENT_NOT_TRUSTED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Verify that the sclogon oid is in the client certificate, alternately
|
|
// that the sclogon oid or template name are in kdc certificates.
|
|
//
|
|
if (!VerifyScLogonEku( CertContext, KdcCert))
|
|
{
|
|
DebugLog((DEB_ERROR, "Cert missing SCLogon EKU\n"));
|
|
PolicyStatus.dwError = (DWORD) CERT_E_WRONG_USAGE;
|
|
KerbErr = KDC_ERR_CLIENT_NOT_TRUSTED;
|
|
goto Cleanup;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
Cleanup:
|
|
if (PolicyStatus.dwError != S_OK)
|
|
{
|
|
FILL_EXT_ERROR_EX(pExtendedError, PolicyStatus.dwError,FILENO,__LINE__);
|
|
if (ARGUMENT_PRESENT(FinalChainStatus))
|
|
{
|
|
RtlCopyMemory(
|
|
FinalChainStatus,
|
|
&PolicyStatus,
|
|
sizeof(CERT_CHAIN_POLICY_STATUS)
|
|
);
|
|
}
|
|
}
|
|
|
|
if (ChainContext != NULL)
|
|
{
|
|
CertFreeCertificateChain(ChainContext);
|
|
}
|
|
|
|
return(KerbErr);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcVerifyClientCertName
|
|
//
|
|
// Synopsis: Verifies that the mapping of a client's cert name matches
|
|
// the mapping of the client name from the AS request
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
|
|
KERBERR
|
|
KdcVerifyClientCertName(
|
|
IN PCCERT_CONTEXT ClientCert,
|
|
IN PKDC_TICKET_INFO ClientTicketInfo
|
|
)
|
|
{
|
|
UNICODE_STRING NameString = {0};
|
|
UNICODE_STRING ClientRealm = {0};
|
|
PKERB_INTERNAL_NAME ClientName = NULL;
|
|
KDC_TICKET_INFO TicketInfo = {0};
|
|
BOOLEAN ClientReferral = FALSE;
|
|
KERBERR KerbErr = KDC_ERR_NONE;
|
|
KERB_EXT_ERROR ExtendedError;
|
|
|
|
//
|
|
// Get the client name from the cert
|
|
//
|
|
if(STATUS_SUCCESS != KerbGetPrincipalNameFromCertificate(ClientCert, &NameString))
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
D_DebugLog((DEB_TRACE,"Email name from certificate is %wZ\n",&NameString));
|
|
|
|
KerbErr = KerbConvertStringToKdcName(
|
|
&ClientName,
|
|
&NameString
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
ClientName->NameType = KRB_NT_ENTERPRISE_PRINCIPAL;
|
|
|
|
//
|
|
// Now crack the name & see if it refers to us
|
|
//
|
|
|
|
//
|
|
// Normalize the client name.
|
|
//
|
|
|
|
KerbErr = KdcNormalize(
|
|
ClientName,
|
|
NULL,
|
|
NULL,
|
|
NULL,
|
|
KDC_NAME_CLIENT | KDC_NAME_FOLLOW_REFERRALS | KDC_NAME_CHECK_GC,
|
|
FALSE, // do not restrict user accounts (user2user)
|
|
&ClientReferral,
|
|
&ClientRealm,
|
|
&TicketInfo,
|
|
&ExtendedError,
|
|
NULL, // no user handle
|
|
0L, // no fields to fetch
|
|
0L, // no extended fields
|
|
NULL, // no user all
|
|
NULL // no group membership
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr) )
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to normalize name "));
|
|
KerbPrintKdcName(DEB_ERROR,ClientName);
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// If this is a referral, return an error and the true realm name
|
|
// of the client
|
|
//
|
|
|
|
if (ClientReferral)
|
|
{
|
|
KerbErr = KDC_ERR_WRONG_REALM;
|
|
DebugLog((DEB_WARN,"Client tried to logon to account in another realm\n"));
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Verify the client cert matches the client
|
|
//
|
|
|
|
if (TicketInfo.UserId != ClientTicketInfo->UserId)
|
|
{
|
|
DebugLog((DEB_ERROR,"Cert name doesn't match user name: %wZ, %wZ\n",
|
|
&NameString, &ClientTicketInfo->AccountName));
|
|
KerbErr = KDC_ERR_CLIENT_NAME_MISMATCH;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
KerbFreeString( &NameString);
|
|
KerbFreeKdcName( &ClientName );
|
|
FreeTicketInfo( &TicketInfo );
|
|
return(KerbErr);
|
|
|
|
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcConvertNameString
|
|
//
|
|
// Synopsis: Converts the cr-lf to , in a dn
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
void
|
|
KdcConvertNameString(
|
|
IN PUNICODE_STRING Name,
|
|
IN WCHAR ReplacementChar
|
|
)
|
|
{
|
|
PWCHAR Comma1, Comma2;
|
|
|
|
//
|
|
// Scan through the name, converting "\r\n" to the replacement char. This
|
|
// should be done by the CertNameToStr APIs, but that won't happen for
|
|
// a while.
|
|
//
|
|
|
|
Comma1 = Comma2 = Name->Buffer ;
|
|
while ( *Comma2 )
|
|
{
|
|
*Comma1 = *Comma2 ;
|
|
|
|
if ( *Comma2 == L'\r' )
|
|
{
|
|
if ( *(Comma2 + 1) == L'\n' )
|
|
{
|
|
*Comma1 = ReplacementChar;
|
|
Comma2++ ;
|
|
}
|
|
}
|
|
|
|
Comma1++;
|
|
Comma2++;
|
|
}
|
|
|
|
*Comma1 = L'\0';
|
|
|
|
Name->Length = (USHORT) wcslen( Name->Buffer ) * sizeof( WCHAR );
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcFreePkiAuditInfo
|
|
//
|
|
// Synopsis: Free KDC_PKI_AUDIT_INFO
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//---------------------------------------------------------------------------
|
|
|
|
VOID
|
|
KdcFreePkiAuditInfo(
|
|
IN PKDC_PKI_AUDIT_INFO AuditInfo
|
|
)
|
|
{
|
|
KerbFreeString( &AuditInfo->CertIssuerName );
|
|
KerbFreeString( &AuditInfo->CertSerialNumber );
|
|
KerbFreeString( &AuditInfo->CertThumbprint );
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcFillPkiAuditInfo
|
|
//
|
|
// Synopsis: Gets the cert hash, issuer, etc for a cert.
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: TRUE if it does, false if it doesn't
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
NTSTATUS
|
|
KdcFillPkiAuditInfo(
|
|
IN PCCERT_CONTEXT Cert,
|
|
IN OUT PKDC_PKI_AUDIT_INFO AuditInfo
|
|
)
|
|
{
|
|
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
Status = KerbCreateUnicodeStringFromBlob(
|
|
Cert->pCertInfo->SerialNumber.pbData,
|
|
Cert->pCertInfo->SerialNumber.cbData,
|
|
&AuditInfo->CertSerialNumber,
|
|
FALSE
|
|
);
|
|
|
|
if (!NT_SUCCESS( Status ))
|
|
{
|
|
DebugLog((DEB_ERROR, "KerbCreateUnicodeStringFromBlob failed\n"));
|
|
goto Cleanup;
|
|
}
|
|
|
|
Status = KerbGetCertificateHashString(
|
|
Cert,
|
|
&AuditInfo->CertThumbprint
|
|
);
|
|
|
|
if (!NT_SUCCESS( Status ))
|
|
{
|
|
DebugLog((DEB_ERROR, "KerbGetCertificateHashString failed\n"));
|
|
goto Cleanup;
|
|
}
|
|
|
|
Status = KerbGetCertificateIssuer(
|
|
Cert,
|
|
&AuditInfo->CertIssuerName
|
|
);
|
|
|
|
if (!NT_SUCCESS( Status ))
|
|
{
|
|
DebugLog((DEB_ERROR, "KerbGetCertificateIssuer failed\n"));
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
if (!NT_SUCCESS( Status ))
|
|
{
|
|
KdcFreePkiAuditInfo( AuditInfo );
|
|
}
|
|
|
|
return Status;
|
|
}
|
|
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcCheckForEtype
|
|
//
|
|
// Synopsis: Checks if a client supports a particular etype
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns: TRUE if it does, false if it doesn't
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
BOOLEAN
|
|
KdcCheckForEtype(
|
|
IN PKERB_CRYPT_LIST CryptList,
|
|
IN ULONG Etype
|
|
)
|
|
{
|
|
PKERB_CRYPT_LIST List = CryptList;
|
|
|
|
while (List != NULL)
|
|
{
|
|
if ((ULONG) List->value == Etype)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
List=List->next;
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcCheckPkinitPreAuthData
|
|
//
|
|
// Synopsis:
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
KERBERR
|
|
KdcCheckPkinitPreAuthData(
|
|
IN PKDC_TICKET_INFO ClientTicketInfo,
|
|
IN SAMPR_HANDLE UserHandle,
|
|
IN OPTIONAL PKERB_PA_DATA_LIST PreAuthData,
|
|
IN PKERB_KDC_REQUEST_BODY ClientRequest,
|
|
OUT PKERB_PA_DATA_LIST * OutputPreAuthData,
|
|
OUT PULONG Nonce,
|
|
OUT PKERB_ENCRYPTION_KEY EncryptionKey,
|
|
OUT PUNICODE_STRING TransitedRealm,
|
|
OUT PKDC_PKI_AUDIT_INFO PkiAuditInfo,
|
|
OUT PKERB_EXT_ERROR pExtendedError
|
|
)
|
|
{
|
|
NTSTATUS Status;
|
|
KERBERR KerbErr = KDC_ERR_NONE;
|
|
PKERB_PA_PK_AS_REQ PkAsReq = NULL;
|
|
PKERB_PA_PK_AS_REQ2 PkAsReq2 = NULL;
|
|
PKERB_CERTIFICATE UserCert = NULL;
|
|
PCCERT_CONTEXT CertContext = NULL;
|
|
PCCERT_CONTEXT KdcCert = NULL;
|
|
HCRYPTKEY ClientKey = NULL;
|
|
PBYTE PackedAuthenticator = NULL;
|
|
ULONG PackedAuthenticatorSize;
|
|
PBYTE PackedKeyPack = NULL;
|
|
ULONG PackedKeyPackSize;
|
|
PBYTE SignedKeyPack = NULL;
|
|
ULONG SignedKeyPackSize;
|
|
PKERB_SIGNATURE Signature = NULL;
|
|
PKERB_PK_AUTHENTICATOR PkAuthenticator = NULL;
|
|
CERT_CHAIN_POLICY_STATUS FinalChainStatus = {0};
|
|
UNICODE_STRING ClientKdcName = {0};
|
|
ULONG ClientKdcNameType;
|
|
LARGE_INTEGER ClientTime;
|
|
LARGE_INTEGER CurrentTime;
|
|
PULONG EtypeArray = NULL;
|
|
ULONG EtypeCount = 0;
|
|
ULONG CommonEtype;
|
|
KERB_SIGNED_REPLY_KEY_PACKAGE KeyPack = {0};
|
|
KERB_REPLY_KEY_PACKAGE ReplyKey = {0};
|
|
HCRYPTPROV KdcProvider = NULL;
|
|
BOOL FreeProvider = FALSE;
|
|
#define KERB_PK_MAX_SIGNATURE_SIZE 128
|
|
BYTE PkSignature[KERB_PK_MAX_SIGNATURE_SIZE];
|
|
ULONG PkSignatureLength = KERB_PK_MAX_SIGNATURE_SIZE;
|
|
ULONG RequiredSize = 0;
|
|
PBYTE EncryptedKeyPack = NULL;
|
|
PKERB_PA_DATA_LIST PackedPkAsRep = NULL;
|
|
PBYTE PackedKey = NULL;
|
|
ULONG PackedKeySize = 0;
|
|
KERB_ENCRYPTION_KEY TempKey = {0};
|
|
PKERB_CERTIFICATE_LIST CertList = NULL;
|
|
CRYPT_ALGORITHM_IDENTIFIER CryptAlg = {0};
|
|
PKERB_AUTH_PACKAGE AuthPack = NULL;
|
|
BOOLEAN Used3Des = FALSE;
|
|
|
|
//
|
|
// Prepare the output variables
|
|
//
|
|
|
|
*OutputPreAuthData = NULL;
|
|
RtlZeroMemory(
|
|
EncryptionKey,
|
|
sizeof(KERB_ENCRYPTION_KEY)
|
|
);
|
|
*Nonce = 0;
|
|
|
|
//
|
|
// If we don't do this preauth, return such
|
|
//
|
|
|
|
Status = KdcGetKdcCertificate(&KdcCert);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
|
|
//
|
|
// Log an event
|
|
//
|
|
ReportServiceEvent(
|
|
EVENTLOG_ERROR_TYPE,
|
|
KDCEVENT_NO_KDC_CERTIFICATE,
|
|
0,
|
|
NULL,
|
|
0
|
|
);
|
|
|
|
FILL_EXT_ERROR_EX(pExtendedError, STATUS_PKINIT_FAILURE, FILENO, __LINE__);
|
|
return(KDC_ERR_PADATA_TYPE_NOSUPP);
|
|
}
|
|
|
|
|
|
GetSystemTimeAsFileTime((PFILETIME) &CurrentTime );
|
|
|
|
//
|
|
// First, unpack the outer KRB-PA-PK-AS-REQ
|
|
//
|
|
|
|
|
|
KerbErr = KerbUnpackData(
|
|
PreAuthData->value.preauth_data.value,
|
|
PreAuthData->value.preauth_data.length,
|
|
KERB_PA_PK_AS_REQ_PDU,
|
|
(PVOID *) &PkAsReq
|
|
);
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
//
|
|
// Try the older variation
|
|
//
|
|
|
|
KerbErr = KerbUnpackData(
|
|
PreAuthData->value.preauth_data.value,
|
|
PreAuthData->value.preauth_data.length,
|
|
KERB_PA_PK_AS_REQ2_PDU,
|
|
(PVOID *) &PkAsReq2
|
|
);
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to unpack PA-PK-AS-REQ(2): 0x%x\n",KerbErr));
|
|
goto Cleanup;
|
|
}
|
|
|
|
}
|
|
|
|
if (PkAsReq != NULL)
|
|
{
|
|
//
|
|
// Verify the signature
|
|
//
|
|
|
|
Status = ScHelperVerifyPkcsMessage(
|
|
NULL,
|
|
KdcClientProvider,
|
|
PkAsReq->signed_auth_pack.value,
|
|
PkAsReq->signed_auth_pack.length,
|
|
PackedAuthenticator,
|
|
&PackedAuthenticatorSize,
|
|
NULL // don't return certificate context
|
|
);
|
|
if ((Status != ERROR_MORE_DATA) && (Status != STATUS_SUCCESS))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to verify message: %x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
PackedAuthenticator = (PBYTE) MIDL_user_allocate(PackedAuthenticatorSize);
|
|
if (PackedAuthenticator == NULL)
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Status = ScHelperVerifyPkcsMessage(
|
|
NULL,
|
|
KdcClientProvider,
|
|
PkAsReq->signed_auth_pack.value,
|
|
PkAsReq->signed_auth_pack.length,
|
|
PackedAuthenticator,
|
|
&PackedAuthenticatorSize,
|
|
&CertContext
|
|
);
|
|
if (Status != STATUS_SUCCESS)
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to verify message: %x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Unpack the auth package
|
|
//
|
|
|
|
KerbErr = KerbUnpackData(
|
|
PackedAuthenticator,
|
|
PackedAuthenticatorSize,
|
|
KERB_AUTH_PACKAGE_PDU,
|
|
(PVOID *)&AuthPack
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
PkAuthenticator = &AuthPack->pk_authenticator;
|
|
|
|
}
|
|
else
|
|
{
|
|
DsysAssert(PkAsReq2 != NULL);
|
|
|
|
//
|
|
// Get the user certificate & verify
|
|
//
|
|
|
|
if ((PkAsReq2->bit_mask & user_certs_present) == 0)
|
|
{
|
|
DebugLog((DEB_ERROR,"Client tried to use pkinit w/o client cert\n"));
|
|
KerbErr = KDC_ERR_BADOPTION;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Just use the first of the certificates
|
|
//
|
|
|
|
UserCert = &PkAsReq2->user_certs->value;
|
|
|
|
//
|
|
// We only handle x509 certificates
|
|
//
|
|
|
|
if (UserCert->cert_type != KERB_CERTIFICATE_TYPE_X509)
|
|
{
|
|
DebugLog((DEB_ERROR,"User supplied bad cert type: %d\n",UserCert->cert_type));
|
|
KerbErr = KDC_ERR_BADOPTION;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Decode the certificate.
|
|
//
|
|
|
|
CertContext = CertCreateCertificateContext(
|
|
X509_ASN_ENCODING,
|
|
UserCert->cert_data.value,
|
|
UserCert->cert_data.length
|
|
);
|
|
if (CertContext == NULL)
|
|
{
|
|
Status = GetLastError();
|
|
DebugLog((DEB_ERROR,"Failed to create certificate context: 0x%x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Verify the authenticator
|
|
//
|
|
|
|
Signature = &PkAsReq2->signed_auth_pack.auth_package_signature;
|
|
|
|
//
|
|
// Now import the key from the certificate
|
|
//
|
|
|
|
if (!CryptImportPublicKeyInfo(
|
|
KdcClientProvider,
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
&CertContext->pCertInfo->SubjectPublicKeyInfo,
|
|
&ClientKey
|
|
))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to import public key: 0x%x\n",GetLastError()));
|
|
FILL_EXT_ERROR(pExtendedError, GetLastError(), FILENO, __LINE__);
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Encode the data to be verified
|
|
//
|
|
|
|
KerbErr = KerbPackData(
|
|
&PkAsReq2->signed_auth_pack.auth_package,
|
|
KERB_AUTH_PACKAGE_PDU,
|
|
&PackedAuthenticatorSize,
|
|
&PackedAuthenticator
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Verify the signature on the message
|
|
//
|
|
|
|
if (!KerbCompareObjectIds(
|
|
Signature->signature_algorithm.algorithm,
|
|
KdcSignatureAlg
|
|
))
|
|
{
|
|
DebugLog((DEB_ERROR,"Unsupported signature algorithm (not MD5)\n"));
|
|
KerbErr = KDC_ERR_SUMTYPE_NOSUPP;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Status = ScHelperVerifyMessage(
|
|
NULL, // no logon info
|
|
KdcClientProvider,
|
|
CertContext,
|
|
KERB_PKINIT_SIGNATURE_ALG,
|
|
PackedAuthenticator,
|
|
PackedAuthenticatorSize,
|
|
Signature->pkcs_signature.value,
|
|
Signature->pkcs_signature.length / 8 // because it is a bit string
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to verify message: 0x%x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KDC_ERR_INVALID_SIG;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Now check the information in the authenticator itself.
|
|
//
|
|
|
|
PkAuthenticator = &PkAsReq2->signed_auth_pack.auth_package.pk_authenticator;
|
|
|
|
}
|
|
|
|
|
|
//
|
|
// Fill in the audit information for the certificate - this is non-fatal, though...
|
|
//
|
|
KerbErr = KdcFillPkiAuditInfo(
|
|
CertContext,
|
|
PkiAuditInfo
|
|
);
|
|
|
|
|
|
if (!KERB_SUCCESS( KerbErr ))
|
|
{
|
|
DebugLog((DEB_ERROR, "Failed to build audit information %x\n", KerbErr));
|
|
DsysAssert(FALSE);
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// Call a helper routine to verify the certificate. It will check
|
|
// CRLs, CTLs,
|
|
//
|
|
|
|
KerbErr = KdcCheckCertificate(
|
|
CertContext,
|
|
pExtendedError,
|
|
&FinalChainStatus,
|
|
FALSE // not a kdc certificate
|
|
);
|
|
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
//
|
|
// Dumb this down for release?
|
|
//
|
|
KdcReportBadClientCertificate(
|
|
&ClientTicketInfo->AccountName,
|
|
&FinalChainStatus,
|
|
sizeof(FinalChainStatus) - sizeof(void*),
|
|
pExtendedError->status
|
|
);
|
|
|
|
DebugLog((DEB_ERROR,"Failed to check CLIENT certificate: 0x%x\n",KerbErr));
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Verify the cert is for the right client
|
|
//
|
|
KerbErr = KdcVerifyClientCertName(
|
|
CertContext,
|
|
ClientTicketInfo
|
|
);
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
DebugLog((DEB_ERROR,"KDC failed to verify client's identity from cert\n"));
|
|
goto Cleanup;
|
|
}
|
|
|
|
#ifdef later
|
|
//
|
|
// BUG 455112: this code breaks MIT KDCs, which can't handle a strange
|
|
// x.500 name in the transited field. So, for NT5, disable the code
|
|
//
|
|
|
|
//
|
|
// Put the issuer name in as a transited realm, as it is invovled in
|
|
// the authentication decision.
|
|
//
|
|
|
|
TransitedLength = CertNameToStr( CertContext->dwCertEncodingType,
|
|
&CertContext->pCertInfo->Issuer,
|
|
dwNameToStrFlags,
|
|
NULL,
|
|
0 );
|
|
|
|
|
|
if ( TransitedLength == 0 )
|
|
{
|
|
D_DebugLog((DEB_ERROR,"Failed to get issuer name: 0x%x\n",GetLastError()));
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
TransitedRealm->MaximumLength = (USHORT) TransitedLength * sizeof(WCHAR) + sizeof(WCHAR);
|
|
TransitedRealm->Length = (USHORT) TransitedLength * sizeof(WCHAR);
|
|
TransitedRealm->Buffer = (LPWSTR) MIDL_user_allocate( TransitedRealm->MaximumLength );
|
|
|
|
if ( TransitedRealm->Buffer == NULL )
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
TransitedLength = CertNameToStr( CertContext->dwCertEncodingType,
|
|
&CertContext->pCertInfo->Issuer,
|
|
dwNameToStrFlags,
|
|
TransitedRealm->Buffer,
|
|
TransitedLength );
|
|
|
|
if ( TransitedLength == 0 )
|
|
{
|
|
D_DebugLog((DEB_ERROR,"Failed to get issuer name: 0x%x\n",GetLastError()));
|
|
FILL_EXT_ERROR(pExtendedError, GetLastError(), FILENO, __LINE__);
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Convert the "." to "/"
|
|
//
|
|
|
|
|
|
KdcConvertNameString(
|
|
TransitedRealm,
|
|
L'/'
|
|
);
|
|
|
|
#endif // later
|
|
|
|
//
|
|
// Verify the realm name is correct
|
|
//
|
|
|
|
if (!SecData.IsOurRealm(
|
|
&PkAuthenticator->kdc_realm
|
|
))
|
|
{
|
|
DebugLog((DEB_ERROR,"Client used wrong realm in PK authenticator: %s\n",
|
|
PkAuthenticator->kdc_realm
|
|
));
|
|
|
|
KerbErr = KDC_ERR_S_PRINCIPAL_UNKNOWN;
|
|
goto Cleanup;
|
|
|
|
}
|
|
|
|
//
|
|
// Verify the service realm and kdc name is correct
|
|
//
|
|
|
|
KerbErr = KerbConvertPrincipalNameToString(
|
|
&ClientKdcName,
|
|
&ClientKdcNameType,
|
|
&PkAuthenticator->kdc_name
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
if (!RtlEqualUnicodeString(
|
|
SecData.KdcFullServiceKdcName(),
|
|
&ClientKdcName,
|
|
TRUE))
|
|
{
|
|
if (!RtlEqualUnicodeString(
|
|
SecData.KdcFullServiceDnsName(),
|
|
&ClientKdcName,
|
|
TRUE))
|
|
{
|
|
if (!RtlEqualUnicodeString(
|
|
SecData.KdcFullServiceName(),
|
|
&ClientKdcName,
|
|
TRUE))
|
|
{
|
|
DebugLog((DEB_ERROR,"Client provided KDC name is wrong: %wZ\n",
|
|
&ClientKdcName));
|
|
|
|
KerbErr = KDC_ERR_KDC_NAME_MISMATCH;
|
|
goto Cleanup;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
//
|
|
// Now verify the time
|
|
//
|
|
|
|
KerbConvertGeneralizedTimeToLargeInt(
|
|
&ClientTime,
|
|
&PkAuthenticator->client_time,
|
|
PkAuthenticator->cusec
|
|
);
|
|
|
|
if (!KerbCheckTimeSkew(
|
|
&CurrentTime,
|
|
&ClientTime,
|
|
&SkewTime))
|
|
{
|
|
KerbErr = KRB_AP_ERR_SKEW;
|
|
goto Cleanup;
|
|
}
|
|
|
|
*Nonce = PkAuthenticator->nonce;
|
|
|
|
//
|
|
// Generate a temporary key. First find a good encryption type
|
|
//
|
|
|
|
KerbErr = KerbConvertCryptListToArray(
|
|
&EtypeArray,
|
|
&EtypeCount,
|
|
ClientRequest->encryption_type
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
Status = CDFindCommonCSystem(
|
|
EtypeCount,
|
|
EtypeArray,
|
|
&CommonEtype
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
KerbErr = KDC_ERR_ETYPE_NOTSUPP;
|
|
goto Cleanup;
|
|
}
|
|
|
|
KerbErr = KerbMakeKey(
|
|
CommonEtype,
|
|
EncryptionKey
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Build the return structure
|
|
//
|
|
|
|
PackedPkAsRep = (PKERB_PA_DATA_LIST) MIDL_user_allocate(sizeof(KERB_PA_DATA_LIST));
|
|
if (PackedPkAsRep == NULL)
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
RtlZeroMemory(
|
|
PackedPkAsRep,
|
|
sizeof(KERB_PA_DATA_LIST)
|
|
);
|
|
|
|
PackedPkAsRep->next = NULL;
|
|
PackedPkAsRep->value.preauth_data_type = KRB5_PADATA_PK_AS_REP;
|
|
|
|
//
|
|
// Success. Now build the reply
|
|
//
|
|
|
|
if (PkAsReq2 != NULL)
|
|
{
|
|
KERB_PA_PK_AS_REP2 Reply = {0};
|
|
|
|
//
|
|
// Create the reply key package
|
|
//
|
|
|
|
//
|
|
// Create the reply key package, which contains the key used to encrypt
|
|
// the AS_REPLY.
|
|
//
|
|
|
|
KeyPack.reply_key_package.nonce = *Nonce;
|
|
KeyPack.reply_key_package.reply_key = *EncryptionKey;
|
|
|
|
KerbErr = KerbPackData(
|
|
&KeyPack.reply_key_package,
|
|
KERB_REPLY_KEY_PACKAGE2_PDU,
|
|
&PackedKeyPackSize,
|
|
&PackedKeyPack
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Acquire a crypt context for the private key of the certificate
|
|
//
|
|
|
|
if (!CryptAcquireCertificatePrivateKey(
|
|
KdcCert,
|
|
0, // no flags
|
|
NULL, // reserved
|
|
&KdcProvider,
|
|
NULL, // no key spec
|
|
&FreeProvider
|
|
))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to acquire KDC certificate private key: 0x%x\n",GetLastError()));
|
|
FILL_EXT_ERROR(pExtendedError, GetLastError(), FILENO, __LINE__);
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Now, to sign the reply key package
|
|
//
|
|
|
|
Status = ScHelperSignMessage(
|
|
NULL, // no pin
|
|
NULL, // no logon info
|
|
KdcProvider,
|
|
KERB_PKINIT_SIGNATURE_ALG,
|
|
PackedKeyPack,
|
|
PackedKeyPackSize,
|
|
PkSignature,
|
|
&PkSignatureLength
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to sign keypack: 0x%x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Copy the temporary signature into the return structure
|
|
//
|
|
|
|
KeyPack.reply_key_signature.pkcs_signature.length = PkSignatureLength * 8; // because it is a bit string
|
|
KeyPack.reply_key_signature.pkcs_signature.value = PkSignature;
|
|
KeyPack.reply_key_signature.signature_algorithm.algorithm = KdcSignatureAlg;
|
|
|
|
//
|
|
// Now marshall the signed key package
|
|
//
|
|
|
|
KerbErr = KerbPackData(
|
|
&KeyPack,
|
|
KERB_SIGNED_REPLY_KEY_PACKAGE_PDU,
|
|
&SignedKeyPackSize,
|
|
&SignedKeyPack
|
|
);
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Just encrypt the key package
|
|
//
|
|
|
|
PackedKey = SignedKeyPack;
|
|
PackedKeySize = SignedKeyPackSize;
|
|
|
|
//
|
|
// Zero these out so we don't free them twice
|
|
//
|
|
|
|
SignedKeyPack = NULL;
|
|
SignedKeyPackSize = 0;
|
|
|
|
|
|
//
|
|
// Compute the size of the encrypted temp key
|
|
//
|
|
//
|
|
|
|
|
|
ChangeCryptAlg2:
|
|
|
|
if (Kdc3DesSupported && KdcCheckForEtype(ClientRequest->encryption_type, KERB_PKINIT_SEAL_ETYPE))
|
|
{
|
|
Used3Des = TRUE;
|
|
CryptAlg.pszObjId = KERB_PKINIT_SEAL_OID;
|
|
}
|
|
else
|
|
{
|
|
CryptAlg.pszObjId = KERB_PKINIT_EXPORT_SEAL_OID;
|
|
if (!KdcCheckForEtype(ClientRequest->encryption_type, KERB_PKINIT_EXPORT_SEAL_ETYPE))
|
|
{
|
|
DebugLog((DEB_WARN,"Client doesn't claim to support exportable pkinit encryption type %d\n",
|
|
KERB_PKINIT_EXPORT_SEAL_ETYPE));
|
|
}
|
|
}
|
|
|
|
RequiredSize = 0;
|
|
Status = ScHelperEncryptMessage(
|
|
NULL,
|
|
KdcClientProvider,
|
|
CertContext,
|
|
&CryptAlg,
|
|
PackedKey,
|
|
PackedKeySize,
|
|
NULL,
|
|
(PULONG) &RequiredSize
|
|
);
|
|
if ((Status != ERROR_MORE_DATA) && (Status != STATUS_SUCCESS))
|
|
{
|
|
//
|
|
// 3des is only supported on domestic builds with the
|
|
// strong cryptography pack installed.
|
|
//
|
|
|
|
if ((Status == NTE_BAD_ALGID) && (Used3Des))
|
|
{
|
|
Kdc3DesSupported = FALSE;
|
|
goto ChangeCryptAlg2;
|
|
}
|
|
DebugLog((DEB_ERROR,"Failed to encrypt message: %x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
//
|
|
// Allocate the output size
|
|
//
|
|
|
|
EncryptedKeyPack = (PBYTE) MIDL_user_allocate(RequiredSize);
|
|
if (EncryptedKeyPack == NULL)
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Really do the encryption
|
|
//
|
|
|
|
|
|
Status = ScHelperEncryptMessage(
|
|
NULL,
|
|
KdcClientProvider,
|
|
CertContext,
|
|
&CryptAlg,
|
|
PackedKey,
|
|
PackedKeySize,
|
|
EncryptedKeyPack,
|
|
&RequiredSize
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to encrypt message: %x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Create the cert list for the reply
|
|
//
|
|
|
|
KerbErr = KerbCreateCertificateList(
|
|
&CertList,
|
|
KdcCert
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
//
|
|
// We will be returning the KDC cert as well as a package containing
|
|
// a temporary key
|
|
//
|
|
|
|
Reply.bit_mask |= KERB_PA_PK_AS_REP2_kdc_cert_present;
|
|
|
|
|
|
//
|
|
// Now, to finish the reply, we need a handle to the KDCs certificate
|
|
//
|
|
|
|
Reply.kdc_cert = (KERB_PA_PK_AS_REP2_kdc_cert) CertList;
|
|
|
|
Reply.temp_key_package.choice = pkinit_enveloped_data_chosen;
|
|
Reply.temp_key_package.u.pkinit_enveloped_data.length = (int) RequiredSize;
|
|
Reply.temp_key_package.u.pkinit_enveloped_data.value = EncryptedKeyPack;
|
|
|
|
KerbErr = KerbPackData(
|
|
&Reply,
|
|
KERB_PA_PK_AS_REP2_PDU,
|
|
(PULONG) &PackedPkAsRep->value.preauth_data.length,
|
|
&PackedPkAsRep->value.preauth_data.value
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
KERB_PA_PK_AS_REP Reply = {0};
|
|
|
|
//
|
|
// Create the reply key package
|
|
//
|
|
|
|
//
|
|
// Create the reply key package, which contains the key used to encrypt
|
|
// the AS_REPLY.
|
|
//
|
|
|
|
ReplyKey.nonce = *Nonce;
|
|
ReplyKey.reply_key = *EncryptionKey;
|
|
|
|
KerbErr = KerbPackData(
|
|
&ReplyKey,
|
|
KERB_REPLY_KEY_PACKAGE_PDU,
|
|
&PackedKeyPackSize,
|
|
&PackedKeyPack
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Acquire a crypt context for the private key of the certificate
|
|
//
|
|
|
|
if (!CryptAcquireCertificatePrivateKey(
|
|
KdcCert,
|
|
0, // no flags
|
|
NULL, // reserved
|
|
&KdcProvider,
|
|
NULL, // no key spec
|
|
&FreeProvider
|
|
))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to acquire KDC certificate private key: 0x%x\n",GetLastError()));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Now, to sign the reply key package
|
|
//
|
|
|
|
CryptAlg.pszObjId = KERB_PKINIT_SIGNATURE_OID;
|
|
|
|
Status = ScHelperSignPkcsMessage(
|
|
NULL, // no pin
|
|
NULL, // no logon info
|
|
KdcProvider,
|
|
KdcCert,
|
|
&CryptAlg,
|
|
CRYPT_MESSAGE_SILENT_KEYSET_FLAG, // dwSignMessageFlags
|
|
PackedKeyPack,
|
|
PackedKeyPackSize,
|
|
SignedKeyPack,
|
|
&SignedKeyPackSize
|
|
);
|
|
|
|
|
|
|
|
if ((Status != ERROR_MORE_DATA) && (Status != STATUS_SUCCESS))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to encrypt message: %x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
SignedKeyPack = (PBYTE) MIDL_user_allocate(SignedKeyPackSize);
|
|
if (SignedKeyPack == NULL)
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
Status = ScHelperSignPkcsMessage(
|
|
NULL, // no pin
|
|
NULL, // no logon info
|
|
KdcProvider,
|
|
KdcCert,
|
|
&CryptAlg,
|
|
CRYPT_MESSAGE_SILENT_KEYSET_FLAG, // dwSignMessageFlags
|
|
PackedKeyPack,
|
|
PackedKeyPackSize,
|
|
SignedKeyPack,
|
|
&SignedKeyPackSize
|
|
);
|
|
|
|
if (Status != STATUS_SUCCESS)
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to sign pkcs message: 0x%x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Now encrypt the content
|
|
//
|
|
|
|
//
|
|
// Compute the size of the encrypted temp key
|
|
//
|
|
//
|
|
|
|
|
|
ChangeCryptAlg:
|
|
if (Kdc3DesSupported && KdcCheckForEtype(ClientRequest->encryption_type, KERB_PKINIT_SEAL_ETYPE))
|
|
{
|
|
Used3Des = TRUE;
|
|
CryptAlg.pszObjId = KERB_PKINIT_SEAL_OID;
|
|
}
|
|
else
|
|
{
|
|
CryptAlg.pszObjId = KERB_PKINIT_EXPORT_SEAL_OID;
|
|
if (!KdcCheckForEtype(ClientRequest->encryption_type, KERB_PKINIT_EXPORT_SEAL_ETYPE))
|
|
{
|
|
DebugLog((DEB_WARN,"Client doesn't claim to support exportable pkinit encryption type %d\n",
|
|
KERB_PKINIT_EXPORT_SEAL_ETYPE));
|
|
}
|
|
}
|
|
|
|
RequiredSize = 0;
|
|
Status = ScHelperEncryptMessage(
|
|
NULL,
|
|
KdcClientProvider,
|
|
CertContext,
|
|
&CryptAlg,
|
|
SignedKeyPack,
|
|
SignedKeyPackSize,
|
|
NULL,
|
|
(PULONG) &RequiredSize
|
|
);
|
|
if ((Status != ERROR_MORE_DATA) && (Status != STATUS_SUCCESS))
|
|
{
|
|
//
|
|
// 3des is only supported on domestic builds with the
|
|
// strong cryptography pack installed.
|
|
//
|
|
|
|
if ((Status == NTE_BAD_ALGID) && (Used3Des))
|
|
{
|
|
Kdc3DesSupported = FALSE;
|
|
goto ChangeCryptAlg;
|
|
}
|
|
|
|
DebugLog((DEB_ERROR,"Failed to encrypt message (crypto mismatch?): %x\n",Status));
|
|
FILL_EXT_ERROR_EX(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
//
|
|
// Allocate the output size
|
|
//
|
|
|
|
EncryptedKeyPack = (PBYTE) MIDL_user_allocate(RequiredSize);
|
|
if (EncryptedKeyPack == NULL)
|
|
{
|
|
KerbErr = KRB_ERR_GENERIC;
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Really do the encryption
|
|
//
|
|
|
|
|
|
Status = ScHelperEncryptMessage(
|
|
NULL,
|
|
KdcClientProvider,
|
|
CertContext,
|
|
&CryptAlg,
|
|
SignedKeyPack,
|
|
SignedKeyPackSize,
|
|
EncryptedKeyPack,
|
|
&RequiredSize
|
|
);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
DebugLog((DEB_ERROR,"Failed to encrypt message: %x\n",Status));
|
|
FILL_EXT_ERROR(pExtendedError, Status, FILENO, __LINE__);
|
|
KerbErr = KRB_AP_ERR_MODIFIED;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Reply.u.key_package.value = EncryptedKeyPack;
|
|
Reply.u.key_package.length = RequiredSize;
|
|
Reply.choice = pkinit_enveloped_data_chosen;
|
|
|
|
KerbErr = KerbPackData(
|
|
&Reply,
|
|
KERB_PA_PK_AS_REP_PDU,
|
|
(PULONG) &PackedPkAsRep->value.preauth_data.length,
|
|
&PackedPkAsRep->value.preauth_data.value
|
|
);
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
}
|
|
|
|
*OutputPreAuthData = PackedPkAsRep;
|
|
PackedPkAsRep = NULL;
|
|
|
|
Cleanup:
|
|
|
|
if (FreeProvider)
|
|
{
|
|
CryptReleaseContext(
|
|
KdcProvider,
|
|
0
|
|
);
|
|
}
|
|
if (PkAsReq != NULL)
|
|
{
|
|
KerbFreeData(
|
|
KERB_PA_PK_AS_REQ_PDU,
|
|
PkAsReq
|
|
);
|
|
}
|
|
if (PkAsReq2 != NULL)
|
|
{
|
|
KerbFreeData(
|
|
KERB_PA_PK_AS_REQ2_PDU,
|
|
PkAsReq2
|
|
);
|
|
}
|
|
if (SignedKeyPack != NULL)
|
|
{
|
|
KdcFreeEncodedData(SignedKeyPack);
|
|
}
|
|
if (PackedKeyPack != NULL)
|
|
{
|
|
KdcFreeEncodedData(PackedKeyPack);
|
|
}
|
|
if (PackedAuthenticator != NULL)
|
|
{
|
|
KdcFreeEncodedData(PackedAuthenticator);
|
|
}
|
|
if (ClientKey != NULL)
|
|
{
|
|
CryptDestroyKey(ClientKey);
|
|
}
|
|
if (CertContext != NULL)
|
|
{
|
|
CertFreeCertificateContext(CertContext);
|
|
}
|
|
if(KdcCert)
|
|
{
|
|
CertFreeCertificateContext(KdcCert);
|
|
}
|
|
if (EncryptedKeyPack != NULL)
|
|
{
|
|
MIDL_user_free(EncryptedKeyPack);
|
|
}
|
|
if (EtypeArray != NULL)
|
|
{
|
|
MIDL_user_free(EtypeArray);
|
|
}
|
|
KerbFreeCertificateList(
|
|
CertList
|
|
);
|
|
KerbFreeKey(&TempKey);
|
|
if (PackedKey != NULL)
|
|
{
|
|
MIDL_user_free(PackedKey);
|
|
}
|
|
if (PackedPkAsRep != NULL)
|
|
{
|
|
if (PackedPkAsRep->value.preauth_data.value != NULL)
|
|
{
|
|
MIDL_user_free(PackedPkAsRep->value.preauth_data.value);
|
|
}
|
|
MIDL_user_free(PackedPkAsRep);
|
|
}
|
|
|
|
KerbFreeString(&ClientKdcName);
|
|
return(KerbErr);
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcMyStoreWaitHandler
|
|
//
|
|
// Synopsis: Retrieves a copy of the KDC cert
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
VOID
|
|
KdcMyStoreWaitHandler(
|
|
PVOID pVoid,
|
|
BOOLEAN fTimeout
|
|
)
|
|
{
|
|
|
|
PCCERT_CONTEXT Certificate = NULL, OldCertificate = NULL, Candidate = NULL;
|
|
CERT_CHAIN_POLICY_STATUS FinalChainStatus = {0};
|
|
KERB_EXT_ERROR DummyError;
|
|
|
|
KERBERR KerbErr;
|
|
BOOLEAN Found = FALSE;
|
|
ULONG PropertySize = 0;
|
|
|
|
// Diagnostic: When's the last time this event fired?
|
|
GetSystemTimeAsFileTime((PFILETIME) &KdcLastChangeEventTime);
|
|
|
|
//
|
|
// This was triggered by a timeout, so disable the store notification
|
|
// for now...
|
|
//
|
|
if (fTimeout)
|
|
{
|
|
if (!CertControlStore(
|
|
KdcCertStore, // in, the store to be controlled
|
|
0, // in, not used.
|
|
CERT_STORE_CTRL_CANCEL_NOTIFY,
|
|
&KdcCertStoreChangeEvent
|
|
))
|
|
{
|
|
D_DebugLog((DEB_ERROR, "CertControlStore (cancel notify) failed - %x\n", GetLastError()));
|
|
}
|
|
}
|
|
|
|
D_DebugLog((DEB_T_PKI, "Triggering KdcMyStoreWaitHandler()\n"));
|
|
|
|
|
|
//
|
|
// Resync store
|
|
//
|
|
CertControlStore(
|
|
KdcCertStore, // in, the store to be controlled
|
|
0, // in, not used.
|
|
CERT_STORE_CTRL_RESYNC, // in, control action type
|
|
NULL // Just resync store
|
|
);
|
|
|
|
|
|
RtlEnterCriticalSection(&KdcGlobalCertCritSect);
|
|
|
|
|
|
// Our my store changed, so we need to find the cert again.
|
|
if(GlobalKdcCert)
|
|
{
|
|
OldCertificate = CertDuplicateCertificateContext(GlobalKdcCert);
|
|
KerbErr = KdcCheckCertificate(
|
|
GlobalKdcCert,
|
|
&DummyError,
|
|
&FinalChainStatus,
|
|
TRUE // this is a kdc certificate
|
|
);
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
CertFreeCertificateContext(GlobalKdcCert);
|
|
GlobalKdcCert = NULL;
|
|
}
|
|
else
|
|
{
|
|
// certificate is good!
|
|
// However, it may have been deleted, so
|
|
// verify its existance
|
|
while ((Certificate = CertEnumCertificatesInStore(
|
|
KdcCertStore,
|
|
Certificate)) != NULL)
|
|
{
|
|
if (CertCompareCertificate(
|
|
X509_ASN_ENCODING | PKCS_7_ASN_ENCODING,
|
|
GlobalKdcCert->pCertInfo,
|
|
Certificate->pCertInfo
|
|
))
|
|
{
|
|
Found = TRUE;
|
|
break; // still there
|
|
}
|
|
}
|
|
|
|
if (NULL != Certificate)
|
|
{
|
|
CertFreeCertificateContext(Certificate);
|
|
Certificate = NULL;
|
|
}
|
|
|
|
if (Found)
|
|
{
|
|
goto Rearm;
|
|
}
|
|
|
|
CertFreeCertificateContext(GlobalKdcCert);
|
|
GlobalKdcCert = NULL;
|
|
}
|
|
}
|
|
|
|
if (NULL == GlobalKdcCert)
|
|
{
|
|
//
|
|
// Enumerate all the certificates looking for the one we want
|
|
//
|
|
while ((Certificate = CertEnumCertificatesInStore(
|
|
KdcCertStore,
|
|
Certificate)) != NULL)
|
|
{
|
|
CERT_CHAIN_POLICY_STATUS TempStatus;
|
|
|
|
//
|
|
// Check to see if the certificate is the one we want
|
|
//
|
|
if (!CertGetCertificateContextProperty(
|
|
Certificate,
|
|
CERT_KEY_PROV_INFO_PROP_ID,
|
|
NULL, // no data
|
|
&PropertySize))
|
|
{
|
|
continue;
|
|
}
|
|
|
|
//
|
|
// Make sure the cert we selected was "good"
|
|
//
|
|
KerbErr = KdcCheckCertificate(
|
|
Certificate,
|
|
&DummyError,
|
|
&TempStatus,
|
|
TRUE // this is a kdc certificate
|
|
);
|
|
|
|
|
|
if (!KERB_SUCCESS(KerbErr))
|
|
{
|
|
//
|
|
// Hack - lots of times we can't find a CRL, but we have a "mostly"
|
|
// valid certificate.
|
|
//
|
|
if (TempStatus.dwError == CRYPT_E_REVOCATION_OFFLINE)
|
|
{
|
|
if ( Candidate != NULL )
|
|
{
|
|
CertFreeCertificateContext(Candidate);
|
|
}
|
|
|
|
Candidate = CertDuplicateCertificateContext(Certificate);
|
|
D_DebugLog((DEB_ERROR, "Revocation offline - using somewhat good certificate\n"));
|
|
}
|
|
|
|
continue;
|
|
}
|
|
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Couldn't find a good certificate!
|
|
if (NULL == Certificate)
|
|
{
|
|
|
|
//
|
|
// Keep the old one... We might just be getting an offline CA
|
|
//
|
|
if (OldCertificate != NULL || Candidate != NULL)
|
|
{
|
|
|
|
if (OldCertificate)
|
|
{
|
|
D_DebugLog((DEB_T_PKI, "Re-using old certificate\n"));
|
|
GlobalKdcCert = OldCertificate;
|
|
OldCertificate = NULL;
|
|
}
|
|
else
|
|
{
|
|
GlobalKdcCert = Candidate;
|
|
Candidate = NULL;
|
|
}
|
|
|
|
ReportServiceEvent(
|
|
EVENTLOG_WARNING_TYPE,
|
|
KDCEVENT_INVALID_KDC_CERTIFICATE,
|
|
sizeof(FinalChainStatus) - sizeof(void*), // don't need ptr.
|
|
&FinalChainStatus,
|
|
0
|
|
);
|
|
|
|
}
|
|
else
|
|
//
|
|
// Never had one...
|
|
//
|
|
{
|
|
DebugLog((DEB_ERROR, "No valid KDC certificate was available\n"));
|
|
GlobalKdcCert = NULL;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
D_DebugLog((DEB_T_PKI, "Picked new KDC certificate\n"));
|
|
GlobalKdcCert = Certificate;
|
|
}
|
|
|
|
|
|
Rearm:
|
|
|
|
if (OldCertificate != NULL)
|
|
{
|
|
CertFreeCertificateContext(OldCertificate);
|
|
}
|
|
|
|
if (Candidate != NULL)
|
|
{
|
|
CertFreeCertificateContext(Candidate);
|
|
}
|
|
|
|
|
|
RtlLeaveCriticalSection(&KdcGlobalCertCritSect);
|
|
|
|
//
|
|
// This was moved here because of race conditions associated w/ my store
|
|
// chain building, where the event was getting fired rapidly, leading
|
|
// us to loose notification, and thus- the re-arm.
|
|
//
|
|
|
|
|
|
CertControlStore(
|
|
KdcCertStore, // in, the store to be controlled
|
|
0, // in, not used.
|
|
CERT_STORE_CTRL_NOTIFY_CHANGE, // in, control action type
|
|
&KdcCertStoreChangeEvent // in, the handle of the event
|
|
);
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcGetKdcCertificate
|
|
//
|
|
// Synopsis: Retrieves a copy of the KDC cert
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
KdcGetKdcCertificate(
|
|
PCCERT_CONTEXT *KdcCert
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
|
|
if(!KdcGlobalCertCritSectInitialized)
|
|
{
|
|
return STATUS_OBJECT_NAME_NOT_FOUND;
|
|
}
|
|
RtlEnterCriticalSection(&KdcGlobalCertCritSect);
|
|
|
|
|
|
if (GlobalKdcCert == NULL)
|
|
{
|
|
DebugLog((DEB_WARN,"Unable to find KDC certificate in KDC store\n"));
|
|
Status = STATUS_OBJECT_NAME_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
// Increment the ref count, so if we change certs while the caller of this
|
|
// is still using this cert, we won't delete it out from under.
|
|
|
|
*KdcCert = CertDuplicateCertificateContext(GlobalKdcCert);
|
|
if(*KdcCert == NULL)
|
|
{
|
|
Status = STATUS_OBJECT_NAME_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
Cleanup:
|
|
|
|
|
|
RtlLeaveCriticalSection(&KdcGlobalCertCritSect);
|
|
|
|
return(Status);
|
|
}
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcInitializeCerts
|
|
//
|
|
// Synopsis: Initializes data for cert handling
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
NTSTATUS
|
|
KdcInitializeCerts(
|
|
VOID
|
|
)
|
|
{
|
|
NTSTATUS Status = STATUS_SUCCESS;
|
|
ULONG Index;
|
|
LPSTR TempString = NULL, StringCopy = NULL, EndPtr = NULL;
|
|
ULONG TenHours;
|
|
|
|
|
|
TenHours = (ULONG) 1000 * 60 * 60 * 10;
|
|
|
|
Status = RtlInitializeCriticalSection(&KdcGlobalCertCritSect);
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
goto Cleanup;
|
|
}
|
|
|
|
KdcGlobalCertCritSectInitialized = TRUE;
|
|
|
|
if (!CryptAcquireContext(
|
|
&KdcClientProvider,
|
|
NULL, // default container
|
|
NULL,
|
|
PROV_RSA_FULL,
|
|
CRYPT_VERIFYCONTEXT
|
|
))
|
|
{
|
|
Status = GetLastError();
|
|
DebugLog((DEB_ERROR,"Failed to acquire client crypt context: 0x%x\n",Status));
|
|
goto Cleanup;
|
|
}
|
|
|
|
//
|
|
// Open the KDC store to get the KDC cert
|
|
//
|
|
|
|
KdcCertStore = CertOpenStore(
|
|
CERT_STORE_PROV_SYSTEM_W,
|
|
0, // no encoding
|
|
NULL, // no provider
|
|
CERT_STORE_OPEN_EXISTING_FLAG |
|
|
CERT_STORE_NO_CRYPT_RELEASE_FLAG |
|
|
CERT_SYSTEM_STORE_LOCAL_MACHINE,
|
|
KDC_PRIVATE_MY_STORE
|
|
);
|
|
if (KdcCertStore == NULL)
|
|
{
|
|
Status = GetLastError();
|
|
DebugLog((DEB_ERROR,"Failed to open %ws store: 0x%x\n", KDC_PRIVATE_MY_STORE,Status));
|
|
Status = STATUS_OBJECT_NAME_NOT_FOUND;
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
// Create an auto-reset event that is to be signaled when
|
|
// the my store is changed. This event is initialized to Signaled
|
|
// so that on first call to get a cert, we assume the my store is changed
|
|
// and do all the work.
|
|
|
|
KdcCertStoreChangeEvent = CreateEvent(
|
|
NULL,
|
|
FALSE,
|
|
FALSE,
|
|
NULL);
|
|
|
|
if(NULL == KdcCertStoreChangeEvent)
|
|
{
|
|
Status = GetLastError();
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
if (! RegisterWaitForSingleObject(&KdcCertStoreWait,
|
|
KdcCertStoreChangeEvent,
|
|
KdcMyStoreWaitHandler,
|
|
NULL,
|
|
TenHours,
|
|
WT_EXECUTEDEFAULT
|
|
))
|
|
{
|
|
Status = GetLastError();
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
// Arm the cert store for change notification
|
|
// CERT_CONTROL_STORE_NOTIFY_CHANGE.
|
|
|
|
if(!CertControlStore(
|
|
KdcCertStore, // The store to be controlled
|
|
0, // Not used
|
|
CERT_STORE_CTRL_NOTIFY_CHANGE, // Control action type
|
|
&KdcCertStoreChangeEvent)) // Points to the event handle.
|
|
// When a change is detected,
|
|
// a signal is written to the
|
|
// space pointed to by
|
|
// hHandle.
|
|
{
|
|
// Notification is not avaialble, so kill the Event
|
|
Status = GetLastError();
|
|
goto Cleanup;
|
|
}
|
|
|
|
|
|
//
|
|
// Initialize the object IDs
|
|
//
|
|
|
|
Index = 0;
|
|
StringCopy = (LPSTR) MIDL_user_allocate(strlen(KERB_PKINIT_SIGNATURE_OID)+1);
|
|
if (StringCopy == NULL)
|
|
{
|
|
Status = STATUS_INSUFFICIENT_RESOURCES;
|
|
goto Cleanup;
|
|
|
|
}
|
|
|
|
//
|
|
// Scan the string for every '.' separated number
|
|
//
|
|
|
|
strcpy(
|
|
StringCopy,
|
|
KERB_PKINIT_SIGNATURE_OID
|
|
);
|
|
|
|
TempString = StringCopy;
|
|
EndPtr = TempString;
|
|
|
|
while (TempString != NULL)
|
|
{
|
|
ULONG Temp;
|
|
|
|
while (*EndPtr != '\0' && *EndPtr != '.')
|
|
{
|
|
EndPtr++;
|
|
}
|
|
if (*EndPtr == '.')
|
|
{
|
|
*EndPtr = '\0';
|
|
EndPtr++;
|
|
}
|
|
else
|
|
{
|
|
EndPtr = NULL;
|
|
}
|
|
|
|
sscanf(TempString,"%u",&Temp);
|
|
KdcSignatureAlg[Index].value = (USHORT) Temp;
|
|
KdcSignatureAlg[Index].next = &KdcSignatureAlg[Index+1];
|
|
Index++;
|
|
|
|
|
|
TempString = EndPtr;
|
|
|
|
|
|
}
|
|
DsysAssert(Index != 0);
|
|
KdcSignatureAlg[Index-1].next = NULL;
|
|
MIDL_user_free(StringCopy);
|
|
StringCopy = NULL;
|
|
|
|
|
|
|
|
Cleanup:
|
|
if (!NT_SUCCESS(Status))
|
|
{
|
|
KdcCleanupCerts(FALSE);
|
|
}
|
|
return(Status);
|
|
|
|
}
|
|
|
|
|
|
//+-------------------------------------------------------------------------
|
|
//
|
|
// Function: KdcCleanupCerts
|
|
//
|
|
// Synopsis: Cleans up data associated with certificate handling
|
|
//
|
|
// Effects:
|
|
//
|
|
// Arguments:
|
|
//
|
|
// Requires:
|
|
//
|
|
// Returns:
|
|
//
|
|
// Notes:
|
|
//
|
|
//
|
|
//--------------------------------------------------------------------------
|
|
|
|
|
|
VOID
|
|
KdcCleanupCerts(
|
|
IN BOOLEAN CleanupScavenger
|
|
)
|
|
{
|
|
|
|
HANDLE WaitHandle;
|
|
|
|
|
|
//
|
|
// Pete code used to hold the critsec in the callback.
|
|
//
|
|
if(KdcCertStoreWait)
|
|
{
|
|
WaitHandle = (HANDLE) InterlockedExchangePointer(&KdcCertStoreWait,NULL);
|
|
UnregisterWaitEx(WaitHandle, INVALID_HANDLE_VALUE);
|
|
}
|
|
|
|
|
|
if(KdcGlobalCertCritSectInitialized)
|
|
{
|
|
RtlEnterCriticalSection(&KdcGlobalCertCritSect);
|
|
}
|
|
|
|
if (GlobalKdcCert != NULL)
|
|
{
|
|
CertFreeCertificateContext(
|
|
GlobalKdcCert
|
|
);
|
|
GlobalKdcCert = NULL;
|
|
}
|
|
|
|
if (KdcCertStore != NULL)
|
|
{
|
|
CertCloseStore(
|
|
KdcCertStore,
|
|
CERT_CLOSE_STORE_FORCE_FLAG
|
|
);
|
|
KdcCertStore = NULL;
|
|
}
|
|
|
|
if(KdcCertStoreChangeEvent)
|
|
{
|
|
CloseHandle(KdcCertStoreChangeEvent);
|
|
KdcCertStoreChangeEvent = NULL;
|
|
}
|
|
|
|
if (KdcClientProvider != NULL)
|
|
{
|
|
CryptReleaseContext(
|
|
KdcClientProvider,
|
|
0 // no flags
|
|
);
|
|
KdcClientProvider = NULL;
|
|
}
|
|
|
|
|
|
|
|
if(KdcGlobalCertCritSectInitialized)
|
|
{
|
|
RtlLeaveCriticalSection(&KdcGlobalCertCritSect);
|
|
|
|
RtlDeleteCriticalSection(&KdcGlobalCertCritSect);
|
|
KdcGlobalCertCritSectInitialized = FALSE;
|
|
}
|
|
}
|