📄 pkcs11.c
字号:
return( CRYPT_ARGERROR_STR1 );
if( tokenSlot > slotCount - 1 ) /* Slots numbered from zero */
return( CRYPT_ERROR_NOTFOUND );
status = C_GetTokenInfo( slotList[ tokenSlot ], &tokenInfo );
if( status != CKR_OK )
return( CRYPT_ERROR_NOTFOUND );
}
else
{
/* Check each (named) slot for a token matching the given name */
for( tokenSlot = 0; tokenSlot < slotCount; tokenSlot++ )
{
status = C_GetTokenInfo( slotList[ tokenSlot ], &tokenInfo );
if( status == CKR_OK && \
!strnicmp( tokenName, tokenInfo.label, tokenNameLength ) )
break;
};
if( tokenSlot == slotCount )
return( CRYPT_ERROR_NOTFOUND );
}
}
pkcs11Info->slotID = slotList[ tokenSlot ];
/* Get information on device-specific capabilities */
status = C_GetSlotInfo( pkcs11Info->slotID, &slotInfo );
if( status != CKR_OK )
{
shutdownFunction( deviceInfo );
return( mapError( pkcs11Info, status, CRYPT_ERROR_OPEN ) );
}
if( slotInfo.flags & CKF_REMOVABLE_DEVICE )
/* The device is removable */
deviceInfo->flags |= DEVICE_REMOVABLE;
status = C_GetTokenInfo( pkcs11Info->slotID, &tokenInfo );
if( status != CKR_OK )
{
shutdownFunction( deviceInfo );
return( mapError( pkcs11Info, status, CRYPT_ERROR_OPEN ) );
}
if( tokenInfo.flags & CKF_RNG )
/* The device has an onboard RNG that we can use */
deviceInfo->getRandomFunction = getRandomFunction;
#if 0 /* The Spyrus driver for pre-Lynks-II cards returns the local system
time (with a GMT/localtime offset), ignoring the fact that the
token has an onboard clock, so having the CKF_CLOCK_ON_TOKEN not
set is accurate, although having it ignore the presence of the
clock isn't very valid */
if( !( tokenInfo.flags & CKF_CLOCK_ON_TOKEN ) && \
( !strCompare( tokenInfo.label, "Lynks Token", 11 ) || \
!strCompare( tokenInfo.model, "Rosetta", 7 ) ) )
/* Fix buggy Spyrus PKCS #11 drivers which claim that the token
doesn't have a RTC even though it does (the Rosetta (smart card)
form of the token is even worse, it returns garbage in the label
and manufacturer fields, but the model field is OK). There is a
chance that there's a genuine problem with the clock (there are
batches of tokens with bad clocks), but the time check that
follows below will catch those */
tokenInfo.flags |= CKF_CLOCK_ON_TOKEN;
#endif /* 0 */
if( tokenInfo.flags & CKF_CLOCK_ON_TOKEN )
{
const time_t theTime = getTokenTime( &tokenInfo );
const time_t currentTime = getTime();
/* The token claims to have an onboard clock that we can use. Since
this could be arbitrarily inaccurate, we compare it with the
system time and only rely on it if it's within +/- 1 day of the
system time.
There is a second check that we should make to catch drivers that
claim to read the time from the token but actually use the local
computer's time, but this isn't easy to do. The most obvious way
is to set the system time to a bogus value and check whether this
matches the returned time, but this is somewhat drastic and
requires superuser privs on most systems. An alternative is to
check whether the claimed token time exactly matches the system
time, but this will produce false positives if (for example) the
token has been recently synchronised to the system time. For now
all we can do is throw an exception if it appears that the token
time is faked */
if( theTime > MIN_TIME_VALUE && \
theTime >= currentTime - 86400 && \
theTime <= currentTime + 86400 )
deviceInfo->flags |= DEVICE_TIME;
/* If this assertion is triggered, the token time may be faked, since
it's identical to the host system time - see the comment above for
details. We make an exception for soft-tokens, which will (by
definition) have the same time as the system time */
assert( ( pkcs11InfoTbl[ pkcs11Info->deviceNo ].name[ 0 ] && \
!strCompare( pkcs11InfoTbl[ pkcs11Info->deviceNo ].name,
"Software", 8 ) ) || \
theTime < currentTime - 1 || theTime > currentTime + 1 );
}
if( tokenInfo.flags & CKF_WRITE_PROTECTED )
/* The device can't have data on it changed */
deviceInfo->flags |= DEVICE_READONLY;
if( ( tokenInfo.flags & CKF_LOGIN_REQUIRED ) || \
!( tokenInfo.flags & CKF_USER_PIN_INITIALIZED ) )
/* The user needs to log in before using various device functions.
We check for the absence of CKF_USER_PIN_INITIALIZED as well as
the more obvious CKF_LOGIN_REQUIRED because if we've got an
uninitialised device there's no PIN set so some devices will
report that there's no login required (or at least none is
possible). We need to introduce some sort of pipeline stall if
this is the case because otherwise the user could successfully
perform some functions that don't require a login (where the
exact details of what's allowed without a login are device-
specific) before running into mysterious failures when they get
to functions that do require a login. To avoid this, we make an
uninitialised device look like a login-required device, so the
user gets an invalid-PIN error if they try and proceed */
deviceInfo->flags |= DEVICE_NEEDSLOGIN;
if( ( pkcs11Info->minPinSize = ( int ) tokenInfo.ulMinPinLen ) < 4 )
/* Some devices report silly PIN sizes */
pkcs11Info->minPinSize = 4;
if( ( pkcs11Info->maxPinSize = ( int ) tokenInfo.ulMaxPinLen ) < 4 )
/* Some devices report silly PIN sizes (setting this to ULONG_MAX or
4GB, which becomes -1 as an int, counts as silly). Since we can't
differentiate between 0xFFFFFFFF = bogus value and 0xFFFFFFFF =
ULONG_MAX we play it safe and set the limit to 8 bytes, which most
devices should be able to handle */
pkcs11Info->maxPinSize = 8;
labelPtr = tokenInfo.label;
for( labelLength = 32;
labelLength > 0 && \
( labelPtr[ labelLength - 1 ] == ' ' || \
!labelPtr[ labelLength - 1 ] );
labelLength-- ); /* Strip trailing blanks/nulls */
while( labelLength > 0 && *labelPtr == ' ' )
{
/* Strip leading blanks */
labelPtr++;
labelLength--;
}
if( labelLength > 0 )
{
memcpy( pkcs11Info->labelBuffer, labelPtr, labelLength );
pkcs11Info->labelBuffer[ labelLength ] = '\0';
deviceInfo->label = pkcs11Info->labelBuffer;
}
else
{
/* There's no label for the token, use the device label instead */
if( pkcs11InfoTbl[ pkcs11Info->deviceNo ].name[ 0 ] )
{
strcpy( pkcs11Info->labelBuffer,
pkcs11InfoTbl[ pkcs11Info->deviceNo ].name );
deviceInfo->label = pkcs11Info->labelBuffer;
}
}
/* Open a session with the device. This gets a bit awkward because we
can't tell whether a R/W session is OK without opening a session, but
we can't open a session unless we know whether a R/W session is OK,
so we first try for a RW session and if that fails we go for a read-
only session */
status = C_OpenSession( pkcs11Info->slotID,
CKF_RW_SESSION | CKF_SERIAL_SESSION, NULL_PTR,
NULL_PTR, &hSession );
if( status == CKR_TOKEN_WRITE_PROTECTED )
status = C_OpenSession( pkcs11Info->slotID,
CKF_SERIAL_SESSION, NULL_PTR, NULL_PTR,
&hSession );
if( status != CKR_OK )
{
cryptStatus = mapError( pkcs11Info, status, CRYPT_ERROR_OPEN );
if( cryptStatus == CRYPT_ERROR_OPEN && \
!( tokenInfo.flags & CKF_USER_PIN_INITIALIZED ) )
/* We couldn't do much with the error code, it could be that the
token hasn't been initialised yet but unfortunately PKCS #11
doesn't define an error code for this condition. In addition
many tokens will allow a session to be opened and then fail
with a "PIN not set" error at a later point (which allows for
more accurate error reporting), however a small number won't
allow a session to be opened and return some odd-looking error
because there's nothing useful available. The best way to
report this in a meaningful manner to the caller is to check
whether the user PIN has been initialised, if it hasn't then
it's likely that the token as a whole hasn't been initialised
so we return a not initialised error */
cryptStatus = CRYPT_ERROR_NOTINITED;
return( cryptStatus );
}
pkcs11Info->hSession = hSession;
deviceInfo->flags |= DEVICE_ACTIVE;
/* Set up the capability information for this device */
cryptStatus = getCapabilities( deviceInfo );
if( cryptStatusError( cryptStatus ) )
{
shutdownFunction( deviceInfo );
return( ( cryptStatus == CRYPT_ERROR ) ? \
CRYPT_ERROR_OPEN : ( int ) cryptStatus );
}
return( CRYPT_OK );
}
/* Handle device control functions */
static int controlFunction( DEVICE_INFO *deviceInfo,
const CRYPT_ATTRIBUTE_TYPE type,
const void *data, const int dataLength )
{
CK_RV status;
PKCS11_INFO *pkcs11Info = deviceInfo->devicePKCS11;
/* Handle token present/active checks */
if( type == CRYPT_DEVINFO_LOGGEDIN )
{
CK_TOKEN_INFO tokenInfo;
CK_SLOT_INFO slotInfo;
/* Check whether the user is still logged in. This is rather
problematic because some devices can't detect a token removal,
and if they do they often can't report it to the driver. It's
also possible in some devices to remove the token and re-insert
it later without that being regarded as logging out (or you can
remove the smart card and insert your frequent flyer card and
it's still regarded as a card present). In addition if the
reader supports its own authentication mechanisms (even if it
forces a logout if the token is removed) it's possible for the
user to reinsert the token and reauthenticate themselves and it
appears as if they never logged out. In fact the only totally
foolproof way to detect a token removal/change is to try and use
the token to perform a crypto operation, which is a rather
suboptimal detection mechanism.
Because of this, the best that we can do here is check the token-
present flag and report a token-changed error if it's not set.
In addition since some devices only do a minimal check with
C_GetSlotInfo() (e.g. checking whether a microswitch is held
open by something in the slot, see above) we first call
C_GetTokenInfo(), which has a greater chance of actually trying
to access the token, before we call C_GetSlotInfo().
If there's a problem reported, we don't perform an implicit
shutdown since the user may choose to re-authenticate to the
device or perform some other action that we have no control over
in response to the token-removed notification */
status = C_GetTokenInfo( pkcs11Info->slotID, &tokenInfo );
if( status == CKR_OK )
status = C_GetSlotInfo( pkcs11Info->slotID, &slotInfo );
if( status != CKR_OK )
return( mapError( pkcs11Info, status, CRYPT_ERROR_SIGNALLED ) );
if( !( slotInfo.flags & CKF_TOKEN_PRESENT ) )
return( CRYPT_ERROR_SIGNALLED );
return( CRYPT_OK );
}
/* Handle user authorisation */
if( type == CRYPT_DEVINFO_AUTHENT_USER || \
type == CRYPT_DEVINFO_AUTHENT_SUPERVISOR )
{
/* If the user is already logged in, log them out before we try
logging in with a new authentication value */
if( deviceInfo->flags & DEVICE_LOGGEDIN )
{
C_Logout( pkcs11Info->hSession );
deviceInfo->flags &= ~DEVICE_LOGGEDIN;
}
/* Authenticate the user to the device */
status = C_Login( pkcs11Info->hSession,
( type == CRYPT_DEVINFO_AUTHENT_USER ) ? \
CKU_USER : CKU_SO, ( CK_CHAR_PTR ) data,
( CK_ULONG ) dataLength );
if( status != CKR_OK )
{
static const CK_OBJECT_CLASS class = CKO_SECRET_KEY;
const CK_KEY_TYPE type = CKK_DES;
static const CK_BBOOL bFalse = FALSE, bTrue = TRUE;
CK_ATTRIBUTE keyTemplate[] = {
{ CKA_CLASS, ( CK_VOID_PTR ) &class, sizeof( CK_OBJECT_CLASS ) },
{ CKA_KEY_TYPE, ( CK_VOID_PTR ) &type, sizeof( CK_KEY_TYPE ) },
{ CKA_TOKEN, ( CK_VOID_PTR ) &bFalse, sizeof( CK_BBOOL ) },
{ CKA_PRIVATE, ( CK_VOID_PTR ) &bTrue, sizeof( CK_BBOOL ) },
{ CKA_SENSITIVE, ( CK_VOID_PTR ) &bTrue, sizeof( CK_BBOOL ) },
{ CKA_VALUE, "12345678", 8 }
};
CK_OBJECT_HANDLE hObject;
/* The check for CKR_USER_ALREADY_LOGGED_IN is logical since we
may already be logged in from another session, however
several buggy drivers return CKR_USER_ALREADY_LOGGED_IN
without actually logging the user in, so that all further
operations fail with CKR_USER_NOT_LOGGED_IN. To try and
detect this, if we get a CKR_USER_ALREADY_LOGGED_IN we try
and create the sort of object that's likely to require a
login and use that to see whether we're really logged in or
not */
if( status != CKR_USER_ALREADY_LOGGED_IN )
return( mapError( pkcs11Info, status, CRYPT_ERROR_FAILED ) );
/* Try and create the sort of object that'd normally require a
login. This can fail for reasons other than the login bug
(for example DES isn't supported for this token type) so we
only check for the specific login bug error code */
status = C_CreateObject( pkcs11Info->hSession,
( CK_ATTRIBUTE_PTR ) keyTemplate, 6,
&hObject );
if( status == CKR_USER_NOT_LOGGED_IN )
{
assert( NOTREACHED );
return( CRYPT_ERROR_NOTINITED );
}
C_DestroyObject( pkcs11Info->hSession, hObject );
}
/* The device is now ready for use */
deviceInfo->flags |= DEVICE_LOGGEDIN;
return( CRYPT_OK );
}
/* Handle authorisation value changes. The init SO/user PIN
functionality is a bit awkward in that it has to fill the gap between
C_InitToken() (which usually sets the SSO PIN but may also take an
initialisation PIN and leave the token in a state where the only valid
operation is to set the SSO PIN) and C_SetPIN() (which can only set the
SSO PIN for the SSO or the user PIN for the user). Setting the user
⌨️ 快捷键说明
复制代码
Ctrl + C
搜索代码
Ctrl + F
全屏模式
F11
切换主题
Ctrl + Shift + D
显示快捷键
?
增大字号
Ctrl + =
减小字号
Ctrl + -