usr/src/lib/pkcs11/libpkcs11/common/pkcs11Digest.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License, Version 1.0 only
   6  * (the "License").  You may not use this file except in compliance
   7  * with the License.
   8  *
   9  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
  10  * or http://www.opensolaris.org/os/licensing.
  11  * See the License for the specific language governing permissions
  12  * and limitations under the License.
  13  *
  14  * When distributing Covered Code, include this CDDL HEADER in each
  15  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  16  * If applicable, add the following below this CDDL HEADER, with the
  17  * fields enclosed by brackets "[]" replaced with your own identifying
  18  * information: Portions Copyright [yyyy] [name of copyright owner]
  19  *
  20  * CDDL HEADER END
  21  */
  22 /*
  23  * Copyright 2003 Sun Microsystems, Inc.  All rights reserved.
  24  * Use is subject to license terms.
  25  */
  26
  27 #pragma ident   "%Z%%M% %I%     %E% SMI"
  28
  29 #include <security/cryptoki.h>
  30 #include "pkcs11Global.h"
  31 #include "pkcs11Conf.h"
  32 #include "pkcs11Session.h"
  33 #include "pkcs11Slot.h"
  34
  35 /*
  36  * C_DigestInit will verify that the session handle is valid within
  37  * the framework, that the mechanism is not disabled for the slot
  38  * associated with this session, and then redirect to the underlying
  39  * provider.  Policy is only checked for C_DigestInit, since it is
  40  * required to be called before C_Digest and C_DigestUpdate.
  41  */
  42 CK_RV
  43 C_DigestInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism)
  44 {
  45
  46         CK_RV rv;
  47         pkcs11_session_t *sessp;
  48         CK_SLOT_ID slotid;
  49
  50         /* Check for a fastpath */
  51         if (purefastpath || policyfastpath) {
  52                 if (policyfastpath &&
  53                     pkcs11_is_dismech(fast_slot, pMechanism->mechanism)) {
  54                         return (CKR_MECHANISM_INVALID);
  55                 }
  56                 return (fast_funcs->C_DigestInit(hSession, pMechanism));
  57         }
  58
  59         if (!pkcs11_initialized) {
  60                 return (CKR_CRYPTOKI_NOT_INITIALIZED);
  61         }
  62
  63         /* Obtain the session pointer */
  64         HANDLE2SESSION(hSession, sessp, rv);
  65
  66         if (rv != CKR_OK) {
  67                 return (rv);
  68         }
  69
  70         slotid = sessp->se_slotid;
  71
  72         /* Make sure this is not a disabled mechanism */
  73         if (pkcs11_is_dismech(slotid, pMechanism->mechanism)) {
  74                 return (CKR_MECHANISM_INVALID);
  75         }
  76
  77         /* Initialize the digest with the underlying provider */
  78         rv = FUNCLIST(slotid)->C_DigestInit(sessp->se_handle,
  79             pMechanism);
  80
  81         /* Present consistent interface to the application */
  82         if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
  83                 return (CKR_FUNCTION_FAILED);
  84         }
  85
  86         return (rv);
  87 }
  88
  89 /*
  90  * C_Digest is a pure wrapper to the underlying provider.
  91  * The only argument checked is whether or not hSession is valid.
  92  */
  93 CK_RV
  94 C_Digest(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
  95     CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen)
  96 {
  97
  98         CK_RV rv;
  99         pkcs11_session_t *sessp;
 100
 101         /* Check for a fastpath */
 102         if (purefastpath || policyfastpath) {
 103                 return (fast_funcs->C_Digest(hSession, pData, ulDataLen,
 104                             pDigest, pulDigestLen));
 105         }
 106
 107         if (!pkcs11_initialized) {
 108                 return (CKR_CRYPTOKI_NOT_INITIALIZED);
 109         }
 110
 111         /* Obtain the session pointer */
 112         HANDLE2SESSION(hSession, sessp, rv);
 113
 114         if (rv != CKR_OK) {
 115                 return (rv);
 116         }
 117
 118         /* Pass data to the provider */
 119         rv = FUNCLIST(sessp->se_slotid)->C_Digest(sessp->se_handle, pData,
 120             ulDataLen, pDigest, pulDigestLen);
 121
 122         /* Present consistent interface to the application */
 123         if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
 124                 return (CKR_FUNCTION_FAILED);
 125         }
 126
 127         return (rv);
 128
 129 }
 130
 131 /*
 132  * C_DigestUpdate is a pure wrapper to the underlying provider.
 133  * The only argument checked is whether or not hSession is valid.
 134  */
 135 CK_RV
 136 C_DigestUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
 137     CK_ULONG ulPartLen)
 138 {
 139         CK_RV rv;
 140         pkcs11_session_t *sessp;
 141
 142         /* Check for a fastpath */
 143         if (purefastpath || policyfastpath) {
 144                 return (fast_funcs->C_DigestUpdate(hSession, pPart,
 145                             ulPartLen));
 146         }
 147
 148         if (!pkcs11_initialized) {
 149                 return (CKR_CRYPTOKI_NOT_INITIALIZED);
 150         }
 151
 152         /* Obtain the session pointer */
 153         HANDLE2SESSION(hSession, sessp, rv);
 154
 155         if (rv != CKR_OK) {
 156                 return (rv);
 157         }
 158
 159         /* Pass data to the provider */
 160         rv = FUNCLIST(sessp->se_slotid)->C_DigestUpdate(sessp->se_handle,
 161             pPart, ulPartLen);
 162
 163         /* Present consistent interface to the application */
 164         if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
 165                 return (CKR_FUNCTION_FAILED);
 166         }
 167
 168         return (rv);
 169 }
 170
 171 /*
 172  * C_DigestKey is a pure wrapper to the underlying provider.
 173  * The only argument checked is whether or not hSession is valid.
 174  */
 175 CK_RV
 176 C_DigestKey(CK_SESSION_HANDLE hSession, CK_OBJECT_HANDLE hKey)
 177 {
 178         CK_RV rv;
 179         pkcs11_session_t *sessp;
 180
 181         /* Check for a fastpath */
 182         if (purefastpath || policyfastpath) {
 183                 return (fast_funcs->C_DigestKey(hSession, hKey));
 184         }
 185
 186         if (!pkcs11_initialized) {
 187                 return (CKR_CRYPTOKI_NOT_INITIALIZED);
 188         }
 189
 190         /* Obtain the session pointer */
 191         HANDLE2SESSION(hSession, sessp, rv);
 192
 193         if (rv != CKR_OK) {
 194                 return (rv);
 195         }
 196
 197         /* Pass data to the provider */
 198         rv = FUNCLIST(sessp->se_slotid)->C_DigestKey(sessp->se_handle, hKey);
 199
 200         /* Present consistent interface to the application */
 201         if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
 202                 return (CKR_FUNCTION_FAILED);
 203         }
 204
 205         return (rv);
 206 }
 207
 208 /*
 209  * C_DigestFinal is a pure wrapper to the underlying provider.
 210  * The only argument checked is whether or not hSession is valid.
 211  */
 212 CK_RV
 213 C_DigestFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pDigest,
 214     CK_ULONG_PTR pulDigestLen)
 215 {
 216         CK_RV rv;
 217         pkcs11_session_t *sessp;
 218
 219         /* Check for a fastpath */
 220         if (purefastpath || policyfastpath) {
 221                 return (fast_funcs->C_DigestFinal(hSession, pDigest,
 222                             pulDigestLen));
 223         }
 224
 225         if (!pkcs11_initialized) {
 226                 return (CKR_CRYPTOKI_NOT_INITIALIZED);
 227         }
 228
 229         /* Obtain the session pointer */
 230         HANDLE2SESSION(hSession, sessp, rv);
 231
 232         if (rv != CKR_OK) {
 233                 return (rv);
 234         }
 235
 236         /* Pass data to the provider */
 237         rv = FUNCLIST(sessp->se_slotid)->C_DigestFinal(sessp->se_handle,
 238             pDigest, pulDigestLen);
 239
 240         /* Present consistent interface to the application */
 241         if (rv == CKR_FUNCTION_NOT_SUPPORTED) {
 242                 return (CKR_FUNCTION_FAILED);
 243         }
 244
 245         return (rv);
 246 }