diff --git a/OSX/CMakeLists.txt b/OSX/CMakeLists.txt index 61a90e65..dae240b9 100644 --- a/OSX/CMakeLists.txt +++ b/OSX/CMakeLists.txt @@ -11,6 +11,8 @@ add_subdirectory(libsecurity_keychain/lib) add_subdirectory(libsecurity_authorization/lib) add_subdirectory(libsecurity_utilities/lib) add_subdirectory(utilities/src) +add_subdirectory(libsecurity_cssm/lib) +#add_subdirectory(libsecurity_transform/lib) SET(CMAKE_INSTALL_RPATH "${CMAKE_INSTALL_PREFIX}/${CMAKE_INSTALL_LIBDIR}/darling") SET(CMAKE_BUILD_WITH_INSTALL_RPATH TRUE) @@ -20,8 +22,12 @@ add_library(Security SHARED $ $ $ + $ + $ + $ + # $ ) -target_link_libraries(Security system auto CFFExtra CFF sqlite3) +target_link_libraries(Security system auto CFFExtra CFF sqlite3 xpc) install(TARGETS Security DESTINATION ${CMAKE_INSTALL_LIBDIR}/darling) diff --git a/OSX/libsecurity_cssm/derived_src/cssmexports.gen b/OSX/libsecurity_cssm/derived_src/cssmexports.gen new file mode 100644 index 00000000..f48b23e1 --- /dev/null +++ b/OSX/libsecurity_cssm/derived_src/cssmexports.gen @@ -0,0 +1,634 @@ +_CSSM_CSP_GetOperationalStatistics +_CSSMOID_PKCS5_HMAC_SHA1 +_CSSMOID_UniqueIdentifier +_CSSMOID_PKIX_OCSP_BASIC +_CSSM_DL_DataGetFromUniqueRecordId +_CSSM_DL_ChangeDbAcl +_CSSMOID_RoleOccupant +_CSSM_GetContextAttribute +_CSSMOID_SHA1WithDSA_JDK +_CSSMOID_PKCS9_CertTypes +_CSSMOID_PKIX_OCSP_NONCE +_CSSMOID_OCSPSigning +_CSSM_QuerySize +_CSSM_TP_CrlVerify +_CSSMOID_X509V3CertificateExtensionCritical +_CSSMOID_sect163r1 +_CSSMOID_ExtendedCertificateAttributes +_CSSM_DL_Authenticate +_CSSMOID_DOTMAC_CERT +_CSSM_CL_CrlRemoveCert +_CSSM_CSP_ObtainPrivateKeyFromPublicKey +_CSSMOID_DOTMAC_CERT_REQ_ARCHIVE_LIST +_CSSMOID_APPLE_ASC +_CSSMOID_X509V3SignedCertificateCStruct +_CSSM_DL_DestroyRelation +_CSSM_CSP_CreateSignatureContext +_CSSMOID_CertificateRevocationList +_CSSM_AC_AuthCompute +_CSSMOID_APPLE_TP_APPLEID_SHARING +_CSSMOID_DOTMAC_CERT_REQ_ARCHIVE_STORE +_CSSM_CL_CertCache +_CSSMOID_sect571r1 +_CSSMOID_APPLE_TP_REVOCATION_CRL +_CSSMOID_DOTMAC_CERT_REQ_VALUE_IS_PENDING +_CSSMOID_PKCS9_Id_Ct_TSTInfo +_CSSMOID_APPLE_TP_CODE_SIGNING +_CSSMOID_DSA_CMS +_CSSMOID_APPLE_EKU_CODE_SIGNING +_CSSMOID_DOTMAC_CERT_REQ_EMAIL_ENCRYPT +_CSSMOID_ANSI_DH_STATIC +_CSSM_GetModuleGUIDFromHandle +_CSSMOID_X509V2CRLRevokedEntrySingleExtensionStruct +_CSSM_TP_CrlSign +_CSSMOID_PKCS7_SignedAndEnvelopedData +_CSSM_CL_CrlSetFields +_CSSMOID_PKCS5_ENCRYPT_ALG +_CSSM_DecryptDataInitP +_CSSMOID_PKCS5_pbeWithSHA1AndRC2 +_CSSM_TP_PassThrough +_CSSMOID_DeltaCrlIndicator +_CSSM_Unintroduce +_CSSMOID_DomainComponent +_CSSMOID_APPLE_X509_BASIC +_CSSMOID_X9_62_EllCurve +_CSSM_DigestDataInit +_CSSMOID_PKCS9_X509Crl +_CSSMOID_secp112r1 +_CSSM_DigestDataClone +_CSSMOID_APPLE_TP_CSR_GEN +_CSSMOID_PKCS9_FriendlyName +_CSSMOID_APPLE_EXTENSION_INTERMEDIATE_MARKER +_CSSMOID_X509V2CRLExtensionCritical +_CSSMOID_X9_62 +_CSSMOID_EmailProtection +_CSSMOID_SubjectDirectoryAttributes +_CSSM_VerifyMacFinal +_CSSMOID_PKCS7_DigestedData +_CSSMOID_PKCS9_TimeStampToken +_CSSMOID_MD5WithRSA +_CSSM_TP_ApplyCrlToDb +_CSSMOID_X509V1SerialNumber +_CSSMOID_APPLE_EXTENSION_PASSBOOK_SIGNING +_CSSMOID_DestinationIndicator +_CSSMOID_DOTMAC_CERT_REQ_VALUE_PASSWORD +_CSSMOID_X9_62_SigType +_CSSM_ChangeKeyAcl +_CSSM_GenerateKeyPairP +_CSSM_CL_CertGroupToSignedBundle +_CSSMOID_ANSI_DH_ONE_FLOW +_CSSMOID_PrivateKeyUsagePeriod +_CSSM_CSP_CreatePassThroughContext +_CSSM_SetContext +_CSSMOID_SeeAlso +_CSSMOID_SubjectPicture +_CSSMOID_X509V1CRLRevokedEntryRevocationDate +_CSSMOID_PKCS5_pbeWithMD2AndRC2 +_CSSM_TP_CertReclaimAbort +_CSSMOID_SHA1 +_CSSMOID_X509V1SubjectNameStd +_CSSMOID_X509V3CertificateExtensionsCStruct +_CSSM_DeleteContext +_CSSM_CSP_CreateRandomGenContext +_CSSM_TP_CertGroupVerify +_CSSM_CSP_Logout +_CSSM_TP_CrlCreateTemplate +_CSSMOID_NetscapeCertType +_CSSM_CL_CertGetFirstCachedFieldValue +_CSSMOID_CollectiveTelexTerminalIdentifier +_CSSMOID_APPLE_EXTENSION_ADC_DEV_SIGNING +_CSSM_TP_CertCreateTemplate +_CSSMOID_ANSI_MQV2_SHA1 +_CSSMOID_OAEP_MGF1 +_CSSMOID_SHA224 +_CSSMOID_X9_62_C_TwoCurve +_CSSMOID_SubjectInfoAccess +_CSSM_DL_DataGetFirst +_CSSMOID_ANSI_MQV2 +_CSSMOID_SHA224WithRSA +_CSSMOID_X509V1CRLRevokedEntrySerialNumber +_CSSMOID_X509V3CertificateNumberOfExtensions +_CSSMOID_DNQualifier +_CSSMOID_ECDSA_WithSHA384 +_CSSM_TP_CertGroupConstruct +_CSSMOID_secp160r2 +_CSSMOID_CountryName +_CSSMOID_PKIX_OCSP_ARCHIVE_CUTOFF +_CSSM_TP_ReceiveConfirmation +_CSSM_DL_CreateRelation +_CSSMOID_MOBILE_STORE_SIGNING_POLICY +_CSSMOID_MD4WithRSA +_CSSMOID_X509V2CRLSignedCrlStruct +_CSSMOID_CollectivePhysicalDeliveryOfficeName +_CSSMOID_X509V1SignatureAlgorithm +_CSSMOID_MACAPPSTORE_CERT_POLICY +_CSSMOID_ANSI_DH_STATIC_SHA1 +_CSSMOID_AD_CA_REPOSITORY +_CSSMOID_PKCS7_SignedData +_CSSM_CSP_CreateAsymmetricContext +_CSSM_CL_CrlGetFirstFieldValue +_CSSMOID_PKCS12_pbeWithSHAAnd128BitRC2CBC +_CSSMOID_X509V2CRLRevokedEntryExtensionCritical +_CSSM_CL_CertSign +_CSSMOID_PKCS12_pbeWithSHAAnd40BitRC4 +_CSSMOID_X509V3CertificateExtensionsStruct +_CSSMOID_SHA1WithDSA +_CSSMOID_TelexNumber +_CSSMOID_ProtocolInformation +_CSSMOID_CrlDistributionPoints +_CSSMOID_PostalCode +_CSSMOID_SHA256 +_CSSMOID_PostalAddress +_CSSMOID_APPLE_EXTENSION_APPLE_SIGNING +_CSSMOID_X509V1CRLThisUpdate +_CSSMOID_HoldInstructionCode +_CSSM_DecryptDataInit +_CSSMOID_ObjectClass +_CSSMOID_DOTMAC_CERT_EMAIL_SIGN +_CSSM_SetPrivilege +_CSSMOID_PDA_DATE_OF_BIRTH +_CSSM_TP_RetrieveCredResult +_CSSMOID_PKCS12_keyBag +_CSSM_CL_CrlAddCert +_CSSM_CL_CertGetAllTemplateFields +_CSSMOID_DOTMAC_CERT_REQ_VALUE_USERNAME +_CSSMOID_sect283k1 +_CSSMOID_QC_Statements +_CSSM_DL_DbDelete +_CSSMOID_PKCS7_EnvelopedData +_CSSM_GenerateKeyPair +_CSSMOID_ANSI_DH_EPHEM_SHA1 +_CSSMOID_MD4 +_CSSMOID_X_121Address +_CSSMOID_secp128r1 +_CSSM_CL_CrlDescribeFormat +_CSSMOID_X509V1SignatureStruct +_CSSM_RetrieveUniqueId +_CSSMOID_APPLE_FEE +_CSSMOID_sect409k1 +_CSSMOID_PKCS12_crlBag +_CSSMOID_ECDSA_WithSHA224 +_CSSMOID_CrlNumber +_CSSMOID_sect131r2 +_CSSMOID_ANSI_DH_PUB_NUMBER +_CSSM_DL_PassThrough +_CSSM_SignDataUpdate +_CSSMOID_StreetAddress +_CSSMOID_PKIX_OCSP_RESPONSE +_CSSM_DecryptData +_CSSM_EncryptDataFinal +_CSSMOID_PKCS9_LocalKeyId +_CSSMOID_APPLE_EXTENSION_ITMS_INTERMEDIATE +_CSSMOID_DOTMAC_CERT_REQ_VALUE_ASYNC +_CSSMOID_HouseIdentifier +_CSSM_GetContext +_CSSM_TP_CertSign +_CSSMOID_BiometricInfo +_CSSM_CSP_ChangeLoginOwner +_CSSMOID_APPLE_EXTENSION_WWDR_INTERMEDIATE +_CSSMOID_CertIssuer +_CSSM_GenerateKeyP +_CSSMOID_secp224r1 +_CSSMOID_CollectiveStreetAddress +_CSSMOID_X509V3CertificateExtensionType +_CSSM_CL_CrlCache +_CSSM_CL_CertGetNextCachedFieldValue +_CSSMOID_UseExemptions +_CSSMOID_APPLE_ISIGN +_CSSM_CL_CertGetKeyInfo +_CSSMOID_APPLE_EKU_ICHAT_ENCRYPTION +_CSSM_FreeKey +_CSSM_TP_CertGetAllTemplateFields +_CSSMOID_sect233r1 +_CSSMOID_PKIX_OCSP +_CSSM_CSP_CreateSymmetricContext +_CSSMOID_CerticomEllCurve +_CSSMOID_APPLE_TP_PKINIT_SERVER +_CSSM_DeleteContextAttributes +_CSSMOID_TelexTerminalIdentifier +_CSSMOID_APPLE_TP_MOBILE_STORE +_CSSMOID_APPLE_TP_SMIME +_CSSMOID_PhysicalDeliveryOfficeName +_CSSMOID_X509V3CertificateCStruct +_CSSMOID_QT_CPS +_CSSMOID_PKCS5_DES_EDE3_CBC +_CSSMOID_SHA384WithRSA +_CSSMOID_X509V1SubjectPublicKeyAlgorithm +_CSSMOID_APPLE_EKU_SYSTEM_IDENTITY +_CSSM_GetPrivilege +_CSSMOID_PKCS12_pbeWithSHAAnd128BitRC4 +_CSSM_CSP_CreateKeyGenContext +_CSSMOID_APPLE_TP_PROVISIONING_PROFILE_SIGNING +_CSSMOID_CollectiveStateProvinceName +_CSSMOID_X509V1SignatureCStruct +_CSSMOID_PKCS5_PBKDF2 +_CSSMOID_APPLE_TP_SW_UPDATE_SIGNING +_CSSMOID_MessageDigest +_CSSMOID_PKCS7_EncryptedData +_CSSMOID_X509V1IssuerNameCStruct +_CSSMOID_LocalityName +_CSSMOID_APPLE_TP_SSL +_CSSMOID_APPLE_EXTENSION +_CSSMOID_secp128r2 +_CSSM_VerifyDevice +_CSSMOID_UserPassword +_CSSMOID_X509V1SubjectNameCStruct +_CSSM_Terminate +_CSSMOID_APPLE_TP_PROFILE_SIGNING +_CSSMOID_DSA +_CSSM_GenerateMacUpdate +_CSSM_CL_CertDescribeFormat +_CSSM_DL_DbOpen +_CSSMOID_X509V2CRLSignedCrlCStruct +_CSSM_TP_CertRemoveFromCrlTemplate +_CSSM_GetSubserviceUIDFromHandle +_CSSM_DL_DataInsert +_CSSMOID_IssuingDistributionPoint +_CSSMOID_MD5 +_CSSMOID_PKCS7_DataWithAttributes +_CSSM_DL_DataModify +_CSSMOID_APPLE_TP_REVOCATION +_CSSMOID_APPLE_TP_QA_PROFILE_SIGNING +_CSSM_CSP_ChangeLoginAcl +_CSSMOID_X509V1Signature +_CSSMOID_MACAPPSTORE_RECEIPT_CERT_POLICY +_CSSMOID_X509V1CRLRevokedCertificatesCStruct +_CSSMOID_PKIX_OCSP_CRL +_CSSMOID_APPLE_EKU_ICHAT_SIGNING +_CSSM_ListAttachedModuleManagers +_CSSMOID_PKCS5_DIGEST_ALG +_CSSMOID_CollectivePostalAddress +_CSSMOID_IssuingDistributionPoints +_CSSMOID_SupportedApplicationContext +_CSSMOID_DOTMAC_CERT_POLICY +_CSSM_Introduce +_CSSMOID_CollectiveFacsimileTelephoneNumber +_CSSMOID_KERBv5_PKINIT_DH_KEY_DATA +_CSSMOID_AuthorityRevocationList +_CSSMOID_X509V1SubjectPublicKey +_CSSMOID_X509V2CRLRevokedEntryExtensionValue +_CSSMOID_APPLE_TP_ESCROW_SERVICE +_CSSMOID_X509V2CRLRevokedEntryExtensionType +_CSSMOID_APPLE_EXTENSION_APPLEID_INTERMEDIATE +_CSSMOID_NetscapeSGC +_CSSM_DL_GetDbNames +_CSSM_EncryptDataP +_CSSMOID_X509V1CRLRevokedCertificatesStruct +_CSSMOID_X509V3CertificateExtensionValue +_CSSMOID_PKCS5_pbeWithMD5AndDES +_CSSM_CL_CrlAbortCache +_CSSMOID_PKCS5_pbeWithMD2AndDES +_CSSMOID_X509V2CRLRevokedEntryAllExtensionsCStruct +_CSSM_CL_CrlGetFirstCachedFieldValue +_CSSM_EncryptDataInitP +_CSSMOID_UniqueMember +_CSSMOID_APPLE_TP_RESOURCE_SIGN +_CSSMOID_X509V1CRLIssuerNameCStruct +_CSSMOID_DOTMAC_CERT_EXTENSION +_CSSMOID_X509V1IssuerNameStd +_CSSMOID_Name +_CSSMOID_X509V3SignedCertificate +_CSSMOID_APPLE_CERT_POLICY +_CSSM_ModuleLoad +_CSSMOID_X509V2CRLNumberOfExtensions +_CSSMOID_APPLE_TP_MACAPPSTORE_RECEIPT +_CSSMOID_ADC_CERT_POLICY +_CSSMOID_MicrosoftSGC +_CSSM_CL_CrlCreateTemplate +_CSSM_GetTimeValue +_CSSMOID_secp521r1 +_CSSM_GenerateMacFinal +_CSSMOID_NetscapeCertSequence +_CSSMOID_NameConstraints +_CSSMOID_Description +_CSSMOID_AuthorityKeyIdentifier +_CSSMOID_X509V1IssuerNameLDAP +_CSSM_VerifyDataInit +_CSSMOID_AD_TIME_STAMPING +_CSSM_GenerateMac +_CSSMOID_APPLE_EKU_CODE_SIGNING_DEV +_CSSM_GetKeyAcl +_CSSM_SignData +_CSSMOID_DOTMAC_CERT_REQ_VALUE_HOSTNAME +_CSSMOID_PolicyMappings +_CSSMOID_APPLE_EKU_PROFILE_SIGNING +_CSSMOID_ExtendedUseCodeSigning +_CSSM_TP_CertGroupToTupleGroup +_CSSMOID_X509V2CRLTbsCertListCStruct +_CSSM_UnwrapKey +_CSSMOID_X509V1SubjectName +_CSSMOID_CollectivePostalCode +_CSSMOID_DSA_JDK +_CSSMOID_PKCS12_pbeWithSHAAnd3Key3DESCBC +_CSSMOID_APPLE_TP_ICHAT +_CSSM_UnwrapKeyP +_CSSM_FreeContext +_CSSMOID_DH +_CSSM_GenerateMacInit +_CSSMOID_sect131r1 +_CSSM_CSP_PassThrough +_CSSMOID_APPLEID_SHARING_CERT_POLICY +_CSSMOID_X509V1IssuerName +_CSSM_CSP_CreateDigestContext +_CSSM_CL_CertGetNextFieldValue +_CSSMOID_sect193r1 +_CSSMOID_APPLE_FEED +_CSSMOID_APPLE_EXTENSION_ADC_APPLE_SIGNING +_CSSMOID_GenerationQualifier +_CSSMOID_X509V1CRLIssuerStruct +_CSSM_CL_FreeFieldValue +_CSSM_SignDataInit +_CSSM_TP_SubmitCredRequest +_CSSMOID_OID_QCS_SYNTAX_V1 +_CSSMOID_X509V3CertificateExtensionStruct +_CSSMOID_X509V2CRLRevokedEntryExtensionId +_CSSMOID_ANSI_DH_HYBRID2 +_CSSMOID_SubjectSignatureBitmap +_CSSMOID_PKCS9_X509Certificate +_CSSM_CL_CrlSign +_CSSMOID_ETSI_QCS_QC_COMPLIANCE +_CSSMOID_TelephoneNumber +_CSSMOID_BasicConstraints +_CSSM_CL_CrlGetNextCachedFieldValue +_CSSMOID_OAEP_ID_PSPECIFIED +_CSSMOID_ContentType +_CSSMOID_APPLE_TP_LOCAL_CERT_GEN +_CSSMOID_APPLE_TP_PASSBOOK_SIGNING +_CSSMOID_X509V2CRLRevokedEntryNumberOfExtensions +_CSSM_GenerateAlgorithmParams +_CSSMOID_RSA +_CSSMOID_PKCS12_pbeWithSHAAnd2Key3DESCBC +_CSSMOID_CollectiveOrganizationName +_CSSMOID_PostOfficeBox +_CSSMOID_SHA512 +_CSSMOID_X509V1SubjectNameLDAP +_CSSM_CSP_Login +_CSSMOID_PresentationAddress +_CSSM_CL_CertVerify +_CSSM_CL_CertAbortQuery +_CSSMOID_AD_CA_ISSUERS +_CSSMOID_IssuerAltName +_CSSMOID_CertificatePolicies +_CSSMOID_APPLE_TP_EAP +_CSSMOID_PKIX_OCSP_NOCHECK +_CSSM_CL_CrlGetAllFields +_CSSMOID_PKCS12_shroudedKeyBag +_CSSMOID_ExtendedKeyUsageAny +_CSSM_TP_ConfirmCredResult +_CSSMOID_X509V2CRLVersion +_CSSMOID_CrlReason +_CSSMOID_X9_62_FieldType +_CSSMOID_PKCS9_CrlTypes +_CSSMOID_X509V1CRLNumberOfRevokedCertEntries +_CSSMOID_ChallengePassword +_CSSMOID_KeyUsage +_CSSMOID_X509V1CRLIssuerNameLDAP +_CSSMOID_SerialNumber +_CSSMOID_X509V1CRLRevokedEntryStruct +_CSSM_RetrieveCounter +_CSSMOID_APPLE_EXTENSION_SERVER_AUTHENTICATION +_CSSMOID_PKCS5_RC2_CBC +_CSSMOID_AuthorityInfoAccess +_CSSM_CL_CertGroupFromVerifiedBundle +_CSSMOID_ANSI_DH_HYBRID_ONEFLOW +_CSSMOID_PreferredDeliveryMethod +_CSSMOID_PKCS5_RC5_CBC +_CSSM_WrapKeyP +_CSSMOID_Certicom +_CSSMOID_sect283r1 +_CSSMOID_ECDSA_WithSpecified +_CSSMOID_CounterSignature +_CSSMOID_PKCS9_SdsiCertificate +_CSSMOID_X509V1SignatureAlgorithmTBS +_CSSMOID_Surname +_CSSMOID_ETSI_QCS_QC_RETENTION +_CSSMOID_Initials +_CSSMOID_PKCS12_certBag +_CSSMOID_X509V1SignatureAlgorithmParameters +_CSSM_WrapKey +_CSSM_AC_PassThrough +_CSSMOID_CrossCertificatePair +_CSSMOID_CollectiveInternationalISDNNumber +_CSSMOID_ANSI_DH_HYBRID2_SHA1 +_CSSM_CL_CrlAbortQuery +_CSSMOID_Member +_CSSMOID_X509V1CRLRevokedEntryCStruct +_CSSM_DL_ChangeDbOwner +_CSSM_EncryptData +_CSSMOID_secp160k1 +_CSSMOID_secp256r1 +_CSSMOID_APPLE_TP_PACKAGE_SIGNING +_CSSMOID_CollectivePostOfficeBox +_CSSMOID_InhibitAnyPolicy +_CSSMOID_PDA_COUNTRY_CITIZEN +_CSSMOID_secp384r1 +_CSSM_ModuleAttach +_CSSM_DecryptDataP +_CSSMOID_DOTMAC_CERT_REQ +_CSSM_DecryptDataUpdate +_CSSMOID_PKCS7_Data +_CSSMOID_APPLE_EKU_PASSBOOK_SIGNING +_CSSMOID_APPLE_EXTENSION_SYSINT2_INTERMEDIATE +_CSSMOID_X9_62_PubKeyType +_CSSM_DL_DataDelete +_CSSMOID_sect163k1 +_CSSM_CL_CertGetFirstFieldValue +_CSSMOID_DOTMAC_CERT_REQ_SHARED_SERVICES +_CSSMOID_sect409r1 +_CSSM_CL_FreeFields +_CSSMOID_sect571k1 +_CSSM_TP_FormSubmit +_CSSMOID_CACertificate +_CSSMOID_ECDSA_WithSHA1 +_CSSMOID_DistinguishedName +_CSSMOID_ECDSA_WithSHA256 +_CSSMOID_sect239k1 +_CSSMOID_DES_CBC +_CSSM_DecryptDataFinal +_CSSMOID_X509V2CRLExtensionType +_CSSM_VerifyMacInit +_CSSMOID_FacsimileTelephoneNumber +_CSSMOID_SubjectKeyIdentifier +_CSSMOID_X9_62_PrimeCurve +_CSSM_TP_FormRequest +_CSSMOID_ANSI_MQV1 +_CSSM_CL_CertVerifyWithKey +_CSSMOID_DOTMAC_CERT_REQ_EMAIL_SIGN +_CSSMOID_QT_UNOTICE +_CSSMOID_APPLE_TP_IP_SEC +_CSSMOID_PKCS5_PBES2 +_CSSM_DL_GetDbAcl +_CSSM_VerifyMacUpdate +_CSSM_DL_GetDbOwner +_CSSMOID_CollectiveTelexNumber +_CSSMOID_AliasedEntryName +_CSSMOID_CSSMKeyStruct +_CSSMOID_ECDSA_WithSHA512 +_CSSMOID_X509V1CertificateSubjectUniqueId +_CSSMOID_APPLE_TP_TIMESTAMPING +_CSSMOID_X509V1SubjectPublicKeyAlgorithmParameters +_CSSM_CL_CrlVerifyWithKey +_CSSMOID_X509V2CRLRevokedEntryAllExtensionsStruct +_CSSMOID_PKCS12_safeContentsBag +_CSSMOID_X509V1ValidityNotBefore +_CSSMOID_APPLE_EKU_RESOURCE_SIGNING +_CSSM_CL_CrlGetNextFieldValue +_CSSM_CSP_GetLoginAcl +_CSSMOID_X509V1CertificateIssuerUniqueId +_CSSMOID_DOTMAC_CERT_REQ_ARCHIVE_FETCH +_CSSM_CL_PassThrough +_CSSMOID_X509V2CRLAllExtensionsStruct +_CSSMOID_ServerAuth +_CSSM_CL_IsCertInCrl +_CSSMOID_APPLE_EXTENSION_APPLEID_SHARING +_CSSMOID_APPLE_FEE_MD5 +_CSSMOID_Title +_CSSM_CL_CrlGetAllCachedRecordFields +_CSSMOID_X509V2CRLRevokedEntrySingleExtensionCStruct +_CSSMOID_UnstructuredName +_CSSMOID_GivenName +_CSSM_VerifyData +_CSSMOID_PKCS5_pbeWithSHA1AndDES +_CSSMOID_ANSI_MQV1_SHA1 +_CSSMOID_BusinessCategory +_CSSMOID_InternationalISDNNumber +_CSSM_CL_CertGetAllFields +_CSSMOID_EKU_IPSec +_CSSMOID_OrganizationalUnitName +_CSSMOID_X509V3Certificate +_CSSMOID_MD2WithRSA +_CSSMOID_sect113r1 +_CSSMOID_PKCS5_pbeWithMD5AndRC2 +_CSSM_QueryKeySizeInBits +_CSSM_DeriveKey +_CSSMOID_PKCS7_EncryptedPrivateKeyInfo +_CSSMOID_ClientAuth +_CSSM_DigestData +_CSSMOID_sect163r2 +_CSSMOID_secp160r1 +_CSSMOID_PKCS12_secretBag +_CSSM_DL_FreeNameList +_CSSM_TP_TupleGroupToCertGroup +_CSSM_ModuleDetach +_CSSMOID_PKIX_OCSP_SERVICE_LOCATOR +_CSSMOID_StateProvinceName +_CSSMOID_RegisteredAddress +_CSSM_EncryptDataInit +_CSSMOID_ETSI_QCS_QC_LIMIT_VALUE +_CSSMOID_APPLE_TP_CODE_SIGN +_CSSMOID_PDA_PLACE_OF_BIRTH +_CSSMOID_UserCertificate +_CSSM_CSP_GetLoginOwner +_CSSMOID_CollectiveOrganizationalUnitName +_CSSM_CL_CertAbortCache +_CSSMOID_secp224k1 +_CSSMOID_SHA1WithRSA +_CSSMOID_X509V2CRLAllExtensionsCStruct +_CSSM_VerifyDataUpdate +_CSSMOID_DOTMAC_CERT_EMAIL_ENCRYPT +_CSSMOID_ETSI_QCS_QC_SSCD +_CSSM_DL_FreeUniqueRecord +_CSSM_VerifyDataFinal +_CSSMOID_EmailAddress +_CSSMOID_SearchGuide +_CSSM_GetKeyOwner +_CSSMOID_TEST_MOBILE_STORE_SIGNING_POLICY +_CSSM_DigestDataFinal +_CSSM_DL_DbClose +_CSSMOID_DOTMAC_CERT_REQ_IDENTITY +_CSSMOID_OrganizationName +_CSSMOID_ANSI_DH_EPHEM +_CSSM_SignDataFinal +_CSSMOID_SubjectEmailAddress +_CSSM_DL_DataGetNext +_CSSMOID_ExtendedKeyUsage +_CSSMOID_X509V2CRLSingleExtensionCStruct +_CSSMOID_KERBv5_PKINIT_RKEY_DATA +_CSSMOID_TimeStamping +_CSSMOID_RSAWithOAEP +_CSSMOID_AD_OCSP +_CSSM_CL_CrlVerify +_CSSMOID_APPLE_TP_PKINIT_CLIENT +_CSSM_CSP_CreateMacContext +_CSSMOID_X509V1CRLNextUpdate +_CSSMOID_APPLE_EXTENSION_CODE_SIGNING +_CSSM_ModuleUnload +_CSSMOID_SigningTime +_CSSMOID_sect113r2 +_CSSMOID_ecPublicKey +_CSSMOID_KnowledgeInformation +_CSSM_CL_CertCreateTemplate +_CSSMOID_APPLE_EKU_QA_PROFILE_SIGNING +_CSSMOID_UserID +_CSSMOID_secp112r2 +_CSSMOID_APPLE_FEE_SHA1 +_CSSMOID_PKCS5_PBMAC1 +_CSSMOID_DOTMAC_CERT_REQ_VALUE_RENEW +_CSSM_EncryptDataUpdate +_CSSMOID_secp192k1 +_CSSMOID_SHA1WithDSA_CMS +_CSSM_DL_GetDbNameFromHandle +_CSSMOID_X509V1Version +_CSSMOID_CollectiveTelephoneNumber +_CSSMOID_EnhancedSearchGuide +_CSSMOID_APPLE_EXTENSION_DEVELOPER_AUTHENTICATION +_CSSMOID_SHA384 +_CSSMOID_APPLE_EXTENSION_AAI_INTERMEDIATE +_CSSM_Init +_CSSM_CL_IsCertInCachedCrl +_CSSMOID_DOTMAC_CERT_REQ_ARCHIVE_REMOVE +_CSSM_DL_DbCreate +_CSSMOID_APPLE_EXTENSION_MACAPPSTORE_RECEIPT +_CSSMOID_X509V3CertificateExtensionCStruct +_CSSMOID_APPLE_TP_PCS_ESCROW_SERVICE +_CSSMOID_ANSI_DH_HYBRID1 +_CSSMOID_PolicyConstraints +_CSSMOID_X509V2CRLExtensionId +_CSSMOID_SHA512WithRSA +_CSSMOID_X509V1ValidityNotAfter +_CSSM_DigestDataUpdate +_CSSM_GenerateKey +_CSSMOID_ANSI_DH_HYBRID1_SHA1 +_CSSMOID_KERBv5_PKINIT_KP_KDC +_CSSMOID_PDA_COUNTRY_RESIDENCE +_CSSM_ChangeKeyOwner +_CSSMOID_KERBv5_PKINIT_AUTH_DATA +_CSSMOID_APPLEID_CERT_POLICY +_CSSMOID_InvalidityDate +_CSSMOID_APPLE_ECDSA +_CSSMOID_SHA256WithRSA +_CSSMOID_sect233k1 +_CSSMOID_sect193r2 +_CSSMOID_Owner +_CSSMOID_APPLE_TP_TEST_MOBILE_STORE +_CSSMOID_secp256k1 +_CSSMOID_DOTMAC_CERT_IDENTITY +_CSSM_DL_DataAbortQuery +_CSSMOID_APPLE_EXTENSION_ESCROW_SERVICE +_CSSM_TP_CertRevoke +_CSSM_UpdateContextAttributes +_CSSMOID_PDA_GENDER +_CSSMOID_OID_QCS_SYNTAX_V2 +_CSSMOID_KERBv5_PKINIT_KP_CLIENT_AUTH +_CSSM_VerifyMac +_CSSMOID_PKCS12_pbewithSHAAnd40BitRC2CBC +_CSSMOID_X509V3CertificateExtensionId +_CSSMOID_X509V2CRLSingleExtensionStruct +_CSSM_TP_CertReclaimKey +_CSSMOID_X509V1SubjectPublicKeyCStruct +_CSSMOID_MD2 +_CSSM_GenerateRandom +_CSSMOID_SubjectAltName +_CSSM_GetAPIMemoryFunctions +_CSSMOID_PKCS3 +_CSSMOID_UnstructuredAddress +_CSSM_CSP_CreateDeriveKeyContext +_CSSMOID_X509V2CRLTbsCertListStruct +_CSSMOID_CommonName +_CSSMOID_ANSI_DH_ONE_FLOW_SHA1 +_CSSMOID_APPLE_TP_REVOCATION_OCSP +_CSSMOID_APPLE_EXTENSION_PROVISIONING_PROFILE_SIGNING +_CSSMOID_SHA1WithRSA_OIW +_CSSMOID_APPLE_FEEDEXP +_CSSM_TP_CertGroupPrune +_CSSMOID_secp192r1 diff --git a/OSX/libsecurity_cssm/derived_src/funcnames.gen b/OSX/libsecurity_cssm/derived_src/funcnames.gen new file mode 100644 index 00000000..f08d0f6e --- /dev/null +++ b/OSX/libsecurity_cssm/derived_src/funcnames.gen @@ -0,0 +1,163 @@ +// +// Standard plugin name tables +// This file was automatically generated. Do not edit on penalty of futility! +// +extern const char *const TPNameTable[] = { + "SubmitCredRequest", + "RetrieveCredResult", + "ConfirmCredResult", + "ReceiveConfirmation", + "CertReclaimKey", + "CertReclaimAbort", + "FormRequest", + "FormSubmit", + "CertGroupVerify", + "CertCreateTemplate", + "CertGetAllTemplateFields", + "CertSign", + "CrlVerify", + "CrlCreateTemplate", + "CertRevoke", + "CertRemoveFromCrlTemplate", + "CrlSign", + "ApplyCrlToDb", + "CertGroupConstruct", + "CertGroupPrune", + "CertGroupToTupleGroup", + "TupleGroupToCertGroup", + "PassThrough", +}; + +extern const char *const CLNameTable[] = { + "CertCreateTemplate", + "CertGetAllTemplateFields", + "CertSign", + "CertVerify", + "CertVerifyWithKey", + "CertGetFirstFieldValue", + "CertGetNextFieldValue", + "CertAbortQuery", + "CertGetKeyInfo", + "CertGetAllFields", + "FreeFields", + "FreeFieldValue", + "CertCache", + "CertGetFirstCachedFieldValue", + "CertGetNextCachedFieldValue", + "CertAbortCache", + "CertGroupToSignedBundle", + "CertGroupFromVerifiedBundle", + "CertDescribeFormat", + "CrlCreateTemplate", + "CrlSetFields", + "CrlAddCert", + "CrlRemoveCert", + "CrlSign", + "CrlVerify", + "CrlVerifyWithKey", + "IsCertInCrl", + "CrlGetFirstFieldValue", + "CrlGetNextFieldValue", + "CrlAbortQuery", + "CrlGetAllFields", + "CrlCache", + "IsCertInCachedCrl", + "CrlGetFirstCachedFieldValue", + "CrlGetNextCachedFieldValue", + "CrlGetAllCachedRecordFields", + "CrlAbortCache", + "CrlDescribeFormat", + "PassThrough", +}; + +extern const char *const ACNameTable[] = { + "AuthCompute", + "PassThrough", +}; + +extern const char *const CSPNameTable[] = { + "EventNotify", + "QuerySize", + "SignData", + "SignDataInit", + "SignDataUpdate", + "SignDataFinal", + "VerifyData", + "VerifyDataInit", + "VerifyDataUpdate", + "VerifyDataFinal", + "DigestData", + "DigestDataInit", + "DigestDataUpdate", + "DigestDataClone", + "DigestDataFinal", + "GenerateMac", + "GenerateMacInit", + "GenerateMacUpdate", + "GenerateMacFinal", + "VerifyMac", + "VerifyMacInit", + "VerifyMacUpdate", + "VerifyMacFinal", + "EncryptData", + "EncryptDataInit", + "EncryptDataUpdate", + "EncryptDataFinal", + "DecryptData", + "DecryptDataInit", + "DecryptDataUpdate", + "DecryptDataFinal", + "QueryKeySizeInBits", + "GenerateKey", + "GenerateKeyPair", + "GenerateRandom", + "GenerateAlgorithmParams", + "WrapKey", + "UnwrapKey", + "DeriveKey", + "FreeKey", + "PassThrough", + "Login", + "Logout", + "ChangeLoginAcl", + "ObtainPrivateKeyFromPublicKey", + "RetrieveUniqueId", + "RetrieveCounter", + "VerifyDevice", + "GetTimeValue", + "GetOperationalStatistics", + "GetLoginAcl", + "GetKeyAcl", + "ChangeKeyAcl", + "GetKeyOwner", + "ChangeKeyOwner", + "GetLoginOwner", + "ChangeLoginOwner", +}; + +extern const char *const DLNameTable[] = { + "DbOpen", + "DbClose", + "DbCreate", + "DbDelete", + "CreateRelation", + "DestroyRelation", + "Authenticate", + "GetDbAcl", + "ChangeDbAcl", + "GetDbOwner", + "ChangeDbOwner", + "GetDbNames", + "GetDbNameFromHandle", + "FreeNameList", + "DataInsert", + "DataDelete", + "DataModify", + "DataGetFirst", + "DataGetNext", + "DataAbortQuery", + "DataGetFromUniqueRecordId", + "FreeUniqueRecord", + "PassThrough", +}; + diff --git a/OSX/libsecurity_cssm/derived_src/generator.rpt b/OSX/libsecurity_cssm/derived_src/generator.rpt new file mode 100644 index 00000000..445e1d8f --- /dev/null +++ b/OSX/libsecurity_cssm/derived_src/generator.rpt @@ -0,0 +1,33 @@ +CSSM_CSP_CreateAsymmetricContext not in cssmcspi.h +CSSM_CSP_CreateDeriveKeyContext not in cssmcspi.h +CSSM_CSP_CreateDigestContext not in cssmcspi.h +CSSM_CSP_CreateKeyGenContext not in cssmcspi.h +CSSM_CSP_CreateMacContext not in cssmcspi.h +CSSM_CSP_CreatePassThroughContext not in cssmcspi.h +CSSM_CSP_CreateRandomGenContext not in cssmcspi.h +CSSM_CSP_CreateSignatureContext not in cssmcspi.h +CSSM_CSP_CreateSymmetricContext not in cssmcspi.h +CSSM_DeleteContext not in cssmcspi.h +CSSM_DeleteContextAttributes not in cssmcspi.h +CSSM_DigestDataClone has custom implementation +CSSM_FreeContext has no module type +CSSM_GenerateAlgorithmParams has custom implementation +CSSM_GetAPIMemoryFunctions has no module type +CSSM_GetContext not in cssmcspi.h +CSSM_GetContextAttribute has no module type +CSSM_GetModuleGUIDFromHandle has no module type +CSSM_GetPrivilege has no module type +CSSM_GetSubserviceUIDFromHandle has no module type +CSSM_Init has no module type +CSSM_Introduce has no module type +CSSM_ListAttachedModuleManagers has no module type +CSSM_ModuleAttach has no module type +CSSM_ModuleDetach has no module type +CSSM_ModuleLoad has no module type +CSSM_ModuleUnload has no module type +CSSM_QueryKeySizeInBits has custom implementation +CSSM_SetContext not in cssmcspi.h +CSSM_SetPrivilege has no module type +CSSM_Terminate has no module type +CSSM_Unintroduce has no module type +CSSM_UpdateContextAttributes not in cssmcspi.h diff --git a/OSX/libsecurity_cssm/derived_src/transition.gen b/OSX/libsecurity_cssm/derived_src/transition.gen new file mode 100644 index 00000000..036f6686 --- /dev/null +++ b/OSX/libsecurity_cssm/derived_src/transition.gen @@ -0,0 +1,2510 @@ +// +// This file was automatically generated. Do not edit on penalty of futility! +// +CSSM_RETURN CSSMAPI +CSSM_AC_AuthCompute (CSSM_AC_HANDLE ACHandle, + const CSSM_TUPLEGROUP *BaseAuthorizations, + const CSSM_TUPLEGROUP *Credentials, + uint32 NumberOfRequestors, + const CSSM_LIST *Requestors, + const CSSM_LIST *RequestedAuthorizationPeriod, + const CSSM_LIST *RequestedAuthorization, + CSSM_TUPLEGROUP_PTR AuthorizationResult) +{ + BEGIN_API + ACAttachment &attachment = enterAttachment(ACHandle); + TransitLock _(attachment); + return attachment.downcalls.AuthCompute(ACHandle, + BaseAuthorizations, + Credentials, + NumberOfRequestors, + Requestors, + RequestedAuthorizationPeriod, + RequestedAuthorization, + AuthorizationResult); + END_API(AC) +} + +CSSM_RETURN CSSMAPI +CSSM_AC_PassThrough (CSSM_AC_HANDLE ACHandle, + CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DL_DB_LIST *DBList, + uint32 PassThroughId, + const void *InputParams, + void **OutputParams) +{ + BEGIN_API + ACAttachment &attachment = enterAttachment(ACHandle); + TransitLock _(attachment); + return attachment.downcalls.PassThrough(ACHandle, + TPHandle, + CLHandle, + CCHandle, + DBList, + PassThroughId, + InputParams, + OutputParams); + END_API(AC) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertAbortCache (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE CertHandle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertAbortCache(CLHandle, + CertHandle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertAbortQuery (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE ResultsHandle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertAbortQuery(CLHandle, + ResultsHandle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertCache (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + CSSM_HANDLE_PTR CertHandle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertCache(CLHandle, + Cert, + CertHandle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertCreateTemplate (CSSM_CL_HANDLE CLHandle, + uint32 NumberOfFields, + const CSSM_FIELD *CertFields, + CSSM_DATA_PTR CertTemplate) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertCreateTemplate(CLHandle, + NumberOfFields, + CertFields, + CertTemplate); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertDescribeFormat (CSSM_CL_HANDLE CLHandle, + uint32 *NumberOfFields, + CSSM_OID_PTR *OidList) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertDescribeFormat(CLHandle, + NumberOfFields, + OidList); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetAllFields (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + uint32 *NumberOfFields, + CSSM_FIELD_PTR *CertFields) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetAllFields(CLHandle, + Cert, + NumberOfFields, + CertFields); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetAllTemplateFields (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *CertTemplate, + uint32 *NumberOfFields, + CSSM_FIELD_PTR *CertFields) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetAllTemplateFields(CLHandle, + CertTemplate, + NumberOfFields, + CertFields); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetFirstCachedFieldValue (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE CertHandle, + const CSSM_OID *CertField, + CSSM_HANDLE_PTR ResultsHandle, + uint32 *NumberOfMatchedFields, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetFirstCachedFieldValue(CLHandle, + CertHandle, + CertField, + ResultsHandle, + NumberOfMatchedFields, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetFirstFieldValue (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + const CSSM_OID *CertField, + CSSM_HANDLE_PTR ResultsHandle, + uint32 *NumberOfMatchedFields, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetFirstFieldValue(CLHandle, + Cert, + CertField, + ResultsHandle, + NumberOfMatchedFields, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetKeyInfo (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + CSSM_KEY_PTR *Key) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetKeyInfo(CLHandle, + Cert, + Key); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetNextCachedFieldValue (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE ResultsHandle, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetNextCachedFieldValue(CLHandle, + ResultsHandle, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGetNextFieldValue (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE ResultsHandle, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetNextFieldValue(CLHandle, + ResultsHandle, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGroupFromVerifiedBundle (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_CERT_BUNDLE *CertBundle, + const CSSM_DATA *SignerCert, + CSSM_CERTGROUP_PTR *CertGroup) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGroupFromVerifiedBundle(CLHandle, + CCHandle, + CertBundle, + SignerCert, + CertGroup); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertGroupToSignedBundle (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_CERTGROUP *CertGroupToBundle, + const CSSM_CERT_BUNDLE_HEADER *BundleInfo, + CSSM_DATA_PTR SignedBundle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGroupToSignedBundle(CLHandle, + CCHandle, + CertGroupToBundle, + BundleInfo, + SignedBundle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertSign (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CertTemplate, + const CSSM_FIELD *SignScope, + uint32 ScopeSize, + CSSM_DATA_PTR SignedCert) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertSign(CLHandle, + CCHandle, + CertTemplate, + SignScope, + ScopeSize, + SignedCert); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertVerify (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CertToBeVerified, + const CSSM_DATA *SignerCert, + const CSSM_FIELD *VerifyScope, + uint32 ScopeSize) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertVerify(CLHandle, + CCHandle, + CertToBeVerified, + SignerCert, + VerifyScope, + ScopeSize); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CertVerifyWithKey (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CertToBeVerified) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CertVerifyWithKey(CLHandle, + CCHandle, + CertToBeVerified); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlAbortCache (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE CrlHandle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlAbortCache(CLHandle, + CrlHandle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlAbortQuery (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE ResultsHandle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlAbortQuery(CLHandle, + ResultsHandle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlAddCert (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *Cert, + uint32 NumberOfFields, + const CSSM_FIELD *CrlEntryFields, + const CSSM_DATA *OldCrl, + CSSM_DATA_PTR NewCrl) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlAddCert(CLHandle, + CCHandle, + Cert, + NumberOfFields, + CrlEntryFields, + OldCrl, + NewCrl); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlCache (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Crl, + CSSM_HANDLE_PTR CrlHandle) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlCache(CLHandle, + Crl, + CrlHandle); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlCreateTemplate (CSSM_CL_HANDLE CLHandle, + uint32 NumberOfFields, + const CSSM_FIELD *CrlTemplate, + CSSM_DATA_PTR NewCrl) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlCreateTemplate(CLHandle, + NumberOfFields, + CrlTemplate, + NewCrl); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlDescribeFormat (CSSM_CL_HANDLE CLHandle, + uint32 *NumberOfFields, + CSSM_OID_PTR *OidList) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlDescribeFormat(CLHandle, + NumberOfFields, + OidList); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlGetAllCachedRecordFields (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE CrlHandle, + const CSSM_DATA *CrlRecordIndex, + uint32 *NumberOfFields, + CSSM_FIELD_PTR *CrlFields) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlGetAllCachedRecordFields(CLHandle, + CrlHandle, + CrlRecordIndex, + NumberOfFields, + CrlFields); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlGetAllFields (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Crl, + uint32 *NumberOfCrlFields, + CSSM_FIELD_PTR *CrlFields) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlGetAllFields(CLHandle, + Crl, + NumberOfCrlFields, + CrlFields); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlGetFirstCachedFieldValue (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE CrlHandle, + const CSSM_DATA *CrlRecordIndex, + const CSSM_OID *CrlField, + CSSM_HANDLE_PTR ResultsHandle, + uint32 *NumberOfMatchedFields, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlGetFirstCachedFieldValue(CLHandle, + CrlHandle, + CrlRecordIndex, + CrlField, + ResultsHandle, + NumberOfMatchedFields, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlGetFirstFieldValue (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Crl, + const CSSM_OID *CrlField, + CSSM_HANDLE_PTR ResultsHandle, + uint32 *NumberOfMatchedFields, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlGetFirstFieldValue(CLHandle, + Crl, + CrlField, + ResultsHandle, + NumberOfMatchedFields, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlGetNextCachedFieldValue (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE ResultsHandle, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlGetNextCachedFieldValue(CLHandle, + ResultsHandle, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlGetNextFieldValue (CSSM_CL_HANDLE CLHandle, + CSSM_HANDLE ResultsHandle, + CSSM_DATA_PTR *Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlGetNextFieldValue(CLHandle, + ResultsHandle, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlRemoveCert (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + const CSSM_DATA *OldCrl, + CSSM_DATA_PTR NewCrl) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlRemoveCert(CLHandle, + Cert, + OldCrl, + NewCrl); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlSetFields (CSSM_CL_HANDLE CLHandle, + uint32 NumberOfFields, + const CSSM_FIELD *CrlTemplate, + const CSSM_DATA *OldCrl, + CSSM_DATA_PTR ModifiedCrl) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlSetFields(CLHandle, + NumberOfFields, + CrlTemplate, + OldCrl, + ModifiedCrl); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlSign (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *UnsignedCrl, + const CSSM_FIELD *SignScope, + uint32 ScopeSize, + CSSM_DATA_PTR SignedCrl) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlSign(CLHandle, + CCHandle, + UnsignedCrl, + SignScope, + ScopeSize, + SignedCrl); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlVerify (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CrlToBeVerified, + const CSSM_DATA *SignerCert, + const CSSM_FIELD *VerifyScope, + uint32 ScopeSize) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlVerify(CLHandle, + CCHandle, + CrlToBeVerified, + SignerCert, + VerifyScope, + ScopeSize); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_CrlVerifyWithKey (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CrlToBeVerified) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlVerifyWithKey(CLHandle, + CCHandle, + CrlToBeVerified); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_FreeFieldValue (CSSM_CL_HANDLE CLHandle, + const CSSM_OID *CertOrCrlOid, + CSSM_DATA_PTR Value) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.FreeFieldValue(CLHandle, + CertOrCrlOid, + Value); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_FreeFields (CSSM_CL_HANDLE CLHandle, + uint32 NumberOfFields, + CSSM_FIELD_PTR *Fields) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.FreeFields(CLHandle, + NumberOfFields, + Fields); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_IsCertInCachedCrl (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + CSSM_HANDLE CrlHandle, + CSSM_BOOL *CertFound, + CSSM_DATA_PTR CrlRecordIndex) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.IsCertInCachedCrl(CLHandle, + Cert, + CrlHandle, + CertFound, + CrlRecordIndex); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_IsCertInCrl (CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *Cert, + const CSSM_DATA *Crl, + CSSM_BOOL *CertFound) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.IsCertInCrl(CLHandle, + Cert, + Crl, + CertFound); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CL_PassThrough (CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + uint32 PassThroughId, + const void *InputParams, + void **OutputParams) +{ + BEGIN_API + CLAttachment &attachment = enterAttachment(CLHandle); + TransitLock _(attachment); + return attachment.downcalls.PassThrough(CLHandle, + CCHandle, + PassThroughId, + InputParams, + OutputParams); + END_API(CL) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_ChangeLoginAcl (CSSM_CSP_HANDLE CSPHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_ACL_EDIT *AclEdit) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.ChangeLoginAcl(CSPHandle, + AccessCred, + AclEdit); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_ChangeLoginOwner (CSSM_CSP_HANDLE CSPHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_ACL_OWNER_PROTOTYPE *NewOwner) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.ChangeLoginOwner(CSPHandle, + AccessCred, + NewOwner); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_GetLoginAcl (CSSM_CSP_HANDLE CSPHandle, + const CSSM_STRING *SelectionTag, + uint32 *NumberOfAclInfos, + CSSM_ACL_ENTRY_INFO_PTR *AclInfos) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.GetLoginAcl(CSPHandle, + SelectionTag, + NumberOfAclInfos, + AclInfos); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_GetLoginOwner (CSSM_CSP_HANDLE CSPHandle, + CSSM_ACL_OWNER_PROTOTYPE_PTR Owner) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.GetLoginOwner(CSPHandle, + Owner); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_GetOperationalStatistics (CSSM_CSP_HANDLE CSPHandle, + CSSM_CSP_OPERATIONAL_STATISTICS *Statistics) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.GetOperationalStatistics(CSPHandle, + Statistics); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_Login (CSSM_CSP_HANDLE CSPHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_DATA *LoginName, + const void *Reserved) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.Login(CSPHandle, + AccessCred, + LoginName, + Reserved); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_Logout (CSSM_CSP_HANDLE CSPHandle) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.Logout(CSPHandle); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_ObtainPrivateKeyFromPublicKey (CSSM_CSP_HANDLE CSPHandle, + const CSSM_KEY *PublicKey, + CSSM_KEY_PTR PrivateKey) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.ObtainPrivateKeyFromPublicKey(CSPHandle, + PublicKey, + PrivateKey); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_CSP_PassThrough (CSSM_CC_HANDLE CCHandle, + uint32 PassThroughId, + const void *InData, + void **OutData) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.PassThrough(context.CSPHandle, CCHandle, &context, + PassThroughId, + InData, + OutData); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_ChangeKeyAcl (CSSM_CSP_HANDLE CSPHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_ACL_EDIT *AclEdit, + const CSSM_KEY *Key) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.ChangeKeyAcl(CSPHandle, + AccessCred, + AclEdit, + Key); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_ChangeKeyOwner (CSSM_CSP_HANDLE CSPHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_KEY *Key, + const CSSM_ACL_OWNER_PROTOTYPE *NewOwner) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.ChangeKeyOwner(CSPHandle, + AccessCred, + Key, + NewOwner); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_Authenticate (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_DB_ACCESS_TYPE AccessRequest, + const CSSM_ACCESS_CREDENTIALS *AccessCred) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.Authenticate(DLDBHandle, + AccessRequest, + AccessCred); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_ChangeDbAcl (CSSM_DL_DB_HANDLE DLDBHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_ACL_EDIT *AclEdit) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.ChangeDbAcl(DLDBHandle, + AccessCred, + AclEdit); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_ChangeDbOwner (CSSM_DL_DB_HANDLE DLDBHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_ACL_OWNER_PROTOTYPE *NewOwner) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.ChangeDbOwner(DLDBHandle, + AccessCred, + NewOwner); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_CreateRelation (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_DB_RECORDTYPE RelationID, + const char *RelationName, + uint32 NumberOfAttributes, + const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *pAttributeInfo, + uint32 NumberOfIndexes, + const CSSM_DB_SCHEMA_INDEX_INFO *pIndexInfo) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.CreateRelation(DLDBHandle, + RelationID, + RelationName, + NumberOfAttributes, + pAttributeInfo, + NumberOfIndexes, + pIndexInfo); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataAbortQuery (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_HANDLE ResultsHandle) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataAbortQuery(DLDBHandle, + ResultsHandle); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataDelete (CSSM_DL_DB_HANDLE DLDBHandle, + const CSSM_DB_UNIQUE_RECORD *UniqueRecordIdentifier) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataDelete(DLDBHandle, + UniqueRecordIdentifier); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataGetFirst (CSSM_DL_DB_HANDLE DLDBHandle, + const CSSM_QUERY *Query, + CSSM_HANDLE_PTR ResultsHandle, + CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes, + CSSM_DATA_PTR Data, + CSSM_DB_UNIQUE_RECORD_PTR *UniqueId) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataGetFirst(DLDBHandle, + Query, + ResultsHandle, + Attributes, + Data, + UniqueId); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataGetFromUniqueRecordId (CSSM_DL_DB_HANDLE DLDBHandle, + const CSSM_DB_UNIQUE_RECORD *UniqueRecord, + CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes, + CSSM_DATA_PTR Data) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataGetFromUniqueRecordId(DLDBHandle, + UniqueRecord, + Attributes, + Data); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataGetNext (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_HANDLE ResultsHandle, + CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes, + CSSM_DATA_PTR Data, + CSSM_DB_UNIQUE_RECORD_PTR *UniqueId) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataGetNext(DLDBHandle, + ResultsHandle, + Attributes, + Data, + UniqueId); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataInsert (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_DB_RECORDTYPE RecordType, + const CSSM_DB_RECORD_ATTRIBUTE_DATA *Attributes, + const CSSM_DATA *Data, + CSSM_DB_UNIQUE_RECORD_PTR *UniqueId) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataInsert(DLDBHandle, + RecordType, + Attributes, + Data, + UniqueId); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DataModify (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_DB_RECORDTYPE RecordType, + CSSM_DB_UNIQUE_RECORD_PTR UniqueRecordIdentifier, + const CSSM_DB_RECORD_ATTRIBUTE_DATA *AttributesToBeModified, + const CSSM_DATA *DataToBeModified, + CSSM_DB_MODIFY_MODE ModifyMode) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DataModify(DLDBHandle, + RecordType, + UniqueRecordIdentifier, + AttributesToBeModified, + DataToBeModified, + ModifyMode); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DbClose (CSSM_DL_DB_HANDLE DLDBHandle) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DbClose(DLDBHandle); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DbCreate (CSSM_DL_HANDLE DLHandle, + const char *DbName, + const CSSM_NET_ADDRESS *DbLocation, + const CSSM_DBINFO *DBInfo, + CSSM_DB_ACCESS_TYPE AccessRequest, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + const void *OpenParameters, + CSSM_DB_HANDLE *DbHandle) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DbCreate(DLHandle, + DbName, + DbLocation, + DBInfo, + AccessRequest, + CredAndAclEntry, + OpenParameters, + DbHandle); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DbDelete (CSSM_DL_HANDLE DLHandle, + const char *DbName, + const CSSM_NET_ADDRESS *DbLocation, + const CSSM_ACCESS_CREDENTIALS *AccessCred) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DbDelete(DLHandle, + DbName, + DbLocation, + AccessCred); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DbOpen (CSSM_DL_HANDLE DLHandle, + const char *DbName, + const CSSM_NET_ADDRESS *DbLocation, + CSSM_DB_ACCESS_TYPE AccessRequest, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const void *OpenParameters, + CSSM_DB_HANDLE *DbHandle) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DbOpen(DLHandle, + DbName, + DbLocation, + AccessRequest, + AccessCred, + OpenParameters, + DbHandle); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_DestroyRelation (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_DB_RECORDTYPE RelationID) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.DestroyRelation(DLDBHandle, + RelationID); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_FreeNameList (CSSM_DL_HANDLE DLHandle, + CSSM_NAME_LIST_PTR NameList) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLHandle); + TransitLock _(attachment); + return attachment.downcalls.FreeNameList(DLHandle, + NameList); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_FreeUniqueRecord (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_DB_UNIQUE_RECORD_PTR UniqueRecord) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.FreeUniqueRecord(DLDBHandle, + UniqueRecord); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_GetDbAcl (CSSM_DL_DB_HANDLE DLDBHandle, + const CSSM_STRING *SelectionTag, + uint32 *NumberOfAclInfos, + CSSM_ACL_ENTRY_INFO_PTR *AclInfos) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.GetDbAcl(DLDBHandle, + SelectionTag, + NumberOfAclInfos, + AclInfos); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_GetDbNameFromHandle (CSSM_DL_DB_HANDLE DLDBHandle, + char **DbName) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.GetDbNameFromHandle(DLDBHandle, + DbName); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_GetDbNames (CSSM_DL_HANDLE DLHandle, + CSSM_NAME_LIST_PTR *NameList) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLHandle); + TransitLock _(attachment); + return attachment.downcalls.GetDbNames(DLHandle, + NameList); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_GetDbOwner (CSSM_DL_DB_HANDLE DLDBHandle, + CSSM_ACL_OWNER_PROTOTYPE_PTR Owner) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.GetDbOwner(DLDBHandle, + Owner); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DL_PassThrough (CSSM_DL_DB_HANDLE DLDBHandle, + uint32 PassThroughId, + const void *InputParams, + void **OutputParams) +{ + BEGIN_API + DLAttachment &attachment = enterAttachment(DLDBHandle.DLHandle); + TransitLock _(attachment); + return attachment.downcalls.PassThrough(DLDBHandle, + PassThroughId, + InputParams, + OutputParams); + END_API(DL) +} + +CSSM_RETURN CSSMAPI +CSSM_DecryptData (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CipherBufs, + uint32 CipherBufCount, + CSSM_DATA_PTR ClearBufs, + uint32 ClearBufCount, + CSSM_SIZE *bytesDecrypted, + CSSM_DATA_PTR RemData) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DecryptData(context.CSPHandle, CCHandle, &context, + CipherBufs, + CipherBufCount, + ClearBufs, + ClearBufCount, + bytesDecrypted, + RemData, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DecryptDataFinal (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR RemData) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DecryptDataFinal(context.CSPHandle, CCHandle, + RemData); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DecryptDataInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DecryptDataInit(context.CSPHandle, CCHandle, &context, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DecryptDataInitP (CSSM_CC_HANDLE CCHandle, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DecryptDataInit(context.CSPHandle, CCHandle, &context, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DecryptDataP (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CipherBufs, + uint32 CipherBufCount, + CSSM_DATA_PTR ClearBufs, + uint32 ClearBufCount, + CSSM_SIZE *bytesDecrypted, + CSSM_DATA_PTR RemData, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DecryptData(context.CSPHandle, CCHandle, &context, + CipherBufs, + CipherBufCount, + ClearBufs, + ClearBufCount, + bytesDecrypted, + RemData, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DecryptDataUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CipherBufs, + uint32 CipherBufCount, + CSSM_DATA_PTR ClearBufs, + uint32 ClearBufCount, + CSSM_SIZE *bytesDecrypted) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DecryptDataUpdate(context.CSPHandle, CCHandle, + CipherBufs, + CipherBufCount, + ClearBufs, + ClearBufCount, + bytesDecrypted); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DeriveKey (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR Param, + uint32 KeyUsage, + uint32 KeyAttr, + const CSSM_DATA *KeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR DerivedKey) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DeriveKey(context.CSPHandle, CCHandle, &context, + Param, + KeyUsage, + KeyAttr, + KeyLabel, + CredAndAclEntry, + DerivedKey); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DigestData (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount, + CSSM_DATA_PTR Digest) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DigestData(context.CSPHandle, CCHandle, &context, + DataBufs, + DataBufCount, + Digest); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DigestDataFinal (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR Digest) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DigestDataFinal(context.CSPHandle, CCHandle, + Digest); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DigestDataInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DigestDataInit(context.CSPHandle, CCHandle, &context); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_DigestDataUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.DigestDataUpdate(context.CSPHandle, CCHandle, + DataBufs, + DataBufCount); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_EncryptData (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *ClearBufs, + uint32 ClearBufCount, + CSSM_DATA_PTR CipherBufs, + uint32 CipherBufCount, + CSSM_SIZE *bytesEncrypted, + CSSM_DATA_PTR RemData) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.EncryptData(context.CSPHandle, CCHandle, &context, + ClearBufs, + ClearBufCount, + CipherBufs, + CipherBufCount, + bytesEncrypted, + RemData, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_EncryptDataFinal (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR RemData) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.EncryptDataFinal(context.CSPHandle, CCHandle, + RemData); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_EncryptDataInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.EncryptDataInit(context.CSPHandle, CCHandle, &context, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_EncryptDataInitP (CSSM_CC_HANDLE CCHandle, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.EncryptDataInit(context.CSPHandle, CCHandle, &context, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_EncryptDataP (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *ClearBufs, + uint32 ClearBufCount, + CSSM_DATA_PTR CipherBufs, + uint32 CipherBufCount, + CSSM_SIZE *bytesEncrypted, + CSSM_DATA_PTR RemData, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.EncryptData(context.CSPHandle, CCHandle, &context, + ClearBufs, + ClearBufCount, + CipherBufs, + CipherBufCount, + bytesEncrypted, + RemData, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_EncryptDataUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *ClearBufs, + uint32 ClearBufCount, + CSSM_DATA_PTR CipherBufs, + uint32 CipherBufCount, + CSSM_SIZE *bytesEncrypted) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.EncryptDataUpdate(context.CSPHandle, CCHandle, + ClearBufs, + ClearBufCount, + CipherBufs, + CipherBufCount, + bytesEncrypted); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_FreeKey (CSSM_CSP_HANDLE CSPHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + CSSM_KEY_PTR KeyPtr, + CSSM_BOOL Delete) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.FreeKey(CSPHandle, + AccessCred, + KeyPtr, + Delete); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateKey (CSSM_CC_HANDLE CCHandle, + uint32 KeyUsage, + uint32 KeyAttr, + const CSSM_DATA *KeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR Key) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateKey(context.CSPHandle, CCHandle, &context, + KeyUsage, + KeyAttr, + KeyLabel, + CredAndAclEntry, + Key, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateKeyP (CSSM_CC_HANDLE CCHandle, + uint32 KeyUsage, + uint32 KeyAttr, + const CSSM_DATA *KeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR Key, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateKey(context.CSPHandle, CCHandle, &context, + KeyUsage, + KeyAttr, + KeyLabel, + CredAndAclEntry, + Key, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateKeyPair (CSSM_CC_HANDLE CCHandle, + uint32 PublicKeyUsage, + uint32 PublicKeyAttr, + const CSSM_DATA *PublicKeyLabel, + CSSM_KEY_PTR PublicKey, + uint32 PrivateKeyUsage, + uint32 PrivateKeyAttr, + const CSSM_DATA *PrivateKeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR PrivateKey) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateKeyPair(context.CSPHandle, CCHandle, &context, + PublicKeyUsage, + PublicKeyAttr, + PublicKeyLabel, + PublicKey, + PrivateKeyUsage, + PrivateKeyAttr, + PrivateKeyLabel, + CredAndAclEntry, + PrivateKey, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateKeyPairP (CSSM_CC_HANDLE CCHandle, + uint32 PublicKeyUsage, + uint32 PublicKeyAttr, + const CSSM_DATA *PublicKeyLabel, + CSSM_KEY_PTR PublicKey, + uint32 PrivateKeyUsage, + uint32 PrivateKeyAttr, + const CSSM_DATA *PrivateKeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR PrivateKey, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateKeyPair(context.CSPHandle, CCHandle, &context, + PublicKeyUsage, + PublicKeyAttr, + PublicKeyLabel, + PublicKey, + PrivateKeyUsage, + PrivateKeyAttr, + PrivateKeyLabel, + CredAndAclEntry, + PrivateKey, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateMac (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount, + CSSM_DATA_PTR Mac) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateMac(context.CSPHandle, CCHandle, &context, + DataBufs, + DataBufCount, + Mac); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateMacFinal (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR Mac) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateMacFinal(context.CSPHandle, CCHandle, + Mac); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateMacInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateMacInit(context.CSPHandle, CCHandle, &context); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateMacUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateMacUpdate(context.CSPHandle, CCHandle, + DataBufs, + DataBufCount); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GenerateRandom (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR RandomNumber) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.GenerateRandom(context.CSPHandle, CCHandle, &context, + RandomNumber); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GetKeyAcl (CSSM_CSP_HANDLE CSPHandle, + const CSSM_KEY *Key, + const CSSM_STRING *SelectionTag, + uint32 *NumberOfAclInfos, + CSSM_ACL_ENTRY_INFO_PTR *AclInfos) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.GetKeyAcl(CSPHandle, + Key, + SelectionTag, + NumberOfAclInfos, + AclInfos); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GetKeyOwner (CSSM_CSP_HANDLE CSPHandle, + const CSSM_KEY *Key, + CSSM_ACL_OWNER_PROTOTYPE_PTR Owner) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.GetKeyOwner(CSPHandle, + Key, + Owner); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_GetTimeValue (CSSM_CSP_HANDLE CSPHandle, + CSSM_ALGORITHMS TimeAlgorithm, + CSSM_DATA *TimeData) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.GetTimeValue(CSPHandle, + TimeAlgorithm, + TimeData); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_QuerySize (CSSM_CC_HANDLE CCHandle, + CSSM_BOOL Encrypt, + uint32 QuerySizeCount, + CSSM_QUERY_SIZE_DATA_PTR DataBlockSizes) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.QuerySize(context.CSPHandle, CCHandle, &context, + Encrypt, + QuerySizeCount, + DataBlockSizes); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_RetrieveCounter (CSSM_CSP_HANDLE CSPHandle, + CSSM_DATA_PTR Counter) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.RetrieveCounter(CSPHandle, + Counter); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_RetrieveUniqueId (CSSM_CSP_HANDLE CSPHandle, + CSSM_DATA_PTR UniqueID) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.RetrieveUniqueId(CSPHandle, + UniqueID); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_SignData (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount, + CSSM_ALGORITHMS DigestAlgorithm, + CSSM_DATA_PTR Signature) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.SignData(context.CSPHandle, CCHandle, &context, + DataBufs, + DataBufCount, + DigestAlgorithm, + Signature); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_SignDataFinal (CSSM_CC_HANDLE CCHandle, + CSSM_DATA_PTR Signature) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.SignDataFinal(context.CSPHandle, CCHandle, + Signature); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_SignDataInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.SignDataInit(context.CSPHandle, CCHandle, &context); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_SignDataUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.SignDataUpdate(context.CSPHandle, CCHandle, + DataBufs, + DataBufCount); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_ApplyCrlToDb (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_ENCODED_CRL *CrlToBeApplied, + const CSSM_CERTGROUP *SignerCertGroup, + const CSSM_TP_VERIFY_CONTEXT *ApplyCrlVerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR ApplyCrlVerifyResult) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.ApplyCrlToDb(TPHandle, + CLHandle, + CSPHandle, + CrlToBeApplied, + SignerCertGroup, + ApplyCrlVerifyContext, + ApplyCrlVerifyResult); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertCreateTemplate (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + uint32 NumberOfFields, + const CSSM_FIELD *CertFields, + CSSM_DATA_PTR CertTemplate) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertCreateTemplate(TPHandle, + CLHandle, + NumberOfFields, + CertFields, + CertTemplate); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertGetAllTemplateFields (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + const CSSM_DATA *CertTemplate, + uint32 *NumberOfFields, + CSSM_FIELD_PTR *CertFields) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGetAllTemplateFields(TPHandle, + CLHandle, + CertTemplate, + NumberOfFields, + CertFields); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertGroupConstruct (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_DL_DB_LIST *DBList, + const void *ConstructParams, + const CSSM_CERTGROUP *CertGroupFrag, + CSSM_CERTGROUP_PTR *CertGroup) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGroupConstruct(TPHandle, + CLHandle, + CSPHandle, + DBList, + ConstructParams, + CertGroupFrag, + CertGroup); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertGroupPrune (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + const CSSM_DL_DB_LIST *DBList, + const CSSM_CERTGROUP *OrderedCertGroup, + CSSM_CERTGROUP_PTR *PrunedCertGroup) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGroupPrune(TPHandle, + CLHandle, + DBList, + OrderedCertGroup, + PrunedCertGroup); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertGroupToTupleGroup (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + const CSSM_CERTGROUP *CertGroup, + CSSM_TUPLEGROUP_PTR *TupleGroup) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGroupToTupleGroup(TPHandle, + CLHandle, + CertGroup, + TupleGroup); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertGroupVerify (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_CERTGROUP *CertGroupToBeVerified, + const CSSM_TP_VERIFY_CONTEXT *VerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR VerifyContextResult) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertGroupVerify(TPHandle, + CLHandle, + CSPHandle, + CertGroupToBeVerified, + VerifyContext, + VerifyContextResult); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertReclaimAbort (CSSM_TP_HANDLE TPHandle, + CSSM_LONG_HANDLE KeyCacheHandle) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertReclaimAbort(TPHandle, + KeyCacheHandle); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertReclaimKey (CSSM_TP_HANDLE TPHandle, + const CSSM_CERTGROUP *CertGroup, + uint32 CertIndex, + CSSM_LONG_HANDLE KeyCacheHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertReclaimKey(TPHandle, + CertGroup, + CertIndex, + KeyCacheHandle, + CSPHandle, + CredAndAclEntry); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertRemoveFromCrlTemplate (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_DATA *OldCrlTemplate, + const CSSM_CERTGROUP *CertGroupToBeRemoved, + const CSSM_CERTGROUP *RevokerCertGroup, + const CSSM_TP_VERIFY_CONTEXT *RevokerVerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult, + CSSM_DATA_PTR NewCrlTemplate) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertRemoveFromCrlTemplate(TPHandle, + CLHandle, + CSPHandle, + OldCrlTemplate, + CertGroupToBeRemoved, + RevokerCertGroup, + RevokerVerifyContext, + RevokerVerifyResult, + NewCrlTemplate); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertRevoke (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_DATA *OldCrlTemplate, + const CSSM_CERTGROUP *CertGroupToBeRevoked, + const CSSM_CERTGROUP *RevokerCertGroup, + const CSSM_TP_VERIFY_CONTEXT *RevokerVerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult, + CSSM_TP_CERTCHANGE_REASON Reason, + CSSM_DATA_PTR NewCrlTemplate) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertRevoke(TPHandle, + CLHandle, + CSPHandle, + OldCrlTemplate, + CertGroupToBeRevoked, + RevokerCertGroup, + RevokerVerifyContext, + RevokerVerifyResult, + Reason, + NewCrlTemplate); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CertSign (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *CertTemplateToBeSigned, + const CSSM_CERTGROUP *SignerCertGroup, + const CSSM_TP_VERIFY_CONTEXT *SignerVerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR SignerVerifyResult, + CSSM_DATA_PTR SignedCert) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CertSign(TPHandle, + CLHandle, + CCHandle, + CertTemplateToBeSigned, + SignerCertGroup, + SignerVerifyContext, + SignerVerifyResult, + SignedCert); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_ConfirmCredResult (CSSM_TP_HANDLE TPHandle, + const CSSM_DATA *ReferenceIdentifier, + const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthCredentials, + const CSSM_TP_CONFIRM_RESPONSE *Responses, + const CSSM_TP_AUTHORITY_ID *PreferredAuthority) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.ConfirmCredResult(TPHandle, + ReferenceIdentifier, + CallerAuthCredentials, + Responses, + PreferredAuthority); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CrlCreateTemplate (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + uint32 NumberOfFields, + const CSSM_FIELD *CrlFields, + CSSM_DATA_PTR NewCrlTemplate) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlCreateTemplate(TPHandle, + CLHandle, + NumberOfFields, + CrlFields, + NewCrlTemplate); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CrlSign (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_ENCODED_CRL *CrlToBeSigned, + const CSSM_CERTGROUP *SignerCertGroup, + const CSSM_TP_VERIFY_CONTEXT *SignerVerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR SignerVerifyResult, + CSSM_DATA_PTR SignedCrl) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlSign(TPHandle, + CLHandle, + CCHandle, + CrlToBeSigned, + SignerCertGroup, + SignerVerifyContext, + SignerVerifyResult, + SignedCrl); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_CrlVerify (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CSP_HANDLE CSPHandle, + const CSSM_ENCODED_CRL *CrlToBeVerified, + const CSSM_CERTGROUP *SignerCertGroup, + const CSSM_TP_VERIFY_CONTEXT *VerifyContext, + CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.CrlVerify(TPHandle, + CLHandle, + CSPHandle, + CrlToBeVerified, + SignerCertGroup, + VerifyContext, + RevokerVerifyResult); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_FormRequest (CSSM_TP_HANDLE TPHandle, + const CSSM_TP_AUTHORITY_ID *PreferredAuthority, + CSSM_TP_FORM_TYPE FormType, + CSSM_DATA_PTR BlankForm) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.FormRequest(TPHandle, + PreferredAuthority, + FormType, + BlankForm); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_FormSubmit (CSSM_TP_HANDLE TPHandle, + CSSM_TP_FORM_TYPE FormType, + const CSSM_DATA *Form, + const CSSM_TP_AUTHORITY_ID *ClearanceAuthority, + const CSSM_TP_AUTHORITY_ID *RepresentedAuthority, + CSSM_ACCESS_CREDENTIALS_PTR Credentials) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.FormSubmit(TPHandle, + FormType, + Form, + ClearanceAuthority, + RepresentedAuthority, + Credentials); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_PassThrough (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + CSSM_CC_HANDLE CCHandle, + const CSSM_DL_DB_LIST *DBList, + uint32 PassThroughId, + const void *InputParams, + void **OutputParams) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.PassThrough(TPHandle, + CLHandle, + CCHandle, + DBList, + PassThroughId, + InputParams, + OutputParams); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_ReceiveConfirmation (CSSM_TP_HANDLE TPHandle, + const CSSM_DATA *ReferenceIdentifier, + CSSM_TP_CONFIRM_RESPONSE_PTR *Responses, + sint32 *ElapsedTime) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.ReceiveConfirmation(TPHandle, + ReferenceIdentifier, + Responses, + ElapsedTime); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_RetrieveCredResult (CSSM_TP_HANDLE TPHandle, + const CSSM_DATA *ReferenceIdentifier, + const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthCredentials, + sint32 *EstimatedTime, + CSSM_BOOL *ConfirmationRequired, + CSSM_TP_RESULT_SET_PTR *RetrieveOutput) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.RetrieveCredResult(TPHandle, + ReferenceIdentifier, + CallerAuthCredentials, + EstimatedTime, + ConfirmationRequired, + RetrieveOutput); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_SubmitCredRequest (CSSM_TP_HANDLE TPHandle, + const CSSM_TP_AUTHORITY_ID *PreferredAuthority, + CSSM_TP_AUTHORITY_REQUEST_TYPE RequestType, + const CSSM_TP_REQUEST_SET *RequestInput, + const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthContext, + sint32 *EstimatedTime, + CSSM_DATA_PTR ReferenceIdentifier) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.SubmitCredRequest(TPHandle, + PreferredAuthority, + RequestType, + RequestInput, + CallerAuthContext, + EstimatedTime, + ReferenceIdentifier); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_TP_TupleGroupToCertGroup (CSSM_TP_HANDLE TPHandle, + CSSM_CL_HANDLE CLHandle, + const CSSM_TUPLEGROUP *TupleGroup, + CSSM_CERTGROUP_PTR *CertTemplates) +{ + BEGIN_API + TPAttachment &attachment = enterAttachment(TPHandle); + TransitLock _(attachment); + return attachment.downcalls.TupleGroupToCertGroup(TPHandle, + CLHandle, + TupleGroup, + CertTemplates); + END_API(TP) +} + +CSSM_RETURN CSSMAPI +CSSM_UnwrapKey (CSSM_CC_HANDLE CCHandle, + const CSSM_KEY *PublicKey, + const CSSM_WRAP_KEY *WrappedKey, + uint32 KeyUsage, + uint32 KeyAttr, + const CSSM_DATA *KeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR UnwrappedKey, + CSSM_DATA_PTR DescriptiveData) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.UnwrapKey(context.CSPHandle, CCHandle, &context, + PublicKey, + WrappedKey, + KeyUsage, + KeyAttr, + KeyLabel, + CredAndAclEntry, + UnwrappedKey, + DescriptiveData, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_UnwrapKeyP (CSSM_CC_HANDLE CCHandle, + const CSSM_KEY *PublicKey, + const CSSM_WRAP_KEY *WrappedKey, + uint32 KeyUsage, + uint32 KeyAttr, + const CSSM_DATA *KeyLabel, + const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry, + CSSM_KEY_PTR UnwrappedKey, + CSSM_DATA_PTR DescriptiveData, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.UnwrapKey(context.CSPHandle, CCHandle, &context, + PublicKey, + WrappedKey, + KeyUsage, + KeyAttr, + KeyLabel, + CredAndAclEntry, + UnwrappedKey, + DescriptiveData, + Privilege); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyData (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount, + CSSM_ALGORITHMS DigestAlgorithm, + const CSSM_DATA *Signature) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyData(context.CSPHandle, CCHandle, &context, + DataBufs, + DataBufCount, + DigestAlgorithm, + Signature); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyDataFinal (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *Signature) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyDataFinal(context.CSPHandle, CCHandle, + Signature); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyDataInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyDataInit(context.CSPHandle, CCHandle, &context); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyDataUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyDataUpdate(context.CSPHandle, CCHandle, + DataBufs, + DataBufCount); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyDevice (CSSM_CSP_HANDLE CSPHandle, + const CSSM_DATA *DeviceCert) +{ + BEGIN_API + CSPAttachment &attachment = enterAttachment(CSPHandle); + TransitLock _(attachment); + return attachment.downcalls.VerifyDevice(CSPHandle, + DeviceCert); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyMac (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount, + const CSSM_DATA *Mac) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyMac(context.CSPHandle, CCHandle, &context, + DataBufs, + DataBufCount, + Mac); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyMacFinal (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *Mac) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyMacFinal(context.CSPHandle, CCHandle, + Mac); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyMacInit (CSSM_CC_HANDLE CCHandle) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyMacInit(context.CSPHandle, CCHandle, &context); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_VerifyMacUpdate (CSSM_CC_HANDLE CCHandle, + const CSSM_DATA *DataBufs, + uint32 DataBufCount) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.VerifyMacUpdate(context.CSPHandle, CCHandle, + DataBufs, + DataBufCount); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_WrapKey (CSSM_CC_HANDLE CCHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_KEY *Key, + const CSSM_DATA *DescriptiveData, + CSSM_WRAP_KEY_PTR WrappedKey) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.WrapKey(context.CSPHandle, CCHandle, &context, + AccessCred, + Key, + DescriptiveData, + WrappedKey, + attachment.module.cssm.getPrivilege()); + END_API(CSP) +} + +CSSM_RETURN CSSMAPI +CSSM_WrapKeyP (CSSM_CC_HANDLE CCHandle, + const CSSM_ACCESS_CREDENTIALS *AccessCred, + const CSSM_KEY *Key, + const CSSM_DATA *DescriptiveData, + CSSM_WRAP_KEY_PTR WrappedKey, + CSSM_PRIVILEGE Privilege) +{ + BEGIN_API + HandleContext &context = enterContext(CCHandle); + CSPAttachment &attachment = context.attachment; + TransitLock _(attachment); + return attachment.downcalls.WrapKey(context.CSPHandle, CCHandle, &context, + AccessCred, + Key, + DescriptiveData, + WrappedKey, + Privilege); + END_API(CSP) +} diff --git a/OSX/libsecurity_cssm/lib/CMakeLists.txt b/OSX/libsecurity_cssm/lib/CMakeLists.txt new file mode 100644 index 00000000..c80eecb3 --- /dev/null +++ b/OSX/libsecurity_cssm/lib/CMakeLists.txt @@ -0,0 +1,47 @@ +project(libsecurity_cssm) + +cmake_minimum_required(VERSION 2.4.0) +enable_language(C ASM) + +if(COMMAND cmake_policy) + cmake_policy(SET CMP0003 NEW) + cmake_policy(SET CMP0005 NEW) +endif(COMMAND cmake_policy) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse -msse2 -msse3 -w -nostdinc -fblocks") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__DARWIN_UNIX03 -fPIC -w") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc -nostdinc++ -fblocks -Wno-deprecated -fPIC") +set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -nostdlib -Wl,--version-script=${DARLING_TOP_DIRECTORY}/darwin.map") + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/../derived_src) +include_directories(${CMAKE_SOURCE_DIR}/src/external/corefoundation/Headers) +include_directories(${CMAKE_BINARY_DIR}/src/external/corefoundation/Headers) +include_directories(${CMAKE_SOURCE_DIR}/src/external/foundation/Headers) +include_directories(${CMAKE_SOURCE_DIR}/src/external/libcxx/include) +include_directories(${CMAKE_SOURCE_DIR}/src/external/libdispatch) +include_directories(${CMAKE_SOURCE_DIR}/src/CommonCrypto) + +add_definitions(-DOBJC2RUNTIME=1) + +set(security_cssm_sources + attachfactory.cpp + attachment.cpp + cspattachment.cpp + cssmcontext.cpp + cssm.cpp + cssmmds.cpp + guids.cpp + manager.cpp + modloader.cpp + modload_plugin.cpp + modload_static.cpp + module.cpp + oidscert.cpp + oidscrl.cpp + transition.cpp +) + +add_library(security_cssm OBJECT ${security_cssm_sources}) + diff --git a/OSX/libsecurity_keychain/lib/CMakeLists.txt b/OSX/libsecurity_keychain/lib/CMakeLists.txt index d7534aa8..4f348f8c 100644 --- a/OSX/libsecurity_keychain/lib/CMakeLists.txt +++ b/OSX/libsecurity_keychain/lib/CMakeLists.txt @@ -10,7 +10,7 @@ endif(COMMAND cmake_policy) set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse -msse2 -msse3 -w -nostdinc -fblocks") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__DARWIN_UNIX03 -fPIC -w") -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc -nostdinc++ -fblocks -Wno-deprecated") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc -nostdinc++ -fblocks -Wno-deprecated -fPIC") set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -nostdlib -Wl,--version-script=${DARLING_TOP_DIRECTORY}/darwin.map") include_directories(${CMAKE_CURRENT_SOURCE_DIR}/) @@ -95,5 +95,5 @@ set(security_keychain_sources UnlockReferralItem.cpp ) -add_library(security_keychain STATIC ${security_keychain_sources}) +add_library(security_keychain OBJECT ${security_keychain_sources}) diff --git a/OSX/libsecurity_keychain/libDER/CMakeLists.txt b/OSX/libsecurity_keychain/libDER/CMakeLists.txt index 18bdf690..8826441f 100644 --- a/OSX/libsecurity_keychain/libDER/CMakeLists.txt +++ b/OSX/libsecurity_keychain/libDER/CMakeLists.txt @@ -25,5 +25,5 @@ set(der_sources libDERUtils/printFields.c ) -add_library(der STATIC ${der_sources}) +add_library(der OBJECT ${der_sources}) diff --git a/OSX/libsecurity_transform/forceinclude.h b/OSX/libsecurity_transform/forceinclude.h new file mode 100644 index 00000000..a1b8c32e --- /dev/null +++ b/OSX/libsecurity_transform/forceinclude.h @@ -0,0 +1,5 @@ +#include +#include +#include +#include + diff --git a/OSX/libsecurity_transform/lib/CMakeLists.txt b/OSX/libsecurity_transform/lib/CMakeLists.txt new file mode 100644 index 00000000..a8eefd4f --- /dev/null +++ b/OSX/libsecurity_transform/lib/CMakeLists.txt @@ -0,0 +1,62 @@ +project(libsecurity_transform) + +cmake_minimum_required(VERSION 2.4.0) +enable_language(C ASM) + +if(COMMAND cmake_policy) + cmake_policy(SET CMP0003 NEW) + cmake_policy(SET CMP0005 NEW) +endif(COMMAND cmake_policy) + +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse -msse2 -msse3 -w -nostdinc -fblocks") +set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -D__DARWIN_UNIX03 -fPIC -w -include ${CMAKE_CURRENT_SOURCE_DIR}/../forceinclude.h") +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -nostdinc -nostdinc++ -fblocks -Wno-deprecated -fPIC -include ${CMAKE_CURRENT_SOURCE_DIR}/../forceinclude.h") +set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -nostdlib -Wl,--version-script=${DARLING_TOP_DIRECTORY}/darwin.map") + +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/) +include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..) +include_directories(${CMAKE_SOURCE_DIR}/src/external/corefoundation/Headers) +include_directories(${CMAKE_BINARY_DIR}/src/external/corefoundation/Headers) +include_directories(${CMAKE_SOURCE_DIR}/src/external/foundation/Headers) +include_directories(${CMAKE_SOURCE_DIR}/src/external/libcxx/include) +include_directories(${CMAKE_SOURCE_DIR}/src/external/libdispatch) +include_directories(${CMAKE_SOURCE_DIR}/src/external/corecrypto) +include_directories(${CMAKE_SOURCE_DIR}/src/external/zlib) +include_directories(${CMAKE_SOURCE_DIR}/src/CommonCrypto) + +add_definitions(-DOBJC2RUNTIME=1) + +set(security_transform_sources + CEncryptDecrypt.c + CoreFoundationBasics.cpp + c++utils.cpp + Digest.cpp + EncodeDecodeTransforms.c + EncryptTransform.cpp + EncryptTransformUtilities.cpp + GroupTransform.cpp + LinkedList.cpp + misc.c + Monitor.cpp + NullTransform.cpp + SecCollectTransform.cpp + SecCustomTransform.cpp + SecDigestTransform.cpp + SecEncryptTransform.cpp + SecExternalSourceTransform.cpp + SecGroupTransform.cpp + SecMaskGenerationFunctionTransform.c + SecNullTransform.cpp + SecSignVerifyTransform.c + SecTransform.cpp + SecTransformReadTransform.cpp + SingleShotSource.cpp + Source.cpp + StreamSource.cpp + Transform.cpp + TransformFactory.cpp + Utilities.cpp +) + +add_library(security_transform OBJECT ${security_transform_sources}) +