[SmartcardServices-Changes] [127] trunk/Tokend/PKCS11

Revision: 127 http://trac.macosforge.org/projects/smartcardservices/changeset/127 Author: ludovic.rousseau@gmail.com Date: 2010-06-07 02:13:55 -0700 (Mon, 07 Jun 2010) Log Message: ----------- Do some space character formatting '( ' -> '(' ' )' -> ')' 'if(' -> 'if (' Modified Paths: -------------- trunk/Tokend/PKCS11/GemaltoAttributeCoder.cpp trunk/Tokend/PKCS11/GemaltoError.cpp trunk/Tokend/PKCS11/GemaltoKeyHandle.cpp trunk/Tokend/PKCS11/GemaltoRecord.cpp trunk/Tokend/PKCS11/GemaltoRecord.h trunk/Tokend/PKCS11/GemaltoSchema.cpp trunk/Tokend/PKCS11/GemaltoToken.cpp trunk/Tokend/PKCS11/GemaltoToken.h Modified: trunk/Tokend/PKCS11/GemaltoAttributeCoder.cpp =================================================================== --- trunk/Tokend/PKCS11/GemaltoAttributeCoder.cpp 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoAttributeCoder.cpp 2010-06-07 09:13:55 UTC (rev 127) @@ -51,7 +51,7 @@ void KeyEncryptAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyEncryptAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyEncryptAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -66,11 +66,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyEncryptAttributeCoder::decode - Class <%lu> - Value <%lu>\n", keyRecord.getClass(), boolValue ); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyEncryptAttributeCoder::decode - Class <%lu> - Value <%lu>\n", keyRecord.getClass(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyEncryptAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyEncryptAttributeCoder::decode <END>\n"); } @@ -84,7 +84,7 @@ void KeyDecryptAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyDecryptAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyDecryptAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -99,11 +99,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyDecryptAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyDecryptAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyDecryptAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyDecryptAttributeCoder::decode <END>\n"); } @@ -117,7 +117,7 @@ void KeySignAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeySignAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeySignAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -132,11 +132,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeySignAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeySignAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeySignAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeySignAttributeCoder::decode <END>\n"); } @@ -150,7 +150,7 @@ void KeyVerifyAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyVerifyAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyVerifyAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -165,11 +165,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyVerifyAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyVerifyAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyVerifyAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyVerifyAttributeCoder::decode <END>\n"); } @@ -183,7 +183,7 @@ void KeySignRecoverAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeySignRecoverAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeySignRecoverAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -198,11 +198,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeySignRecoverAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeySignRecoverAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeySignRecoverAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeySignRecoverAttributeCoder::decode <END>\n"); } @@ -216,7 +216,7 @@ void KeyVerifyRecoverAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyVerifyRecoverAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyVerifyRecoverAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -231,11 +231,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyVerifyRecoverAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyVerifyRecoverAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyVerifyRecoverAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyVerifyRecoverAttributeCoder::decode <END>\n"); } @@ -249,7 +249,7 @@ void KeyWrapAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyWrapAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyWrapAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -264,11 +264,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyWrapAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyWrapAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyWrapAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyWrapAttributeCoder::decode <END>\n"); } @@ -282,7 +282,7 @@ void KeyUnwrapAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyUnwrapAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyUnwrapAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = true; @@ -297,11 +297,11 @@ } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyUnwrapAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyUnwrapAttributeCoder::decode - Label <%s> - bool <%u>\n", str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyUnwrapAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyUnwrapAttributeCoder::decode <END>\n"); } @@ -315,17 +315,17 @@ void KeyDeriveAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyDeriveAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyDeriveAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); bool boolValue = keyRecord.derive(); std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyDeriveAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType( ),str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyDeriveAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType(),str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyDeriveAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyDeriveAttributeCoder::decode <END>\n"); } @@ -339,17 +339,17 @@ void KeySensitiveAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeySensitiveAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeySensitiveAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); const bool boolValue = (keyRecord.getClass() == CKO_PRIVATE_KEY); std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeySensitiveAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType( ), str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeySensitiveAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType(), str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeySensitiveAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeySensitiveAttributeCoder::decode <END>\n"); } @@ -363,17 +363,17 @@ void KeyPrivateAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyPrivateAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyPrivateAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); const bool boolValue = (keyRecord.getClass() == CKO_PRIVATE_KEY); std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyPrivateAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType( ), str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyPrivateAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType(), str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyPrivateAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyPrivateAttributeCoder::decode <END>\n"); } @@ -387,17 +387,17 @@ void KeyAlwaysSensitiveAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyAlwaysSensitiveAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyAlwaysSensitiveAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); const bool boolValue = (keyRecord.getClass() == CKO_PRIVATE_KEY); std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyAlwaysSensitiveAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType( ), str.c_str( ), boolValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyAlwaysSensitiveAttributeCoder::decode - Label <%s> - keyType <%ld> - bool <%u>\n", keyRecord.getType(), str.c_str(), boolValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(boolValue)); - GemaltoToken::log( "KeyAlwaysSensitiveAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyAlwaysSensitiveAttributeCoder::decode <END>\n"); } @@ -411,17 +411,17 @@ void KeySizeAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeySizeAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeySizeAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); const uint32 longValue = keyRecord.sizeInBits(); std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeySizeAttributeCoder::decode - Label <%s> - keyType <%ld> - size <%lu>\n", str.c_str( ), keyRecord.getType( ), longValue); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeySizeAttributeCoder::decode - Label <%s> - keyType <%ld> - size <%lu>\n", str.c_str(), keyRecord.getType(), longValue); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(longValue)); - GemaltoToken::log( "KeySizeAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeySizeAttributeCoder::decode <END>\n"); } @@ -435,7 +435,7 @@ void KeyAlgorithmAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyAlgorithmAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyAlgorithmAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); const CK_KEY_TYPE keyType = keyRecord.getType(); @@ -507,18 +507,18 @@ break; */ default: - GemaltoToken::log( "KeyAlgorithmAttributeCoder::decode - Unknown CKA_KEY_TYPE <%02lX> - r <%p> - rid <%08lX> - aid <%lu>\n", keyType, &record, metaAttribute.metaRecord().relationId(), metaAttribute.attributeId()); + GemaltoToken::log("KeyAlgorithmAttributeCoder::decode - Unknown CKA_KEY_TYPE <%02lX> - r <%p> - rid <%08lX> - aid <%lu>\n", keyType, &record, metaAttribute.metaRecord().relationId(), metaAttribute.attributeId()); algID = CSSM_ALGID_CUSTOM; break; } std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyAlgorithmAttributeCoder::decode - Label <%s> - keyType <%lu> - algID <%lu>\n", str.c_str( ), keyRecord.getType( ), algID); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyAlgorithmAttributeCoder::decode - Label <%s> - keyType <%lu> - algID <%lu>\n", str.c_str(), keyRecord.getType(), algID); record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(algID)); - GemaltoToken::log( "KeyAlgorithmAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyAlgorithmAttributeCoder::decode <END>\n"); } @@ -532,15 +532,15 @@ void KeyNameAttributeCoder::decode(Tokend::TokenContext */*tokenContext*/, const Tokend::MetaAttribute &metaAttribute, Tokend::Record &record) { - GemaltoToken::log( "\nKeyNameAttributeCoder::decode <BEGIN>\n" ); + GemaltoToken::log("\nKeyNameAttributeCoder::decode <BEGIN>\n"); GemaltoKeyRecord &keyRecord = dynamic_cast<GemaltoKeyRecord &>(record); std::string str = ""; - GemaltoToken::toStringHex( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel().size( ), str ); - GemaltoToken::log( "KeyNameAttributeCoder::decode - Label <%s>\n", str.c_str( ) ); + GemaltoToken::toStringHex(keyRecord.getLabel().ptr(), keyRecord.getLabel().size(), str); + GemaltoToken::log("KeyNameAttributeCoder::decode - Label <%s>\n", str.c_str()); - record.attributeAtIndex( metaAttribute.attributeIndex(), new Attribute( keyRecord.getLabel( ).ptr( ), keyRecord.getLabel( ).size( ) ) ); + record.attributeAtIndex(metaAttribute.attributeIndex(), new Attribute(keyRecord.getLabel().ptr(), keyRecord.getLabel().size())); - GemaltoToken::log( "KeyNameAttributeCoder::decode <END>\n" ); + GemaltoToken::log("KeyNameAttributeCoder::decode <END>\n"); } Modified: trunk/Tokend/PKCS11/GemaltoError.cpp =================================================================== --- trunk/Tokend/PKCS11/GemaltoError.cpp 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoError.cpp 2010-06-07 09:13:55 UTC (rev 127) @@ -183,7 +183,7 @@ void CKError::debugDiagnose(const void *id) const { - GemaltoToken::log( "### Exception - <%p> CKError debugDiagnose <%s> <%08lX>\n", this, pkcs11_error(resultValue), resultValue); + GemaltoToken::log("### Exception - <%p> CKError debugDiagnose <%s> <%08lX>\n", this, pkcs11_error(resultValue), resultValue); } //#endif //NDEBUG @@ -200,7 +200,7 @@ OSStatus CKError::osStatus() const { - GemaltoToken::log( "### Exception - <%p> CKError osStatus <%s> <%08lX>\n", this, pkcs11_error(resultValue), resultValue); + GemaltoToken::log("### Exception - <%p> CKError osStatus <%s> <%08lX>\n", this, pkcs11_error(resultValue), resultValue); // Map pkcs11 errors to CSSM switch (resultValue) @@ -244,7 +244,7 @@ int CKError::unixError() const { - GemaltoToken::log( "### Exception - <%p> CKError unixError <%s> <%08lX>\n", this, pkcs11_error(resultValue), resultValue); + GemaltoToken::log("### Exception - <%p> CKError unixError <%s> <%08lX>\n", this, pkcs11_error(resultValue), resultValue); switch (resultValue) { Modified: trunk/Tokend/PKCS11/GemaltoKeyHandle.cpp =================================================================== --- trunk/Tokend/PKCS11/GemaltoKeyHandle.cpp 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoKeyHandle.cpp 2010-06-07 09:13:55 UTC (rev 127) @@ -54,23 +54,23 @@ void GemaltoKeyHandle::getKeySize(CSSM_KEY_SIZE &keySize) { - GemaltoToken::log( "\nGemaltoKeyHandle::getKeySize <BEGIN>\n" ); - GemaltoToken::log( "GemaltoKeyHandle::getOutputSize - sizeInBits <%lu>", mKey.sizeInBits() ); + GemaltoToken::log("\nGemaltoKeyHandle::getKeySize <BEGIN>\n"); + GemaltoToken::log("GemaltoKeyHandle::getOutputSize - sizeInBits <%lu>", mKey.sizeInBits()); keySize.EffectiveKeySizeInBits = mKey.sizeInBits(); keySize.LogicalKeySizeInBits = mKey.sizeInBits(); - GemaltoToken::log( "GemaltoKeyHandle::getKeySize <END>\n" ); + GemaltoToken::log("GemaltoKeyHandle::getKeySize <END>\n"); } uint32 GemaltoKeyHandle::getOutputSize(const Context &/*context*/, uint32 inputSize, bool encrypting) { - GemaltoToken::log( "\nGemaltoKeyHandle::getOutputSize <BEGIN>\n" ); - GemaltoToken::log( "GemaltoKeyHandle::getOutputSize - inputSize <%lu> - encrypting <%d>", inputSize, encrypting ); - GemaltoToken::log( "GemaltoKeyHandle::getOutputSize - sizeInBits / 8 <%lu>", ( mKey.sizeInBits() / 8 ) ); + GemaltoToken::log("\nGemaltoKeyHandle::getOutputSize <BEGIN>\n"); + GemaltoToken::log("GemaltoKeyHandle::getOutputSize - inputSize <%lu> - encrypting <%d>", inputSize, encrypting); + GemaltoToken::log("GemaltoKeyHandle::getOutputSize - sizeInBits / 8 <%lu>", (mKey.sizeInBits() / 8)); - GemaltoToken::log( "GemaltoKeyHandle::getOutputSize <END>\n" ); + GemaltoToken::log("GemaltoKeyHandle::getOutputSize <END>\n"); return (mKey.sizeInBits() / 8); } @@ -102,18 +102,18 @@ void GemaltoKeyHandle::generateSignature(const Context &context, CSSM_ALGORITHMS signOnly, const CssmData &input, CssmData &signature) { - GemaltoToken::log( "\nGemaltoKeyHandle::generateSignature <BEGIN>\n" ); - GemaltoToken::log( "Algo <%lu> - SignOnly <%lu> Input <%s> - Signature <%s>\n", context.algorithm(), signOnly, input.toHex( ).c_str( ), signature.toHex( ).c_str( ) ); + GemaltoToken::log("\nGemaltoKeyHandle::generateSignature <BEGIN>\n"); + GemaltoToken::log("Algo <%lu> - SignOnly <%lu> Input <%s> - Signature <%s>\n", context.algorithm(), signOnly, input.toHex().c_str(), signature.toHex().c_str()); if (context.type() != CSSM_ALGCLASS_SIGNATURE) { - GemaltoToken::log( "## Error ## CSSMERR_CSP_INVALID_CONTEXT\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_INVALID_CONTEXT\n"); CssmError::throwMe(CSSMERR_CSP_INVALID_CONTEXT); } if (context.algorithm() != CSSM_ALGID_RSA) { - GemaltoToken::log( "## Error ## CSSMERR_CSP_INVALID_ALGORITHM\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_INVALID_ALGORITHM\n"); CssmError::throwMe(CSSMERR_CSP_INVALID_ALGORITHM); } @@ -124,12 +124,12 @@ CK_ULONG mech = CKM_RSA_PKCS; if (signOnly == CSSM_ALGID_SHA1) { - GemaltoToken::log( "Case CSSM_ALGID_SHA1\n" ); + GemaltoToken::log("Case CSSM_ALGID_SHA1\n"); //secdebug("Gemalto.tokend", "GemaltoKeyHandle: CSSM_ALGID_SHA1 (%lu)", input.Length); if (input.Length != 20) { - GemaltoToken::log( "## Error ## CSSMERR_CSP_BLOCK_SIZE_MISMATCH\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_BLOCK_SIZE_MISMATCH\n"); CssmError::throwMe(CSSMERR_CSP_BLOCK_SIZE_MISMATCH); } header = sha1sigheader; @@ -137,12 +137,12 @@ } else if (signOnly == CSSM_ALGID_MD5) { - GemaltoToken::log( "Case CSSM_ALGID_MD5\n" ); + GemaltoToken::log("Case CSSM_ALGID_MD5\n"); //secdebug("Gemalto.tokend", "GemaltoKeyHandle: CSSM_ALGID_MD5 (%lu)", input.Length); if (input.Length != 16) { - GemaltoToken::log( "## Error ## CSSMERR_CSP_BLOCK_SIZE_MISMATCH\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_BLOCK_SIZE_MISMATCH\n"); CssmError::throwMe(CSSMERR_CSP_BLOCK_SIZE_MISMATCH); } @@ -151,7 +151,7 @@ } else if (signOnly == CSSM_ALGID_NONE) { - GemaltoToken::log( "Case CSSM_ALGID_NONE\n" ); + GemaltoToken::log("Case CSSM_ALGID_NONE\n"); //secdebug("Gemalto.tokend", "GemaltoKeyHandle: CSSM_ALGID_NONE"); // Special case used by SSL it's an RSA signature, without the ASN1 stuff @@ -160,7 +160,7 @@ } else { - GemaltoToken::log( "## Error ## CSSMERR_CSP_INVALID_DIGEST_ALGORITHM\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_INVALID_DIGEST_ALGORITHM\n"); //secdebug("Gemalto.tokend", "GemaltoKeyHandle: Invalid sign algo"); CssmError::throwMe(CSSMERR_CSP_INVALID_DIGEST_ALGORITHM); } @@ -175,7 +175,7 @@ // Get padding, but default to pkcs1 style padding uint32 padding = CSSM_PADDING_PKCS1; context.getInt(CSSM_ATTRIBUTE_PADDING, padding); - GemaltoToken::log( "Padding <%lu>\n", padding ); + GemaltoToken::log("Padding <%lu>\n", padding); //JCD /* @@ -185,7 +185,7 @@ } */ // Gemalto pkcs11 can handle PKCS1 padding only - switch( padding ) + switch(padding) { case CSSM_PADDING_PKCS1: mech = CKM_RSA_PKCS; @@ -206,10 +206,10 @@ case CSSM_PADDING_RANDOM: case CSSM_PADDING_VENDOR_DEFINED: default: - GemaltoToken::log( "## Error ## CSSMERR_CSP_INVALID_ATTR_PADDING\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_INVALID_ATTR_PADDING\n"); CssmError::throwMe(CSSMERR_CSP_INVALID_ATTR_PADDING); } - GemaltoToken::log( "Mechanism <%lu>\n", mech ); + GemaltoToken::log("Mechanism <%lu>\n", mech); //JCD // Now copy the ASN1 header into the input buffer. @@ -238,7 +238,7 @@ } catch (...) { - GemaltoToken::log( "## Error ## key computeSign\n" ); + GemaltoToken::log("## Error ## key computeSign\n"); // @@@ Switch to using tokend allocators free(outputData); @@ -248,15 +248,15 @@ signature.Data = outputData; signature.Length = outputLength; - GemaltoToken::log( "GemaltoKeyHandle::generateSignature <END>\n" ); + GemaltoToken::log("GemaltoKeyHandle::generateSignature <END>\n"); } void GemaltoKeyHandle::verifySignature(const Context &/*context*/, CSSM_ALGORITHMS /*signOnly*/, const CssmData &/*input*/, const CssmData &/*signature*/) { - GemaltoToken::log( "\nGemaltoKeyHandle::verifySignature <BEGIN>\n" ); - GemaltoToken::log( "## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n" ); - GemaltoToken::log( "GemaltoKeyHandle::verifySignature <END>\n" ); + GemaltoToken::log("\nGemaltoKeyHandle::verifySignature <BEGIN>\n"); + GemaltoToken::log("## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n"); + GemaltoToken::log("GemaltoKeyHandle::verifySignature <END>\n"); CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED); } @@ -264,9 +264,9 @@ void GemaltoKeyHandle::generateMac(const Context &/*context*/, const CssmData &/*input*/, CssmData &/*output*/) { - GemaltoToken::log( "\nGemaltoKeyHandle::generateMac <BEGIN>\n" ); - GemaltoToken::log( "## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n" ); - GemaltoToken::log( "GemaltoKeyHandle::generateMac <END>\n" ); + GemaltoToken::log("\nGemaltoKeyHandle::generateMac <BEGIN>\n"); + GemaltoToken::log("## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n"); + GemaltoToken::log("GemaltoKeyHandle::generateMac <END>\n"); CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED); } @@ -274,9 +274,9 @@ void GemaltoKeyHandle::verifyMac(const Context &, const CssmData &, const CssmData &) { - GemaltoToken::log( "\nGemaltoKeyHandle::verifyMac <BEGIN>\n" ); - GemaltoToken::log( "## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n" ); - GemaltoToken::log( "GemaltoKeyHandle::verifyMac <END>\n" ); + GemaltoToken::log("\nGemaltoKeyHandle::verifyMac <BEGIN>\n"); + GemaltoToken::log("## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n"); + GemaltoToken::log("GemaltoKeyHandle::verifyMac <END>\n"); CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED); } @@ -284,9 +284,9 @@ void GemaltoKeyHandle::encrypt(const Context &, const CssmData &, CssmData &) { - GemaltoToken::log( "\nGemaltoKeyHandle::encrypt <BEGIN>\n" ); - GemaltoToken::log( "## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n" ); - GemaltoToken::log( "GemaltoKeyHandle::encrypt <END>\n" ); + GemaltoToken::log("\nGemaltoKeyHandle::encrypt <BEGIN>\n"); + GemaltoToken::log("## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n"); + GemaltoToken::log("GemaltoKeyHandle::encrypt <END>\n"); CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED); } @@ -294,20 +294,20 @@ void GemaltoKeyHandle::decrypt(const Context &context, const CssmData &cipher, CssmData &clear) { - GemaltoToken::log( "\nGemaltoKeyHandle::decrypt <BEGIN>\n" ); - GemaltoToken::log( "Alg <%lu> - cipher <%s> - clear <%s>\n", context.algorithm( ), cipher.toHex( ).c_str( ), clear.toHex( ).c_str( ) ); + GemaltoToken::log("\nGemaltoKeyHandle::decrypt <BEGIN>\n"); + GemaltoToken::log("Alg <%lu> - cipher <%s> - clear <%s>\n", context.algorithm(), cipher.toHex().c_str(), clear.toHex().c_str()); size_t keyLength = mKey.sizeInBits() / 8; // Get padding, but default to pkcs1 style padding uint32 padding = CSSM_PADDING_PKCS1; context.getInt(CSSM_ATTRIBUTE_PADDING, padding); - GemaltoToken::log( "Padding <%lu>\n", padding ); + GemaltoToken::log("Padding <%lu>\n", padding); // Gemalto pkcs11 can handle PKCS1 padding only if (padding != CSSM_PADDING_PKCS1) { - GemaltoToken::log( "## Error ## CSSMERR_CSP_INVALID_ATTR_PADDING\n" ); + GemaltoToken::log("## Error ## CSSMERR_CSP_INVALID_ATTR_PADDING\n"); CssmError::throwMe(CSSMERR_CSP_INVALID_ATTR_PADDING); } @@ -323,7 +323,7 @@ } catch (...) { - GemaltoToken::log( "## Error ## mKey.computeDecrypt\n" ); + GemaltoToken::log("## Error ## mKey.computeDecrypt\n"); // @@@ Switch to using tokend allocators free(outputData); @@ -333,15 +333,15 @@ clear.Data = outputData; clear.Length = outputLength; - GemaltoToken::log( "GemaltoKeyHandle::decrypt <END>\n" ); + GemaltoToken::log("GemaltoKeyHandle::decrypt <END>\n"); } void GemaltoKeyHandle::exportKey(const Context &, const AccessCredentials *, CssmKey &) { - GemaltoToken::log( "\nGemaltoKeyHandle::exportKey <BEGIN>\n" ); - GemaltoToken::log( "## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n" ); - GemaltoToken::log( "GemaltoKeyHandle::exportKey <END>\n" ); + GemaltoToken::log("\nGemaltoKeyHandle::exportKey <BEGIN>\n"); + GemaltoToken::log("## Error ## CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED\n"); + GemaltoToken::log("GemaltoKeyHandle::exportKey <END>\n"); CssmError::throwMe(CSSM_ERRCODE_FUNCTION_NOT_IMPLEMENTED); } @@ -357,12 +357,12 @@ Tokend::KeyHandle* GemaltoKeyHandleFactory::keyHandle(Tokend::TokenContext *tokenContext, const Tokend::MetaRecord &metaRecord, Tokend::Record &record) const { - GemaltoToken::log( "\nGemaltoKeyHandleFactory::keyHandle <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoKeyHandleFactory::keyHandle <BEGIN>\n"); GemaltoKeyRecord &key = dynamic_cast<GemaltoKeyRecord &>(record); GemaltoToken &gemaltoToken = static_cast<GemaltoToken &>(*tokenContext); - GemaltoToken::log( "GemaltoKeyHandleFactory::keyHandle <END>\n" ); + GemaltoToken::log("GemaltoKeyHandleFactory::keyHandle <END>\n"); return new GemaltoKeyHandle(gemaltoToken, metaRecord, key); } Modified: trunk/Tokend/PKCS11/GemaltoRecord.cpp =================================================================== --- trunk/Tokend/PKCS11/GemaltoRecord.cpp 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoRecord.cpp 2010-06-07 09:13:55 UTC (rev 127) @@ -50,14 +50,14 @@ } -GemaltoRecord::GemaltoRecord( ) +GemaltoRecord::GemaltoRecord() { mHandle = 0; mClass = 0; } -GemaltoRecord::~GemaltoRecord( ) +GemaltoRecord::~GemaltoRecord() { } @@ -75,12 +75,12 @@ mKeyPubWrap(FALSE), mKeyPubEncrypt(FALSE), mKeyPrvSign(FALSE), - mKeyPrvUnwrap( FALSE), + mKeyPrvUnwrap(FALSE), mKeyPrvDecrypt(FALSE), mSelfSigned(FALSE), mCA(FALSE) { - GemaltoToken::log( "\nGemaltoCertRecord::GemaltoCertRecord <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoCertRecord::GemaltoCertRecord <BEGIN>\n"); mClass = CKO_CERTIFICATE; @@ -94,74 +94,74 @@ CKError::check(CK_D_(C_GetAttributeValue)(gemaltoToken.session(), mHandle, &valueAttr, 1)); std::string szOut = ""; - GemaltoToken::toStringHex( mValue.ptr(), mValue.size( ), szOut ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Value - len <%lu> - value <%s>\n", mValue.size( ), szOut.c_str( ) ); + GemaltoToken::toStringHex(mValue.ptr(), mValue.size(), szOut); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Value - len <%lu> - value <%s>\n", mValue.size(), szOut.c_str()); // Get a X509 OpenSSL certificate instance - const unsigned char* p = mValue.ptr( ); - X509* cert = d2i_X509( NULL, &p, mValue.size( ) ); - if ( NULL == cert ) + const unsigned char* p = mValue.ptr(); + X509* cert = d2i_X509(NULL, &p, mValue.size()); + if (NULL == cert) { - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - ## ERROR ## Cannot create OpenSSL certificate instance\n" ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - ## ERROR ## Cannot create OpenSSL certificate instance\n"); CssmError::throwMe(CSSM_ERRCODE_INVALID_SAMPLE_VALUE); } // Initialize internal registers - X509_check_purpose( cert, -1, 0 ); + X509_check_purpose(cert, -1, 0); // Get the subject name char attr[1024]; - memset( attr, 0, sizeof( attr ) ); + memset(attr, 0, sizeof(attr)); std::string s = "Unknown subject name"; /* - X509_NAME_oneline( X509_get_subject_name( cert ), attr, sizeof( attr ) ); + X509_NAME_oneline(X509_get_subject_name(cert), attr, sizeof(attr)); s = attr; - mSubject.copy( (CK_BYTE*)s.c_str( ), s.size( ) ); + mSubject.copy((CK_BYTE*)s.c_str(), s.size()); */ - X509_NAME* pName = X509_get_subject_name( cert ); - if ( pName ) + X509_NAME* pName = X509_get_subject_name(cert); + if (pName) { - X509_NAME_get_text_by_NID( pName, NID_commonName, attr, sizeof( attr ) ); + X509_NAME_get_text_by_NID(pName, NID_commonName, attr, sizeof(attr)); s = attr; } - mSubject.copy( (CK_BYTE*)s.c_str( ), s.size( ) ); + mSubject.copy((CK_BYTE*)s.c_str(), s.size()); szOut = ""; - GemaltoToken::toStringHex( mSubject.ptr( ), mSubject.size( ), szOut ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Subject - len <%lu> - value <%s>\n", mSubject.size( ), szOut.c_str( ) ); + GemaltoToken::toStringHex(mSubject.ptr(), mSubject.size(), szOut); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Subject - len <%lu> - value <%s>\n", mSubject.size(), szOut.c_str()); // Get the issuer name - memset( attr, 0, sizeof( attr ) ); + memset(attr, 0, sizeof(attr)); s = ""; - X509_NAME_oneline( X509_get_issuer_name( cert ), attr, sizeof( attr ) ); + X509_NAME_oneline(X509_get_issuer_name(cert), attr, sizeof(attr)); s = attr; - mIssuer.copy( (CK_BYTE*)s.c_str( ), s.size( ) ); + mIssuer.copy((CK_BYTE*)s.c_str(), s.size()); szOut = ""; - GemaltoToken::toStringHex( mIssuer.ptr( ), mIssuer.size( ), szOut ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Issuer - len <%lu> - value <%s>\n", mIssuer.size( ), szOut.c_str( ) ); - //GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Issuer - value <%s>\n", GemaltoDataString( mIssuer ) ); + GemaltoToken::toStringHex(mIssuer.ptr(), mIssuer.size(), szOut); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Issuer - len <%lu> - value <%s>\n", mIssuer.size(), szOut.c_str()); + //GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Issuer - value <%s>\n", GemaltoDataString(mIssuer)); // Compute if the certificate is selfsigned mSelfSigned = FALSE; // First check if the issuer and the subject are the same - if ( 0 == X509_NAME_cmp( X509_get_subject_name( cert ), X509_get_issuer_name( cert ) ) ) + if (0 == X509_NAME_cmp(X509_get_subject_name(cert), X509_get_issuer_name(cert))) { // Then, check the signature // Get the certificate public key - //SSL_library_init( ); + //SSL_library_init(); // Get issuer public key and verify this signature EVP_PKEY* l_CertPubKey = NULL; - l_CertPubKey = X509_get_pubkey( cert ); - if ( NULL != l_CertPubKey ) + l_CertPubKey = X509_get_pubkey(cert); + if (NULL != l_CertPubKey) { // Verify this signature - int l_RetVal = X509_verify( cert, l_CertPubKey ); - EVP_PKEY_free( l_CertPubKey ); + int l_RetVal = X509_verify(cert, l_CertPubKey); + EVP_PKEY_free(l_CertPubKey); // If signature verification is ok, issuer has been found, stop - if ( 0 < l_RetVal ) + if (0 < l_RetVal) { mSelfSigned = TRUE; } @@ -169,55 +169,55 @@ //mSelfSigned = TRUE; } - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - mSelfSigned - value <%lu>\n", mSelfSigned ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - mSelfSigned - value <%lu>\n", mSelfSigned); // Check that the public key type is RSA - if ( NID_rsaEncryption != OBJ_obj2nid(cert->cert_info->key->algor->algorithm)) + if (NID_rsaEncryption != OBJ_obj2nid(cert->cert_info->key->algor->algorithm)) { - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - ## Error CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED\n" ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - ## Error CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED\n"); CssmError::throwMe(CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED); } mKeyType = CKK_RSA; - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Public key type RSA <%lu>\n", mKeyType ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Public key type RSA <%lu>\n", mKeyType); // Get the public key - EVP_PKEY* pKey = X509_get_pubkey( cert ); - if ( NULL == pKey ) + EVP_PKEY* pKey = X509_get_pubkey(cert); + if (NULL == pKey) { - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - ## ERROR ## CSSM_ERRCODE_INVALID_SAMPLE_VALUE\n" ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - ## ERROR ## CSSM_ERRCODE_INVALID_SAMPLE_VALUE\n"); CssmError::throwMe(CSSM_ERRCODE_INVALID_SAMPLE_VALUE); } // Get public key size mKeySize = BN_num_bits(pKey->pkey.rsa->n); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Public key size <%lu>\n", mKeySize ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Public key size <%lu>\n", mKeySize); // Get the public key modulus - mKeyModulus.reserve( mKeySize / 8 ); - BN_bn2bin( pKey->pkey.rsa->n, mKeyModulus.ptr( ) ); + mKeyModulus.reserve(mKeySize / 8); + BN_bn2bin(pKey->pkey.rsa->n, mKeyModulus.ptr()); // If a keyUsage extension is present, parse it - if ( EXFLAG_KUSAGE == (cert->ex_flags & EXFLAG_KUSAGE) ) + if (EXFLAG_KUSAGE == (cert->ex_flags & EXFLAG_KUSAGE)) { - if ( KU_CRL_SIGN == (cert->ex_kusage & KU_CRL_SIGN) ) + if (KU_CRL_SIGN == (cert->ex_kusage & KU_CRL_SIGN)) { mKeyPrvSign = TRUE; mKeyPubVerify = TRUE; } - if ( KU_DATA_ENCIPHERMENT == (cert->ex_kusage & KU_DATA_ENCIPHERMENT) ) + if (KU_DATA_ENCIPHERMENT == (cert->ex_kusage & KU_DATA_ENCIPHERMENT)) { mKeyPubWrap = TRUE; mKeyPubEncrypt = TRUE; mKeyPrvUnwrap = TRUE; mKeyPrvDecrypt = TRUE; } - if ( KU_DIGITAL_SIGNATURE == (cert->ex_kusage & KU_DIGITAL_SIGNATURE) ) + if (KU_DIGITAL_SIGNATURE == (cert->ex_kusage & KU_DIGITAL_SIGNATURE)) { mKeyPrvSign = TRUE; mKeyPubVerify = TRUE; } - if ( KU_ENCIPHER_ONLY == (cert->ex_kusage & KU_ENCIPHER_ONLY) ) + if (KU_ENCIPHER_ONLY == (cert->ex_kusage & KU_ENCIPHER_ONLY)) { mKeyPubWrap = TRUE; mKeyPubEncrypt = TRUE; @@ -226,27 +226,27 @@ mKeyPrvSign = FALSE; mKeyPubVerify = FALSE; } - if ( KU_KEY_AGREEMENT == (cert->ex_kusage & KU_KEY_AGREEMENT) ) + if (KU_KEY_AGREEMENT == (cert->ex_kusage & KU_KEY_AGREEMENT)) { mKeyPubWrap = TRUE; mKeyPubEncrypt = TRUE; mKeyPrvUnwrap = TRUE; mKeyPrvDecrypt = TRUE; } - if ( KU_KEY_CERT_SIGN == (cert->ex_kusage & KU_KEY_CERT_SIGN) ) + if (KU_KEY_CERT_SIGN == (cert->ex_kusage & KU_KEY_CERT_SIGN)) { // Attribut de ca mKeyPrvSign = TRUE; mKeyPubVerify = TRUE; } - if ( KU_KEY_ENCIPHERMENT == (cert->ex_kusage & KU_KEY_ENCIPHERMENT) ) + if (KU_KEY_ENCIPHERMENT == (cert->ex_kusage & KU_KEY_ENCIPHERMENT)) { mKeyPubWrap = TRUE; mKeyPubEncrypt = TRUE; mKeyPrvUnwrap = TRUE; mKeyPrvDecrypt = TRUE; } - if ( KU_NON_REPUDIATION == (cert->ex_kusage & KU_NON_REPUDIATION) ) + if (KU_NON_REPUDIATION == (cert->ex_kusage & KU_NON_REPUDIATION)) { mKeyPrvSign = TRUE; mKeyPubVerify = TRUE; @@ -254,19 +254,19 @@ } // If an extendedKeyUsage extension is present parse it - if ( EXFLAG_XKUSAGE == (cert->ex_flags & EXFLAG_XKUSAGE) ) + if (EXFLAG_XKUSAGE == (cert->ex_flags & EXFLAG_XKUSAGE)) { - if ( ( XKU_CODE_SIGN == (cert->ex_xkusage & XKU_CODE_SIGN) ) - || ( XKU_SSL_CLIENT == (cert->ex_xkusage & XKU_SSL_CLIENT) ) - || ( XKU_TIMESTAMP == (cert->ex_xkusage & XKU_TIMESTAMP) ) - || ( XKU_OCSP_SIGN == (cert->ex_xkusage & XKU_OCSP_SIGN) ) - ) + if ((XKU_CODE_SIGN == (cert->ex_xkusage & XKU_CODE_SIGN)) + || (XKU_SSL_CLIENT == (cert->ex_xkusage & XKU_SSL_CLIENT)) + || (XKU_TIMESTAMP == (cert->ex_xkusage & XKU_TIMESTAMP)) + || (XKU_OCSP_SIGN == (cert->ex_xkusage & XKU_OCSP_SIGN)) + ) { mKeyPrvSign = TRUE; mKeyPubVerify = TRUE; } - if ( ( XKU_SMIME == (cert->ex_xkusage & XKU_SMIME) ) - || ( XKU_SSL_SERVER == (cert->ex_xkusage & XKU_SSL_SERVER) ) + if ((XKU_SMIME == (cert->ex_xkusage & XKU_SMIME)) + || (XKU_SSL_SERVER == (cert->ex_xkusage & XKU_SSL_SERVER)) ) { mKeyPrvSign = TRUE; @@ -281,22 +281,22 @@ BASIC_CONSTRAINTS* bs = (BASIC_CONSTRAINTS*) X509_get_ext_d2i(cert, NID_basic_constraints, NULL, NULL); mCA = (bs && bs->ca); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - CA <%lu>\n", mCA ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - CA <%lu>\n", mCA); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPrvSign <%lu>\n", mKeyPrvSign ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPubVerify <%lu>\n", mKeyPubVerify ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPubWrap <%lu>\n", mKeyPubWrap ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPubEncrypt <%lu>\n", mKeyPubEncrypt ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPrvUnwrap <%lu>\n", mKeyPrvUnwrap ); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPrvDecrypt <%lu>\n", mKeyPrvDecrypt ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPrvSign <%lu>\n", mKeyPrvSign); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPubVerify <%lu>\n", mKeyPubVerify); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPubWrap <%lu>\n", mKeyPubWrap); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPubEncrypt <%lu>\n", mKeyPubEncrypt); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPrvUnwrap <%lu>\n", mKeyPrvUnwrap); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord - Key usage mKeyPrvDecrypt <%lu>\n", mKeyPrvDecrypt); - GemaltoToken::log( "GemaltoCertRecord::GemaltoCertRecord <END>\n" ); + GemaltoToken::log("GemaltoCertRecord::GemaltoCertRecord <END>\n"); } /* GemaltoCertRecord Default constructor */ -GemaltoCertRecord::GemaltoCertRecord( ) +GemaltoCertRecord::GemaltoCertRecord() : GemaltoRecord(), mSubjectName(NULL), mIssuerName(NULL), @@ -306,7 +306,7 @@ mKeyPubWrap(FALSE), mKeyPubEncrypt(FALSE), mKeyPrvSign(FALSE), - mKeyPrvUnwrap( FALSE), + mKeyPrvUnwrap(FALSE), mKeyPrvDecrypt(FALSE), mSelfSigned(FALSE), mCA(FALSE) @@ -317,31 +317,31 @@ GemaltoCertRecord::~GemaltoCertRecord() { - if( NULL != mSubjectName ) + if (NULL != mSubjectName) { - X509_NAME_free( mSubjectName ); + X509_NAME_free(mSubjectName); mSubjectName = NULL; } - if( NULL != mIssuerName ) + if (NULL != mIssuerName) { - X509_NAME_free( mIssuerName ); + X509_NAME_free(mIssuerName); mIssuerName = NULL; } } -Tokend::Attribute *GemaltoCertRecord::getDataAttribute( Tokend::TokenContext */*tokenContext*/ ) +Tokend::Attribute *GemaltoCertRecord::getDataAttribute(Tokend::TokenContext */*tokenContext*/) { - GemaltoToken::log( "\nGemaltoCertRecord::getDataAttribute <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoCertRecord::getDataAttribute <BEGIN>\n"); std::string s = ""; - GemaltoToken::toStringHex( mValue.ptr( ), mValue.size( ), s ); - GemaltoToken::log( "GemaltoCertRecord::getDataAttribute - size <%lu> - value <%s>\n", mValue.size( ), s.c_str( ) ); + GemaltoToken::toStringHex(mValue.ptr(), mValue.size(), s); + GemaltoToken::log("GemaltoCertRecord::getDataAttribute - size <%lu> - value <%s>\n", mValue.size(), s.c_str()); - GemaltoToken::log( "GemaltoCertRecord::getDataAttribute <END>\n" ); + GemaltoToken::log("GemaltoCertRecord::getDataAttribute <END>\n"); - return new Tokend::Attribute( mValue.ptr( ), mValue.size( ) ); + return new Tokend::Attribute(mValue.ptr(), mValue.size()); } @@ -356,7 +356,7 @@ mKeyPubWrap(FALSE), mKeyPubEncrypt(FALSE) { - GemaltoToken::log( "\nGemaltoKeyRecord::GemaltoKeyRecord <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoKeyRecord::GemaltoKeyRecord <BEGIN>\n"); mHandle = cert.getHandle(); @@ -365,25 +365,25 @@ mKeyType = cert.getType(); mKeySize = cert.sizeInBits(); - mKeyPubVerify = cert.verify( ); - mKeyPubWrap = cert.wrap( ); - mKeyPubEncrypt = cert.encrypt( ); + mKeyPubVerify = cert.verify(); + mKeyPubWrap = cert.wrap(); + mKeyPubEncrypt = cert.encrypt(); - mLabel = cert.getSubject( ); + mLabel = cert.getSubject(); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord - Handle <%ld>\n", mHandle ); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord - Handle <%ld>\n", mHandle); std::string str = ""; - GemaltoToken::toStringHex( mLabel.ptr( ), mLabel.size( ), str ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Class <%lu>\n", mClass ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key type <%lu>\n", mKeyType ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key size <%lu>\n", mKeySize ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubVerify <%lu>\n", mKeyPubVerify ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubWrap <%lu>\n", mKeyPubWrap ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubEncrypt <%lu>\n", mKeyPubEncrypt ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key label <%s>\n", str.c_str( ) ); + GemaltoToken::toStringHex(mLabel.ptr(), mLabel.size(), str); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Class <%lu>\n", mClass); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key type <%lu>\n", mKeyType); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key size <%lu>\n", mKeySize); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubVerify <%lu>\n", mKeyPubVerify); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubWrap <%lu>\n", mKeyPubWrap); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubEncrypt <%lu>\n", mKeyPubEncrypt); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key label <%s>\n", str.c_str()); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord <END>\n" ); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord <END>\n"); } @@ -406,12 +406,12 @@ void GemaltoKeyRecord::computeSign(GemaltoToken &/*gemaltoToken*/, CK_ULONG /*mech*/, const AccessCredentials */*cred*/, unsigned char */*data*/, size_t /*dataLength*/, unsigned char */*output*/, size_t &/*outputLength*/) { - GemaltoToken::log( "\nGemaltoKeyRecord::computeSign <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoKeyRecord::computeSign <BEGIN>\n"); std::string str = ""; - GemaltoToken::toStringHex( mLabel.ptr( ), mLabel.size( ), str ); - GemaltoToken::log( "GemaltoKeyRecord::computeSign() - Label <%s>\n", str.c_str( ) ); - GemaltoToken::log( "trow CSSMERR_CSP_KEY_USAGE_INCORRECT\n" ); - GemaltoToken::log( "GemaltoKeyRecord::computeSign <END>\n" ); + GemaltoToken::toStringHex(mLabel.ptr(), mLabel.size(), str); + GemaltoToken::log("GemaltoKeyRecord::computeSign() - Label <%s>\n", str.c_str()); + GemaltoToken::log("trow CSSMERR_CSP_KEY_USAGE_INCORRECT\n"); + GemaltoToken::log("GemaltoKeyRecord::computeSign <END>\n"); CssmError::throwMe(CSSMERR_CSP_KEY_USAGE_INCORRECT); } @@ -419,12 +419,12 @@ void GemaltoKeyRecord::computeDecrypt(GemaltoToken &/*gemaltoToken*/, CK_ULONG /*mech*/, const AccessCredentials */*cred*/, unsigned char */*data*/, size_t /*dataLength*/, unsigned char */*output*/, size_t &/*outputLength*/) { - GemaltoToken::log( "\nGemaltoKeyRecord::computeDecrypt <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoKeyRecord::computeDecrypt <BEGIN>\n"); std::string str = ""; - GemaltoToken::toStringHex( mLabel.ptr( ), mLabel.size( ), str ); - GemaltoToken::log( "GemaltoKeyRecord::computeDecrypt - Label <%s>\n", str.c_str( ) ); - GemaltoToken::log( "trow CSSMERR_CSP_KEY_USAGE_INCORRECT\n" ); - GemaltoToken::log( "GemaltoKeyRecord::computeDecrypt <END>\n" ); + GemaltoToken::toStringHex(mLabel.ptr(), mLabel.size(), str); + GemaltoToken::log("GemaltoKeyRecord::computeDecrypt - Label <%s>\n", str.c_str()); + GemaltoToken::log("trow CSSMERR_CSP_KEY_USAGE_INCORRECT\n"); + GemaltoToken::log("GemaltoKeyRecord::computeDecrypt <END>\n"); CssmError::throwMe(CSSMERR_CSP_KEY_USAGE_INCORRECT); } @@ -436,9 +436,9 @@ GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord(const GemaltoCertRecord &cert) - : GemaltoKeyRecord( cert ) + : GemaltoKeyRecord(cert) { - GemaltoToken::log( "\nGemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord <BEGIN>\n"); secdebug("Gemalto.tokend", "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord(cert)"); @@ -449,29 +449,29 @@ mKeyType = cert.getType(); mKeySize = cert.sizeInBits(); - mKeyModulus = cert.getKeyPubModulus( ); + mKeyModulus = cert.getKeyPubModulus(); - mKeyPrvSign = cert.verify( ); - mKeyPrvUnwrap = cert.wrap( ); - mKeyPrvDecrypt = cert.encrypt( ); + mKeyPrvSign = cert.verify(); + mKeyPrvUnwrap = cert.wrap(); + mKeyPrvDecrypt = cert.encrypt(); - mLabel = cert.getSubject( ); + mLabel = cert.getSubject(); - GemaltoToken::log( "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord - Handle <%ld>\n", mHandle ); + GemaltoToken::log("GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord - Handle <%ld>\n", mHandle); std::string str = ""; - GemaltoToken::toStringHex( mLabel.ptr( ), mLabel.size( ), str ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Class <%lu>\n", mClass ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Key type <%lu>\n", mKeyType ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Key size <%lu>\n", mKeySize ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubVerify <%lu>\n", mKeyPubVerify ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubWrap <%lu>\n", mKeyPubWrap ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubEncrypt <%lu>\n", mKeyPubEncrypt ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPrvSign <%lu>\n", mKeyPrvSign ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPrvUnwrap <%lu>\n", mKeyPrvUnwrap ); - GemaltoToken::log( "GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPrvDecrypt <%lu>\n", mKeyPrvDecrypt ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Key label <%s>\n", str.c_str( ) ); + GemaltoToken::toStringHex(mLabel.ptr(), mLabel.size(), str); + GemaltoToken::log("GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Class <%lu>\n", mClass); + GemaltoToken::log("GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Key type <%lu>\n", mKeyType); + GemaltoToken::log("GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Key size <%lu>\n", mKeySize); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubVerify <%lu>\n", mKeyPubVerify); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubWrap <%lu>\n", mKeyPubWrap); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPubEncrypt <%lu>\n", mKeyPubEncrypt); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPrvSign <%lu>\n", mKeyPrvSign); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPrvUnwrap <%lu>\n", mKeyPrvUnwrap); + GemaltoToken::log("GemaltoKeyRecord::GemaltoKeyRecord() - Key mKeyPrvDecrypt <%lu>\n", mKeyPrvDecrypt); + GemaltoToken::log("GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord() - Key label <%s>\n", str.c_str()); - GemaltoToken::log( "GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord <END>\n" ); + GemaltoToken::log("GemaltoPrivateKeyRecord::GemaltoPrivateKeyRecord <END>\n"); } @@ -482,17 +482,17 @@ void GemaltoPrivateKeyRecord::computeSign(GemaltoToken &gemaltoToken, CK_ULONG mech, const AccessCredentials *cred, unsigned char *data, size_t dataLength, unsigned char *output, size_t &outputLength) { - GemaltoToken::log( "\nGemaltoPrivateKeyRecord::computeSign <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoPrivateKeyRecord::computeSign <BEGIN>\n"); std::string str = ""; - GemaltoToken::toStringHex( getLabel( ).ptr( ), getLabel().size( ), str ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeSign - Label <%s>\n", str.c_str( ) ); + GemaltoToken::toStringHex(getLabel().ptr(), getLabel().size(), str); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeSign - Label <%s>\n", str.c_str()); str = ""; - GemaltoToken::toStringHex( getModulus( ).ptr( ), getModulus().size( ), str ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeSign - Modulus <%s>\n", str.c_str( ) ); + GemaltoToken::toStringHex(getModulus().ptr(), getModulus().size(), str); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeSign - Modulus <%s>\n", str.c_str()); if (dataLength > (mKeySize / 8)) { - GemaltoToken::log( "## Error ## Bad data length <%lu>\n", dataLength ); + GemaltoToken::log("## Error ## Bad data length <%lu>\n", dataLength); CssmError::throwMe(CSSMERR_CSP_BLOCK_SIZE_MISMATCH); } @@ -517,21 +517,21 @@ if (!found) { - GemaltoToken::log( "## Error ## Credentials not found\n" ); + GemaltoToken::log("## Error ## Credentials not found\n"); CssmError::throwMe(CSSM_ERRCODE_ACL_SUBJECT_TYPE_NOT_SUPPORTED); } } - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeSign - Required Class <%lu>\n", mClass ); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeSign - Required Class <%lu>\n", mClass); std::string s = ""; - GemaltoToken::toStringHex( mKeyModulus.ptr( ), mKeyModulus.size( ), s ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeSign - Required Modulus <%s>\n", s.c_str( ) ); + GemaltoToken::toStringHex(mKeyModulus.ptr(), mKeyModulus.size(), s); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeSign - Required Modulus <%s>\n", s.c_str()); CK_ATTRIBUTE attrs[] = { {CKA_CLASS, &mClass, sizeof(mClass)}, //{CKA_ID, mId.ptr(), mId.size()}}; - { CKA_MODULUS, mKeyModulus.ptr( ), mKeyModulus.size( ) } + { CKA_MODULUS, mKeyModulus.ptr(), mKeyModulus.size() } }; CKError::check(CK_D_(C_FindObjectsInit)(gemaltoToken.session(), attrs, 2)); @@ -542,7 +542,7 @@ CKError::check(CK_D_(C_FindObjects)(gemaltoToken.session(), &hObject, 1, &ulObjectCount)); if (ulObjectCount == 0) { - GemaltoToken::log( "## Error ## Private key not found\n" ); + GemaltoToken::log("## Error ## Private key not found\n"); CssmError::throwMe(CSSMERR_CSP_PRIVATE_KEY_NOT_FOUND); } CK_D_(C_FindObjectsFinal)(gemaltoToken.session()); @@ -560,29 +560,29 @@ CKError::check(CK_D_(C_Sign)(gemaltoToken.session(), (unsigned char*) data, dataLength, output, &dummy)); outputLength = dummy; - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeSign <END>\n" ); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeSign <END>\n"); } void GemaltoPrivateKeyRecord::computeDecrypt(GemaltoToken &gemaltoToken, CK_ULONG mech, const AccessCredentials *cred, unsigned char *data, size_t dataLength, unsigned char *output, size_t &outputLength) { - GemaltoToken::log( "\nGemaltoPrivateKeyRecord::computeDecrypt <BEGIN>\n" ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - mechanism <%lu>\n", mech ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - cred <%p>\n", cred ); + GemaltoToken::log("\nGemaltoPrivateKeyRecord::computeDecrypt <BEGIN>\n"); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - mechanism <%lu>\n", mech); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - cred <%p>\n", cred); char strData[6000]; - memset( strData, '\0', sizeof( strData ) ); + memset(strData, '\0', sizeof(strData)); char* str = strData; for (size_t i=0; i<dataLength; i++) { - str += sprintf( str, "%02x ", data[i]); + str += sprintf(str, "%02x ", data[i]); } - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - dataLength <%lu> - data <%s>\n", dataLength, strData ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - output <%p>\n", output ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - outputLength <%lu>\n", outputLength ); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - dataLength <%lu> - data <%s>\n", dataLength, strData); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - output <%p>\n", output); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - outputLength <%lu>\n", outputLength); if (dataLength > (mKeySize / 8)) { - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - ## Error bad data length <%lu> !\n", dataLength); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - ## Error bad data length <%lu> !\n", dataLength); CssmError::throwMe(CSSMERR_CSP_BLOCK_SIZE_MISMATCH); } @@ -607,7 +607,7 @@ if (!found) { - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt - ## Error cred not found!"); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt - ## Error cred not found!"); CssmError::throwMe(CSSM_ERRCODE_ACL_SUBJECT_TYPE_NOT_SUPPORTED); } } @@ -620,7 +620,7 @@ { {CKA_CLASS, &mClass, sizeof(mClass)}, //{CKA_ID, mId.ptr(), mId.size()}}; - { CKA_MODULUS, mKeyModulus.ptr( ), mKeyModulus.size( ) } + { CKA_MODULUS, mKeyModulus.ptr(), mKeyModulus.size() } }; CKError::check(CK_D_(C_FindObjectsInit)(gemaltoToken.session(), attrs, 2)); @@ -646,14 +646,14 @@ CKError::check(CK_D_(C_Decrypt)(gemaltoToken.session(), (unsigned char*) data, dataLength, output, &dummy)); outputLength = dummy; - GemaltoToken::log( "GemaltoPrivateKeyRecord::computeDecrypt <END>\n" ); + GemaltoToken::log("GemaltoPrivateKeyRecord::computeDecrypt <END>\n"); } void GemaltoPrivateKeyRecord::getAcl(const char *tag, uint32 &count, AclEntryInfo *&acls) { - GemaltoToken::log( "\nGemaltoPrivateKeyRecord::getAcl <BEGIN>\n" ); - GemaltoToken::log( "GemaltoPrivateKeyRecord::getAcl - tag <%s>\n", tag ); + GemaltoToken::log("\nGemaltoPrivateKeyRecord::getAcl <BEGIN>\n"); + GemaltoToken::log("GemaltoPrivateKeyRecord::getAcl - tag <%s>\n", tag); // @@@ Key 1 has any acl for sign, key 2 has pin1 acl, and key3 has pin1 // acl with auto-lock which we express as a prompted password subject. @@ -680,5 +680,5 @@ count = mAclEntries.size(); acls = mAclEntries.entries(); - GemaltoToken::log( "GemaltoPrivateKeyRecord::getAcl <END>\n" ); + GemaltoToken::log("GemaltoPrivateKeyRecord::getAcl <END>\n"); } Modified: trunk/Tokend/PKCS11/GemaltoRecord.h =================================================================== --- trunk/Tokend/PKCS11/GemaltoRecord.h 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoRecord.h 2010-06-07 09:13:55 UTC (rev 127) @@ -45,7 +45,7 @@ GemaltoData(CK_BYTE_PTR ptr, CK_ULONG size) : _ptr(NULL) { copy(ptr, size); } ~GemaltoData() { - if( NULL != _ptr ) + if (NULL != _ptr) { delete[] _ptr; } @@ -56,7 +56,7 @@ void copy(CK_BYTE_PTR ptr, CK_ULONG size) { - if( NULL != _ptr ) + if (NULL != _ptr) { delete[] _ptr; } @@ -72,7 +72,7 @@ void reserve(CK_ULONG n) { - if( NULL != _ptr ) + if (NULL != _ptr) { delete[] _ptr; } @@ -143,13 +143,13 @@ CK_KEY_TYPE getType() const { return mKeyType; } uint32 sizeInBits() const { return mKeySize; } - const GemaltoData& getKeyPubModulus( ) const { return mKeyModulus; } + const GemaltoData& getKeyPubModulus() const { return mKeyModulus; } CK_BBOOL verify() const { return mKeyPubVerify; } - CK_BBOOL verifyRecover() const { return ( mKeyPubVerify | mKeyPrvSign); } - CK_BBOOL encrypt() const { return ( mKeyPubWrap | mKeyPubEncrypt); } + CK_BBOOL verifyRecover() const { return (mKeyPubVerify | mKeyPrvSign); } + CK_BBOOL encrypt() const { return (mKeyPubWrap | mKeyPubEncrypt); } CK_BBOOL derive() const { return FALSE; } - CK_BBOOL wrap() const { return ( mKeyPubWrap | mKeyPubEncrypt); } + CK_BBOOL wrap() const { return (mKeyPubWrap | mKeyPubEncrypt); } CK_BBOOL isSelfSigned() const { return mSelfSigned; } CK_BBOOL isCA() const { return mCA; } @@ -197,18 +197,18 @@ virtual CK_BBOOL verify() const { return mKeyPubVerify; } virtual CK_BBOOL verifyRecover() const { return mKeyPubVerify; } - virtual CK_BBOOL encrypt() const { return ( mKeyPubWrap | mKeyPubEncrypt); } + virtual CK_BBOOL encrypt() const { return (mKeyPubWrap | mKeyPubEncrypt); } virtual CK_BBOOL derive() const { return FALSE; } virtual CK_BBOOL wrap() const { return mKeyPubWrap; } - virtual const GemaltoData& getModulus( ) const { return mKeyModulus; } + virtual const GemaltoData& getModulus() const { return mKeyModulus; } virtual void computeSign(GemaltoToken &gemaltoToken, CK_ULONG mech, const AccessCredentials *cred, unsigned char *data, size_t dataLength, unsigned char *result, size_t &resultLength); virtual void computeDecrypt(GemaltoToken &gemaltoToken, CK_ULONG mech, const AccessCredentials *cred, unsigned char *data, size_t dataLength, unsigned char *result, size_t &resultLength); protected: - GemaltoKeyRecord( ); + GemaltoKeyRecord(); GemaltoData mLabel; @@ -238,10 +238,10 @@ void getAcl(const char *tag, uint32 &count, AclEntryInfo *&acls); CK_BBOOL verify() const { return mKeyPubVerify; } - CK_BBOOL verifyRecover() const { return ( mKeyPubVerify | mKeyPrvSign); } - CK_BBOOL encrypt() const { return ( mKeyPubWrap | mKeyPubEncrypt); } + CK_BBOOL verifyRecover() const { return (mKeyPubVerify | mKeyPrvSign); } + CK_BBOOL encrypt() const { return (mKeyPubWrap | mKeyPubEncrypt); } CK_BBOOL derive() const { return FALSE; } - CK_BBOOL wrap() const { return ( mKeyPubWrap | mKeyPubEncrypt); } + CK_BBOOL wrap() const { return (mKeyPubWrap | mKeyPubEncrypt); } protected: CK_BBOOL mKeyPrvSign; Modified: trunk/Tokend/PKCS11/GemaltoSchema.cpp =================================================================== --- trunk/Tokend/PKCS11/GemaltoSchema.cpp 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoSchema.cpp 2010-06-07 09:13:55 UTC (rev 127) @@ -43,8 +43,8 @@ Tokend::Relation* GemaltoSchema::createKeyRelation(CSSM_DB_RECORDTYPE keyType) { - GemaltoToken::log( "\nGemaltoSchema::createKeyRelation <BEGIN>\n" ); - GemaltoToken::log( "CSSM_DB_RECORDTYPE <%ld>\n", keyType ); + GemaltoToken::log("\nGemaltoSchema::createKeyRelation <BEGIN>\n"); + GemaltoToken::log("CSSM_DB_RECORDTYPE <%ld>\n", keyType); Relation *rn = createStandardRelation(keyType); @@ -80,7 +80,7 @@ mr.attributeCoder(kSecKeyVerifyRecover, &mVerifyRecoverCoder); mr.attributeCoder(kSecKeyDerive, &mDeriveCoder); - GemaltoToken::log( "\nGemaltoSchema::createKeyRelation <END>\n" ); + GemaltoToken::log("\nGemaltoSchema::createKeyRelation <END>\n"); return rn; } @@ -88,7 +88,7 @@ void GemaltoSchema::create() { - GemaltoToken::log( "\nGemaltoSchema::create <BEGIN>\n" ); + GemaltoToken::log("\nGemaltoSchema::create <BEGIN>\n"); Schema::create(); @@ -100,5 +100,5 @@ rn_publ->metaRecord().attributeCoder(kSecKeyLabel, &mZeroCoder); //rn_publ->metaRecord().attributeCoder(kSecKeyLabel, &mKeyNameCoder); - GemaltoToken::log( "\nGemaltoSchema::create <END>\n" ); + GemaltoToken::log("\nGemaltoSchema::create <END>\n"); } Modified: trunk/Tokend/PKCS11/GemaltoToken.cpp =================================================================== --- trunk/Tokend/PKCS11/GemaltoToken.cpp 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoToken.cpp 2010-06-07 09:13:55 UTC (rev 127) @@ -67,7 +67,7 @@ mCKSession(CK_INVALID_HANDLE), mDLHandle(NULL) { - log( "\nGemaltoToken::GemaltoToken <BEGIN>\n" ); + log("\nGemaltoToken::GemaltoToken <BEGIN>\n"); mTokenContext = this; @@ -75,15 +75,15 @@ ::ERR_load_crypto_strings(); ::X509V3_add_standard_extensions(); - log( "GemaltoToken::GemaltoToken <END>\n" ); + log("GemaltoToken::GemaltoToken <END>\n"); } GemaltoToken::~GemaltoToken() { - log( "\nGemaltoToken::~GemaltoToken <BEGIN>\n" ); + log("\nGemaltoToken::~GemaltoToken <BEGIN>\n"); - if( NULL != mSchema ) + if (NULL != mSchema) { delete mSchema; } @@ -93,41 +93,41 @@ if (s_CK_pFunctionList) { CK_D_(C_Logout)(mCKSession); - log( "GemaltoToken::~GemaltoToken <LogOut>\n" ); + log("GemaltoToken::~GemaltoToken <LogOut>\n"); if (mCKSession != CK_INVALID_HANDLE) { CK_D_(C_CloseSession)(mCKSession); mCKSession = CK_INVALID_HANDLE; } - log( "GemaltoToken::~GemaltoToken <CloseSession>\n" ); + log("GemaltoToken::~GemaltoToken <CloseSession>\n"); CK_D_(C_Finalize)(NULL_PTR); //(*(GemaltoToken::s_CK_pFunctionList->C_Finalize))(NULL_PTR); - log( "GemaltoToken::~GemaltoToken <Finalize>\n" ); + log("GemaltoToken::~GemaltoToken <Finalize>\n"); s_CK_pFunctionList = NULL; } } - catch( ... ) + catch(...) { - log( "## Error ## Crash \n" ); + log("## Error ## Crash \n"); } - if( NULL != mDLHandle ) + if (NULL != mDLHandle) { - dlclose( mDLHandle ); + dlclose(mDLHandle); } - log( "GemaltoToken::~GemaltoToken <END>\n" ); + log("GemaltoToken::~GemaltoToken <END>\n"); } void GemaltoToken::changePIN(int pinNum, const unsigned char *oldPin, size_t oldPinLength, const unsigned char *newPin, size_t newPinLength) { - log( "\nGemaltoToken::changePIN <BEGIN>\n" ); - //log( "pinNum <%d> - oldPin <%.*s> - newPin <%.*s>\n", pinNum, (int) oldPinLength, oldPin, (int) newPinLength, newPin); + log("\nGemaltoToken::changePIN <BEGIN>\n"); + //log("pinNum <%d> - oldPin <%.*s> - newPin <%.*s>\n", pinNum, (int) oldPinLength, oldPin, (int) newPinLength, newPin); if (pinNum != 1) CssmError::throwMe(CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED); @@ -137,15 +137,15 @@ CssmError::throwMe(CSSM_ERRCODE_INVALID_SAMPLE_VALUE); CK_BYTE* pOldPIN = new CK_BYTE[oldPinLength]; - memset( pOldPIN, 0, sizeof( CK_BYTE ) * oldPinLength ); - for( size_t i = 0 ; i < oldPinLength ; i++ ) + memset(pOldPIN, 0, sizeof(CK_BYTE) * oldPinLength); + for(size_t i = 0 ; i < oldPinLength ; i++) { pOldPIN[ i ] = (CK_BYTE)oldPin[ i ]; } CK_BYTE* pNewPIN = new CK_BYTE[newPinLength]; - memset( pNewPIN, 0, sizeof( CK_BYTE ) * newPinLength ); - for( size_t j = 0 ; j < newPinLength ; j++ ) + memset(pNewPIN, 0, sizeof(CK_BYTE) * newPinLength); + for(size_t j = 0 ; j < newPinLength ; j++) { pNewPIN[ j ] = (CK_BYTE)newPin[ j ]; } @@ -153,50 +153,50 @@ // Log the user only if he was not previously logged in bool bUserAlreadyLoggedIn = false; CK_RV rv = CK_D_(C_Login)(mCKSession, CKU_USER, pOldPIN, oldPinLength); - if( rv == CKR_USER_ALREADY_LOGGED_IN) + if (rv == CKR_USER_ALREADY_LOGGED_IN) { bUserAlreadyLoggedIn = true; } - else if( rv != CKR_OK ) + else if (rv != CKR_OK) { delete[] pOldPIN; delete[] pNewPIN; - log( "GemaltoToken::changePIN - ## Error ## <%ld>\n", rv ); + log("GemaltoToken::changePIN - ## Error ## <%ld>\n", rv); - CKError::check( rv ); + CKError::check(rv); } // Change PIN rv = CK_D_(C_SetPIN)(mCKSession, pOldPIN, oldPinLength, pNewPIN, newPinLength); delete[] pOldPIN; delete[] pNewPIN; - CKError::check( rv ); + CKError::check(rv); // LogOut only if the user not previously logged in - if( false == bUserAlreadyLoggedIn ) + if (false == bUserAlreadyLoggedIn) { CKError::check(CK_D_(C_Logout)(mCKSession)); } mPinStatus = SCARD_SUCCESS; - log( "GemaltoToken::changePIN <END>\n" ); + log("GemaltoToken::changePIN <END>\n"); } uint32_t GemaltoToken::pinStatus(int pinNum) { - log( "\nGemaltoToken::pinStatus <BEGIN>\n" ); - log( "pinNum <%d>\n", pinNum ); + log("\nGemaltoToken::pinStatus <BEGIN>\n"); + log("pinNum <%d>\n", pinNum); if (pinNum != 1) { - log( "## Error ## pinStatus CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED\n" ); + log("## Error ## pinStatus CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED\n"); CssmError::throwMe(CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED); } - log( "GemaltoToken::pinStatus <END>\n" ); + log("GemaltoToken::pinStatus <END>\n"); return mPinStatus; } @@ -204,40 +204,40 @@ void GemaltoToken::verifyPIN(int pinNum, const uint8_t *pin, size_t pinLength) { - log( "\nGemaltoToken::verifyPIN <BEGIN>\n" ); - //log( "pinNum <%d> - pin <%.*s>\n", pinNum, (int) pinLength, pin ); + log("\nGemaltoToken::verifyPIN <BEGIN>\n"); + //log("pinNum <%d> - pin <%.*s>\n", pinNum, (int) pinLength, pin); if (pinNum != 1) { - log( "GemaltoToken::verifyPIN - ## ERROR ## Invalid pinNum <%d>\n", pinNum ); + log("GemaltoToken::verifyPIN - ## ERROR ## Invalid pinNum <%d>\n", pinNum); CssmError::throwMe(CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED); } - if ( ( pinLength < mCKTokenInfo.ulMinPinLen ) || ( pinLength > mCKTokenInfo.ulMaxPinLen ) ) + if ((pinLength < mCKTokenInfo.ulMinPinLen) || (pinLength > mCKTokenInfo.ulMaxPinLen)) { - log( "GemaltoToken::verifyPIN - ## ERROR ## Invalid PIN length\n" ); + log("GemaltoToken::verifyPIN - ## ERROR ## Invalid PIN length\n"); CssmError::throwMe(CSSM_ERRCODE_INVALID_SAMPLE_VALUE); } CK_BYTE* pPIN = new CK_BYTE[pinLength]; - memset( pPIN, 0, sizeof( CK_BYTE ) * pinLength ); - for( size_t i = 0 ; i < pinLength ; i++ ) + memset(pPIN, 0, sizeof(CK_BYTE) * pinLength); + for(size_t i = 0 ; i < pinLength ; i++) { pPIN[ i ] = (CK_BYTE)pin[ i ]; } - CK_RV rv = CK_D_(C_Login)( mCKSession, CKU_USER, pPIN, pinLength ); + CK_RV rv = CK_D_(C_Login)(mCKSession, CKU_USER, pPIN, pinLength); mPinStatus = SCARD_AUTHENTICATION_FAILED; - if ( ( CKR_OK == rv ) || ( CKR_USER_ALREADY_LOGGED_IN == rv ) ) + if ((CKR_OK == rv) || (CKR_USER_ALREADY_LOGGED_IN == rv)) { mPinStatus = SCARD_SUCCESS; } else { - log( "GemaltoToken::verifyPIN - ## Error ## <%ld>\n", rv ); + log("GemaltoToken::verifyPIN - ## Error ## <%ld>\n", rv); - if ( CKR_PIN_LOCKED == rv ) + if (CKR_PIN_LOCKED == rv) { mPinStatus = SCARD_AUTHENTICATION_BLOCKED; } @@ -246,14 +246,14 @@ delete[ ] pPIN; - log( "GemaltoToken::verifyPIN <END>\n" ); + log("GemaltoToken::verifyPIN <END>\n"); } void GemaltoToken::unverifyPIN(int pinNum) { - log( "\nGemaltoToken::unverifyPIN <BEGIN>\n" ); - log( "pinNum <%d>\n", pinNum ); + log("\nGemaltoToken::unverifyPIN <BEGIN>\n"); + log("pinNum <%d>\n", pinNum); if (pinNum != -1) CssmError::throwMe(CSSM_ERRCODE_SAMPLE_VALUE_NOT_SUPPORTED); @@ -270,16 +270,16 @@ mPinStatus = 0; - log( "GemaltoToken::unverifyPIN <END>\n" ); + log("GemaltoToken::unverifyPIN <END>\n"); } #define PKCS11_FAILED(fct, rv) log("GemaltoToken::probe - " fct "() failed: %s\n", pkcs11_error(rv)); uint32 GemaltoToken::probe(SecTokendProbeFlags flags, char tokenUid[TOKEND_MAX_UID]) { - log( "\nGemaltoToken::probe <BEGIN>\n" ); - log( "GemaltoToken::probe - flags <%x>\n", (unsigned int) flags ); - log( "GemaltoToken::probe - tokenUid <%s>\n", tokenUid ); + log("\nGemaltoToken::probe <BEGIN>\n"); + log("GemaltoToken::probe - flags <%x>\n", (unsigned int) flags); + log("GemaltoToken::probe - tokenUid <%s>\n", tokenUid); uint32 score = 0; @@ -288,10 +288,10 @@ const SCARD_READERSTATE &readerState = *(*startupReaderInfo)(); if (readerState.cbAtr) { - log( "GemaltoToken::probe - Reader <%s>\n", readerState.szReader); + log("GemaltoToken::probe - Reader <%s>\n", readerState.szReader); std::string s = ""; - GemaltoToken::toStringHex( readerState.rgbAtr, readerState.cbAtr, s ); - log( "GemaltoToken::probe - ATR <%s>\n", s.c_str( ) ); + GemaltoToken::toStringHex(readerState.rgbAtr, readerState.cbAtr, s); + log("GemaltoToken::probe - ATR <%s>\n", s.c_str()); DIR *dirp = opendir(PKCS11LIB_PATH); if (NULL == dirp) @@ -320,19 +320,19 @@ lib_name.append(dir_entry->d_name); dlPath = lib_name.c_str(); - log( "GemaltoToken::probe - Using %s PKCS#11 library\n", dlPath ); + log("GemaltoToken::probe - Using %s PKCS#11 library\n", dlPath); mDLHandle = dlopen(dlPath, RTLD_LAZY | RTLD_GLOBAL); if (NULL == mDLHandle) { - log( "GemaltoToken::probe - ## ERROR ## Cannot load the PKCS#11 library\n" ); + log("GemaltoToken::probe - ## ERROR ## Cannot load the PKCS#11 library\n"); continue; } CK_C_GetFunctionList C_GetFunctionList_PTR = (CK_C_GetFunctionList) dlsym(mDLHandle, "C_GetFunctionList"); if (NULL == C_GetFunctionList_PTR) { - log( "GemaltoToken::probe - ## ERROR ## Cannot load the PKCS#11 function list\n", dlerror() ); + log("GemaltoToken::probe - ## ERROR ## Cannot load the PKCS#11 function list\n", dlerror()); continue; } @@ -392,13 +392,13 @@ // Setup the tokendUID char label[ sizeof(mCKTokenInfo.label)+1 ]; label[sizeof(mCKTokenInfo.label)] = '\0'; - memcpy( label, mCKTokenInfo.label, sizeof(mCKTokenInfo.label) ); - char* trimLabel = trim_line( label ); - snprintf(tokenUid, TOKEND_MAX_UID, "Gemalto smartcard %s (%.*s)", trimLabel, (int) sizeof(mCKTokenInfo.serialNumber), mCKTokenInfo.serialNumber ); + memcpy(label, mCKTokenInfo.label, sizeof(mCKTokenInfo.label)); + char* trimLabel = trim_line(label); + snprintf(tokenUid, TOKEND_MAX_UID, "Gemalto smartcard %s (%.*s)", trimLabel, (int) sizeof(mCKTokenInfo.serialNumber), mCKTokenInfo.serialNumber); for (size_t len=strlen(tokenUid); tokenUid[len-1]==' '; len--) tokenUid[len-1] = '\0'; - log( "tokenUid <%s>\n", tokenUid ); + log("tokenUid <%s>\n", tokenUid); found = true; mCKSlotId = pSlotID[i]; @@ -426,7 +426,7 @@ score = 0; } - log( "GemaltoToken::probe <END>\n" ); + log("GemaltoToken::probe <END>\n"); return score; } @@ -434,8 +434,8 @@ void GemaltoToken::establish(const CSSM_GUID *guid, uint32 subserviceId, SecTokendEstablishFlags flags, const char *cacheDirectory, const char *workDirectory, char mdsDirectory[PATH_MAX], char printName[PATH_MAX]) { - log( "\nGemaltoToken::establish <BEGIN>\n" ); - log( "flags <%x> - cacheDirectory <%s> - workDirectory <%s>\n", (unsigned int)flags, cacheDirectory, workDirectory ); + log("\nGemaltoToken::establish <BEGIN>\n"); + log("flags <%x> - cacheDirectory <%s> - workDirectory <%s>\n", (unsigned int)flags, cacheDirectory, workDirectory); Token::establish(guid, subserviceId, flags, cacheDirectory, workDirectory, mdsDirectory, printName); @@ -448,15 +448,15 @@ populate(); char label[ 33 ]; - memset( label, 0, sizeof( label ) ); - memcpy( label, mCKTokenInfo.label, sizeof(mCKTokenInfo.label) ); - char* trimLabel = trim_line( label ); - snprintf(printName, PATH_MAX, "Gemalto smartcard %s (%.*s)", trimLabel, (int) sizeof(mCKTokenInfo.serialNumber), mCKTokenInfo.serialNumber ); + memset(label, 0, sizeof(label)); + memcpy(label, mCKTokenInfo.label, sizeof(mCKTokenInfo.label)); + char* trimLabel = trim_line(label); + snprintf(printName, PATH_MAX, "Gemalto smartcard %s (%.*s)", trimLabel, (int) sizeof(mCKTokenInfo.serialNumber), mCKTokenInfo.serialNumber); for (size_t len=strlen(printName); printName[len-1]==' '; len--) printName[len-1] = '\0'; - log( "printName <%s>\n", printName ); - log( "GemaltoToken::establish <END>\n" ); + log("printName <%s>\n", printName); + log("GemaltoToken::establish <END>\n"); } @@ -465,7 +465,7 @@ // void GemaltoToken::getOwner(AclOwnerPrototype &owner) { - log( "\nGemaltoToken::getOwner <BEGIN>\n" ); + log("\nGemaltoToken::getOwner <BEGIN>\n"); // we don't really know (right now), so claim we're owned by PIN #1 if (!mAclOwner) { @@ -474,14 +474,14 @@ } owner = mAclOwner; - log( "GemaltoToken::getOwner <END>\n" ); + log("GemaltoToken::getOwner <END>\n"); } void GemaltoToken::getAcl(const char *tag, uint32 &count, AclEntryInfo *&acls) { - log( "\nGemaltoToken::getAcl <BEGIN>\n" ); - log( "tag <%s> - count <%lu>\n", tag, count ); + log("\nGemaltoToken::getAcl <BEGIN>\n"); + log("tag <%s> - count <%lu>\n", tag, count); Allocator &alloc = Allocator::standard(); @@ -493,11 +493,11 @@ uint32_t status = this->pinStatus(pin); if (status == SCARD_SUCCESS) { - _addPinState(acl, pin, CSSM_ACL_PREAUTH_TRACKING_AUTHORIZED ); + _addPinState(acl, pin, CSSM_ACL_PREAUTH_TRACKING_AUTHORIZED); } - else if ( SCARD_AUTHENTICATION_BLOCKED == status ) + else if (SCARD_AUTHENTICATION_BLOCKED == status) { - _addPinState(acl, pin, CSSM_ACL_PREAUTH_TRACKING_BLOCKED ); + _addPinState(acl, pin, CSSM_ACL_PREAUTH_TRACKING_BLOCKED); } else { @@ -506,9 +506,9 @@ count = acl.size(); acls = acl.entries(); - log( "count <%lu>\n", count ); + log("count <%lu>\n", count); - log( "GemaltoToken::getAcl <END>\n" ); + log("GemaltoToken::getAcl <END>\n"); return; } @@ -530,8 +530,8 @@ count = mAclEntries.size(); acls = mAclEntries.entries(); - log( "count <%lu>\n", count ); - log( "GemaltoToken::getAcl <END>\n" ); + log("count <%lu>\n", count); + log("GemaltoToken::getAcl <END>\n"); } @@ -540,53 +540,53 @@ void GemaltoToken::populate() { - log( "\nGemaltoToken::populate <BEGIN>\n" ); + log("\nGemaltoToken::populate <BEGIN>\n"); Tokend::Relation &certRelation = mSchema->findRelation(CSSM_DL_DB_RECORD_X509_CERTIFICATE); Tokend::Relation &privateKeyRelation = mSchema->findRelation(CSSM_DL_DB_RECORD_PRIVATE_KEY); // Find all certificates into the smartcard CK_OBJECT_CLASS ulClass = CKO_CERTIFICATE; - CK_ATTRIBUTE classAttr = { CKA_CLASS, &ulClass, sizeof( CK_OBJECT_CLASS ) }; - CKError::check( CK_D_(C_FindObjectsInit)( mCKSession, &classAttr, 1 ) ); - while ( 1 ) + CK_ATTRIBUTE classAttr = { CKA_CLASS, &ulClass, sizeof(CK_OBJECT_CLASS) }; + CKError::check(CK_D_(C_FindObjectsInit)(mCKSession, &classAttr, 1)); + while (1) { CK_OBJECT_HANDLE ulObject = CK_INVALID_HANDLE; CK_ULONG ulObjectCount = 0; - CKError::check( CK_D_(C_FindObjects)( mCKSession, &ulObject, 1, &ulObjectCount ) ); - if ( 0 == ulObjectCount ) + CKError::check(CK_D_(C_FindObjects)(mCKSession, &ulObject, 1, &ulObjectCount)); + if (0 == ulObjectCount) { - log( "GemaltoToken::populate - No more certificate into the smartcard. Nothing more to do !!!\n" ); + log("GemaltoToken::populate - No more certificate into the smartcard. Nothing more to do !!!\n"); break; } - log( "GemaltoToken::populate - Found a certificate into the smartcard \n" ); + log("GemaltoToken::populate - Found a certificate into the smartcard \n"); // Create a certificate instance - RefPointer<GemaltoCertRecord> cert( new GemaltoCertRecord( *this, ulObject ) ); - certRelation.insertRecord( cert ); + RefPointer<GemaltoCertRecord> cert(new GemaltoCertRecord(*this, ulObject)); + certRelation.insertRecord(cert); // If the current certificate is not a ROOT CA certificate - if ( false == cert->isCA( ) ) + if (false == cert->isCA()) { // If the current certificat is able to perform a cryptographic operation - if ( cert->verify( ) || cert->verifyRecover( ) || cert->encrypt( ) || cert->wrap( ) ) + if (cert->verify() || cert->verifyRecover() || cert->encrypt() || cert->wrap()) { - log( "GemaltoToken::populate - The current certificate is not a ROOT and owns private key usage(s). Create associated private key.\n" ); + log("GemaltoToken::populate - The current certificate is not a ROOT and owns private key usage(s). Create associated private key.\n"); // Create a private key - RefPointer<GemaltoKeyRecord> keyPrvRecord( new GemaltoPrivateKeyRecord( *cert ) ); - privateKeyRelation.insertRecord( keyPrvRecord ); + RefPointer<GemaltoKeyRecord> keyPrvRecord(new GemaltoPrivateKeyRecord(*cert)); + privateKeyRelation.insertRecord(keyPrvRecord); // The Adornment class links a particular CertificateRecord with its corresponding KeyRecord record - keyPrvRecord->setAdornment( mSchema->publicKeyHashCoder( ).certificateKey( ), new Tokend::LinkedRecordAdornment( cert ) ); + keyPrvRecord->setAdornment(mSchema->publicKeyHashCoder().certificateKey(), new Tokend::LinkedRecordAdornment(cert)); } } } - CK_D_(C_FindObjectsFinal)( mCKSession ); + CK_D_(C_FindObjectsFinal)(mCKSession); - log( "GemaltoToken::populate <END>\n" ); + log("GemaltoToken::populate <END>\n"); } @@ -653,9 +653,9 @@ void GemaltoToken::_addPinState(AutoAclEntryInfoList& acl, uint32 slot, uint32 status) { char tag[20]; - snprintf( tag, sizeof(tag), "PIN%d?", (int) slot ); + snprintf(tag, sizeof(tag), "PIN%d?", (int) slot); - TypedList subj( acl.allocator(), CSSM_WORDID_PIN, new(acl.allocator()) ListElement(slot), new(acl.allocator()) ListElement(status)); + TypedList subj(acl.allocator(), CSSM_WORDID_PIN, new(acl.allocator()) ListElement(slot), new(acl.allocator()) ListElement(status)); acl.add(subj, CSSM_WORDID_PIN, tag); } @@ -667,17 +667,17 @@ // Define to unable if you want to activate trace into the code #define __DEBUG_GEMALTO__ -void GemaltoToken::toStringHex( const unsigned char* buffer, const std::size_t& size, std::string &result ) +void GemaltoToken::toStringHex(const unsigned char* buffer, const std::size_t& size, std::string &result) { #ifdef __DEBUG_GEMALTO__ - if( ( NULL == buffer ) || ( 1 > size ) ) + if ((NULL == buffer) || (1 > size)) { - //result.assign( "null" ); + //result.assign("null"); return; } std::ostringstream oss; - oss.rdbuf( )->str( "" ); + oss.rdbuf()->str(""); // Afficher en hexadecimal et en majuscule oss << std::hex << std::uppercase; @@ -685,7 +685,7 @@ // Remplir les blancs avec des z\x8Eros oss << std::setfill('0'); - for( std::size_t i = 0; i < size; ++i ) + for(std::size_t i = 0; i < size; ++i) { // Separer chaque octet par un espace /*if (i != 0) @@ -693,21 +693,21 @@ // Afficher sa valeur hexad\xE9cimale pr\xE9c\xE9d\xE9e de "0x" // setw(2) permet de forcer l'affichage \xE0 2 caract\xE8res - oss << /*"0x" <<*/ std::setw(2) << static_cast<int>( buffer[i] ); + oss << /*"0x" <<*/ std::setw(2) << static_cast<int>(buffer[i]); } - result.assign( oss.str( ) ); + result.assign(oss.str()); #endif } #define LOG_FILE "/tmp/Gemalto.TokenD.log" /* Log a message into the LOG_FILE file */ -void GemaltoToken::log( const char * format, ... ) +void GemaltoToken::log(const char * format, ...) { #ifdef __DEBUG_GEMALTO__ // Try to open the file - FILE* pLog = fopen( LOG_FILE, "a" ); - if ( NULL == pLog ) + FILE* pLog = fopen(LOG_FILE, "a"); + if (NULL == pLog) { // The file does not exit // Nothing to log @@ -715,12 +715,12 @@ } va_list args; - va_start( args, format ); + va_start(args, format); vfprintf(pLog, format, args); - va_end( args ); + va_end(args); // Close the file - fclose( pLog ); + fclose(pLog); #endif } Modified: trunk/Tokend/PKCS11/GemaltoToken.h =================================================================== --- trunk/Tokend/PKCS11/GemaltoToken.h 2010-05-27 07:14:20 UTC (rev 126) +++ trunk/Tokend/PKCS11/GemaltoToken.h 2010-06-07 09:13:55 UTC (rev 127) @@ -59,8 +59,8 @@ static CK_FUNCTION_LIST_PTR s_CK_pFunctionList; - static void log( const char * format, ... ); - static void toStringHex( const unsigned char* pIn, const std::size_t &ulInLen, std::string &szOut ); + static void log(const char * format, ...); + static void toStringHex(const unsigned char* pIn, const std::size_t &ulInLen, std::string &szOut); inline CK_SESSION_HANDLE session(void) const { return mCKSession; } inline const CK_TOKEN_INFO* info(void) const { return &mCKTokenInfo; }