📄 cryptses.c
字号:
/* Remember the value */
return( addSessionAttribute( &sessionInfoPtr->attributeList,
messageValue, msgData->data,
msgData->length ) );
case CRYPT_SESSINFO_SERVER_NAME:
{
const PROTOCOL_INFO *protocolInfoPtr = \
sessionInfoPtr->protocolInfo;
URL_INFO urlInfo;
int status;
assert( msgData->length > 0 && msgData->length < MAX_URL_SIZE );
if( findSessionAttribute( sessionInfoPtr->attributeList,
CRYPT_SESSINFO_SERVER_NAME ) != NULL )
return( exitErrorInited( sessionInfoPtr,
CRYPT_SESSINFO_SERVER_NAME ) );
/* If there's already a transport session or network socket
specified, we can't set a server name as well */
if( sessionInfoPtr->transportSession != CRYPT_ERROR )
return( exitErrorInited( sessionInfoPtr,
CRYPT_SESSINFO_SESSION ) );
if( sessionInfoPtr->networkSocket != CRYPT_ERROR )
return( exitErrorInited( sessionInfoPtr,
CRYPT_SESSINFO_NETWORKSOCKET ) );
/* Parse the server name */
status = sNetParseURL( &urlInfo, msgData->data,
msgData->length );
if( cryptStatusError( status ) )
return( exitError( sessionInfoPtr, CRYPT_SESSINFO_SERVER_NAME,
CRYPT_ERRTYPE_ATTR_VALUE,
CRYPT_ARGERROR_STR1 ) );
/* We can only use autodetection with PKI services */
if( !strCompare( msgData->data, "[Autodetect]",
msgData->length ) && \
!protocolInfoPtr->isReqResp )
return( exitError( sessionInfoPtr, CRYPT_SESSINFO_SERVER_NAME,
CRYPT_ERRTYPE_ATTR_VALUE,
CRYPT_ARGERROR_STR1 ) );
/* If there's a port or user name specified in the URL, set the
appropriate attributes */
if( urlInfo.userInfoLen > 0 )
{
RESOURCE_DATA userInfoMsgData;
krnlSendMessage( sessionInfoPtr->objectHandle,
IMESSAGE_DELETEATTRIBUTE, NULL,
CRYPT_SESSINFO_USERNAME );
setMessageData( &userInfoMsgData, ( void * ) urlInfo.userInfo,
urlInfo.userInfoLen );
status = krnlSendMessage( sessionInfoPtr->objectHandle,
IMESSAGE_SETATTRIBUTE_S,
&userInfoMsgData,
CRYPT_SESSINFO_USERNAME );
}
if( cryptStatusOK( status ) && urlInfo.port > 0 )
{
krnlSendMessage( sessionInfoPtr->objectHandle,
IMESSAGE_DELETEATTRIBUTE, NULL,
CRYPT_SESSINFO_SERVER_PORT );
status = krnlSendMessage( sessionInfoPtr->objectHandle,
IMESSAGE_SETATTRIBUTE, &urlInfo.port,
CRYPT_SESSINFO_SERVER_PORT );
}
if( cryptStatusError( status ) )
return( exitError( sessionInfoPtr, CRYPT_SESSINFO_SERVER_NAME,
CRYPT_ERRTYPE_ATTR_VALUE,
CRYPT_ARGERROR_STR1 ) );
/* Remember the server name */
if( urlInfo.hostLen + urlInfo.locationLen + 1 > MAX_URL_SIZE )
{
/* This should never happen since the overall URL size has
to be less than MAX_URL_SIZE */
assert( NOTREACHED );
return( exitError( sessionInfoPtr, CRYPT_SESSINFO_SERVER_NAME,
CRYPT_ERRTYPE_ATTR_VALUE,
CRYPT_ARGERROR_STR1 ) );
}
if( urlInfo.locationLen <= 0 )
status = addSessionAttribute( &sessionInfoPtr->attributeList,
CRYPT_SESSINFO_SERVER_NAME,
urlInfo.host, urlInfo.hostLen );
else
{
char urlBuffer[ MAX_URL_SIZE ];
memcpy( urlBuffer, urlInfo.host, urlInfo.hostLen );
memcpy( urlBuffer + urlInfo.hostLen,
urlInfo.location, urlInfo.locationLen );
status = addSessionAttribute( &sessionInfoPtr->attributeList,
CRYPT_SESSINFO_SERVER_NAME, urlBuffer,
urlInfo.hostLen + urlInfo.locationLen );
}
if( cryptStatusError( status ) )
return( status );
/* Remember the transport type */
if( protocolInfoPtr->altProtocolInfo != NULL && \
urlInfo.schemaLen == \
strlen( protocolInfoPtr->altProtocolInfo->uriType ) && \
!strCompare( urlInfo.schema,
protocolInfoPtr->altProtocolInfo->uriType,
strlen( protocolInfoPtr->altProtocolInfo->uriType ) ) )
{
/* The caller has specified the use of the altnernate
transport protocol type, switch to that instead of HTTP */
sessionInfoPtr->flags &= ~protocolInfoPtr->altProtocolInfo->oldFlagsMask;
sessionInfoPtr->flags |= protocolInfoPtr->altProtocolInfo->newFlags;
}
else
if( sessionInfoPtr->protocolInfo->flags & SESSION_ISHTTPTRANSPORT )
{
sessionInfoPtr->flags &= ~SESSION_USEALTTRANSPORT;
sessionInfoPtr->flags |= SESSION_ISHTTPTRANSPORT;
}
return( CRYPT_OK );
}
}
assert( NOTREACHED );
return( CRYPT_ERROR ); /* Get rid of compiler warning */
}
static int processDeleteAttribute( SESSION_INFO *sessionInfoPtr,
const int messageValue )
{
const ATTRIBUTE_LIST *attributeListPtr;
/* Handle the various information types */
switch( messageValue )
{
case CRYPT_OPTION_NET_CONNECTTIMEOUT:
if( sessionInfoPtr->connectTimeout == CRYPT_ERROR )
return( exitErrorNotFound( sessionInfoPtr,
CRYPT_ERROR_NOTINITED ) );
sessionInfoPtr->connectTimeout = CRYPT_ERROR;
return( CRYPT_OK );
case CRYPT_OPTION_NET_READTIMEOUT:
if( sessionInfoPtr->readTimeout == CRYPT_ERROR )
return( exitErrorNotFound( sessionInfoPtr,
CRYPT_ERROR_NOTINITED ) );
sessionInfoPtr->readTimeout = CRYPT_ERROR;
return( CRYPT_OK );
case CRYPT_OPTION_NET_WRITETIMEOUT:
if( sessionInfoPtr->writeTimeout == CRYPT_ERROR )
return( exitErrorNotFound( sessionInfoPtr,
CRYPT_ERROR_NOTINITED ) );
sessionInfoPtr->writeTimeout = CRYPT_ERROR;
return( CRYPT_OK );
case CRYPT_SESSINFO_USERNAME:
case CRYPT_SESSINFO_PASSWORD:
case CRYPT_SESSINFO_SERVER_NAME:
case CRYPT_SESSINFO_SERVER_PORT:
/* Make sure that the attribute to delete is actually present */
attributeListPtr = \
findSessionAttribute( sessionInfoPtr->attributeList,
messageValue );
if( attributeListPtr == NULL )
return( exitErrorNotFound( sessionInfoPtr, messageValue ) );
/* Delete the attribute */
deleteSessionAttribute( &sessionInfoPtr->attributeList,
( ATTRIBUTE_LIST * ) attributeListPtr );
return( CRYPT_OK );
case CRYPT_SESSINFO_REQUEST:
if( sessionInfoPtr->iCertRequest == CRYPT_ERROR )
return( exitErrorNotFound( sessionInfoPtr,
CRYPT_SESSINFO_REQUEST ) );
krnlSendNotifier( sessionInfoPtr->iCertRequest,
IMESSAGE_DECREFCOUNT );
sessionInfoPtr->iCertRequest = CRYPT_ERROR;
return( CRYPT_OK );
case CRYPT_SESSINFO_TSP_MSGIMPRINT:
if( sessionInfoPtr->sessionTSP->imprintAlgo == CRYPT_ALGO_NONE || \
sessionInfoPtr->sessionTSP->imprintSize <= 0 )
return( exitErrorNotFound( sessionInfoPtr,
CRYPT_SESSINFO_TSP_MSGIMPRINT ) );
sessionInfoPtr->sessionTSP->imprintAlgo = CRYPT_ALGO_NONE;
sessionInfoPtr->sessionTSP->imprintSize = 0;
return( CRYPT_OK );
}
assert( NOTREACHED );
return( CRYPT_ERROR ); /* Get rid of compiler warning */
}
/****************************************************************************
* *
* Session Message Handler *
* *
****************************************************************************/
/* Handle a message sent to a session object */
static int sessionMessageFunction( const void *objectInfoPtr,
const MESSAGE_TYPE message,
void *messageDataPtr,
const int messageValue )
{
SESSION_INFO *sessionInfoPtr = ( SESSION_INFO * ) objectInfoPtr;
/* Process destroy object messages */
if( message == MESSAGE_DESTROY )
{
/* Shut down the session if required. Nemo nisi mors */
if( sessionInfoPtr->flags & SESSION_ISOPEN )
sessionInfoPtr->shutdownFunction( sessionInfoPtr );
/* Clear and free session state information if necessary */
if( sessionInfoPtr->sendBuffer != NULL )
{
zeroise( sessionInfoPtr->sendBuffer,
sessionInfoPtr->sendBufSize );
clFree( "sessionMessageFunction", sessionInfoPtr->sendBuffer );
}
if( sessionInfoPtr->receiveBuffer != NULL )
{
zeroise( sessionInfoPtr->receiveBuffer,
sessionInfoPtr->receiveBufSize );
clFree( "sessionMessageFunction", sessionInfoPtr->receiveBuffer );
}
/* Clear session attributes if necessary */
if( sessionInfoPtr->attributeList != NULL )
deleteSessionAttributes( &sessionInfoPtr->attributeList );
/* Clean up any session-related objects if necessary */
if( sessionInfoPtr->iKeyexCryptContext != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iKeyexCryptContext,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iKeyexAuthContext != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iKeyexAuthContext,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iCryptInContext != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iCryptInContext,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iCryptOutContext != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iCryptOutContext,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iAuthInContext != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iAuthInContext,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iAuthOutContext != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iAuthOutContext,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iCertRequest != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iCertRequest,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->iCertResponse != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->iCertResponse,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->privateKey != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->privateKey,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->cryptKeyset != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->cryptKeyset,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->privKeyset != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->privKeyset,
IMESSAGE_DECREFCOUNT );
if( sessionInfoPtr->transportSession != CRYPT_ERROR )
krnlSendNotifier( sessionInfoPtr->transportSession,
IMESSAGE_DECREFCOUNT );
return( CRYPT_OK );
}
/* Process attribute get/set/delete messages */
if( isAttributeMessage( message ) )
{
/* If it's a protocol-specific attribute, forward it directly to
the low-level code */
if( message != MESSAGE_DELETEATTRIBUTE && \
( ( messageValue >= CRYPT_SESSINFO_FIRST_SPECIFIC && \
messageValue <= CRYPT_SESSINFO_LAST_SPECIFIC ) || \
messageValue == CRYPT_IATTRIBUTE_ENC_TIMESTAMP ) )
{
int status;
if( message == MESSAGE_SETATTRIBUTE || \
message == MESSAGE_SETATTRIBUTE_S )
{
assert( sessionInfoPtr->setAttributeFunction != NULL );
status = sessionInfoPtr->setAttributeFunction( sessionInfoPtr,
messageDataPtr, messageValue );
if( status == CRYPT_ERROR_INITED )
return( exitErrorInited( sessionInfoPtr,
messageValue ) );
}
else
{
assert( message == MESSAGE_GETATTRIBUTE || \
message == MESSAGE_GETATTRIBUTE_S );
assert( sessionInfoPtr->getAttributeFunction != NULL );
status = sessionInfoPtr->getAttributeFunction( sessionInfoPtr,
messageDataPtr, messageValue );
if( status == CRYPT_ERROR_NOTFOUND )
return( exitErrorNotFound( sessionInfoPtr,
messageValue ) );
}
return( status );
}
if( message == MESSAGE_SETATTRIBUTE )
return( processSetAttribute( sessionInfoPtr, messageDataPtr,
messageValue ) );
if( message == MESSAGE_SETATTRIBUTE_S )
return( processSetAttributeS( sessionInfoPtr, messageDataPtr,
messageValue ) );
if( message == MESSAGE_GETATTRIBUTE )
return( processGetAttribute( sessionInfoPtr, messageDataPtr,
messageValue ) );
if( message == MESSAGE_GETATTRIBUTE_S )
return( processGetAttributeS( sessionInfoPtr, messageDataPtr,
messageValue ) );
if( message == MESSAGE_DELETEATTRIBUTE )
return( processDeleteAttribute( sessionInfoPtr, messageValue ) );
assert( NOTREACHED );
return( CRYPT_ERROR ); /* Get rid of compiler warning */
}
/* Process object-specific messages */
if( message == MESSAGE_ENV_PUSHDATA )
{
RESOURCE_DATA *msgData = ( RESOURCE_DATA * ) messageDataPtr;
const int length = msgData->length;
int bytesCopied, status;
/* Unless we're told otherwise, we've copied zero bytes */
msgData->length = 0;
/* If the session isn't open yet, perform an implicit open */
if( !( sessionInfoPtr->flags & SESSION_ISOPEN ) )
{
status = krnlSendMessage( sessionInfoPtr->objectHandle,
IMESSAGE_SETATTRIBUTE, MESSAGE_VALUE_TRUE,
CRYPT_SESSINFO_ACTIVE );
if( cryptStatusError( status ) )
return( status );
/* The session is ready to process data, move it into the high
state */
krnlSendMessage( sessionInfoPtr->objectHandle,
IMESSAGE_SETATTRIBUTE, MESSAGE_VALUE_UNUSED,
CRYPT_IATTRIBUTE_INITIALISED );
}
assert( sessionInfoPtr->flags & SESSION_ISOPEN );
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -