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 (the "License"). 6 * You may not use this file except in compliance with the License. 7 * 8 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 9 * or http://www.opensolaris.org/os/licensing. 10 * See the License for the specific language governing permissions 11 * and limitations under the License. 12 * 13 * When distributing Covered Code, include this CDDL HEADER in each 14 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 15 * If applicable, add the following below this CDDL HEADER, with the 16 * fields enclosed by brackets "[]" replaced with your own identifying 17 * information: Portions Copyright [yyyy] [name of copyright owner] 18 * 19 * CDDL HEADER END 20 */ 21 /* 22 * Copyright 2007 Sun Microsystems, Inc. All rights reserved. 23 * Use is subject to license terms. 24 */ 25 26 #pragma ident "%Z%%M% %I% %E% SMI" 27 28 /* 29 * Signing and MACing Functions 30 * (as defined in PKCs#11 spec section 11.11) 31 */ 32 33 #include "metaGlobal.h" 34 35 36 /* 37 * meta_SignInit 38 * 39 */ 40 CK_RV 41 meta_SignInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, 42 CK_OBJECT_HANDLE hKey) 43 { 44 CK_RV rv; 45 meta_session_t *session; 46 meta_object_t *key; 47 48 if (pMechanism == NULL) 49 return (CKR_ARGUMENTS_BAD); 50 51 rv = meta_handle2session(hSession, &session); 52 if (rv != CKR_OK) 53 return (rv); 54 55 rv = meta_handle2object(hKey, &key); 56 if (rv != CKR_OK) { 57 REFRELEASE(session); 58 return (rv); 59 } 60 61 rv = meta_operation_init(CKF_SIGN, session, pMechanism, key); 62 63 OBJRELEASE(key); 64 REFRELEASE(session); 65 66 return (rv); 67 } 68 69 70 /* 71 * meta_Sign 72 * 73 */ 74 CK_RV 75 meta_Sign(CK_SESSION_HANDLE hSession, 76 CK_BYTE_PTR pData, CK_ULONG ulDataLen, 77 CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) 78 { 79 CK_RV rv; 80 meta_session_t *session; 81 82 rv = meta_handle2session(hSession, &session); 83 if (rv != CKR_OK) 84 return (rv); 85 86 if (pData == NULL || pulSignatureLen == NULL) { 87 meta_operation_cleanup(session, CKF_SIGN, FALSE); 88 REFRELEASE(session); 89 return (CKR_ARGUMENTS_BAD); 90 } 91 92 rv = meta_do_operation(CKF_SIGN, MODE_SINGLE, session, NULL, 93 pData, ulDataLen, pSignature, pulSignatureLen); 94 95 REFRELEASE(session); 96 97 return (rv); 98 } 99 100 101 /* 102 * meta_SignUpdate 103 * 104 */ 105 CK_RV 106 meta_SignUpdate(CK_SESSION_HANDLE hSession, 107 CK_BYTE_PTR pPart, CK_ULONG ulPartLen) 108 { 109 CK_RV rv; 110 meta_session_t *session; 111 112 rv = meta_handle2session(hSession, &session); 113 if (rv != CKR_OK) 114 return (rv); 115 116 if (pPart == NULL) { 117 meta_operation_cleanup(session, CKF_SIGN, FALSE); 118 REFRELEASE(session); 119 return (CKR_ARGUMENTS_BAD); 120 } 121 122 rv = meta_do_operation(CKF_SIGN, MODE_UPDATE, session, NULL, 123 pPart, ulPartLen, NULL, NULL); 124 125 REFRELEASE(session); 126 127 return (rv); 128 } 129 130 131 /* 132 * meta_SignFinal 133 * 134 */ 135 CK_RV 136 meta_SignFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature, 137 CK_ULONG_PTR pulSignatureLen) 138 { 139 CK_RV rv; 140 meta_session_t *session; 141 142 rv = meta_handle2session(hSession, &session); 143 if (rv != CKR_OK) 144 return (rv); 145 146 if (pulSignatureLen == NULL) { 147 meta_operation_cleanup(session, CKF_SIGN, FALSE); 148 REFRELEASE(session); 149 return (CKR_ARGUMENTS_BAD); 150 } 151 152 rv = meta_do_operation(CKF_SIGN, MODE_FINAL, session, NULL, 153 NULL, 0, pSignature, pulSignatureLen); 154 155 REFRELEASE(session); 156 157 return (rv); 158 } 159 160 /* 161 * meta_SignRecoverInit 162 * 163 */ 164 CK_RV 165 meta_SignRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, 166 CK_OBJECT_HANDLE hKey) 167 { 168 CK_RV rv; 169 meta_session_t *session; 170 meta_object_t *key; 171 172 if (pMechanism == NULL) 173 return (CKR_ARGUMENTS_BAD); 174 175 rv = meta_handle2session(hSession, &session); 176 if (rv != CKR_OK) 177 return (rv); 178 179 rv = meta_handle2object(hKey, &key); 180 if (rv != CKR_OK) { 181 REFRELEASE(session); 182 return (rv); 183 } 184 185 rv = meta_operation_init(CKF_SIGN_RECOVER, session, pMechanism, key); 186 187 OBJRELEASE(key); 188 REFRELEASE(session); 189 190 return (rv); 191 } 192 193 194 /* 195 * meta_SignRecover 196 * 197 */ 198 CK_RV 199 meta_SignRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, 200 CK_ULONG ulDataLen, CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen) 201 { 202 CK_RV rv; 203 meta_session_t *session; 204 205 rv = meta_handle2session(hSession, &session); 206 if (rv != CKR_OK) 207 return (rv); 208 209 if (pData == NULL || pulSignatureLen == NULL) { 210 meta_operation_cleanup(session, CKF_SIGN_RECOVER, FALSE); 211 REFRELEASE(session); 212 return (CKR_ARGUMENTS_BAD); 213 } 214 215 rv = meta_do_operation(CKF_SIGN_RECOVER, MODE_SINGLE, session, NULL, 216 pData, ulDataLen, pSignature, pulSignatureLen); 217 218 REFRELEASE(session); 219 220 return (rv); 221 } 222