📄 cryptenv.c
字号:
usage = ACTION_CRYPT;
else
if( envelopeInfoPtr->usage != ACTION_CRYPT && \
envelopeInfoPtr->usage != ACTION_MAC )
return( exitErrorInited( envelopeInfoPtr,
CRYPT_ENVINFO_PASSWORD ) );
/* In general we can't add new enveloping information once we've
started processing data */
if( envelopeInfoPtr->state != STATE_PREDATA && \
!( envelopeInfoPtr->flags & ENVELOPE_ISDEENVELOPE ) )
/* We can't add new information once we've started enveloping */
return( exitErrorInited( envelopeInfoPtr,
CRYPT_ENVINFO_PASSWORD ) );
/* Add it to the envelope */
status = envelopeInfoPtr->addInfo( envelopeInfoPtr,
CRYPT_ENVINFO_PASSWORD, msgData->data, msgData->length );
break;
case CRYPT_ENVINFO_RECIPIENT:
{
MESSAGE_KEYMGMT_INFO getkeyInfo;
/* Set the envelope usage type based on the fact that we've been
fed a recipient email address */
if( envelopeInfoPtr->usage != ACTION_NONE && \
envelopeInfoPtr->usage != ACTION_CRYPT )
return( CRYPT_ARGERROR_VALUE );
usage = ACTION_CRYPT;
/* Make sure that there's a keyset available to pull the
recipient's key from */
if( envelopeInfoPtr->iEncryptionKeyset == CRYPT_ERROR )
return( exitErrorNotInited( envelopeInfoPtr,
CRYPT_ENVINFO_KEYSET_ENCRYPT ) );
/* Try and read the recipient's key from the keyset. Some
keysets (particularly PKCS #11 devices, for which apps set
the usage flags more or less at random) may not be able to
differentiate between encryption and signature keys based on
the information they have. This isn't a problem when matching
a key based on a unique ID, but with the use of the recipient
name as the ID there could be multiple possible matches.
Before we try and use the key we therefore perform an extra
check here to make sure that it really is an encryption-
capable key */
setMessageKeymgmtInfo( &getkeyInfo, CRYPT_KEYID_EMAIL,
msgData->data, msgData->length, NULL, 0,
KEYMGMT_FLAG_USAGE_CRYPT );
status = krnlSendMessage( envelopeInfoPtr->iEncryptionKeyset,
IMESSAGE_KEY_GETKEY, &getkeyInfo,
KEYMGMT_ITEM_PUBLICKEY );
if( cryptStatusOK( status ) && \
cryptStatusError( \
krnlSendMessage( getkeyInfo.cryptHandle, IMESSAGE_CHECK,
NULL, MESSAGE_CHECK_PKC_ENCRYPT ) ) )
{
krnlSendNotifier( getkeyInfo.cryptHandle,
IMESSAGE_DECREFCOUNT );
status = CRYPT_ERROR_NOTFOUND;
}
if( cryptStatusOK( status ) )
{
/* We got the key, add it to the envelope */
status = envelopeInfoPtr->addInfo( envelopeInfoPtr,
CRYPT_ENVINFO_PUBLICKEY,
&getkeyInfo.cryptHandle, 0 );
krnlSendNotifier( getkeyInfo.cryptHandle,
IMESSAGE_DECREFCOUNT );
}
break;
}
default:
assert( NOTREACHED );
}
if( cryptStatusError( status ) )
{
if( status == CRYPT_ERROR_INITED )
return( exitErrorInited( envelopeInfoPtr, messageValue ) );
return( status );
}
if( usage != ACTION_NONE )
/* The action was successfully added, update the usage if
necessary */
envelopeInfoPtr->usage = usage;
return( CRYPT_OK );
}
/****************************************************************************
* *
* Envelope Data Handling Functions *
* *
****************************************************************************/
/* Push data into an envelope */
static int envelopePush( ENVELOPE_INFO *envelopeInfoPtr, void *buffer,
const int length, int *bytesCopied )
{
int status;
/* Clear return value */
*bytesCopied = 0;
/* If we haven't started processing data yet, handle the initial data
specially */
if( envelopeInfoPtr->state == STATE_PREDATA )
{
CRYPT_ATTRIBUTE_TYPE missingInfo;
/* Make sure that all the information we need to proceed is
present */
assert( envelopeInfoPtr->checkMissingInfo != NULL );
missingInfo = envelopeInfoPtr->checkMissingInfo( envelopeInfoPtr );
if( missingInfo != CRYPT_ATTRIBUTE_NONE )
return( exitErrorNotInited( envelopeInfoPtr, missingInfo ) );
/* If the envelope buffer hasn't been allocated yet, allocate it now */
if( envelopeInfoPtr->buffer == NULL )
{
if( ( envelopeInfoPtr->buffer = \
clAlloc( "envelopePush", \
envelopeInfoPtr->bufSize ) ) == NULL )
return( CRYPT_ERROR_MEMORY );
memset( envelopeInfoPtr->buffer, 0, envelopeInfoPtr->bufSize );
}
/* Emit the header information into the envelope */
status = envelopeInfoPtr->processPreambleFunction( envelopeInfoPtr );
if( cryptStatusError( status ) )
{
if( !isRecoverableError( status ) )
envelopeInfoPtr->errorState = status;
return( status );
}
/* The envelope is ready to process data, move it into the high
state */
krnlSendMessage( envelopeInfoPtr->objectHandle, IMESSAGE_SETATTRIBUTE,
MESSAGE_VALUE_UNUSED, CRYPT_IATTRIBUTE_INITIALISED );
envelopeInfoPtr->state = STATE_DATA;
}
/* If we're in the main data processing state, add the data and perform
any necessary actions on it */
if( envelopeInfoPtr->state == STATE_DATA )
{
if( length )
{
/* Copy the data to the envelope */
status = envelopeInfoPtr->copyToEnvelopeFunction( envelopeInfoPtr,
buffer, length );
if( cryptStatusError( status ) )
{
if( !isRecoverableError( status ) )
envelopeInfoPtr->errorState = status;
return( status );
}
*bytesCopied = status;
return( ( *bytesCopied < length ) ? \
CRYPT_ERROR_OVERFLOW : CRYPT_OK );
}
/* This was a flush, move on to the postdata state */
envelopeInfoPtr->state = STATE_POSTDATA;
envelopeInfoPtr->envState = ENVSTATE_NONE;
}
assert( envelopeInfoPtr->state == STATE_POSTDATA );
/* We're past the main data-processing state, emit the postamble */
status = envelopeInfoPtr->processPostambleFunction( envelopeInfoPtr );
if( cryptStatusError( status ) )
{
if( !isRecoverableError( status ) )
envelopeInfoPtr->errorState = status;
return( status );
}
envelopeInfoPtr->state = STATE_FINISHED;
return( CRYPT_OK );
}
static int deenvelopePush( ENVELOPE_INFO *envelopeInfoPtr, void *buffer,
const int length, int *bytesCopied )
{
BYTE *bufPtr = ( BYTE * ) buffer;
int bytesIn = length, status = CRYPT_OK;
/* Clear return value */
*bytesCopied = 0;
/* If we haven't started processing data yet, handle the initial data
specially */
if( envelopeInfoPtr->state == STATE_PREDATA )
{
/* Perform any initialisation actions */
if( envelopeInfoPtr->buffer == NULL )
{
/* Allocate the envelope buffer */
if( ( envelopeInfoPtr->buffer = \
clAlloc( "deenvelopePush", \
envelopeInfoPtr->bufSize ) ) == NULL )
return( CRYPT_ERROR_MEMORY );
memset( envelopeInfoPtr->buffer, 0, envelopeInfoPtr->bufSize );
#ifdef USE_PGP
/* Try and determine what the data format being used is. If it
looks like PGP data, try and process it as such, otherwise
default to PKCS #7/CMS/S/MIME */
if( length && ( bufPtr[ 0 ] & 0x80 ) )
{
/* When we initially created the envelope we defaulted to CMS
formatting, so we first switch to PGP enveloping to
override the CMS default and then finally select PGP de-
enveloping */
envelopeInfoPtr->type = CRYPT_FORMAT_PGP;
initPGPEnveloping( envelopeInfoPtr );
initPGPDeenveloping( envelopeInfoPtr );
}
#endif /* USE_PGP */
}
/* Since we're processing out-of-band information, just copy it in
directly */
if( bytesIn )
{
int bytesToCopy = min( envelopeInfoPtr->bufSize - envelopeInfoPtr->bufPos,
bytesIn );
if( bytesToCopy )
{
memcpy( envelopeInfoPtr->buffer + envelopeInfoPtr->bufPos,
bufPtr, bytesToCopy );
envelopeInfoPtr->bufPos += bytesToCopy;
bytesIn -= bytesToCopy;
*bytesCopied = bytesToCopy;
bufPtr += bytesToCopy;
}
}
/* Process the preamble */
status = envelopeInfoPtr->processPreambleFunction( envelopeInfoPtr );
if( cryptStatusError( status ) )
{
if( !isRecoverableError( status ) )
envelopeInfoPtr->errorState = status;
return( status );
}
/* The envelope is ready to process data, move it into the high
state */
krnlSendMessage( envelopeInfoPtr->objectHandle, IMESSAGE_SETATTRIBUTE,
MESSAGE_VALUE_UNUSED, CRYPT_IATTRIBUTE_INITIALISED );
/* Move on to the data-processing state */
envelopeInfoPtr->state = STATE_DATA;
}
/* If we're in the main data processing state, add the data and perform
any necessary actions on it */
if( envelopeInfoPtr->state == STATE_DATA )
{
/* If there's data to be copied, copy it into the envelope. If we've
come from the predata state, we may have zero bytes to copy if
everything was consumed by the preamble processing, or there may
be room to copy more in now if the preamble processing consumed
some of what was present */
if( bytesIn )
{
/* Copy the data to the envelope */
const int byteCount = \
envelopeInfoPtr->copyToEnvelopeFunction( envelopeInfoPtr,
bufPtr, bytesIn );
if( cryptStatusError( byteCount ) )
{
if( !isRecoverableError( byteCount ) )
envelopeInfoPtr->errorState = byteCount;
return( byteCount );
}
*bytesCopied += byteCount;
bytesIn -= byteCount;
bufPtr += byteCount;
}
/* If we've reached the end of the payload (either by having seen the
EOC octets with the indefinite encoding, by having reached the end
of the single segment with the definite encoding, or through an
explicit flush for unknown-length data), move on to the postdata
state */
if( ( envelopeInfoPtr->dataFlags & ENVDATA_ENDOFCONTENTS ) || \
( envelopeInfoPtr->payloadSize != CRYPT_UNUSED && \
envelopeInfoPtr->segmentSize <= 0 ) || \
( envelopeInfoPtr->payloadSize == CRYPT_UNUSED && \
envelopeInfoPtr->segmentSize == CRYPT_UNUSED && length <= 0 ) )
{
envelopeInfoPtr->state = STATE_POSTDATA;
envelopeInfoPtr->deenvState = DEENVSTATE_NONE;
}
}
/* If we're past the main data-processing state, process the postamble */
if( envelopeInfoPtr->state == STATE_POSTDATA )
{
/* Since we're processing trailer information, just copy it in
directly */
if( bytesIn )
{
/* The handling of EOC information in all situations is very tricky. With
PKCS #5 padded data the contents look like:
dataLeft bufPos
v v
[ data ][ pad ][ EOC / EOC ]
The previous processEOC() would leave bufPos as above, the new version
moves it down to the same location as dataLeft so that after further
copying it becomes:
dataLeft = bufPos
v
[ data ][ EOC ]
ie it adjusts both dataLeft and bufPos for padding rather than just
dataLeft. For the original version of processEOC(), the two code
alternatives below produced the following results
- 230K encrypted data, indefinite: Second alternative
- 230K signed data, indefinite: First alternative and second alternative
- Short signed data, n-4 bytes, then 4 bytes: First alternative
The new version works with all self-tests and also with large data amounts.
This comment has been retained in case a situation is found where it
doesn't work - 20/09/99 */
#if 1
const int bytesToCopy = \
min( envelopeInfoPtr->bufSize - envelopeInfoPtr->bufPos,
bytesIn );
if( bytesToCopy )
{
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -