503 lines
13 KiB
C++
503 lines
13 KiB
C++
|
||
//+-----------------------------------------------------------------------
|
||
//
|
||
// Microsoft Windows
|
||
//
|
||
// Copyright (c) Microsoft Corporation 2000
|
||
//
|
||
// File: parser.cxx
|
||
//
|
||
// Contents: Digest Access Parser for directives
|
||
// Main entry points into this dll:
|
||
// ParseForNames
|
||
// CheckItemInList
|
||
// Very primitive parser. All strings must be quoted except for NC
|
||
//
|
||
// History: KDamour 16Mar00 Based on IIS authfilt.cxx
|
||
//
|
||
//------------------------------------------------------------------------
|
||
|
||
#include <global.h>
|
||
|
||
|
||
// Used by parser to find the keywords
|
||
// Keep insync with enum MD5_AUTH_NAME
|
||
PSTR MD5_AUTH_NAMES[] = {
|
||
"username",
|
||
"realm",
|
||
"nonce",
|
||
"cnonce",
|
||
"nc",
|
||
"algorithm",
|
||
"qop",
|
||
"method",
|
||
"uri",
|
||
"response",
|
||
"hentity",
|
||
"authzid",
|
||
"domain",
|
||
"stale",
|
||
"opaque",
|
||
"maxbuf",
|
||
"charset",
|
||
"cipher",
|
||
"digest-uri",
|
||
"rspauth",
|
||
"" // Not really needed
|
||
};
|
||
|
||
|
||
|
||
enum STATE_TYPE
|
||
{
|
||
READY,
|
||
DIRECTIVE,
|
||
ASSIGNMENT,
|
||
QUOTEDVALUE,
|
||
VALUE,
|
||
ENDING,
|
||
PROCESS_ENTRY,
|
||
FAILURE
|
||
};
|
||
|
||
|
||
//+--------------------------------------------------------------------
|
||
//
|
||
// Function: DigestParser2
|
||
//
|
||
// Synopsis: Parse list of name=value pairs for known names
|
||
//
|
||
// Effects:
|
||
//
|
||
// Arguments: pszStr - line to parse ( '\0' delimited - terminated)
|
||
// pNameTable - table of known names
|
||
// cNameTable - number of known names
|
||
// pDigest - set all of the directives in pDigest->strParams[x}
|
||
//
|
||
// Returns: STATUS_SUCCESS if success, E_FAIL if error
|
||
//
|
||
// Notes:
|
||
// Buffers are not wide Unicode!
|
||
//
|
||
//
|
||
//---------------------------------------------------------------------
|
||
NTSTATUS DigestParser2(
|
||
PSecBuffer pInputBuf,
|
||
PSTR *pNameTable,
|
||
UINT cNameTable,
|
||
OUT PDIGEST_PARAMETER pDigest
|
||
)
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
PSTR pcBeginName = NULL;
|
||
PSTR pcEndName = NULL;
|
||
PSTR pcBeginValue = NULL;
|
||
PSTR pcEndValue = NULL;
|
||
PSTR pcEndBuffer = NULL; // End of buffer to prevent NC increment from going past end
|
||
PSTR pcCurrent = NULL;
|
||
STATE_TYPE parserstate = READY;
|
||
BOOL fEscapedChar = FALSE;
|
||
|
||
|
||
LONG cbDirective = 0;
|
||
LONG cbValue = 0;
|
||
|
||
// Verify that buffer exists and is of type single byte characters (not Unicode)
|
||
if (!pInputBuf || (pInputBuf->cbBuffer && !pInputBuf->pvBuffer) ||
|
||
(PBUFFERTYPE(pInputBuf) != SECBUFFER_TOKEN))
|
||
{
|
||
Status = SEC_E_INVALID_TOKEN;
|
||
DebugLog((DEB_ERROR, "DigestParser2: Incorrect digest buffer format status 0x%x\n", Status));
|
||
goto CleanUp;
|
||
}
|
||
|
||
if (!pInputBuf->cbBuffer)
|
||
{
|
||
return STATUS_SUCCESS; // Nothing to process happens with makesignature
|
||
}
|
||
|
||
pcEndBuffer = (char *)pInputBuf->pvBuffer + pInputBuf->cbBuffer;
|
||
|
||
for (pcCurrent = (char *)pInputBuf->pvBuffer; pcCurrent < pcEndBuffer; pcCurrent++)
|
||
{
|
||
if (parserstate == FAILURE)
|
||
{
|
||
break;
|
||
}
|
||
if (*pcCurrent == CHAR_NULL)
|
||
{ // If we hit a premature End of String then Exit immediately from scan
|
||
break;
|
||
}
|
||
if (parserstate == READY)
|
||
{
|
||
if (isspace(*pcCurrent) || (*pcCurrent == CHAR_COMMA))
|
||
{
|
||
continue; // get next char within for loop
|
||
}
|
||
pcBeginName = pcCurrent;
|
||
pcEndName = pcCurrent;
|
||
pcBeginValue = pcEndValue = NULL;
|
||
parserstate = DIRECTIVE;
|
||
continue;
|
||
}
|
||
if (parserstate == DIRECTIVE)
|
||
{
|
||
if (*pcCurrent == CHAR_EQUAL)
|
||
{
|
||
parserstate = ASSIGNMENT;
|
||
continue;
|
||
}
|
||
if (isspace(*pcCurrent))
|
||
{
|
||
continue; // get next char within for loop
|
||
}
|
||
pcEndName = pcCurrent;
|
||
continue;
|
||
}
|
||
if (parserstate == ASSIGNMENT)
|
||
{
|
||
if (*pcCurrent == CHAR_DQUOTE)
|
||
{
|
||
pcBeginValue = NULL;
|
||
pcEndValue = NULL;
|
||
parserstate = QUOTEDVALUE;
|
||
continue;
|
||
}
|
||
if (isspace(*pcCurrent))
|
||
{
|
||
continue; // get next char within for loop
|
||
}
|
||
pcBeginValue = pcCurrent;
|
||
pcEndValue = pcCurrent;
|
||
parserstate = VALUE;
|
||
continue;
|
||
}
|
||
if (parserstate == QUOTEDVALUE)
|
||
{
|
||
if ((*pcCurrent == CHAR_BACKSLASH) && (fEscapedChar == FALSE))
|
||
{
|
||
// used to escape the following character
|
||
fEscapedChar = TRUE;
|
||
continue;
|
||
}
|
||
if ((*pcCurrent == CHAR_DQUOTE) && (fEscapedChar == FALSE))
|
||
{
|
||
Status = DigestProcessEntry(pcBeginName, pcEndName, pcBeginValue, pcEndValue,
|
||
pNameTable, cNameTable, TRUE, pDigest);
|
||
parserstate = READY; // start again statemachine
|
||
continue;
|
||
}
|
||
fEscapedChar = FALSE; // reset to not escaped state
|
||
if (!pcBeginValue)
|
||
{
|
||
pcBeginValue = pcCurrent;
|
||
pcEndValue = pcCurrent;
|
||
continue;
|
||
}
|
||
pcEndValue = pcCurrent;
|
||
continue;
|
||
}
|
||
if (parserstate == VALUE)
|
||
{
|
||
if (isspace(*pcCurrent))
|
||
{
|
||
continue; // get next char within for loop
|
||
}
|
||
if (*pcCurrent == CHAR_COMMA)
|
||
{
|
||
Status = DigestProcessEntry(pcBeginName, pcEndName, pcBeginValue, pcEndValue,
|
||
pNameTable, cNameTable, FALSE, pDigest);
|
||
parserstate = READY; // start again statemachine
|
||
continue;
|
||
}
|
||
else
|
||
{
|
||
pcEndValue = pcCurrent;
|
||
}
|
||
}
|
||
}
|
||
|
||
if ((parserstate == FAILURE) || (parserstate == QUOTEDVALUE) ||
|
||
(parserstate == ASSIGNMENT) || (parserstate == DIRECTIVE))
|
||
{
|
||
Status = E_FAIL;
|
||
goto CleanUp;
|
||
}
|
||
|
||
// There might be a NULL terminated directive value to process
|
||
if ((parserstate == VALUE))
|
||
{
|
||
Status = DigestProcessEntry(pcBeginName, pcEndName, pcBeginValue, pcEndValue,
|
||
pNameTable, cNameTable, FALSE, pDigest);
|
||
}
|
||
|
||
|
||
CleanUp:
|
||
DebugLog((DEB_TRACE, "DigestParser: leaving status 0x%x\n", Status));
|
||
return(Status);
|
||
}
|
||
|
||
|
||
NTSTATUS DigestProcessEntry(
|
||
IN PSTR pcBeginName,
|
||
IN PSTR pcEndName,
|
||
IN PSTR pcBeginValue,
|
||
IN PSTR pcEndValue,
|
||
IN PSTR *pNameTable,
|
||
IN UINT cNameTable,
|
||
IN BOOL fBSlashEncoded,
|
||
OUT PDIGEST_PARAMETER pDigest
|
||
)
|
||
{
|
||
NTSTATUS Status = STATUS_SUCCESS;
|
||
USHORT cbName = 0;
|
||
USHORT cbValue = 0;
|
||
UINT iN = 0;
|
||
BOOL fBSPresent = FALSE;
|
||
PCHAR pcTemp = NULL;
|
||
PSTR pcDst = NULL;
|
||
PSTR pcLoc = NULL;
|
||
USHORT iCnt = 0;
|
||
|
||
if (!pcBeginName || !pcEndName)
|
||
{
|
||
DebugLog((DEB_ERROR, "DigestProcessEntry: Badly formed directive\n"));
|
||
return (STATUS_UNSUCCESSFUL);
|
||
}
|
||
cbName = (USHORT)(pcEndName - pcBeginName) + 1;
|
||
|
||
if (pcBeginValue && pcEndValue)
|
||
{
|
||
cbValue = (USHORT)(pcEndValue - pcBeginValue) + 1;
|
||
}
|
||
else
|
||
cbValue = 0;
|
||
|
||
for ( iN = 0 ; iN < cNameTable ; ++iN )
|
||
{
|
||
if ( !_strnicmp( pNameTable[iN], pcBeginName, cbName ) )
|
||
{
|
||
// DebugLog((DEB_TRACE, "DigestParser: Found %s directive in table put in value %s!\n", pszBeginName, pszBeginVal));
|
||
break;
|
||
}
|
||
}
|
||
|
||
if ( iN < cNameTable ) // We found a match!!!!!
|
||
{
|
||
if (iN == MD5_AUTH_DIGESTURI)
|
||
{
|
||
iN = MD5_AUTH_URI; // Map SASL's "digest-uri" to "uri"
|
||
}
|
||
|
||
if (cbValue)
|
||
{
|
||
// For space optimization, if not Backslash encoded then use orginal memory buffer
|
||
// To simply code, can removed all refernces and just use a copy of the original
|
||
// while removing the backslash characters
|
||
if (fBSlashEncoded == TRUE)
|
||
{
|
||
// quick search to see if there is a BackSlash character there
|
||
fBSPresent = CheckBSlashChar(pcBeginValue, cbValue);
|
||
if (fBSPresent == TRUE)
|
||
{
|
||
pcDst = (PCHAR)DigestAllocateMemory(cbValue + 1);
|
||
if (!pcDst)
|
||
{
|
||
Status = SEC_E_INSUFFICIENT_MEMORY;
|
||
DebugLog((DEB_ERROR, "DigestProcessEntry: allocate error 0x%x\n", Status));
|
||
goto CleanUp;
|
||
}
|
||
|
||
// Now copy over the string removing and back slash encoding
|
||
pcLoc = pcBeginValue;
|
||
pcTemp = pcDst;
|
||
while (pcLoc <= pcEndValue)
|
||
{
|
||
if (*pcLoc == CHAR_BACKSLASH)
|
||
{
|
||
pcLoc++; // eat the backslash
|
||
}
|
||
*pcTemp++ = *pcLoc++;
|
||
iCnt++;
|
||
}
|
||
// give the memory to member structure
|
||
pDigest->strDirective[iN].Buffer = pcDst;
|
||
pDigest->strDirective[iN].Length = iCnt;
|
||
pDigest->strDirective[iN].MaximumLength = cbValue+1;
|
||
pcDst = NULL;
|
||
|
||
pDigest->refstrParam[iN].Buffer = pDigest->strDirective[iN].Buffer;
|
||
pDigest->refstrParam[iN].Length = pDigest->strDirective[iN].Length;
|
||
pDigest->refstrParam[iN].MaximumLength = pDigest->strDirective[iN].MaximumLength;
|
||
}
|
||
else
|
||
{
|
||
pDigest->refstrParam[iN].Buffer = pcBeginValue;
|
||
pDigest->refstrParam[iN].Length = cbValue;
|
||
pDigest->refstrParam[iN].MaximumLength = cbValue;
|
||
}
|
||
|
||
}
|
||
else
|
||
{
|
||
pDigest->refstrParam[iN].Buffer = pcBeginValue;
|
||
pDigest->refstrParam[iN].Length = cbValue;
|
||
pDigest->refstrParam[iN].MaximumLength = cbValue;
|
||
}
|
||
}
|
||
}
|
||
|
||
CleanUp:
|
||
|
||
return(Status);
|
||
}
|
||
|
||
|
||
//+--------------------------------------------------------------------
|
||
//
|
||
// Function: CheckBSlashChar
|
||
//
|
||
// Synopsis: Search a string for a Back Slash character
|
||
//
|
||
// Effects:
|
||
//
|
||
// Arguments:
|
||
// pcStr - pointer to string of characters
|
||
// len - number of characters to search
|
||
//
|
||
// Returns: TRUE if found, FALSE otherwise
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//---------------------------------------------------------------------
|
||
BOOL CheckBSlashChar(
|
||
IN PSTR pcStr,
|
||
IN USHORT len)
|
||
{
|
||
BOOL fFound = FALSE;
|
||
USHORT i = 0;
|
||
|
||
for (i = 0; i < len; i++)
|
||
{
|
||
if (*pcStr++ == CHAR_BACKSLASH)
|
||
{
|
||
fFound = TRUE;
|
||
break;
|
||
}
|
||
}
|
||
|
||
return (fFound);
|
||
}
|
||
|
||
|
||
|
||
//+--------------------------------------------------------------------
|
||
//
|
||
// Function: CheckItemInList
|
||
//
|
||
// Synopsis: Searches a comma delimited list for specified string
|
||
//
|
||
// Effects:
|
||
//
|
||
// Arguments:
|
||
// pstrItem - pointer to string Item to look for
|
||
// pstrList - pointer to string of comma delimited list
|
||
// fOneItem - enforce that only 1 item is in List provided (no comma lists)
|
||
//
|
||
// Returns: STATUS_SUCCESS if found, E_FAIL otherwise
|
||
//
|
||
// Notes:
|
||
//
|
||
//
|
||
//---------------------------------------------------------------------
|
||
NTSTATUS CheckItemInList(
|
||
PCHAR pszItem,
|
||
PSTRING pstrList,
|
||
BOOL fOneItem
|
||
)
|
||
{
|
||
int cbItem = 0;
|
||
int cbListItem = 0;
|
||
char *pch = NULL;
|
||
char *pchStart = NULL;
|
||
USHORT cbCnt = 0;
|
||
|
||
ASSERT(pszItem);
|
||
ASSERT(pstrList);
|
||
|
||
// check to make sure that there is data in the list
|
||
if (!pstrList->Length)
|
||
{
|
||
return(E_FAIL);
|
||
}
|
||
|
||
// There MUST be a bu
|
||
ASSERT(pstrList->Buffer);
|
||
|
||
pch = pstrList->Buffer;
|
||
pchStart = NULL;
|
||
cbItem = strlen(pszItem);
|
||
|
||
// If oneItem selected then item MUST match list
|
||
if (fOneItem)
|
||
{
|
||
if ((cbItem == pstrList->Length) &&
|
||
(!_strnicmp(pszItem, pstrList->Buffer, cbItem)))
|
||
{
|
||
return(STATUS_SUCCESS);
|
||
}
|
||
else
|
||
{
|
||
return(E_FAIL);
|
||
}
|
||
}
|
||
|
||
// Scan List until NULL
|
||
while ((*pch != '\0') && (cbCnt < pstrList->Length))
|
||
{
|
||
// At start of next item in list
|
||
// skip any whitespaces
|
||
if (isspace((unsigned int)*pch) || (*pch == ','))
|
||
{
|
||
pch++;
|
||
cbCnt++;
|
||
continue; // skip to the next while
|
||
}
|
||
|
||
// pointing at start of next item
|
||
|
||
pchStart = pch;
|
||
|
||
// scan for end of item
|
||
while ((*pch != ',') && (*pch != '\0') && (cbCnt < pstrList->Length))
|
||
{
|
||
pch++;
|
||
cbCnt++;
|
||
}
|
||
|
||
// pch points to end of item
|
||
cbListItem = (int)(pch - pchStart);
|
||
|
||
// Check it item matches item in list
|
||
if (cbListItem == cbItem)
|
||
{
|
||
if (!_strnicmp(pszItem, pchStart, cbItem))
|
||
{
|
||
// found a match
|
||
return(STATUS_SUCCESS);
|
||
}
|
||
}
|
||
|
||
// If not end of List then skip to next character
|
||
if (*pch != '\0')
|
||
{
|
||
pch++;
|
||
cbCnt++;
|
||
}
|
||
|
||
}
|
||
|
||
return(E_FAIL);
|
||
}
|