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 /*
23 * Copyright 2007 Sun Microsystems, Inc. All rights reserved.
24 * Use is subject to license terms.
25 * Copyright (c) 2018, Joyent, Inc.
26 */
27
28 #include <pthread.h>
29 #include <errno.h>
30 #include <stdio.h>
31 #include <strings.h>
32 #include <sys/crypto/ioctl.h>
33 #include <security/cryptoki.h>
34 #include <security/pkcs11t.h>
35 #include "softSession.h"
36 #include "softObject.h"
37 #include "softOps.h"
38 #include "softMAC.h"
39 #include "kernelSoftCommon.h"
40
41 /*
42 * Do the operation(s) specified by opflag.
43 */
44 CK_RV
45 do_soft_digest(void **s, CK_MECHANISM_PTR pMechanism, CK_BYTE_PTR pData,
46 CK_ULONG ulDataLen, CK_BYTE_PTR pDigest, CK_ULONG_PTR pulDigestLen,
47 int opflag)
48 {
49 soft_session_t *session_p;
50 CK_RV rv = CKR_ARGUMENTS_BAD;
51
52 session_p = *((soft_session_t **)s);
53 if (session_p == NULL) {
54 if (!(opflag & OP_INIT)) {
55 return (CKR_ARGUMENTS_BAD);
56 }
57
58 session_p = calloc(1, sizeof (soft_session_t));
59 /*
60 * Initialize the lock for the newly created session.
61 * We do only the minimum needed setup for the
62 * soft_digest* routines to succeed.
63 */
64 if (pthread_mutex_init(&session_p->session_mutex, NULL) != 0) {
65 free(session_p);
66 return (CKR_CANT_LOCK);
67 }
68
69 *s = session_p;
70 } else if (opflag & OP_INIT) {
71 free_soft_ctx(session_p, OP_DIGEST);
72 }
73
74 if (opflag & OP_INIT) {
75 rv = soft_digest_init(session_p, pMechanism);
76 if (rv != CKR_OK)
77 return (rv);
78 }
79
80 if (opflag & OP_SINGLE) {
81 rv = soft_digest(session_p, pData, ulDataLen,
82 pDigest, pulDigestLen);
83 } else {
84 if (opflag & OP_UPDATE) {
85 rv = soft_digest_update(session_p, pData, ulDataLen);
86 if (rv != CKR_OK)
87 return (rv);
88 }
89
90 if (opflag & OP_FINAL) {
91 rv = soft_digest_final(session_p,
92 pDigest, pulDigestLen);
93 }
94 }
95
96 return (rv);
97 }
98
99 /*
100 * opflag specifies whether this is a sign or verify.
101 */
102 CK_RV
103 do_soft_hmac_init(void **s, CK_MECHANISM_PTR pMechanism,
104 CK_BYTE_PTR kval, CK_ULONG klen, int opflag)
105 {
106 CK_RV rv;
107 soft_object_t keyobj;
108 secret_key_obj_t skeyobj;
109 soft_object_t *key_p;
110 soft_session_t *session_p;
111
112 session_p = *((soft_session_t **)s);
113 if (session_p == NULL) {
114 session_p = calloc(1, sizeof (soft_session_t));
115 /* See comments in do_soft_digest() above */
116 if (pthread_mutex_init(&session_p->session_mutex, NULL) != 0) {
117 free(session_p);
118 return (CKR_CANT_LOCK);
119 }
120
121 *s = session_p;
122 } else if (opflag & OP_INIT) {
123 free_soft_ctx(session_p, opflag);
124 }
125
126 /* Do the minimum needed setup for the call to succeed */
127 key_p = &keyobj;
128 bzero(key_p, sizeof (soft_object_t));
129 key_p->class = CKO_SECRET_KEY;
130 key_p->key_type = CKK_GENERIC_SECRET;
131
132 bzero(&skeyobj, sizeof (secret_key_obj_t));
133 OBJ_SEC(key_p) = &skeyobj;
134 OBJ_SEC_VALUE(key_p) = kval;
135 OBJ_SEC_VALUE_LEN(key_p) = klen;
136
137 rv = soft_hmac_sign_verify_init_common(session_p, pMechanism,
138 key_p, opflag & OP_SIGN);
139
140 return (rv);
141 }
142
143 /*
144 * opflag specifies whether this is a sign or verify.
145 */
146 CK_RV
147 do_soft_hmac_update(void **s, CK_BYTE_PTR pData, CK_ULONG ulDataLen, int opflag)
148 {
149 soft_session_t *session_p;
150
151 session_p = *((soft_session_t **)s);
152 if (session_p == NULL) {
153 return (CKR_ARGUMENTS_BAD);
154 }
155
156 return (soft_hmac_sign_verify_update(session_p,
157 pData, ulDataLen, opflag & OP_SIGN));
158 }
159
160 /*
161 * opflag specifies whether this is a final or single.
162 */
163 CK_RV
164 do_soft_hmac_sign(void **s, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
165 CK_BYTE_PTR pSignature, CK_ULONG_PTR pulSignatureLen, int opflag)
166 {
167 CK_RV rv;
168 soft_session_t *session_p;
169 CK_BYTE hmac[SHA512_DIGEST_LENGTH]; /* use the maximum size */
170
171 session_p = *((soft_session_t **)s);
172 if (session_p == NULL || !(opflag & OP_SINGLE || opflag & OP_FINAL)) {
173 return (CKR_ARGUMENTS_BAD);
174 }
175
176 rv = soft_hmac_sign_verify_common(session_p, pData, ulDataLen,
177 (pSignature != NULL ? hmac : NULL), pulSignatureLen, B_TRUE);
178
179 if ((rv == CKR_OK) && (pSignature != NULL)) {
180 (void) memcpy(pSignature, hmac, *pulSignatureLen);
181 }
182
183 return (rv);
184 }
185
186 /*
187 * opflag specifies whether this is a final or single.
188 */
189 CK_RV
190 do_soft_hmac_verify(void **s, CK_BYTE_PTR pData, CK_ULONG ulDataLen,
191 CK_BYTE_PTR pSignature, CK_ULONG ulSignatureLen, int opflag)
192 {
193 CK_RV rv;
194 CK_ULONG len;
195 soft_session_t *session_p;
196 soft_hmac_ctx_t *hmac_ctx;
197 CK_BYTE hmac[SHA512_DIGEST_LENGTH]; /* use the maximum size */
198
199 session_p = *((soft_session_t **)s);
200 if (session_p == NULL || !(opflag & OP_SINGLE || opflag & OP_FINAL)) {
201 return (CKR_ARGUMENTS_BAD);
202 }
203
204 hmac_ctx = (soft_hmac_ctx_t *)session_p->verify.context;
205 len = hmac_ctx->hmac_len;
206
207 rv = soft_hmac_sign_verify_common(session_p, pData,
208 ulDataLen, hmac, &len, B_FALSE);
209
210 if (rv == CKR_OK) {
211 if (len != ulSignatureLen) {
212 rv = CKR_SIGNATURE_LEN_RANGE;
213 }
214
215 if (memcmp(hmac, pSignature, len) != 0) {
216 rv = CKR_SIGNATURE_INVALID;
217 }
218 }
219
220 return (rv);
221 }
222
223 /*
224 * Helper routine to handle the case when the ctx is abandoned.
225 */
226 void
227 free_soft_ctx(void *s, int opflag)
228 {
229 soft_session_t *session_p;
230
231 session_p = (soft_session_t *)s;
232 if (session_p == NULL)
233 return;
234
235 if (opflag & OP_SIGN) {
236 freezero(session_p->sign.context,
237 sizeof (soft_hmac_ctx_t));
238 session_p->sign.context = NULL;
239 session_p->sign.flags = 0;
240 } else if (opflag & OP_VERIFY) {
241 freezero(session_p->verify.context,
242 sizeof (soft_hmac_ctx_t));
243 session_p->verify.context = NULL;
244 session_p->verify.flags = 0;
245 } else {
246 free(session_p->digest.context);
247 session_p->digest.context = NULL;
248 session_p->digest.flags = 0;
249 }
250 }