Home | History | Annotate | Download | only in common
      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  * Functions for Verifying Signatures and MACS
     30  * (as defined in PKCS#11 spec section 11.13)
     31  */
     32 
     33 #include "metaGlobal.h"
     34 
     35 
     36 /*
     37  * meta_VerifyInit
     38  *
     39  */
     40 CK_RV
     41 meta_VerifyInit(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_VERIFY, session, pMechanism, key);
     62 
     63 	OBJRELEASE(key);
     64 	REFRELEASE(session);
     65 
     66 	return (rv);
     67 }
     68 
     69 
     70 /*
     71  * meta_Verify
     72  *
     73  */
     74 CK_RV
     75 meta_Verify(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
     76     CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen)
     77 {
     78 	CK_RV rv;
     79 	meta_session_t *session;
     80 
     81 	rv = meta_handle2session(hSession, &session);
     82 	if (rv != CKR_OK)
     83 		return (rv);
     84 
     85 	/* Note: unlike other ops, both buffers are inputs, and required. */
     86 	if (pData == NULL || pSignature == NULL) {
     87 		meta_operation_cleanup(session, CKF_VERIFY, FALSE);
     88 		REFRELEASE(session);
     89 		return (CKR_ARGUMENTS_BAD);
     90 	}
     91 
     92 	rv = meta_do_operation(CKF_VERIFY, MODE_SINGLE, session, NULL,
     93 	    pData, ulDataLen, pSignature, &ulSignatureLen);
     94 
     95 	REFRELEASE(session);
     96 
     97 	return (rv);
     98 }
     99 
    100 
    101 /*
    102  * meta_VerifyUpdate
    103  *
    104  */
    105 CK_RV
    106 meta_VerifyUpdate(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pPart,
    107     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_VERIFY, FALSE);
    118 		REFRELEASE(session);
    119 		return (CKR_ARGUMENTS_BAD);
    120 	}
    121 
    122 	rv = meta_do_operation(CKF_VERIFY, MODE_UPDATE, session, NULL,
    123 	    pPart, ulPartLen, NULL, NULL);
    124 
    125 	REFRELEASE(session);
    126 
    127 	return (rv);
    128 }
    129 
    130 
    131 /*
    132  * meta_VerifyFinal
    133  *
    134  */
    135 CK_RV
    136 meta_VerifyFinal(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
    137     CK_ULONG ulSignatureLen)
    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 	/*
    147 	 * Unlike other ops the buffer is an input. Allow NULL if there's
    148 	 * no more input.
    149 	 */
    150 	if (pSignature == NULL && ulSignatureLen != 0) {
    151 		meta_operation_cleanup(session, CKF_VERIFY, FALSE);
    152 		REFRELEASE(session);
    153 		return (CKR_ARGUMENTS_BAD);
    154 	}
    155 
    156 	rv = meta_do_operation(CKF_VERIFY, MODE_FINAL, session, NULL,
    157 	    pSignature, ulSignatureLen, NULL, NULL);
    158 
    159 	REFRELEASE(session);
    160 
    161 	return (rv);
    162 }
    163 
    164 
    165 /*
    166  * meta_VerifyRecoverInit
    167  *
    168  */
    169 CK_RV
    170 meta_VerifyRecoverInit(CK_SESSION_HANDLE hSession, CK_MECHANISM_PTR pMechanism,
    171     CK_OBJECT_HANDLE hKey)
    172 {
    173 	CK_RV rv;
    174 	meta_session_t *session;
    175 	meta_object_t *key;
    176 
    177 	if (pMechanism == NULL)
    178 		return (CKR_ARGUMENTS_BAD);
    179 
    180 	rv = meta_handle2session(hSession, &session);
    181 	if (rv != CKR_OK)
    182 		return (rv);
    183 
    184 	rv = meta_handle2object(hKey, &key);
    185 	if (rv != CKR_OK) {
    186 		REFRELEASE(session);
    187 		return (rv);
    188 	}
    189 
    190 	rv = meta_operation_init(CKF_VERIFY_RECOVER, session, pMechanism, key);
    191 
    192 	OBJRELEASE(key);
    193 	REFRELEASE(session);
    194 
    195 	return (rv);
    196 }
    197 
    198 
    199 /*
    200  * meta_VerifyRecover
    201  *
    202  */
    203 CK_RV
    204 meta_VerifyRecover(CK_SESSION_HANDLE hSession, CK_BYTE_PTR pSignature,
    205     CK_ULONG ulSignatureLen, CK_BYTE_PTR pData, CK_ULONG_PTR pulDataLen)
    206 {
    207 	CK_RV rv;
    208 	meta_session_t *session;
    209 
    210 	rv = meta_handle2session(hSession, &session);
    211 	if (rv != CKR_OK)
    212 		return (rv);
    213 
    214 	if (pSignature == NULL || pulDataLen == NULL) {
    215 		meta_operation_cleanup(session, CKF_VERIFY_RECOVER, FALSE);
    216 		REFRELEASE(session);
    217 		return (CKR_ARGUMENTS_BAD);
    218 	}
    219 
    220 	rv = meta_do_operation(CKF_VERIFY_RECOVER, MODE_SINGLE, session, NULL,
    221 	    pSignature, ulSignatureLen, pData, pulDataLen);
    222 
    223 	REFRELEASE(session);
    224 
    225 	return (rv);
    226 }
    227