cdsa/cdsa/cssmapi.h

   1 /*
   2  * Copyright (c) 2000-2001 Apple Computer, Inc. All Rights Reserved.
   3  *
   4  * The contents of this file constitute Original Code as defined in and are
   5  * subject to the Apple Public Source License Version 1.2 (the 'License').
   6  * You may not use this file except in compliance with the License. Please obtain
   7  * a copy of the License at http://www.apple.com/publicsource and read it before
   8  * using this file.
   9  *
  10  * This Original Code and all software distributed under the License are
  11  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESS
  12  * OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, INCLUDING WITHOUT
  13  * LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
  14  * PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. Please see the License for the
  15  * specific language governing rights and limitations under the License.
  16  */
  17
  18
  19 /*
  20    File:      cssmapi.h
  21
  22    Contains:  Application Programmers Interfaces for CSSM
  23
  24    Copyright: (c) 1999-2000 Apple Computer, Inc., all rights reserved.
  25 */
  26
  27 #ifndef _CSSMAPI_H_
  28 #define _CSSMAPI_H_  1
  29
  30 #include <Security/cssmtype.h>
  31
  32 #ifdef __cplusplus
  33 extern "C" {
  34 #endif
  35
  36 /* Core Functions */
  37
  38 CSSM_RETURN CSSMAPI
  39 CSSM_Init (const CSSM_VERSION *Version,
  40            CSSM_PRIVILEGE_SCOPE Scope,
  41            const CSSM_GUID *CallerGuid,
  42            CSSM_KEY_HIERARCHY KeyHierarchy,
  43            CSSM_PVC_MODE *PvcPolicy,
  44            const void *Reserved);
  45
  46 CSSM_RETURN CSSMAPI
  47 CSSM_Terminate (void);
  48
  49 CSSM_RETURN CSSMAPI
  50 CSSM_ModuleLoad (const CSSM_GUID *ModuleGuid,
  51                  CSSM_KEY_HIERARCHY KeyHierarchy,
  52                  CSSM_API_ModuleEventHandler AppNotifyCallback,
  53                  void *AppNotifyCallbackCtx);
  54
  55 CSSM_RETURN CSSMAPI
  56 CSSM_ModuleUnload (const CSSM_GUID *ModuleGuid,
  57                    CSSM_API_ModuleEventHandler AppNotifyCallback,
  58                    void *AppNotifyCallbackCtx);
  59
  60 CSSM_RETURN CSSMAPI
  61 CSSM_Introduce (const CSSM_GUID *ModuleID,
  62                 CSSM_KEY_HIERARCHY KeyHierarchy);
  63
  64 CSSM_RETURN CSSMAPI
  65 CSSM_Unintroduce (const CSSM_GUID *ModuleID);
  66
  67 CSSM_RETURN CSSMAPI
  68 CSSM_ModuleAttach (const CSSM_GUID *ModuleGuid,
  69                    const CSSM_VERSION *Version,
  70                    const CSSM_API_MEMORY_FUNCS *MemoryFuncs,
  71                    uint32 SubserviceID,
  72                    CSSM_SERVICE_TYPE SubServiceType,
  73                    CSSM_ATTACH_FLAGS AttachFlags,
  74                    CSSM_KEY_HIERARCHY KeyHierarchy,
  75                    CSSM_FUNC_NAME_ADDR *FunctionTable,
  76                    uint32 NumFunctionTable,
  77                    const void *Reserved,
  78                    CSSM_MODULE_HANDLE_PTR NewModuleHandle);
  79
  80 CSSM_RETURN CSSMAPI
  81 CSSM_ModuleDetach (CSSM_MODULE_HANDLE ModuleHandle);
  82
  83 CSSM_RETURN CSSMAPI
  84 CSSM_SetPrivilege (CSSM_PRIVILEGE Privilege);
  85
  86 CSSM_RETURN CSSMAPI
  87 CSSM_GetPrivilege (CSSM_PRIVILEGE *Privilege);
  88
  89 CSSM_RETURN CSSMAPI
  90 CSSM_GetModuleGUIDFromHandle (CSSM_MODULE_HANDLE ModuleHandle,
  91                               CSSM_GUID_PTR ModuleGUID);
  92
  93 CSSM_RETURN CSSMAPI
  94 CSSM_GetSubserviceUIDFromHandle (CSSM_MODULE_HANDLE ModuleHandle,
  95                                  CSSM_SUBSERVICE_UID_PTR SubserviceUID);
  96
  97 CSSM_RETURN CSSMAPI
  98 CSSM_ListAttachedModuleManagers (uint32 *NumberOfModuleManagers,
  99                                  CSSM_GUID_PTR ModuleManagerGuids);
 100
 101 CSSM_RETURN CSSMAPI
 102 CSSM_GetAPIMemoryFunctions (CSSM_MODULE_HANDLE AddInHandle,
 103                             CSSM_API_MEMORY_FUNCS_PTR AppMemoryFuncs);
 104
 105
 106 /* Cryptographic Context Operations */
 107
 108 CSSM_RETURN CSSMAPI
 109 CSSM_CSP_CreateSignatureContext (CSSM_CSP_HANDLE CSPHandle,
 110                                  CSSM_ALGORITHMS AlgorithmID,
 111                                  const CSSM_ACCESS_CREDENTIALS *AccessCred,
 112                                  const CSSM_KEY *Key,
 113                                  CSSM_CC_HANDLE *NewContextHandle);
 114
 115 CSSM_RETURN CSSMAPI
 116 CSSM_CSP_CreateSymmetricContext (CSSM_CSP_HANDLE CSPHandle,
 117                                  CSSM_ALGORITHMS AlgorithmID,
 118                                  CSSM_ENCRYPT_MODE Mode,
 119                                  const CSSM_ACCESS_CREDENTIALS *AccessCred,
 120                                  const CSSM_KEY *Key,
 121                                  const CSSM_DATA *InitVector,
 122                                  CSSM_PADDING Padding,
 123                                  void *Reserved,
 124                                  CSSM_CC_HANDLE *NewContextHandle);
 125
 126 CSSM_RETURN CSSMAPI
 127 CSSM_CSP_CreateDigestContext (CSSM_CSP_HANDLE CSPHandle,
 128                               CSSM_ALGORITHMS AlgorithmID,
 129                               CSSM_CC_HANDLE *NewContextHandle);
 130
 131 CSSM_RETURN CSSMAPI
 132 CSSM_CSP_CreateMacContext (CSSM_CSP_HANDLE CSPHandle,
 133                            CSSM_ALGORITHMS AlgorithmID,
 134                            const CSSM_KEY *Key,
 135                            CSSM_CC_HANDLE *NewContextHandle);
 136
 137 CSSM_RETURN CSSMAPI
 138 CSSM_CSP_CreateRandomGenContext (CSSM_CSP_HANDLE CSPHandle,
 139                                  CSSM_ALGORITHMS AlgorithmID,
 140                                  const CSSM_CRYPTO_DATA *Seed,
 141                                  uint32 Length,
 142                                  CSSM_CC_HANDLE *NewContextHandle);
 143
 144 CSSM_RETURN CSSMAPI
 145 CSSM_CSP_CreateAsymmetricContext (CSSM_CSP_HANDLE CSPHandle,
 146                                   CSSM_ALGORITHMS AlgorithmID,
 147                                   const CSSM_ACCESS_CREDENTIALS *AccessCred,
 148                                   const CSSM_KEY *Key,
 149                                   CSSM_PADDING Padding,
 150                                   CSSM_CC_HANDLE *NewContextHandle);
 151
 152 CSSM_RETURN CSSMAPI
 153 CSSM_CSP_CreateDeriveKeyContext (CSSM_CSP_HANDLE CSPHandle,
 154                                  CSSM_ALGORITHMS AlgorithmID,
 155                                  CSSM_KEY_TYPE DeriveKeyType,
 156                                  uint32 DeriveKeyLengthInBits,
 157                                  const CSSM_ACCESS_CREDENTIALS *AccessCred,
 158                                  const CSSM_KEY *BaseKey,
 159                                  uint32 IterationCount,
 160                                  const CSSM_DATA *Salt,
 161                                  const CSSM_CRYPTO_DATA *Seed,
 162                                  CSSM_CC_HANDLE *NewContextHandle);
 163
 164 CSSM_RETURN CSSMAPI
 165 CSSM_CSP_CreateKeyGenContext (CSSM_CSP_HANDLE CSPHandle,
 166                               CSSM_ALGORITHMS AlgorithmID,
 167                               uint32 KeySizeInBits,
 168                               const CSSM_CRYPTO_DATA *Seed,
 169                               const CSSM_DATA *Salt,
 170                               const CSSM_DATE *StartDate,
 171                               const CSSM_DATE *EndDate,
 172                               const CSSM_DATA *Params,
 173                               CSSM_CC_HANDLE *NewContextHandle);
 174
 175 CSSM_RETURN CSSMAPI
 176 CSSM_CSP_CreatePassThroughContext (CSSM_CSP_HANDLE CSPHandle,
 177                                    const CSSM_KEY *Key,
 178                                    CSSM_CC_HANDLE *NewContextHandle);
 179
 180 CSSM_RETURN CSSMAPI
 181 CSSM_GetContext (CSSM_CC_HANDLE CCHandle,
 182                  CSSM_CONTEXT_PTR *Context);
 183
 184 CSSM_RETURN CSSMAPI
 185 CSSM_FreeContext (CSSM_CONTEXT_PTR Context);
 186
 187 CSSM_RETURN CSSMAPI
 188 CSSM_SetContext (CSSM_CC_HANDLE CCHandle,
 189                  const CSSM_CONTEXT *Context);
 190
 191 CSSM_RETURN CSSMAPI
 192 CSSM_DeleteContext (CSSM_CC_HANDLE CCHandle);
 193
 194 CSSM_RETURN CSSMAPI
 195 CSSM_GetContextAttribute (const CSSM_CONTEXT *Context,
 196                           uint32 AttributeType,
 197                           CSSM_CONTEXT_ATTRIBUTE_PTR *ContextAttribute);
 198
 199 CSSM_RETURN CSSMAPI
 200 CSSM_UpdateContextAttributes (CSSM_CC_HANDLE CCHandle,
 201                               uint32 NumberOfAttributes,
 202                               const CSSM_CONTEXT_ATTRIBUTE *ContextAttributes);
 203
 204 CSSM_RETURN CSSMAPI
 205 CSSM_DeleteContextAttributes (CSSM_CC_HANDLE CCHandle,
 206                               uint32 NumberOfAttributes,
 207                               const CSSM_CONTEXT_ATTRIBUTE *ContextAttributes);
 208
 209
 210 /* Cryptographic Sessions and Controlled Access to Keys */
 211
 212 CSSM_RETURN CSSMAPI
 213 CSSM_CSP_Login (CSSM_CSP_HANDLE CSPHandle,
 214                 const CSSM_ACCESS_CREDENTIALS *AccessCred,
 215                 const CSSM_DATA *LoginName,
 216                 const void *Reserved);
 217
 218 CSSM_RETURN CSSMAPI
 219 CSSM_CSP_Logout (CSSM_CSP_HANDLE CSPHandle);
 220
 221 CSSM_RETURN CSSMAPI
 222 CSSM_CSP_GetLoginAcl (CSSM_CSP_HANDLE CSPHandle,
 223                       const CSSM_STRING *SelectionTag,
 224                       uint32 *NumberOfAclInfos,
 225                       CSSM_ACL_ENTRY_INFO_PTR *AclInfos);
 226
 227 CSSM_RETURN CSSMAPI
 228 CSSM_CSP_ChangeLoginAcl (CSSM_CSP_HANDLE CSPHandle,
 229                          const CSSM_ACCESS_CREDENTIALS *AccessCred,
 230                          const CSSM_ACL_EDIT *AclEdit);
 231
 232 CSSM_RETURN CSSMAPI
 233 CSSM_GetKeyAcl (CSSM_CSP_HANDLE CSPHandle,
 234                 const CSSM_KEY *Key,
 235                 const CSSM_STRING *SelectionTag,
 236                 uint32 *NumberOfAclInfos,
 237                 CSSM_ACL_ENTRY_INFO_PTR *AclInfos);
 238
 239 CSSM_RETURN CSSMAPI
 240 CSSM_ChangeKeyAcl (CSSM_CSP_HANDLE CSPHandle,
 241                    const CSSM_ACCESS_CREDENTIALS *AccessCred,
 242                    const CSSM_ACL_EDIT *AclEdit,
 243                    const CSSM_KEY *Key);
 244
 245 CSSM_RETURN CSSMAPI
 246 CSSM_GetKeyOwner (CSSM_CSP_HANDLE CSPHandle,
 247                   const CSSM_KEY *Key,
 248                   CSSM_ACL_OWNER_PROTOTYPE_PTR Owner);
 249
 250 CSSM_RETURN CSSMAPI
 251 CSSM_ChangeKeyOwner (CSSM_CSP_HANDLE CSPHandle,
 252                      const CSSM_ACCESS_CREDENTIALS *AccessCred,
 253                      const CSSM_KEY *Key,
 254                      const CSSM_ACL_OWNER_PROTOTYPE *NewOwner);
 255
 256 CSSM_RETURN CSSMAPI
 257 CSSM_CSP_GetLoginOwner (CSSM_CSP_HANDLE CSPHandle,
 258                         CSSM_ACL_OWNER_PROTOTYPE_PTR Owner);
 259
 260 CSSM_RETURN CSSMAPI
 261 CSSM_CSP_ChangeLoginOwner (CSSM_CSP_HANDLE CSPHandle,
 262                            const CSSM_ACCESS_CREDENTIALS *AccessCred,
 263                            const CSSM_ACL_OWNER_PROTOTYPE *NewOwner);
 264
 265 CSSM_RETURN CSSMAPI
 266 CSSM_SignData (CSSM_CC_HANDLE CCHandle,
 267                const CSSM_DATA *DataBufs,
 268                uint32 DataBufCount,
 269                CSSM_ALGORITHMS DigestAlgorithm,
 270                CSSM_DATA_PTR Signature);
 271
 272 CSSM_RETURN CSSMAPI
 273 CSSM_SignDataInit (CSSM_CC_HANDLE CCHandle);
 274
 275 CSSM_RETURN CSSMAPI
 276 CSSM_SignDataUpdate (CSSM_CC_HANDLE CCHandle,
 277                      const CSSM_DATA *DataBufs,
 278                      uint32 DataBufCount);
 279
 280 CSSM_RETURN CSSMAPI
 281 CSSM_SignDataFinal (CSSM_CC_HANDLE CCHandle,
 282                     CSSM_DATA_PTR Signature);
 283
 284 CSSM_RETURN CSSMAPI
 285 CSSM_VerifyData (CSSM_CC_HANDLE CCHandle,
 286                  const CSSM_DATA *DataBufs,
 287                  uint32 DataBufCount,
 288                  CSSM_ALGORITHMS DigestAlgorithm,
 289                  const CSSM_DATA *Signature);
 290
 291 CSSM_RETURN CSSMAPI
 292 CSSM_VerifyDataInit (CSSM_CC_HANDLE CCHandle);
 293
 294 CSSM_RETURN CSSMAPI
 295 CSSM_VerifyDataUpdate (CSSM_CC_HANDLE CCHandle,
 296                        const CSSM_DATA *DataBufs,
 297                        uint32 DataBufCount);
 298
 299 CSSM_RETURN CSSMAPI
 300 CSSM_VerifyDataFinal (CSSM_CC_HANDLE CCHandle,
 301                       const CSSM_DATA *Signature);
 302
 303 CSSM_RETURN CSSMAPI
 304 CSSM_DigestData (CSSM_CC_HANDLE CCHandle,
 305                  const CSSM_DATA *DataBufs,
 306                  uint32 DataBufCount,
 307                  CSSM_DATA_PTR Digest);
 308
 309 CSSM_RETURN CSSMAPI
 310 CSSM_DigestDataInit (CSSM_CC_HANDLE CCHandle);
 311
 312 CSSM_RETURN CSSMAPI
 313 CSSM_DigestDataUpdate (CSSM_CC_HANDLE CCHandle,
 314                        const CSSM_DATA *DataBufs,
 315                        uint32 DataBufCount);
 316
 317 CSSM_RETURN CSSMAPI
 318 CSSM_DigestDataClone (CSSM_CC_HANDLE CCHandle,
 319                       CSSM_CC_HANDLE *ClonednewCCHandle);
 320
 321 CSSM_RETURN CSSMAPI
 322 CSSM_DigestDataFinal (CSSM_CC_HANDLE CCHandle,
 323                       CSSM_DATA_PTR Digest);
 324
 325 CSSM_RETURN CSSMAPI
 326 CSSM_GenerateMac (CSSM_CC_HANDLE CCHandle,
 327                   const CSSM_DATA *DataBufs,
 328                   uint32 DataBufCount,
 329                   CSSM_DATA_PTR Mac);
 330
 331 CSSM_RETURN CSSMAPI
 332 CSSM_GenerateMacInit (CSSM_CC_HANDLE CCHandle);
 333
 334 CSSM_RETURN CSSMAPI
 335 CSSM_GenerateMacUpdate (CSSM_CC_HANDLE CCHandle,
 336                         const CSSM_DATA *DataBufs,
 337                         uint32 DataBufCount);
 338
 339 CSSM_RETURN CSSMAPI
 340 CSSM_GenerateMacFinal (CSSM_CC_HANDLE CCHandle,
 341                        CSSM_DATA_PTR Mac);
 342
 343 CSSM_RETURN CSSMAPI
 344 CSSM_VerifyMac (CSSM_CC_HANDLE CCHandle,
 345                 const CSSM_DATA *DataBufs,
 346                 uint32 DataBufCount,
 347                 const CSSM_DATA *Mac);
 348
 349 CSSM_RETURN CSSMAPI
 350 CSSM_VerifyMacInit (CSSM_CC_HANDLE CCHandle);
 351
 352 CSSM_RETURN CSSMAPI
 353 CSSM_VerifyMacUpdate (CSSM_CC_HANDLE CCHandle,
 354                       const CSSM_DATA *DataBufs,
 355                       uint32 DataBufCount);
 356
 357 CSSM_RETURN CSSMAPI
 358 CSSM_VerifyMacFinal (CSSM_CC_HANDLE CCHandle,
 359                      const CSSM_DATA *Mac);
 360
 361 CSSM_RETURN CSSMAPI
 362 CSSM_QuerySize (CSSM_CC_HANDLE CCHandle,
 363                 CSSM_BOOL Encrypt,
 364                 uint32 QuerySizeCount,
 365                 CSSM_QUERY_SIZE_DATA_PTR DataBlockSizes);
 366
 367 CSSM_RETURN CSSMAPI
 368 CSSM_EncryptData (CSSM_CC_HANDLE CCHandle,
 369                   const CSSM_DATA *ClearBufs,
 370                   uint32 ClearBufCount,
 371                   CSSM_DATA_PTR CipherBufs,
 372                   uint32 CipherBufCount,
 373                   uint32 *bytesEncrypted,
 374                   CSSM_DATA_PTR RemData);
 375
 376 CSSM_RETURN CSSMAPI
 377 CSSM_EncryptDataP (CSSM_CC_HANDLE CCHandle,
 378                    const CSSM_DATA *ClearBufs,
 379                    uint32 ClearBufCount,
 380                    CSSM_DATA_PTR CipherBufs,
 381                    uint32 CipherBufCount,
 382                    uint32 *bytesEncrypted,
 383                    CSSM_DATA_PTR RemData,
 384                    CSSM_PRIVILEGE Privilege);
 385
 386 CSSM_RETURN CSSMAPI
 387 CSSM_EncryptDataInit (CSSM_CC_HANDLE CCHandle);
 388
 389 CSSM_RETURN CSSMAPI
 390 CSSM_EncryptDataInitP (CSSM_CC_HANDLE CCHandle,
 391                        CSSM_PRIVILEGE Privilege);
 392
 393 CSSM_RETURN CSSMAPI
 394 CSSM_EncryptDataUpdate (CSSM_CC_HANDLE CCHandle,
 395                         const CSSM_DATA *ClearBufs,
 396                         uint32 ClearBufCount,
 397                         CSSM_DATA_PTR CipherBufs,
 398                         uint32 CipherBufCount,
 399                         uint32 *bytesEncrypted);
 400
 401 CSSM_RETURN CSSMAPI
 402 CSSM_EncryptDataFinal (CSSM_CC_HANDLE CCHandle,
 403                        CSSM_DATA_PTR RemData);
 404
 405 CSSM_RETURN CSSMAPI
 406 CSSM_DecryptData (CSSM_CC_HANDLE CCHandle,
 407                   const CSSM_DATA *CipherBufs,
 408                   uint32 CipherBufCount,
 409                   CSSM_DATA_PTR ClearBufs,
 410                   uint32 ClearBufCount,
 411                   uint32 *bytesDecrypted,
 412                   CSSM_DATA_PTR RemData);
 413
 414 CSSM_RETURN CSSMAPI
 415 CSSM_DecryptDataP (CSSM_CC_HANDLE CCHandle,
 416                    const CSSM_DATA *CipherBufs,
 417                    uint32 CipherBufCount,
 418                    CSSM_DATA_PTR ClearBufs,
 419                    uint32 ClearBufCount,
 420                    uint32 *bytesDecrypted,
 421                    CSSM_DATA_PTR RemData,
 422                    CSSM_PRIVILEGE Privilege);
 423
 424 CSSM_RETURN CSSMAPI
 425 CSSM_DecryptDataInit (CSSM_CC_HANDLE CCHandle);
 426
 427 CSSM_RETURN CSSMAPI
 428 CSSM_DecryptDataInitP (CSSM_CC_HANDLE CCHandle,
 429                        CSSM_PRIVILEGE Privilege);
 430
 431 CSSM_RETURN CSSMAPI
 432 CSSM_DecryptDataUpdate (CSSM_CC_HANDLE CCHandle,
 433                         const CSSM_DATA *CipherBufs,
 434                         uint32 CipherBufCount,
 435                         CSSM_DATA_PTR ClearBufs,
 436                         uint32 ClearBufCount,
 437                         uint32 *bytesDecrypted);
 438
 439 CSSM_RETURN CSSMAPI
 440 CSSM_DecryptDataFinal (CSSM_CC_HANDLE CCHandle,
 441                        CSSM_DATA_PTR RemData);
 442
 443 CSSM_RETURN CSSMAPI
 444 CSSM_QueryKeySizeInBits (CSSM_CSP_HANDLE CSPHandle,
 445                          CSSM_CC_HANDLE CCHandle,
 446                          const CSSM_KEY *Key,
 447                          CSSM_KEY_SIZE_PTR KeySize);
 448
 449 CSSM_RETURN CSSMAPI
 450 CSSM_GenerateKey (CSSM_CC_HANDLE CCHandle,
 451                   uint32 KeyUsage,
 452                   uint32 KeyAttr,
 453                   const CSSM_DATA *KeyLabel,
 454                   const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 455                   CSSM_KEY_PTR Key);
 456
 457 CSSM_RETURN CSSMAPI
 458 CSSM_GenerateKeyP (CSSM_CC_HANDLE CCHandle,
 459                    uint32 KeyUsage,
 460                    uint32 KeyAttr,
 461                    const CSSM_DATA *KeyLabel,
 462                    const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 463                    CSSM_KEY_PTR Key,
 464                    CSSM_PRIVILEGE Privilege);
 465
 466 CSSM_RETURN CSSMAPI
 467 CSSM_GenerateKeyPair (CSSM_CC_HANDLE CCHandle,
 468                       uint32 PublicKeyUsage,
 469                       uint32 PublicKeyAttr,
 470                       const CSSM_DATA *PublicKeyLabel,
 471                       CSSM_KEY_PTR PublicKey,
 472                       uint32 PrivateKeyUsage,
 473                       uint32 PrivateKeyAttr,
 474                       const CSSM_DATA *PrivateKeyLabel,
 475                       const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 476                       CSSM_KEY_PTR PrivateKey);
 477
 478 CSSM_RETURN CSSMAPI
 479 CSSM_GenerateKeyPairP (CSSM_CC_HANDLE CCHandle,
 480                        uint32 PublicKeyUsage,
 481                        uint32 PublicKeyAttr,
 482                        const CSSM_DATA *PublicKeyLabel,
 483                        CSSM_KEY_PTR PublicKey,
 484                        uint32 PrivateKeyUsage,
 485                        uint32 PrivateKeyAttr,
 486                        const CSSM_DATA *PrivateKeyLabel,
 487                        const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 488                        CSSM_KEY_PTR PrivateKey,
 489                        CSSM_PRIVILEGE Privilege);
 490
 491 CSSM_RETURN CSSMAPI
 492 CSSM_GenerateRandom (CSSM_CC_HANDLE CCHandle,
 493                      CSSM_DATA_PTR RandomNumber);
 494
 495 CSSM_RETURN CSSMAPI
 496 CSSM_CSP_ObtainPrivateKeyFromPublicKey (CSSM_CSP_HANDLE CSPHandle,
 497                                         const CSSM_KEY *PublicKey,
 498                                         CSSM_KEY_PTR PrivateKey);
 499
 500 CSSM_RETURN CSSMAPI
 501 CSSM_WrapKey (CSSM_CC_HANDLE CCHandle,
 502               const CSSM_ACCESS_CREDENTIALS *AccessCred,
 503               const CSSM_KEY *Key,
 504               const CSSM_DATA *DescriptiveData,
 505               CSSM_WRAP_KEY_PTR WrappedKey);
 506
 507 CSSM_RETURN CSSMAPI
 508 CSSM_UnwrapKey (CSSM_CC_HANDLE CCHandle,
 509                 const CSSM_KEY *PublicKey,
 510                 const CSSM_WRAP_KEY *WrappedKey,
 511                 uint32 KeyUsage,
 512                 uint32 KeyAttr,
 513                 const CSSM_DATA *KeyLabel,
 514                 const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 515                 CSSM_KEY_PTR UnwrappedKey,
 516                 CSSM_DATA_PTR DescriptiveData);
 517
 518 CSSM_RETURN CSSMAPI
 519 CSSM_WrapKeyP (CSSM_CC_HANDLE CCHandle,
 520                const CSSM_ACCESS_CREDENTIALS *AccessCred,
 521                const CSSM_KEY *Key,
 522                const CSSM_DATA *DescriptiveData,
 523                CSSM_WRAP_KEY_PTR WrappedKey,
 524                CSSM_PRIVILEGE Privilege);
 525
 526 CSSM_RETURN CSSMAPI
 527 CSSM_UnwrapKeyP (CSSM_CC_HANDLE CCHandle,
 528                  const CSSM_KEY *PublicKey,
 529                  const CSSM_WRAP_KEY *WrappedKey,
 530                  uint32 KeyUsage,
 531                  uint32 KeyAttr,
 532                  const CSSM_DATA *KeyLabel,
 533                  const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 534                  CSSM_KEY_PTR UnwrappedKey,
 535                  CSSM_DATA_PTR DescriptiveData,
 536                  CSSM_PRIVILEGE Privilege);
 537
 538 CSSM_RETURN CSSMAPI
 539 CSSM_DeriveKey (CSSM_CC_HANDLE CCHandle,
 540                 CSSM_DATA_PTR Param,
 541                 uint32 KeyUsage,
 542                 uint32 KeyAttr,
 543                 const CSSM_DATA *KeyLabel,
 544                 const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
 545                 CSSM_KEY_PTR DerivedKey);
 546
 547 CSSM_RETURN CSSMAPI
 548 CSSM_FreeKey (CSSM_CSP_HANDLE CSPHandle,
 549               const CSSM_ACCESS_CREDENTIALS *AccessCred,
 550               CSSM_KEY_PTR KeyPtr,
 551               CSSM_BOOL Delete);
 552
 553 CSSM_RETURN CSSMAPI
 554 CSSM_GenerateAlgorithmParams (CSSM_CC_HANDLE CCHandle,
 555                               uint32 ParamBits,
 556                               CSSM_DATA_PTR Param);
 557
 558
 559 /* Miscellaneous Functions for Cryptographic Services */
 560
 561 CSSM_RETURN CSSMAPI
 562 CSSM_CSP_GetOperationalStatistics (CSSM_CSP_HANDLE CSPHandle,
 563                                    CSSM_CSP_OPERATIONAL_STATISTICS *Statistics);
 564
 565 CSSM_RETURN CSSMAPI
 566 CSSM_GetTimeValue (CSSM_CSP_HANDLE CSPHandle,
 567                    CSSM_ALGORITHMS TimeAlgorithm,
 568                    CSSM_DATA *TimeData);
 569
 570 CSSM_RETURN CSSMAPI
 571 CSSM_RetrieveUniqueId (CSSM_CSP_HANDLE CSPHandle,
 572                        CSSM_DATA_PTR UniqueID);
 573
 574 CSSM_RETURN CSSMAPI
 575 CSSM_RetrieveCounter (CSSM_CSP_HANDLE CSPHandle,
 576                       CSSM_DATA_PTR Counter);
 577
 578 CSSM_RETURN CSSMAPI
 579 CSSM_VerifyDevice (CSSM_CSP_HANDLE CSPHandle,
 580                    const CSSM_DATA *DeviceCert);
 581
 582
 583 /* Extensibility Functions for Cryptographic Services */
 584
 585 CSSM_RETURN CSSMAPI
 586 CSSM_CSP_PassThrough (CSSM_CC_HANDLE CCHandle,
 587                       uint32 PassThroughId,
 588                       const void *InData,
 589                       void **OutData);
 590
 591
 592 /* Trust Policy Operations */
 593
 594 CSSM_RETURN CSSMAPI
 595 CSSM_TP_SubmitCredRequest (CSSM_TP_HANDLE TPHandle,
 596                            const CSSM_TP_AUTHORITY_ID *PreferredAuthority,
 597                            CSSM_TP_AUTHORITY_REQUEST_TYPE RequestType,
 598                            const CSSM_TP_REQUEST_SET *RequestInput,
 599                            const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthContext,
 600                            sint32 *EstimatedTime,
 601                            CSSM_DATA_PTR ReferenceIdentifier);
 602
 603 CSSM_RETURN CSSMAPI
 604 CSSM_TP_RetrieveCredResult (CSSM_TP_HANDLE TPHandle,
 605                             const CSSM_DATA *ReferenceIdentifier,
 606                             const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthCredentials,
 607                             sint32 *EstimatedTime,
 608                             CSSM_BOOL *ConfirmationRequired,
 609                             CSSM_TP_RESULT_SET_PTR *RetrieveOutput);
 610
 611 CSSM_RETURN CSSMAPI
 612 CSSM_TP_ConfirmCredResult (CSSM_TP_HANDLE TPHandle,
 613                            const CSSM_DATA *ReferenceIdentifier,
 614                            const CSSM_TP_CALLERAUTH_CONTEXT *CallerAuthCredentials,
 615                            const CSSM_TP_CONFIRM_RESPONSE *Responses,
 616                            const CSSM_TP_AUTHORITY_ID *PreferredAuthority);
 617
 618 CSSM_RETURN CSSMAPI
 619 CSSM_TP_ReceiveConfirmation (CSSM_TP_HANDLE TPHandle,
 620                              const CSSM_DATA *ReferenceIdentifier,
 621                              CSSM_TP_CONFIRM_RESPONSE_PTR *Responses,
 622                              sint32 *ElapsedTime);
 623
 624 CSSM_RETURN CSSMAPI
 625 CSSM_TP_CertReclaimKey (CSSM_TP_HANDLE TPHandle,
 626                         const CSSM_CERTGROUP *CertGroup,
 627                         uint32 CertIndex,
 628                         CSSM_LONG_HANDLE KeyCacheHandle,
 629                         CSSM_CSP_HANDLE CSPHandle,
 630                         const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry);
 631
 632 CSSM_RETURN CSSMAPI
 633 CSSM_TP_CertReclaimAbort (CSSM_TP_HANDLE TPHandle,
 634                           CSSM_LONG_HANDLE KeyCacheHandle);
 635
 636 CSSM_RETURN CSSMAPI
 637 CSSM_TP_FormRequest (CSSM_TP_HANDLE TPHandle,
 638                      const CSSM_TP_AUTHORITY_ID *PreferredAuthority,
 639                      CSSM_TP_FORM_TYPE FormType,
 640                      CSSM_DATA_PTR BlankForm);
 641
 642 CSSM_RETURN CSSMAPI
 643 CSSM_TP_FormSubmit (CSSM_TP_HANDLE TPHandle,
 644                     CSSM_TP_FORM_TYPE FormType,
 645                     const CSSM_DATA *Form,
 646                     const CSSM_TP_AUTHORITY_ID *ClearanceAuthority,
 647                     const CSSM_TP_AUTHORITY_ID *RepresentedAuthority,
 648                     CSSM_ACCESS_CREDENTIALS_PTR Credentials);
 649
 650 CSSM_RETURN CSSMAPI
 651 CSSM_TP_CertGroupVerify (CSSM_TP_HANDLE TPHandle,
 652                          CSSM_CL_HANDLE CLHandle,
 653                          CSSM_CSP_HANDLE CSPHandle,
 654                          const CSSM_CERTGROUP *CertGroupToBeVerified,
 655                          const CSSM_TP_VERIFY_CONTEXT *VerifyContext,
 656                          CSSM_TP_VERIFY_CONTEXT_RESULT_PTR VerifyContextResult);
 657
 658 CSSM_RETURN CSSMAPI
 659 CSSM_TP_CertCreateTemplate (CSSM_TP_HANDLE TPHandle,
 660                             CSSM_CL_HANDLE CLHandle,
 661                             uint32 NumberOfFields,
 662                             const CSSM_FIELD *CertFields,
 663                             CSSM_DATA_PTR CertTemplate);
 664
 665 CSSM_RETURN CSSMAPI
 666 CSSM_TP_CertGetAllTemplateFields (CSSM_TP_HANDLE TPHandle,
 667                                   CSSM_CL_HANDLE CLHandle,
 668                                   const CSSM_DATA *CertTemplate,
 669                                   uint32 *NumberOfFields,
 670                                   CSSM_FIELD_PTR *CertFields);
 671
 672 CSSM_RETURN CSSMAPI
 673 CSSM_TP_CertSign (CSSM_TP_HANDLE TPHandle,
 674                   CSSM_CL_HANDLE CLHandle,
 675                   CSSM_CC_HANDLE CCHandle,
 676                   const CSSM_DATA *CertTemplateToBeSigned,
 677                   const CSSM_CERTGROUP *SignerCertGroup,
 678                   const CSSM_TP_VERIFY_CONTEXT *SignerVerifyContext,
 679                   CSSM_TP_VERIFY_CONTEXT_RESULT_PTR SignerVerifyResult,
 680                   CSSM_DATA_PTR SignedCert);
 681
 682 CSSM_RETURN CSSMAPI
 683 CSSM_TP_CrlVerify (CSSM_TP_HANDLE TPHandle,
 684                    CSSM_CL_HANDLE CLHandle,
 685                    CSSM_CSP_HANDLE CSPHandle,
 686                    const CSSM_ENCODED_CRL *CrlToBeVerified,
 687                    const CSSM_CERTGROUP *SignerCertGroup,
 688                    const CSSM_TP_VERIFY_CONTEXT *VerifyContext,
 689                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult);
 690
 691 CSSM_RETURN CSSMAPI
 692 CSSM_TP_CrlCreateTemplate (CSSM_TP_HANDLE TPHandle,
 693                            CSSM_CL_HANDLE CLHandle,
 694                            uint32 NumberOfFields,
 695                            const CSSM_FIELD *CrlFields,
 696                            CSSM_DATA_PTR NewCrlTemplate);
 697
 698 CSSM_RETURN CSSMAPI
 699 CSSM_TP_CertRevoke (CSSM_TP_HANDLE TPHandle,
 700                     CSSM_CL_HANDLE CLHandle,
 701                     CSSM_CSP_HANDLE CSPHandle,
 702                     const CSSM_DATA *OldCrlTemplate,
 703                     const CSSM_CERTGROUP *CertGroupToBeRevoked,
 704                     const CSSM_CERTGROUP *RevokerCertGroup,
 705                     const CSSM_TP_VERIFY_CONTEXT *RevokerVerifyContext,
 706                     CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult,
 707                     CSSM_TP_CERTCHANGE_REASON Reason,
 708                     CSSM_DATA_PTR NewCrlTemplate);
 709
 710 CSSM_RETURN CSSMAPI
 711 CSSM_TP_CertRemoveFromCrlTemplate (CSSM_TP_HANDLE TPHandle,
 712                                    CSSM_CL_HANDLE CLHandle,
 713                                    CSSM_CSP_HANDLE CSPHandle,
 714                                    const CSSM_DATA *OldCrlTemplate,
 715                                    const CSSM_CERTGROUP *CertGroupToBeRemoved,
 716                                    const CSSM_CERTGROUP *RevokerCertGroup,
 717                                    const CSSM_TP_VERIFY_CONTEXT *RevokerVerifyContext,
 718                                    CSSM_TP_VERIFY_CONTEXT_RESULT_PTR RevokerVerifyResult,
 719                                    CSSM_DATA_PTR NewCrlTemplate);
 720
 721 CSSM_RETURN CSSMAPI
 722 CSSM_TP_CrlSign (CSSM_TP_HANDLE TPHandle,
 723                  CSSM_CL_HANDLE CLHandle,
 724                  CSSM_CC_HANDLE CCHandle,
 725                  const CSSM_ENCODED_CRL *CrlToBeSigned,
 726                  const CSSM_CERTGROUP *SignerCertGroup,
 727                  const CSSM_TP_VERIFY_CONTEXT *SignerVerifyContext,
 728                  CSSM_TP_VERIFY_CONTEXT_RESULT_PTR SignerVerifyResult,
 729                  CSSM_DATA_PTR SignedCrl);
 730
 731 CSSM_RETURN CSSMAPI
 732 CSSM_TP_ApplyCrlToDb (CSSM_TP_HANDLE TPHandle,
 733                       CSSM_CL_HANDLE CLHandle,
 734                       CSSM_CSP_HANDLE CSPHandle,
 735                       const CSSM_ENCODED_CRL *CrlToBeApplied,
 736                       const CSSM_CERTGROUP *SignerCertGroup,
 737                       const CSSM_TP_VERIFY_CONTEXT *ApplyCrlVerifyContext,
 738                       CSSM_TP_VERIFY_CONTEXT_RESULT_PTR ApplyCrlVerifyResult);
 739
 740 CSSM_RETURN CSSMAPI
 741 CSSM_TP_CertGroupConstruct (CSSM_TP_HANDLE TPHandle,
 742                             CSSM_CL_HANDLE CLHandle,
 743                             CSSM_CSP_HANDLE CSPHandle,
 744                             const CSSM_DL_DB_LIST *DBList,
 745                             const void *ConstructParams,
 746                             const CSSM_CERTGROUP *CertGroupFrag,
 747                             CSSM_CERTGROUP_PTR *CertGroup);
 748
 749 CSSM_RETURN CSSMAPI
 750 CSSM_TP_CertGroupPrune (CSSM_TP_HANDLE TPHandle,
 751                         CSSM_CL_HANDLE CLHandle,
 752                         const CSSM_DL_DB_LIST *DBList,
 753                         const CSSM_CERTGROUP *OrderedCertGroup,
 754                         CSSM_CERTGROUP_PTR *PrunedCertGroup);
 755
 756 CSSM_RETURN CSSMAPI
 757 CSSM_TP_CertGroupToTupleGroup (CSSM_TP_HANDLE TPHandle,
 758                                CSSM_CL_HANDLE CLHandle,
 759                                const CSSM_CERTGROUP *CertGroup,
 760                                CSSM_TUPLEGROUP_PTR *TupleGroup);
 761
 762 CSSM_RETURN CSSMAPI
 763 CSSM_TP_TupleGroupToCertGroup (CSSM_TP_HANDLE TPHandle,
 764                                CSSM_CL_HANDLE CLHandle,
 765                                const CSSM_TUPLEGROUP *TupleGroup,
 766                                CSSM_CERTGROUP_PTR *CertTemplates);
 767
 768 CSSM_RETURN CSSMAPI
 769 CSSM_TP_PassThrough (CSSM_TP_HANDLE TPHandle,
 770                      CSSM_CL_HANDLE CLHandle,
 771                      CSSM_CC_HANDLE CCHandle,
 772                      const CSSM_DL_DB_LIST *DBList,
 773                      uint32 PassThroughId,
 774                      const void *InputParams,
 775                      void **OutputParams);
 776
 777
 778 /* Authorization Computation Operations */
 779
 780 CSSM_RETURN CSSMAPI
 781 CSSM_AC_AuthCompute (CSSM_AC_HANDLE ACHandle,
 782                      const CSSM_TUPLEGROUP *BaseAuthorizations,
 783                      const CSSM_TUPLEGROUP *Credentials,
 784                      uint32 NumberOfRequestors,
 785                      const CSSM_LIST *Requestors,
 786                      const CSSM_LIST *RequestedAuthorizationPeriod,
 787                      const CSSM_LIST *RequestedAuthorization,
 788                      CSSM_TUPLEGROUP_PTR AuthorizationResult);
 789
 790 CSSM_RETURN CSSMAPI
 791 CSSM_AC_PassThrough (CSSM_AC_HANDLE ACHandle,
 792                      CSSM_TP_HANDLE TPHandle,
 793                      CSSM_CL_HANDLE CLHandle,
 794                      CSSM_CC_HANDLE CCHandle,
 795                      const CSSM_DL_DB_LIST *DBList,
 796                      uint32 PassThroughId,
 797                      const void *InputParams,
 798                      void **OutputParams);
 799
 800
 801 /* Certificate Library Operations */
 802
 803 CSSM_RETURN CSSMAPI
 804 CSSM_CL_CertCreateTemplate (CSSM_CL_HANDLE CLHandle,
 805                             uint32 NumberOfFields,
 806                             const CSSM_FIELD *CertFields,
 807                             CSSM_DATA_PTR CertTemplate);
 808
 809 CSSM_RETURN CSSMAPI
 810 CSSM_CL_CertGetAllTemplateFields (CSSM_CL_HANDLE CLHandle,
 811                                   const CSSM_DATA *CertTemplate,
 812                                   uint32 *NumberOfFields,
 813                                   CSSM_FIELD_PTR *CertFields);
 814
 815 CSSM_RETURN CSSMAPI
 816 CSSM_CL_CertSign (CSSM_CL_HANDLE CLHandle,
 817                   CSSM_CC_HANDLE CCHandle,
 818                   const CSSM_DATA *CertTemplate,
 819                   const CSSM_FIELD *SignScope,
 820                   uint32 ScopeSize,
 821                   CSSM_DATA_PTR SignedCert);
 822
 823 CSSM_RETURN CSSMAPI
 824 CSSM_CL_CertVerify (CSSM_CL_HANDLE CLHandle,
 825                     CSSM_CC_HANDLE CCHandle,
 826                     const CSSM_DATA *CertToBeVerified,
 827                     const CSSM_DATA *SignerCert,
 828                     const CSSM_FIELD *VerifyScope,
 829                     uint32 ScopeSize);
 830
 831 CSSM_RETURN CSSMAPI
 832 CSSM_CL_CertVerifyWithKey (CSSM_CL_HANDLE CLHandle,
 833                            CSSM_CC_HANDLE CCHandle,
 834                            const CSSM_DATA *CertToBeVerified);
 835
 836 CSSM_RETURN CSSMAPI
 837 CSSM_CL_CertGetFirstFieldValue (CSSM_CL_HANDLE CLHandle,
 838                                 const CSSM_DATA *Cert,
 839                                 const CSSM_OID *CertField,
 840                                 CSSM_HANDLE_PTR ResultsHandle,
 841                                 uint32 *NumberOfMatchedFields,
 842                                 CSSM_DATA_PTR *Value);
 843
 844 CSSM_RETURN CSSMAPI
 845 CSSM_CL_CertGetNextFieldValue (CSSM_CL_HANDLE CLHandle,
 846                                CSSM_HANDLE ResultsHandle,
 847                                CSSM_DATA_PTR *Value);
 848
 849 CSSM_RETURN CSSMAPI
 850 CSSM_CL_CertAbortQuery (CSSM_CL_HANDLE CLHandle,
 851                         CSSM_HANDLE ResultsHandle);
 852
 853 CSSM_RETURN CSSMAPI
 854 CSSM_CL_CertGetKeyInfo (CSSM_CL_HANDLE CLHandle,
 855                         const CSSM_DATA *Cert,
 856                         CSSM_KEY_PTR *Key);
 857
 858 CSSM_RETURN CSSMAPI
 859 CSSM_CL_CertGetAllFields (CSSM_CL_HANDLE CLHandle,
 860                           const CSSM_DATA *Cert,
 861                           uint32 *NumberOfFields,
 862                           CSSM_FIELD_PTR *CertFields);
 863
 864 CSSM_RETURN CSSMAPI
 865 CSSM_CL_FreeFields (CSSM_CL_HANDLE CLHandle,
 866                     uint32 NumberOfFields,
 867                     CSSM_FIELD_PTR *Fields);
 868
 869 CSSM_RETURN CSSMAPI
 870 CSSM_CL_FreeFieldValue (CSSM_CL_HANDLE CLHandle,
 871                         const CSSM_OID *CertOrCrlOid,
 872                         CSSM_DATA_PTR Value);
 873
 874 CSSM_RETURN CSSMAPI
 875 CSSM_CL_CertCache (CSSM_CL_HANDLE CLHandle,
 876                    const CSSM_DATA *Cert,
 877                    CSSM_HANDLE_PTR CertHandle);
 878
 879 CSSM_RETURN CSSMAPI
 880 CSSM_CL_CertGetFirstCachedFieldValue (CSSM_CL_HANDLE CLHandle,
 881                                       CSSM_HANDLE CertHandle,
 882                                       const CSSM_OID *CertField,
 883                                       CSSM_HANDLE_PTR ResultsHandle,
 884                                       uint32 *NumberOfMatchedFields,
 885                                       CSSM_DATA_PTR *Value);
 886
 887 CSSM_RETURN CSSMAPI
 888 CSSM_CL_CertGetNextCachedFieldValue (CSSM_CL_HANDLE CLHandle,
 889                                      CSSM_HANDLE ResultsHandle,
 890                                      CSSM_DATA_PTR *Value);
 891
 892 CSSM_RETURN CSSMAPI
 893 CSSM_CL_CertAbortCache (CSSM_CL_HANDLE CLHandle,
 894                         CSSM_HANDLE CertHandle);
 895
 896 CSSM_RETURN CSSMAPI
 897 CSSM_CL_CertGroupToSignedBundle (CSSM_CL_HANDLE CLHandle,
 898                                  CSSM_CC_HANDLE CCHandle,
 899                                  const CSSM_CERTGROUP *CertGroupToBundle,
 900                                  const CSSM_CERT_BUNDLE_HEADER *BundleInfo,
 901                                  CSSM_DATA_PTR SignedBundle);
 902
 903 CSSM_RETURN CSSMAPI
 904 CSSM_CL_CertGroupFromVerifiedBundle (CSSM_CL_HANDLE CLHandle,
 905                                      CSSM_CC_HANDLE CCHandle,
 906                                      const CSSM_CERT_BUNDLE *CertBundle,
 907                                      const CSSM_DATA *SignerCert,
 908                                      CSSM_CERTGROUP_PTR *CertGroup);
 909
 910 CSSM_RETURN CSSMAPI
 911 CSSM_CL_CertDescribeFormat (CSSM_CL_HANDLE CLHandle,
 912                             uint32 *NumberOfFields,
 913                             CSSM_OID_PTR *OidList);
 914
 915 CSSM_RETURN CSSMAPI
 916 CSSM_CL_CrlCreateTemplate (CSSM_CL_HANDLE CLHandle,
 917                            uint32 NumberOfFields,
 918                            const CSSM_FIELD *CrlTemplate,
 919                            CSSM_DATA_PTR NewCrl);
 920
 921 CSSM_RETURN CSSMAPI
 922 CSSM_CL_CrlSetFields (CSSM_CL_HANDLE CLHandle,
 923                       uint32 NumberOfFields,
 924                       const CSSM_FIELD *CrlTemplate,
 925                       const CSSM_DATA *OldCrl,
 926                       CSSM_DATA_PTR ModifiedCrl);
 927
 928 CSSM_RETURN CSSMAPI
 929 CSSM_CL_CrlAddCert (CSSM_CL_HANDLE CLHandle,
 930                     CSSM_CC_HANDLE CCHandle,
 931                     const CSSM_DATA *Cert,
 932                     uint32 NumberOfFields,
 933                     const CSSM_FIELD *CrlEntryFields,
 934                     const CSSM_DATA *OldCrl,
 935                     CSSM_DATA_PTR NewCrl);
 936
 937 CSSM_RETURN CSSMAPI
 938 CSSM_CL_CrlRemoveCert (CSSM_CL_HANDLE CLHandle,
 939                        const CSSM_DATA *Cert,
 940                        const CSSM_DATA *OldCrl,
 941                        CSSM_DATA_PTR NewCrl);
 942
 943 CSSM_RETURN CSSMAPI
 944 CSSM_CL_CrlSign (CSSM_CL_HANDLE CLHandle,
 945                  CSSM_CC_HANDLE CCHandle,
 946                  const CSSM_DATA *UnsignedCrl,
 947                  const CSSM_FIELD *SignScope,
 948                  uint32 ScopeSize,
 949                  CSSM_DATA_PTR SignedCrl);
 950
 951 CSSM_RETURN CSSMAPI
 952 CSSM_CL_CrlVerify (CSSM_CL_HANDLE CLHandle,
 953                    CSSM_CC_HANDLE CCHandle,
 954                    const CSSM_DATA *CrlToBeVerified,
 955                    const CSSM_DATA *SignerCert,
 956                    const CSSM_FIELD *VerifyScope,
 957                    uint32 ScopeSize);
 958
 959 CSSM_RETURN CSSMAPI
 960 CSSM_CL_CrlVerifyWithKey (CSSM_CL_HANDLE CLHandle,
 961                           CSSM_CC_HANDLE CCHandle,
 962                           const CSSM_DATA *CrlToBeVerified);
 963
 964 CSSM_RETURN CSSMAPI
 965 CSSM_CL_IsCertInCrl (CSSM_CL_HANDLE CLHandle,
 966                      const CSSM_DATA *Cert,
 967                      const CSSM_DATA *Crl,
 968                      CSSM_BOOL *CertFound);
 969
 970 CSSM_RETURN CSSMAPI
 971 CSSM_CL_CrlGetFirstFieldValue (CSSM_CL_HANDLE CLHandle,
 972                                const CSSM_DATA *Crl,
 973                                const CSSM_OID *CrlField,
 974                                CSSM_HANDLE_PTR ResultsHandle,
 975                                uint32 *NumberOfMatchedFields,
 976                                CSSM_DATA_PTR *Value);
 977
 978 CSSM_RETURN CSSMAPI
 979 CSSM_CL_CrlGetNextFieldValue (CSSM_CL_HANDLE CLHandle,
 980                               CSSM_HANDLE ResultsHandle,
 981                               CSSM_DATA_PTR *Value);
 982
 983 CSSM_RETURN CSSMAPI
 984 CSSM_CL_CrlAbortQuery (CSSM_CL_HANDLE CLHandle,
 985                        CSSM_HANDLE ResultsHandle);
 986
 987 CSSM_RETURN CSSMAPI
 988 CSSM_CL_CrlGetAllFields (CSSM_CL_HANDLE CLHandle,
 989                          const CSSM_DATA *Crl,
 990                          uint32 *NumberOfCrlFields,
 991                          CSSM_FIELD_PTR *CrlFields);
 992
 993 CSSM_RETURN CSSMAPI
 994 CSSM_CL_CrlCache (CSSM_CL_HANDLE CLHandle,
 995                   const CSSM_DATA *Crl,
 996                   CSSM_HANDLE_PTR CrlHandle);
 997
 998 CSSM_RETURN CSSMAPI
 999 CSSM_CL_IsCertInCachedCrl (CSSM_CL_HANDLE CLHandle,
1000                            const CSSM_DATA *Cert,
1001                            CSSM_HANDLE CrlHandle,
1002                            CSSM_BOOL *CertFound,
1003                            CSSM_DATA_PTR CrlRecordIndex);
1004
1005 CSSM_RETURN CSSMAPI
1006 CSSM_CL_CrlGetFirstCachedFieldValue (CSSM_CL_HANDLE CLHandle,
1007                                      CSSM_HANDLE CrlHandle,
1008                                      const CSSM_DATA *CrlRecordIndex,
1009                                      const CSSM_OID *CrlField,
1010                                      CSSM_HANDLE_PTR ResultsHandle,
1011                                      uint32 *NumberOfMatchedFields,
1012                                      CSSM_DATA_PTR *Value);
1013
1014 CSSM_RETURN CSSMAPI
1015 CSSM_CL_CrlGetNextCachedFieldValue (CSSM_CL_HANDLE CLHandle,
1016                                     CSSM_HANDLE ResultsHandle,
1017                                     CSSM_DATA_PTR *Value);
1018
1019 CSSM_RETURN CSSMAPI
1020 CSSM_CL_CrlGetAllCachedRecordFields (CSSM_CL_HANDLE CLHandle,
1021                                      CSSM_HANDLE CrlHandle,
1022                                      const CSSM_DATA *CrlRecordIndex,
1023                                      uint32 *NumberOfFields,
1024                                      CSSM_FIELD_PTR *CrlFields);
1025
1026 CSSM_RETURN CSSMAPI
1027 CSSM_CL_CrlAbortCache (CSSM_CL_HANDLE CLHandle,
1028                        CSSM_HANDLE CrlHandle);
1029
1030 CSSM_RETURN CSSMAPI
1031 CSSM_CL_CrlDescribeFormat (CSSM_CL_HANDLE CLHandle,
1032                            uint32 *NumberOfFields,
1033                            CSSM_OID_PTR *OidList);
1034
1035 CSSM_RETURN CSSMAPI
1036 CSSM_CL_PassThrough (CSSM_CL_HANDLE CLHandle,
1037                      CSSM_CC_HANDLE CCHandle,
1038                      uint32 PassThroughId,
1039                      const void *InputParams,
1040                      void **OutputParams);
1041
1042
1043 /* Data Storage Library Operations */
1044
1045 CSSM_RETURN CSSMAPI
1046 CSSM_DL_DbOpen (CSSM_DL_HANDLE DLHandle,
1047                 const char *DbName,
1048                 const CSSM_NET_ADDRESS *DbLocation,
1049                 CSSM_DB_ACCESS_TYPE AccessRequest,
1050                 const CSSM_ACCESS_CREDENTIALS *AccessCred,
1051                 const void *OpenParameters,
1052                 CSSM_DB_HANDLE *DbHandle);
1053
1054 CSSM_RETURN CSSMAPI
1055 CSSM_DL_DbClose (CSSM_DL_DB_HANDLE DLDBHandle);
1056
1057 CSSM_RETURN CSSMAPI
1058 CSSM_DL_DbCreate (CSSM_DL_HANDLE DLHandle,
1059                   const char *DbName,
1060                   const CSSM_NET_ADDRESS *DbLocation,
1061                   const CSSM_DBINFO *DBInfo,
1062                   CSSM_DB_ACCESS_TYPE AccessRequest,
1063                   const CSSM_RESOURCE_CONTROL_CONTEXT *CredAndAclEntry,
1064                   const void *OpenParameters,
1065                   CSSM_DB_HANDLE *DbHandle);
1066
1067 CSSM_RETURN CSSMAPI
1068 CSSM_DL_DbDelete (CSSM_DL_HANDLE DLHandle,
1069                   const char *DbName,
1070                   const CSSM_NET_ADDRESS *DbLocation,
1071                   const CSSM_ACCESS_CREDENTIALS *AccessCred);
1072
1073 CSSM_RETURN CSSMAPI
1074 CSSM_DL_CreateRelation (CSSM_DL_DB_HANDLE DLDBHandle,
1075                         CSSM_DB_RECORDTYPE RelationID,
1076                         const char *RelationName,
1077                         uint32 NumberOfAttributes,
1078                         const CSSM_DB_SCHEMA_ATTRIBUTE_INFO *pAttributeInfo,
1079                         uint32 NumberOfIndexes,
1080                         const CSSM_DB_SCHEMA_INDEX_INFO *pIndexInfo);
1081
1082 CSSM_RETURN CSSMAPI
1083 CSSM_DL_DestroyRelation (CSSM_DL_DB_HANDLE DLDBHandle,
1084                          CSSM_DB_RECORDTYPE RelationID);
1085
1086 CSSM_RETURN CSSMAPI
1087 CSSM_DL_Authenticate (CSSM_DL_DB_HANDLE DLDBHandle,
1088                       CSSM_DB_ACCESS_TYPE AccessRequest,
1089                       const CSSM_ACCESS_CREDENTIALS *AccessCred);
1090
1091 CSSM_RETURN CSSMAPI
1092 CSSM_DL_GetDbAcl (CSSM_DL_DB_HANDLE DLDBHandle,
1093                   const CSSM_STRING *SelectionTag,
1094                   uint32 *NumberOfAclInfos,
1095                   CSSM_ACL_ENTRY_INFO_PTR *AclInfos);
1096
1097 CSSM_RETURN CSSMAPI
1098 CSSM_DL_ChangeDbAcl (CSSM_DL_DB_HANDLE DLDBHandle,
1099                      const CSSM_ACCESS_CREDENTIALS *AccessCred,
1100                      const CSSM_ACL_EDIT *AclEdit);
1101
1102 CSSM_RETURN CSSMAPI
1103 CSSM_DL_GetDbOwner (CSSM_DL_DB_HANDLE DLDBHandle,
1104                     CSSM_ACL_OWNER_PROTOTYPE_PTR Owner);
1105
1106 CSSM_RETURN CSSMAPI
1107 CSSM_DL_ChangeDbOwner (CSSM_DL_DB_HANDLE DLDBHandle,
1108                        const CSSM_ACCESS_CREDENTIALS *AccessCred,
1109                        const CSSM_ACL_OWNER_PROTOTYPE *NewOwner);
1110
1111 CSSM_RETURN CSSMAPI
1112 CSSM_DL_GetDbNames (CSSM_DL_HANDLE DLHandle,
1113                     CSSM_NAME_LIST_PTR *NameList);
1114
1115 CSSM_RETURN CSSMAPI
1116 CSSM_DL_GetDbNameFromHandle (CSSM_DL_DB_HANDLE DLDBHandle,
1117                              char **DbName);
1118
1119 CSSM_RETURN CSSMAPI
1120 CSSM_DL_FreeNameList (CSSM_DL_HANDLE DLHandle,
1121                       CSSM_NAME_LIST_PTR NameList);
1122
1123 CSSM_RETURN CSSMAPI
1124 CSSM_DL_DataInsert (CSSM_DL_DB_HANDLE DLDBHandle,
1125                     CSSM_DB_RECORDTYPE RecordType,
1126                     const CSSM_DB_RECORD_ATTRIBUTE_DATA *Attributes,
1127                     const CSSM_DATA *Data,
1128                     CSSM_DB_UNIQUE_RECORD_PTR *UniqueId);
1129
1130 CSSM_RETURN CSSMAPI
1131 CSSM_DL_DataDelete (CSSM_DL_DB_HANDLE DLDBHandle,
1132                     const CSSM_DB_UNIQUE_RECORD *UniqueRecordIdentifier);
1133
1134 CSSM_RETURN CSSMAPI
1135 CSSM_DL_DataModify (CSSM_DL_DB_HANDLE DLDBHandle,
1136                     CSSM_DB_RECORDTYPE RecordType,
1137                     CSSM_DB_UNIQUE_RECORD_PTR UniqueRecordIdentifier,
1138                     const CSSM_DB_RECORD_ATTRIBUTE_DATA *AttributesToBeModified,
1139                     const CSSM_DATA *DataToBeModified,
1140                     CSSM_DB_MODIFY_MODE ModifyMode);
1141
1142 CSSM_RETURN CSSMAPI
1143 CSSM_DL_DataGetFirst (CSSM_DL_DB_HANDLE DLDBHandle,
1144                       const CSSM_QUERY *Query,
1145                       CSSM_HANDLE_PTR ResultsHandle,
1146                       CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
1147                       CSSM_DATA_PTR Data,
1148                       CSSM_DB_UNIQUE_RECORD_PTR *UniqueId);
1149
1150 CSSM_RETURN CSSMAPI
1151 CSSM_DL_DataGetNext (CSSM_DL_DB_HANDLE DLDBHandle,
1152                      CSSM_HANDLE ResultsHandle,
1153                      CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
1154                      CSSM_DATA_PTR Data,
1155                      CSSM_DB_UNIQUE_RECORD_PTR *UniqueId);
1156
1157 CSSM_RETURN CSSMAPI
1158 CSSM_DL_DataAbortQuery (CSSM_DL_DB_HANDLE DLDBHandle,
1159                         CSSM_HANDLE ResultsHandle);
1160
1161 CSSM_RETURN CSSMAPI
1162 CSSM_DL_DataGetFromUniqueRecordId (CSSM_DL_DB_HANDLE DLDBHandle,
1163                               const CSSM_DB_UNIQUE_RECORD *UniqueRecord,
1164                               CSSM_DB_RECORD_ATTRIBUTE_DATA_PTR Attributes,
1165                               CSSM_DATA_PTR Data);
1166
1167 CSSM_RETURN CSSMAPI
1168 CSSM_DL_FreeUniqueRecord (CSSM_DL_DB_HANDLE DLDBHandle,
1169                           CSSM_DB_UNIQUE_RECORD_PTR UniqueRecord);
1170
1171 CSSM_RETURN CSSMAPI
1172 CSSM_DL_PassThrough (CSSM_DL_DB_HANDLE DLDBHandle,
1173                 uint32 PassThroughId,
1174                 const void *InputParams,
1175                 void **OutputParams);
1176
1177 #ifdef __cplusplus
1178 }
1179 #endif
1180
1181 #endif /* _CSSMAPI_H_ */