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 * Encryption and Decryption Functions 30 * (as defined in PKCS#11 spec sections 11.8 and 11.9) 31 */ 32 33 #include "metaGlobal.h" 34 35 36 /* 37 * meta_EncryptInit 38 * 39 */ 40 CK_RV 41 meta_EncryptInit(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_defer(CKF_ENCRYPT, session, pMechanism, key); 62 63 OBJRELEASE(key); 64 REFRELEASE(session); 65 66 return (rv); 67 } 68 69 70 /* 71 * meta_Encrypt 72 * 73 */ 74 CK_RV 75 meta_Encrypt(CK_SESSION_HANDLE hSession, 76 CK_BYTE_PTR pData, CK_ULONG ulDataLen, 77 CK_BYTE_PTR pEncryptedData, CK_ULONG_PTR pulEncryptedDataLen) 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 || pulEncryptedDataLen == NULL) { 87 meta_operation_cleanup(session, CKF_ENCRYPT, FALSE); 88 REFRELEASE(session); 89 return (CKR_ARGUMENTS_BAD); 90 } 91 92 rv = meta_do_operation(CKF_ENCRYPT, MODE_SINGLE, session, NULL, 93 pData, ulDataLen, pEncryptedData, pulEncryptedDataLen); 94 95 REFRELEASE(session); 96 97 return (rv); 98 } 99 100 101 /* 102 * meta_EncryptUpdate 103 * 104 */ 105 CK_RV 106 meta_EncryptUpdate(CK_SESSION_HANDLE hSession, 107 CK_BYTE_PTR pPart, CK_ULONG ulPartLen, 108 CK_BYTE_PTR pEncryptedPart, CK_ULONG_PTR pulEncryptedPartLen) 109 { 110 CK_RV rv; 111 meta_session_t *session; 112 113 rv = meta_handle2session(hSession, &session); 114 if (rv != CKR_OK) 115 return (rv); 116 117 if (pPart == NULL || pulEncryptedPartLen == NULL) { 118 meta_operation_cleanup(session, CKF_ENCRYPT, FALSE); 119 REFRELEASE(session); 120 return (CKR_ARGUMENTS_BAD); 121 } 122 123 rv = meta_do_operation(CKF_ENCRYPT, MODE_UPDATE, session, NULL, 124 pPart, ulPartLen, pEncryptedPart, pulEncryptedPartLen); 125 126 REFRELEASE(session); 127 128 return (rv); 129 } 130 131 132 /* 133 * meta_EncryptFinal 134 * 135 */ 136 CK_RV 137 meta_EncryptFinal(CK_SESSION_HANDLE hSession, 138 CK_BYTE_PTR pLastEncryptedPart, CK_ULONG_PTR pulLastEncryptedPartLen) 139 { 140 CK_RV rv; 141 meta_session_t *session; 142 143 rv = meta_handle2session(hSession, &session); 144 if (rv != CKR_OK) 145 return (rv); 146 147 if (pulLastEncryptedPartLen == NULL) { 148 meta_operation_cleanup(session, CKF_ENCRYPT, FALSE); 149 REFRELEASE(session); 150 return (CKR_ARGUMENTS_BAD); 151 } 152 153 rv = meta_do_operation(CKF_ENCRYPT, MODE_FINAL, session, NULL, 154 NULL, 0, pLastEncryptedPart, pulLastEncryptedPartLen); 155 156 REFRELEASE(session); 157 158 return (rv); 159 } 160 161 162 /* 163 * meta_DecryptInit 164 * 165 */ 166 CK_RV 167 meta_DecryptInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism, 168 CK_OBJECT_HANDLE hKey) 169 { 170 CK_RV rv; 171 meta_session_t *session; 172 meta_object_t *key; 173 174 if (pMechanism == NULL) 175 return (CKR_ARGUMENTS_BAD); 176 177 rv = meta_handle2session(hSession, &session); 178 if (rv != CKR_OK) 179 return (rv); 180 181 rv = meta_handle2object(hKey, &key); 182 if (rv != CKR_OK) { 183 REFRELEASE(session); 184 return (rv); 185 } 186 187 rv = meta_operation_init_defer(CKF_DECRYPT, session, pMechanism, key); 188 189 OBJRELEASE(key); 190 REFRELEASE(session); 191 192 return (rv); 193 } 194 195 196 /* 197 * meta_Decrypt 198 * 199 */ 200 CK_RV 201 meta_Decrypt(CK_SESSION_HANDLE hSession, 202 CK_BYTE_PTR pEncryptedData, CK_ULONG ulEncryptedDataLen, 203 CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen) 204 { 205 CK_RV rv; 206 meta_session_t *session; 207 208 rv = meta_handle2session(hSession, &session); 209 if (rv != CKR_OK) 210 return (rv); 211 212 if (pEncryptedData == NULL || pulDataLen == NULL) { 213 meta_operation_cleanup(session, CKF_DECRYPT, FALSE); 214 REFRELEASE(session); 215 return (CKR_ARGUMENTS_BAD); 216 } 217 218 rv = meta_do_operation(CKF_DECRYPT, MODE_SINGLE, session, NULL, 219 pEncryptedData, ulEncryptedDataLen, pData, pulDataLen); 220 221 REFRELEASE(session); 222 223 return (rv); 224 } 225 226 227 /* 228 * meta_DecryptUpdate 229 * 230 */ 231 CK_RV 232 meta_DecryptUpdate(CK_SESSION_HANDLE hSession, 233 CK_BYTE_PTR pEncryptedPart, CK_ULONG ulEncryptedPartLen, 234 CK_BYTE_PTR pPart, CK_ULONG_PTR pulPartLen) 235 { 236 CK_RV rv; 237 meta_session_t *session; 238 239 rv = meta_handle2session(hSession, &session); 240 if (rv != CKR_OK) 241 return (rv); 242 243 if (pEncryptedPart == NULL || pulPartLen == NULL) { 244 meta_operation_cleanup(session, CKF_DECRYPT, FALSE); 245 REFRELEASE(session); 246 return (CKR_ARGUMENTS_BAD); 247 } 248 249 rv = meta_do_operation(CKF_DECRYPT, MODE_UPDATE, session, NULL, 250 pEncryptedPart, ulEncryptedPartLen, pPart, pulPartLen); 251 252 REFRELEASE(session); 253 254 return (rv); 255 } 256 257 258 /* 259 * meta_DecryptFinal 260 * 261 */ 262 CK_RV 263 meta_DecryptFinal(CK_SESSION_HANDLE hSession, 264 CK_BYTE_PTR pLastPart, CK_ULONG_PTR pulLastPartLen) 265 { 266 CK_RV rv; 267 meta_session_t *session; 268 269 rv = meta_handle2session(hSession, &session); 270 if (rv != CKR_OK) 271 return (rv); 272 273 if (pulLastPartLen == NULL) { 274 meta_operation_cleanup(session, CKF_DECRYPT, FALSE); 275 REFRELEASE(session); 276 return (CKR_ARGUMENTS_BAD); 277 } 278 279 rv = meta_do_operation(CKF_DECRYPT, MODE_FINAL, session, NULL, 280 NULL, 0, pLastPart, pulLastPartLen); 281 282 REFRELEASE(session); 283 284 return (rv); 285 } 286