1 /*
2 * Copyright (c) 2014, 2015, Oracle and/or its affiliates. All rights reserved.
3 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
4 *
5 * This code is free software; you can redistribute it and/or modify it
6 * under the terms of the GNU General Public License version 2 only, as
7 * published by the Free Software Foundation. Oracle designates this
8 * particular file as subject to the "Classpath" exception as provided
9 * by Oracle in the LICENSE file that accompanied this code.
10 *
11 * This code is distributed in the hope that it will be useful, but WITHOUT
12 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14 * version 2 for more details (a copy is included in the LICENSE file that
15 * accompanied this code).
16 *
17 * You should have received a copy of the GNU General Public License version
18 * 2 along with this work; if not, write to the Free Software Foundation,
19 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
20 *
21 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
22 * or visit www.oracle.com if you need additional information or have any
23 * questions.
24 */
25
26 #include <stdlib.h>
27 #include <string.h>
28 #include <strings.h>
29 #include <jni.h>
30 #include "jni_util.h"
31 #include <libsoftcrypto.h>
32 #include "nativeCrypto.h"
33 #include "nativeFunc.h"
34
35 /*
36 * Dumps out byte array in hex with and name and length info
37 */
38 void printBytes(char* header, unsigned char* bytes, int len) {
39 int i;
40
41 printf("%s", header);
42 printf("len=%d {", len);
43 for (i = 0; i < len; i++) {
44 if (i > 0) printf(":");
45 printf("%02X", bytes[i]);
46 }
47 printf("}\n");
48 }
49
50 /*
51 * Throws java.lang.OutOfMemoryError
52 */
53 void throwOutOfMemoryError(JNIEnv *env, const char *msg)
54 {
55 jclass jExClass = (*env)->FindClass(env, "java/lang/OutOfMemoryError");
56 if (jExClass != 0) /* Otherwise an exception has already been thrown */ {
57 (*env)->ThrowNew(env, jExClass, msg);
58 }
59 /* free the local ref */
60 (*env)->DeleteLocalRef(env, jExClass);
61 }
62
63 JNIEXPORT jint JNICALL DEF_JNI_OnLoad(JavaVM *vm, void *reserved) {
64 return JNI_VERSION_1_4;
65 }
66
67 /*
68 * Class: com_oracle_security_ucrypto_UcryptoProvider
69 * Method: loadLibraries
70 * Signature: ()[Z
71 */
72 JNIEXPORT jbooleanArray JNICALL Java_com_oracle_security_ucrypto_UcryptoProvider_loadLibraries
73 (JNIEnv *env, jclass jcls) {
74 jbooleanArray jResult;
75 jboolean *result;
76 jResult = (*env)->NewBooleanArray(env, 2);
77
78 if (jResult != NULL) {
79 result = loadNative();
80 (*env)->SetBooleanArrayRegion(env, jResult, 0, 2, result);
81 free(result);
82 }
83 return jResult;
84 }
85
86 /*
87 * Class: com_oracle_security_ucrypto_UcryptoProvider
88 * Method: getMechList
89 * Signature: ()Ljava/lang/String;
90 */
91 JNIEXPORT jstring JNICALL Java_com_oracle_security_ucrypto_UcryptoProvider_getMechList
92 (JNIEnv *env, jclass jcls) {
93 jstring jResult;
94 char* result;
95 int length;
96
97 jResult = NULL;
98 if (ftab->ucryptoVersion != NULL && ftab->ucryptoGetMechList != NULL) {
99 length = (*ftab->ucryptoGetMechList)(NULL);
100 if (DEBUG) printf("mech list length: %d\n", length);
101 result = malloc(length);
102 if (result == NULL) {
103 throwOutOfMemoryError(env, NULL);
104 return NULL;
105 }
106 length = (*ftab->ucryptoGetMechList)(result);
107 if (DEBUG) printf("mech list: %s\n", result);
108 jResult = (*env)->NewStringUTF(env, result);
109 free(result);
110 } else {
111 // version 0 on Solaris 10
112 result = "CRYPTO_AES_ECB,CRYPTO_AES_CBC,CRYPTO_AES_CFB128,";
113 jResult = (*env)->NewStringUTF(env, result);
114 }
115 return jResult;
116 }
117
118 /*
119 * Utility function for throwing a UcryptoException when rv is not CRYPTO_OK(0)
120 */
121 void throwUCExceptionUsingRV(JNIEnv *env, int rv) {
122 jclass jExClass;
123 jmethodID jConstructor;
124 jthrowable jException;
125
126 if ((*env)->ExceptionCheck(env)) return;
127
128 jExClass = (*env)->FindClass(env, "com/oracle/security/ucrypto/UcryptoException");
129 /* if jExClass is NULL, an exception has already been thrown */
130 if (jExClass != NULL) {
131 jConstructor = (*env)->GetMethodID(env, jExClass, "<init>", "(I)V");
132 if (jConstructor != NULL) {
133 jException = (jthrowable) (*env)->NewObject(env, jExClass, jConstructor, rv);
134 if (jException != NULL) {
135 (*env)->Throw(env, jException);
136 }
137 }
138 }
139 /* free the local ref */
140 (*env)->DeleteLocalRef(env, jExClass);
141 }
142
143 /*
144 * Utility function for duplicating a byte array from jbyteArray
145 * If anything went wrong, no memory will be allocated.
146 * NOTE: caller is responsible for freeing the allocated memory
147 * once this method returned successfully.
148 */
149 jbyte* getBytes(JNIEnv *env, jbyteArray bytes, int offset, int len) {
150 jbyte* result = NULL;
151
152 if (!(*env)->ExceptionCheck(env)) {
153 result = (jbyte*) calloc(len, sizeof(char));
154 if (result == NULL) {
155 throwOutOfMemoryError(env, NULL);
156 return NULL;
157 }
158 (*env)->GetByteArrayRegion(env, bytes, offset, len, result);
159 if ((*env)->ExceptionCheck(env)) {
160 // free allocated memory if error occurred
161 free(result);
162 return NULL;
163 }
164 }
165 return result;
166 }
167
168
169 int
170 CipherInit(crypto_ctx_t *context, int encrypt, ucrypto_mech_t mech,
171 unsigned char *jKey, int jKeyLen, unsigned char *jIv, int jIvLen,
172 int tagLen, unsigned char *jAad, int jAadLen)
173
174 {
175 int rv = 0;
176 void *iv;
177 size_t ivLen;
178
179 if (DEBUG) printf("CipherInit: mech %i, key %i(%i), iv %i(%i) tagLen %i, aad %i(%i)\n",
180 mech, jKey, jKeyLen, jIv, jIvLen, tagLen, jAad, jAadLen);
181 if (mech == CRYPTO_AES_CTR) {
182 ivLen = sizeof(CK_AES_CTR_PARAMS);
183 iv = (CK_AES_CTR_PARAMS*) malloc(ivLen);
184 if (iv == NULL) return -1;
185
186 ((CK_AES_CTR_PARAMS*)iv)->ulCounterBits = 32;
187 memcpy(((CK_AES_CTR_PARAMS*)iv)->cb, jIv, 16);
188 } else if (mech == CRYPTO_AES_GCM) {
189 ivLen = sizeof(CK_AES_GCM_PARAMS);
190 iv = (CK_AES_GCM_PARAMS*) malloc(ivLen);
191 if (iv == NULL) return -1;
192
193 ((CK_AES_GCM_PARAMS*)iv)->pIv = (uchar_t *)jIv;
194 ((CK_AES_GCM_PARAMS*)iv)->ulIvLen = (ulong_t)jIvLen;
195 ((CK_AES_GCM_PARAMS*)iv)->ulIvBits = 96;
196 ((CK_AES_GCM_PARAMS*)iv)->pAAD = (uchar_t *)jAad;
197 ((CK_AES_GCM_PARAMS*)iv)->ulAADLen = (ulong_t)jAadLen;
198 ((CK_AES_GCM_PARAMS*)iv)->ulTagBits = (ulong_t)tagLen;
199 } else {
200 // normal bytes
201 iv = jIv;
202 ivLen = jIvLen;
203 }
204 if (encrypt) {
205 rv = (*ftab->ucryptoEncryptInit)(context, mech, jKey, (size_t)jKeyLen, iv, ivLen);
206 if (rv != 0 && DEBUG) printf("ucryptoEncryptInit: ret = 0x%x\n", rv);
207 } else {
208 rv =(*ftab->ucryptoDecryptInit)(context, mech, jKey, (size_t)jKeyLen, iv, ivLen);
209 if (rv != 0 && DEBUG) printf("ucryptoDecryptInit: ret = 0x%x\n", rv);
210 }
211
212 if (iv != jIv) {
213 if (mech == CRYPTO_AES_CTR) {
214 free((CK_AES_CTR_PARAMS*)iv);
215 } else {
216 free((CK_AES_GCM_PARAMS*)iv);
217 }
218 }
219
220 return rv;
221 }
222
223 int
224 CipherUpdate(crypto_ctx_t *context, int encrypt, unsigned char *bufIn, int inOfs,
225 int inLen, unsigned char *bufOut, int outOfs, int *outLen)
226 {
227 int rv = 0;
228 size_t outLength;
229
230 outLength = (size_t) *outLen;
231 if (DEBUG) {
232 printf("CipherUpdate: Inofs %i, InLen %i, OutOfs %i, OutLen %i\n", inOfs, inLen, outOfs, *outLen);
233 printBytes("BufIn=", (unsigned char*)(bufIn+inOfs), inLen);
234 }
235 if (encrypt) {
236 rv = (*ftab->ucryptoEncryptUpdate)(context, (unsigned char*)(bufIn+inOfs), (size_t)inLen, (unsigned char*)(bufOut+outOfs), &outLength);
237 if (rv != 0) {
238 if (DEBUG) printf("ucryptoEncryptUpdate: ret = 0x%x\n", rv);
239 } else {
240 *outLen = (int)outLength;
241 }
242 } else {
243 rv = (*ftab->ucryptoDecryptUpdate)(context, (unsigned char*)(bufIn+inOfs), (size_t)inLen, (unsigned char*)(bufOut+outOfs), &outLength);
244 if (rv != 0) {
245 if (DEBUG) printf("ucryptoDecryptUpdate: ret = 0x%x\n", rv);
246 } else {
247 if (DEBUG) printBytes("BufOut=", (unsigned char*)(bufOut+outOfs), outLength);
248 *outLen = (int)outLength;
249 }
250 }
251
252 return rv;
253 }
254
255 int
256 CipherFinal(crypto_ctx_t *context, int encrypt, unsigned char *bufOut, int outOfs, int *outLen)
257 {
258 int rv = 0;
259 size_t outLength;
260
261 outLength = (size_t)*outLen;
262
263 if (DEBUG) printf("CipherFinal: OutOfs %i, outLen %i\n", outOfs, *outLen);
264 if (encrypt) {
265 rv = (*ftab->ucryptoEncryptFinal)(context, (unsigned char*)(bufOut+outOfs), &outLength);
266 if (rv != 0) {
267 if (DEBUG) printf("ucryptoDecryptFinal: ret = 0x%x\n", rv);
268 } else {
269 if (DEBUG) printBytes("BufOut=", (unsigned char*)(bufOut+outOfs), outLength);
270 *outLen = (int)outLength;
271 }
272 } else {
273 rv = (*ftab->ucryptoDecryptFinal)(context, (unsigned char*)(bufOut+outOfs), &outLength);
274 if (rv != 0) {
275 if (DEBUG) printf("ucryptoDecryptFinal: ret = 0x%x\n", rv);
276 } else {
277 if (DEBUG) printBytes("BufOut=", (unsigned char*)(bufOut+outOfs), outLength);
278 *outLen = (int)outLength;
279 }
280 }
281 return rv;
282 }
283
284 ////////////////////////////////////////////////////////
285 // SPECIAL ENTRIES FOR JVM JNI-BYPASSING OPTIMIZATION
286 ////////////////////////////////////////////////////////
287 jlong JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeInit(jint mech) {
288 void *pContext = NULL;
289
290 switch (mech) {
291 case com_oracle_security_ucrypto_NativeDigest_MECH_SHA1:
292 pContext = (SHA1_CTX *) malloc(sizeof(SHA1_CTX));
293 if (pContext != NULL) {
294 (*ftab->sha1Init)((SHA1_CTX *)pContext);
295 }
296 break;
297 case com_oracle_security_ucrypto_NativeDigest_MECH_MD5:
298 pContext = (MD5_CTX *) malloc(sizeof(MD5_CTX));
299 if (pContext != NULL) {
300 (*ftab->md5Init)((MD5_CTX *)pContext);
301 }
302 break;
303 case com_oracle_security_ucrypto_NativeDigest_MECH_SHA256:
304 pContext = (SHA2_CTX *) malloc(sizeof(SHA2_CTX));
305 if (pContext != NULL) {
306 (*ftab->sha2Init)(SHA256, (SHA2_CTX *)pContext);
307 }
308 break;
309 case com_oracle_security_ucrypto_NativeDigest_MECH_SHA384:
310 pContext = (SHA2_CTX *) malloc(sizeof(SHA2_CTX));
311 if (pContext != NULL) {
312 (*ftab->sha2Init)(SHA384, (SHA2_CTX *)pContext);
313 }
314 break;
315 case com_oracle_security_ucrypto_NativeDigest_MECH_SHA512:
316 pContext = (SHA2_CTX *) malloc(sizeof(SHA2_CTX));
317 if (pContext != NULL) {
318 (*ftab->sha2Init)(SHA512, (SHA2_CTX *)pContext);
319 }
320 break;
321 default:
322 if (DEBUG) printf("ERROR: Unsupported mech %i\n", mech);
323 }
324 return (jlong) pContext;
325 }
326
327 jint JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeUpdate
328 (jint mech, jlong pContext, int notUsed, unsigned char* in, jint ofs, jint len) {
329 if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {
330 (*ftab->sha1Update)((SHA1_CTX*)pContext, (unsigned char*)(in+ofs), len);
331 } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {
332 (*ftab->md5Update)((MD5_CTX*)pContext, (unsigned char*)(in+ofs), len);
333 } else { // SHA-2 family
334 (*ftab->sha2Update)((SHA2_CTX*)pContext, (unsigned char*)(in+ofs), len);
335 }
336 return 0;
337 }
338
339 // Do digest and free the context immediately
340 jint JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeDigest
341 (jint mech, jlong pContext, int notUsed, unsigned char* out, jint ofs, jint digestLen) {
342
343 if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {
344 (*ftab->sha1Final)((unsigned char*)(out + ofs), (SHA1_CTX *)pContext);
345 free((SHA1_CTX *)pContext);
346 } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {
347 (*ftab->md5Final)((unsigned char*)(out + ofs), (MD5_CTX *)pContext);
348 free((MD5_CTX *)pContext);
349 } else { // SHA-2 family
350 (*ftab->sha2Final)((unsigned char*)(out + ofs), (SHA2_CTX *)pContext);
351 free((SHA2_CTX *)pContext);
352 }
353 return 0;
354 }
355
356 jlong JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeClone
357 (jint mech, jlong pContext) {
358 void *copy = NULL;
359 size_t len = 0;
360
361 if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {
362 len = sizeof(SHA1_CTX);
363 } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {
364 len = sizeof(MD5_CTX);
365 } else { // SHA-2 family
366 len = sizeof(SHA2_CTX);
367 }
368 copy = (void*) malloc(len);
369 if (copy != NULL) {
370 bcopy((void *)pContext, copy, len);
371 }
372 return (jlong) copy;
373 }
374
375 void JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeFree
376 (jint mech, jlong pContext) {
377 if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_SHA1) {
378 free((SHA1_CTX*) pContext);
379 } else if (mech == com_oracle_security_ucrypto_NativeDigest_MECH_MD5) {
380 free((MD5_CTX*) pContext);
381 } else { // SHA-2 family
382 free((SHA2_CTX*) pContext);
383 }
384 }
385
386 // AES
387 jlong JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeInit
388 (jint mech, jboolean encrypt, int keyLen, unsigned char* bufKey,
389 int ivLen, unsigned char* bufIv, jint tagLen, int aadLen, unsigned char* bufAad) {
390 crypto_ctx_t *context = NULL;
391 int rv;
392
393 context = malloc(sizeof(crypto_ctx_t));
394 if (context != NULL) {
395 rv = CipherInit(context, encrypt, (ucrypto_mech_t) mech, bufKey, keyLen,
396 bufIv, ivLen, tagLen, bufAad, aadLen);
397 if (rv) {
398 free(context);
399 return 0L;
400 }
401 }
402 return (jlong)context;
403 }
404
405 /*
406 * Class: com_oracle_security_ucrypto_NativeCipher
407 * Method: nativeUpdate
408 * Signature: (JZ[BII[BI)I
409 */
410 jint JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeUpdate
411 (jlong pContext, jboolean encrypt, int notUsed, jbyte* bufIn, jint inOfs, jint inLen,
412 int outCapacity, jbyte* bufOut, jint outOfs) {
413 crypto_ctx_t *context;
414 int rv = 0;
415 int outLen = outCapacity - outOfs; // recalculate the real out length
416
417 context = (crypto_ctx_t *) pContext;
418 rv = CipherUpdate(context, encrypt, (unsigned char*)bufIn, inOfs, inLen, (unsigned char*)bufOut, outOfs, &outLen);
419 if (rv) {
420 free(context);
421 context = 0;
422 return -rv; // use negative value to indicate error!
423 }
424
425 return outLen;
426 }
427
428 /*
429 * Class: com_oracle_security_ucrypto_NativeCipher
430 * Method: nativeFinal
431 * Signature: (JZ[BI)I
432 */
433 jint JavaCritical_com_oracle_security_ucrypto_NativeCipher_nativeFinal
434 (jlong pContext, jboolean encrypt, int outLen, jbyte* out, jint outOfs) {
435 crypto_ctx_t *context;
436 int rv = 0;
437 unsigned char* bufOut = (unsigned char*) out;
438
439 context = (crypto_ctx_t *) pContext;
440 // Avoid null output buffer to workaround Solaris bug21481818 (fixed in S12)
441 if (bufOut == NULL) {
442 bufOut = (unsigned char*)(&outLen);
443 outLen = 0;
444 }
445 rv = CipherFinal(context, encrypt, bufOut, outOfs, &outLen);
446 free(context);
447 if (rv) {
448 return -rv; // use negative value to indicate error!
449 }
450
451 return outLen;
452 }
453
454
455
456 /*
457 * Class: com_oracle_security_ucrypto_NativeDigest
458 * Method: nativeInit
459 * Signature: (I)J
460 */
461 JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeInit
462 (JNIEnv *env, jclass jcls, jint mech) {
463 jlong result = JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeInit(mech);
464 if (result == NULL) {
465 throwOutOfMemoryError(env, NULL);
466 }
467 return result;
468 }
469
470 /*
471 * Class: com_oracle_security_ucrypto_NativeDigest
472 * Method: nativeUpdate
473 * Signature: (IJ[BII)I
474 */
475 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeUpdate
476 (JNIEnv *env, jclass jcls, jint mech, jlong pContext, jbyteArray jIn, jint jOfs, jint jLen) {
477 unsigned char *bufIn;
478
479 bufIn = (unsigned char *) getBytes(env, jIn, jOfs, jLen);
480 if (!(*env)->ExceptionCheck(env)) {
481 JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeUpdate(mech, pContext, jLen, bufIn, 0, jLen);
482 free(bufIn);
483 }
484 return 0;
485 }
486
487 /*
488 * Class: com_oracle_security_ucrypto_NativeDigest
489 * Method: nativeDigest
490 * Signature: (IJ[BII)I
491 */
492 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeDigest
493 (JNIEnv *env, jclass jcls, jint mech, jlong pContext, jbyteArray jOut, jint jOutOfs, jint digestLen) {
494 unsigned char *bufOut;
495
496 bufOut = (unsigned char *) malloc(digestLen);
497 if (bufOut == NULL) {
498 throwOutOfMemoryError(env, NULL);
499 return 0;
500 }
501
502 JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeDigest(mech, pContext, digestLen, bufOut, 0, digestLen);
503
504 (*env)->SetByteArrayRegion(env, jOut, jOutOfs, digestLen, (jbyte *) bufOut);
505 free(bufOut);
506 return 0;
507 }
508
509 /*
510 * Class: com_oracle_security_ucrypto_NativeDigest
511 * Method: nativeClone
512 * Signature: (IJ)J
513 */
514 JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeClone
515 (JNIEnv *env, jclass jcls, jint mech, jlong pContext) {
516 return JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeClone(mech, pContext);
517 }
518
519 /*
520 * Class: com_oracle_security_ucrypto_NativeDigest
521 * Method: nativeFree
522 * Signature: (IJ)V
523 */
524 JNIEXPORT void JNICALL Java_com_oracle_security_ucrypto_NativeDigest_nativeFree
525 (JNIEnv *env, jclass jcls, jint mech, jlong pContext) {
526 JavaCritical_com_oracle_security_ucrypto_NativeDigest_nativeFree(mech, pContext);
527 }
528
529 /*
530 * Class: com_oracle_security_ucrypto_NativeCipher
531 * Method: nativeInit
532 * Signature: (IZ[B[BI[B)J
533 */
534 JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeCipher_nativeInit
535 (JNIEnv *env, jclass jcls, jint mech, jboolean encrypt, jbyteArray jKey,
536 jbyteArray jIv, jint tagLen, jbyteArray jAad) {
537
538 crypto_ctx_t *context;
539 unsigned char *bufKey;
540 unsigned char *bufIv;
541 unsigned char *bufAad;
542 int keyLen, ivLen, aadLen, rv = 0;
543 jlong result = 0L;
544
545 bufKey = bufIv = bufAad = NULL;
546 keyLen = ivLen = aadLen = 0;
547 context = malloc(sizeof(crypto_ctx_t));
548 if (context == NULL) {
549 throwOutOfMemoryError(env, NULL);
550 return 0L;
551 }
552
553 // jKey MUST NOT BE NULL;
554 keyLen = (*env)->GetArrayLength(env, jKey);
555 bufKey = (unsigned char *) (*env)->GetByteArrayElements(env, jKey, NULL);
556 if (bufKey == NULL) {
557 goto cleanup;
558 }
559
560 if (jIv != NULL) {
561 ivLen = (*env)->GetArrayLength(env, jIv);
562 bufIv = (unsigned char *) (*env)->GetByteArrayElements(env, jIv, NULL);
563 if (bufIv == NULL) {
564 goto cleanup;
565 }
566 }
567
568 if (jAad != NULL) {
569 aadLen = (*env)->GetArrayLength(env, jAad);
570 bufAad = (unsigned char *) (*env)->GetByteArrayElements(env, jAad, NULL);
571 if (bufAad == NULL) {
572 goto cleanup;
573 }
574 }
575
576 rv = CipherInit(context, encrypt, mech, bufKey, keyLen, bufIv, ivLen, tagLen, bufAad, aadLen);
577 if (rv != 0) {
578 throwUCExceptionUsingRV(env, rv);
579 } else {
580 result = (jlong) context;
581 }
582
583 cleanup:
584 if ((result == 0L) && (context != NULL)) {
585 free(context);
586 }
587 if (bufKey != NULL) {
588 (*env)->ReleaseByteArrayElements(env, jKey, (jbyte *)bufKey, 0);
589 }
590 if (bufIv != NULL) {
591 (*env)->ReleaseByteArrayElements(env, jIv, (jbyte *)bufIv, 0);
592 }
593 if (bufAad != NULL) {
594 (*env)->ReleaseByteArrayElements(env, jAad, (jbyte *)bufAad, 0);
595 }
596
597 return result;
598 }
599
600 /*
601 * Class: com_oracle_security_ucrypto_NativeCipher
602 * Method: nativeUpdate
603 * Signature: (JZ[BII[BI)I
604 */
605 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeCipher_nativeUpdate
606 (JNIEnv *env, jclass jcls, jlong contextID, jboolean encrypt,
607 jbyteArray jIn, jint inOfs, jint inLen, jbyteArray jOut, jint outOfs) {
608 crypto_ctx_t *context;
609 unsigned char *bufIn;
610 unsigned char *bufOut;
611 int outLen, rv = 0;
612
613 context = (crypto_ctx_t *) contextID;
614 bufIn = (unsigned char *) getBytes(env, jIn, inOfs, inLen);
615 if ((*env)->ExceptionCheck(env)) {
616 return 0;
617 }
618
619 outLen = (*env)->GetArrayLength(env, jOut) - outOfs;
620 bufOut = calloc(outLen, sizeof(char));
621 if (bufOut == NULL) {
622 free(bufIn);
623 throwOutOfMemoryError(env, NULL);
624 return 0;
625 }
626
627 rv = CipherUpdate(context, encrypt, bufIn, 0, inLen, bufOut, 0, &outLen);
628 if (rv) {
629 free(context);
630 free(bufIn);
631 free(bufOut);
632 return -rv;
633 } else {
634 (*env)->SetByteArrayRegion(env, jOut, outOfs, outLen, (jbyte *)bufOut);
635 free(bufIn);
636 free(bufOut);
637 return outLen;
638 }
639 }
640
641 /*
642 * Class: com_oracle_security_ucrypto_NativeCipher
643 * Method: nativeFinal
644 * Signature: (JZ[BI)I
645 */
646 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeCipher_nativeFinal
647 (JNIEnv *env, jclass jCls, jlong contextID, jboolean encrypt,
648 jbyteArray out, jint outOfs) {
649 crypto_ctx_t *context;
650 unsigned char *bufIn;
651 unsigned char *bufOut;
652 int outLen, rv = 0;
653 jint rc;
654
655 context = (crypto_ctx_t *) contextID;
656
657 // out is null when nativeFinal() is called solely for resource clean up
658 if (out == NULL) {
659 // Avoid null output buffer to workaround Solaris bug21481818 (fixed in S12)
660 bufOut = (unsigned char *)(&outLen);
661 outLen = 0;
662 } else {
663 outLen = (*env)->GetArrayLength(env, out) - outOfs;
664 bufOut = calloc(outLen, sizeof(char));
665 if (bufOut == NULL) {
666 throwOutOfMemoryError(env, NULL);
667 return 0;
668 }
669 }
670 rv = CipherFinal(context, encrypt, bufOut, 0, &outLen);
671 if (rv) {
672 rc = -rv;
673 } else {
674 if (outLen > 0) {
675 (*env)->SetByteArrayRegion(env, out, outOfs, outLen, (jbyte *)bufOut);
676 }
677 rc = outLen;
678 }
679 free(context);
680 if (bufOut != (unsigned char *)(&outLen)) {
681 free(bufOut);
682 }
683 return rc;
684 }
685
686 /*
687 * Class: com_oracle_security_ucrypto_NativeKey
688 * Method: nativeFree
689 * Signature: (JI)V
690 */
691 void JavaCritical_com_oracle_security_ucrypto_NativeKey_nativeFree
692 (jlong id, jint numOfComponents) {
693 crypto_object_attribute_t* pKey;
694 int i;
695
696 pKey = (crypto_object_attribute_t*) id;
697 for (i = 0; i < numOfComponents; i++) {
698 free(pKey[i].oa_value);
699 }
700 free(pKey);
701 }
702
703 JNIEXPORT void JNICALL Java_com_oracle_security_ucrypto_NativeKey_nativeFree
704 (JNIEnv *env, jclass jCls, jlong id, jint numOfComponents) {
705 JavaCritical_com_oracle_security_ucrypto_NativeKey_nativeFree(id, numOfComponents);
706 }
707
708 /*
709 * Class: com_oracle_security_ucrypto_NativeKey_RSAPrivate
710 * Method: nativeInit
711 * Signature: ([B[B)J
712 */
713 jlong JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPrivate_nativeInit
714 (int modLen, jbyte* jMod, int privLen, jbyte* jPriv) {
715
716 unsigned char *mod, *priv;
717 crypto_object_attribute_t* pKey = NULL;
718
719 pKey = calloc(2, sizeof(crypto_object_attribute_t));
720 if (pKey == NULL) {
721 return 0L;
722 }
723 mod = priv = NULL;
724 mod = malloc(modLen);
725 priv = malloc(privLen);
726 if (mod == NULL || priv == NULL) {
727 free(pKey);
728 free(mod);
729 free(priv);
730 return 0L;
731 } else {
732 memcpy(mod, jMod, modLen);
733 memcpy(priv, jPriv, privLen);
734 }
735
736 // NOTE: numOfComponents should be 2
737 pKey[0].oa_type = SUN_CKA_MODULUS;
738 pKey[0].oa_value = (char*) mod;
739 pKey[0].oa_value_len = (size_t) modLen;
740 pKey[1].oa_type = SUN_CKA_PRIVATE_EXPONENT;
741 pKey[1].oa_value = (char*) priv;
742 pKey[1].oa_value_len = (size_t) privLen;
743
744 return (jlong) pKey;
745 }
746
747 JNIEXPORT jlong JNICALL
748 Java_com_oracle_security_ucrypto_NativeKey_00024RSAPrivate_nativeInit
749 (JNIEnv *env, jclass jCls, jbyteArray jMod, jbyteArray jPriv) {
750
751 int modLen, privLen;
752 jbyte *bufMod, *bufPriv;
753 crypto_object_attribute_t* pKey = NULL;
754
755 bufMod = bufPriv = NULL;
756
757 modLen = (*env)->GetArrayLength(env, jMod);
758 bufMod = getBytes(env, jMod, 0, modLen);
759 if ((*env)->ExceptionCheck(env)) goto cleanup;
760
761 privLen = (*env)->GetArrayLength(env, jPriv);
762 bufPriv = getBytes(env, jPriv, 0, privLen);
763 if ((*env)->ExceptionCheck(env)) goto cleanup;
764
765 // proceed if no error; otherwise free allocated memory
766 pKey = calloc(2, sizeof(crypto_object_attribute_t));
767 if (pKey == NULL) {
768 throwOutOfMemoryError(env, NULL);
769 goto cleanup;
770 }
771
772 // NOTE: numOfComponents should be 2
773 pKey[0].oa_type = SUN_CKA_MODULUS;
774 pKey[0].oa_value = (char*) bufMod;
775 pKey[0].oa_value_len = (size_t) modLen;
776 pKey[1].oa_type = SUN_CKA_PRIVATE_EXPONENT;
777 pKey[1].oa_value = (char*) bufPriv;
778 pKey[1].oa_value_len = (size_t) privLen;
779 return (jlong) pKey;
780
781 cleanup:
782 free(bufMod);
783 free(bufPriv);
784
785 return 0L;
786 }
787
788 /*
789 * Class: com_oracle_security_ucrypto_NativeKey_RSAPrivateCrt
790 * Method: nativeInit
791 * Signature: ([B[B[B[B[B[B[B[B)J
792 */
793 jlong JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPrivateCrt_nativeInit
794 (int modLen, jbyte* jMod, int pubLen, jbyte* jPub, int privLen, jbyte* jPriv,
795 int pLen, jbyte* jP, int qLen, jbyte* jQ, int expPLen, jbyte* jExpP,
796 int expQLen, jbyte* jExpQ, int crtCoeffLen, jbyte* jCrtCoeff) {
797
798 unsigned char *mod, *pub, *priv, *p, *q, *expP, *expQ, *crtCoeff;
799 crypto_object_attribute_t* pKey = NULL;
800
801 pKey = calloc(8, sizeof(crypto_object_attribute_t));
802 if (pKey == NULL) {
803 return 0L;
804 }
805 mod = pub = priv = p = q = expP = expQ = crtCoeff = NULL;
806 mod = malloc(modLen);
807 pub = malloc(pubLen);
808 priv = malloc(privLen);
809 p = malloc(pLen);
810 q = malloc(qLen);
811 expP = malloc(expPLen);
812 expQ = malloc(expQLen);
813 crtCoeff = malloc(crtCoeffLen);
814 if (mod == NULL || pub == NULL || priv == NULL || p == NULL ||
815 q == NULL || expP == NULL || expQ == NULL || crtCoeff == NULL) {
816 free(pKey);
817 free(mod);
818 free(pub);
819 free(priv);
820 free(p);
821 free(q);
822 free(expP);
823 free(expQ);
824 free(crtCoeff);
825 return 0L;
826 } else {
827 memcpy(mod, jMod, modLen);
828 memcpy(pub, jPub, pubLen);
829 memcpy(priv, jPriv, privLen);
830 memcpy(p, jP, pLen);
831 memcpy(q, jQ, qLen);
832 memcpy(expP, jExpP, expPLen);
833 memcpy(expQ, jExpQ, expQLen);
834 memcpy(crtCoeff, jCrtCoeff, crtCoeffLen);
835 }
836
837 // NOTE: numOfComponents should be 8
838 pKey[0].oa_type = SUN_CKA_MODULUS;
839 pKey[0].oa_value = (char*) mod;
840 pKey[0].oa_value_len = (size_t) modLen;
841 pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
842 pKey[1].oa_value = (char*) pub;
843 pKey[1].oa_value_len = (size_t) pubLen;
844 pKey[2].oa_type = SUN_CKA_PRIVATE_EXPONENT;
845 pKey[2].oa_value = (char*) priv;
846 pKey[2].oa_value_len = (size_t) privLen;
847 pKey[3].oa_type = SUN_CKA_PRIME_1;
848 pKey[3].oa_value = (char*) p;
849 pKey[3].oa_value_len = (size_t) pLen;
850 pKey[4].oa_type = SUN_CKA_PRIME_2;
851 pKey[4].oa_value = (char*) q;
852 pKey[4].oa_value_len = (size_t) qLen;
853 pKey[5].oa_type = SUN_CKA_EXPONENT_1;
854 pKey[5].oa_value = (char*) expP;
855 pKey[5].oa_value_len = (size_t) expPLen;
856 pKey[6].oa_type = SUN_CKA_EXPONENT_2;
857 pKey[6].oa_value = (char*) expQ;
858 pKey[6].oa_value_len = (size_t) expQLen;
859 pKey[7].oa_type = SUN_CKA_COEFFICIENT;
860 pKey[7].oa_value = (char*) crtCoeff;
861 pKey[7].oa_value_len = (size_t) crtCoeffLen;
862
863 return (jlong) pKey;
864 }
865
866
867 JNIEXPORT jlong JNICALL
868 Java_com_oracle_security_ucrypto_NativeKey_00024RSAPrivateCrt_nativeInit
869 (JNIEnv *env, jclass jCls, jbyteArray jMod, jbyteArray jPub, jbyteArray jPriv,
870 jbyteArray jP, jbyteArray jQ, jbyteArray jExpP, jbyteArray jExpQ,
871 jbyteArray jCrtCoeff) {
872
873 int modLen, pubLen, privLen, pLen, qLen, expPLen, expQLen, crtCoeffLen;
874 jbyte *bufMod, *bufPub, *bufPriv, *bufP, *bufQ, *bufExpP, *bufExpQ, *bufCrtCoeff;
875 crypto_object_attribute_t* pKey = NULL;
876
877 bufMod = bufPub = bufPriv = bufP = bufQ = bufExpP = bufExpQ = bufCrtCoeff = NULL;
878
879 modLen = (*env)->GetArrayLength(env, jMod);
880 bufMod = getBytes(env, jMod, 0, modLen);
881 if ((*env)->ExceptionCheck(env)) goto cleanup;
882
883 pubLen = (*env)->GetArrayLength(env, jPub);
884 bufPub = getBytes(env, jPub, 0, pubLen);
885 if ((*env)->ExceptionCheck(env)) goto cleanup;
886
887 privLen = (*env)->GetArrayLength(env, jPriv);
888 bufPriv = getBytes(env, jPriv, 0, privLen);
889 if ((*env)->ExceptionCheck(env)) goto cleanup;
890
891 pLen = (*env)->GetArrayLength(env, jP);
892 bufP = getBytes(env, jP, 0, pLen);
893 if ((*env)->ExceptionCheck(env)) goto cleanup;
894
895 qLen = (*env)->GetArrayLength(env, jQ);
896 bufQ = getBytes(env, jQ, 0, qLen);
897 if ((*env)->ExceptionCheck(env)) goto cleanup;
898
899 expPLen = (*env)->GetArrayLength(env, jExpP);
900 bufExpP = getBytes(env, jExpP, 0, expPLen);
901 if ((*env)->ExceptionCheck(env)) goto cleanup;
902
903 expQLen = (*env)->GetArrayLength(env, jExpQ);
904 bufExpQ = getBytes(env, jExpQ, 0, expQLen);
905 if ((*env)->ExceptionCheck(env)) goto cleanup;
906
907 crtCoeffLen = (*env)->GetArrayLength(env, jCrtCoeff);
908 bufCrtCoeff = getBytes(env, jCrtCoeff, 0, crtCoeffLen);
909 if ((*env)->ExceptionCheck(env)) goto cleanup;
910
911 // proceed if no error; otherwise free allocated memory
912 pKey = calloc(8, sizeof(crypto_object_attribute_t));
913 if (pKey == NULL) {
914 throwOutOfMemoryError(env, NULL);
915 goto cleanup;
916 }
917
918 // NOTE: numOfComponents should be 8
919 pKey[0].oa_type = SUN_CKA_MODULUS;
920 pKey[0].oa_value = (char*) bufMod;
921 pKey[0].oa_value_len = (size_t) modLen;
922 pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
923 pKey[1].oa_value = (char*) bufPub;
924 pKey[1].oa_value_len = (size_t) pubLen;
925 pKey[2].oa_type = SUN_CKA_PRIVATE_EXPONENT;
926 pKey[2].oa_value = (char*) bufPriv;
927 pKey[2].oa_value_len = (size_t) privLen;
928 pKey[3].oa_type = SUN_CKA_PRIME_1;
929 pKey[3].oa_value = (char*) bufP;
930 pKey[3].oa_value_len = (size_t) pLen;
931 pKey[4].oa_type = SUN_CKA_PRIME_2;
932 pKey[4].oa_value = (char*) bufQ;
933 pKey[4].oa_value_len = (size_t) qLen;
934 pKey[5].oa_type = SUN_CKA_EXPONENT_1;
935 pKey[5].oa_value = (char*) bufExpP;
936 pKey[5].oa_value_len = (size_t) expPLen;
937 pKey[6].oa_type = SUN_CKA_EXPONENT_2;
938 pKey[6].oa_value = (char*) bufExpQ;
939 pKey[6].oa_value_len = (size_t) expQLen;
940 pKey[7].oa_type = SUN_CKA_COEFFICIENT;
941 pKey[7].oa_value = (char*) bufCrtCoeff;
942 pKey[7].oa_value_len = (size_t) crtCoeffLen;
943 return (jlong) pKey;
944
945 cleanup:
946 free(bufMod);
947 free(bufPub);
948 free(bufPriv);
949 free(bufP);
950 free(bufQ);
951 free(bufExpP);
952 free(bufExpQ);
953 free(bufCrtCoeff);
954
955 return 0L;
956 }
957
958 /*
959 * Class: com_oracle_security_ucrypto_NativeKey_RSAPublic
960 * Method: nativeInit
961 * Signature: ([B[B)J
962 */
963
964 jlong JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPublic_nativeInit
965 (int modLen, jbyte* jMod, int pubLen, jbyte* jPub) {
966 unsigned char *mod, *pub;
967 crypto_object_attribute_t* pKey = NULL;
968
969 pKey = calloc(2, sizeof(crypto_object_attribute_t));
970 if (pKey == NULL) {
971 return 0L;
972 }
973 mod = pub = NULL;
974 mod = malloc(modLen);
975 pub = malloc(pubLen);
976 if (mod == NULL || pub == NULL) {
977 free(pKey);
978 free(mod);
979 free(pub);
980 return 0L;
981 } else {
982 memcpy(mod, jMod, modLen);
983 memcpy(pub, jPub, pubLen);
984 }
985
986 if (DEBUG) {
987 printf("RSAPublicKey Init: keyValue=%ld, keyLen=2\n", pKey);
988 printBytes("RSA PublicKey mod: ", (unsigned char*) mod, modLen);
989 printBytes("RSA PublicKey pubExp: ", (unsigned char*) pub, pubLen);
990 }
991
992 pKey[0].oa_type = SUN_CKA_MODULUS;
993 pKey[0].oa_value = (char*) mod;
994 pKey[0].oa_value_len = (size_t) modLen;
995 pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
996 pKey[1].oa_value = (char*) pub;
997 pKey[1].oa_value_len = (size_t) pubLen;
998
999 return (jlong) pKey;
1000 }
1001
1002 JNIEXPORT jlong JNICALL
1003 Java_com_oracle_security_ucrypto_NativeKey_00024RSAPublic_nativeInit
1004 (JNIEnv *env, jclass jCls, jbyteArray jMod, jbyteArray jPub) {
1005 int modLen, pubLen;
1006 jbyte *bufMod, *bufPub;
1007 crypto_object_attribute_t* pKey = NULL;
1008
1009 bufMod = bufPub = NULL;
1010
1011 modLen = (*env)->GetArrayLength(env, jMod);
1012 bufMod = getBytes(env, jMod, 0, modLen);
1013 if ((*env)->ExceptionCheck(env)) {
1014 return 0L;
1015 }
1016
1017 pubLen = (*env)->GetArrayLength(env, jPub);
1018 bufPub = getBytes(env, jPub, 0, pubLen);
1019 if ((*env)->ExceptionCheck(env)) {
1020 free(bufMod);
1021 return 0L;
1022 }
1023
1024 // proceed if no error; otherwise free allocated memory
1025 pKey = calloc(2, sizeof(crypto_object_attribute_t));
1026 if (pKey != NULL) {
1027 // NOTE: numOfComponents should be 2
1028 pKey[0].oa_type = SUN_CKA_MODULUS;
1029 pKey[0].oa_value = (char*) bufMod;
1030 pKey[0].oa_value_len = (size_t) modLen;
1031 pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
1032 pKey[1].oa_value = (char*) bufPub;
1033 pKey[1].oa_value_len = (size_t) pubLen;
1034 return (jlong) pKey;
1035 } else {
1036 free(bufMod);
1037 free(bufPub);
1038 throwOutOfMemoryError(env, NULL);
1039 return 0L;
1040 }
1041 }
1042
1043 ////////////////////////
1044 // NativeRSASignature
1045 ////////////////////////
1046
1047 int
1048 SignatureInit(crypto_ctx_t *context, jint mechVal, jboolean sign,
1049 uchar_t *pKey, size_t keyLength) {
1050 ucrypto_mech_t mech;
1051 int rv = 0;
1052
1053 mech = (ucrypto_mech_t) mechVal;
1054
1055 if (sign) {
1056 rv = (*ftab->ucryptoSignInit)(context, mech, pKey, keyLength,
1057 NULL, 0);
1058 } else {
1059 rv = (*ftab->ucryptoVerifyInit)(context, mech, pKey, keyLength,
1060 NULL, 0);
1061 }
1062 if (DEBUG) {
1063 printf("SignatureInit: context=%ld, mech=%d, sign=%d, keyValue=%ld, keyLength=%d\n",
1064 context, mech, sign, pKey, keyLength);
1065 printf("SignatureInit, ret => 0x%x\n", rv);
1066 }
1067 return rv;
1068 }
1069
1070 /*
1071 * Class: com_oracle_security_ucrypto_NativeRSASignature
1072 * Method: nativeInit
1073 * Signature: (IZJI[B)J
1074 */
1075 jlong JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeInit
1076 (jint mech, jboolean sign, jlong jKey, jint keyLength) {
1077 crypto_ctx_t *context;
1078 int rv;
1079 uchar_t *pKey;
1080
1081 context = malloc(sizeof(crypto_ctx_t));
1082 if (context != NULL) {
1083 pKey = (uchar_t *) jKey;
1084 rv = SignatureInit(context, mech, sign, pKey, (size_t)keyLength);
1085 if (rv) {
1086 free(context);
1087 return 0L;
1088 }
1089 }
1090 return (jlong)context;
1091 }
1092
1093 JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeInit
1094 (JNIEnv *env, jclass jCls, jint mech, jboolean sign, jlong jKey, jint keyLength) {
1095 crypto_ctx_t *context;
1096 int rv = 0;
1097 uchar_t *pKey;
1098
1099 context = malloc(sizeof(crypto_ctx_t));
1100 if (context == NULL) {
1101 throwOutOfMemoryError(env, NULL);
1102 return 0L;
1103 }
1104
1105 pKey = (uchar_t *) jKey;
1106 rv = SignatureInit(context, mech, sign, pKey, (size_t)keyLength);
1107 if (rv) {
1108 free(context);
1109 throwUCExceptionUsingRV(env, rv);
1110 return 0L;
1111 }
1112
1113 return (jlong)context;
1114 }
1115
1116 /*
1117 * Class: com_oracle_security_ucrypto_NativeRSASignature
1118 * Method: nativeUpdate
1119 * Signature: (JZ[BII)I
1120 */
1121 jint JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1122 (jlong pCtxt, jboolean sign, int notUsed, jbyte* jIn, jint jInOfs, jint jInLen) {
1123 crypto_ctx_t *context;
1124 int rv = 0;
1125
1126 context = (crypto_ctx_t *) pCtxt;
1127 if (DEBUG) {
1128 printf("Signature update: context=%ld, sign=%d, jIn=%ld, jInOfs=%d, jInLen=%d\n",
1129 context, sign, jIn, jInOfs, jInLen);
1130 }
1131 if (sign) {
1132 rv = (*ftab->ucryptoSignUpdate)(context, (uchar_t *) (jIn + jInOfs), (size_t) jInLen);
1133 } else {
1134 rv = (*ftab->ucryptoVerifyUpdate)(context, (uchar_t *) (jIn + jInOfs), (size_t) jInLen);
1135 }
1136 if (DEBUG) printf("Signature update, ret => 0x%x\n", rv);
1137 if (rv) {
1138 free(context);
1139 return -rv; // use negative value to indicate error!
1140 }
1141
1142 return 0;
1143 }
1144
1145 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1146 (JNIEnv *env, jclass jCls, jlong pCtxt, jboolean sign, jbyteArray jIn, jint inOfs, jint inLen) {
1147 int rv = 0;
1148 jbyte* bufIn;
1149
1150 bufIn = getBytes(env, jIn, inOfs, inLen);
1151 if ((*env)->ExceptionCheck(env)) {
1152 return -1; // use negative value to indicate error!
1153 }
1154
1155 if (DEBUG) printBytes("Update w/ data: ", (unsigned char*)bufIn, (size_t) inLen);
1156
1157 rv = JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1158 (pCtxt, sign, inLen, bufIn, 0, inLen);
1159
1160 free(bufIn);
1161 return rv;
1162 }
1163
1164 /*
1165 * Class: com_oracle_security_ucrypto_NativeRSASignature
1166 * Method: nativeUpdate
1167 * Signature: (JZJI)I
1168 */
1169 jint JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI
1170 (jlong pCtxt, jboolean sign, jlong inAddr, jint inLen) {
1171
1172 return JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1173 (pCtxt, sign, inLen, (jbyte*)inAddr, 0, inLen);
1174 }
1175
1176 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI
1177 (JNIEnv *env, jclass jCls, jlong pCtxt, jboolean sign, jlong inAddr, jint inLen) {
1178
1179 return JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1180 (pCtxt, sign, inLen, (jbyte*)inAddr, 0, inLen);
1181 }
1182
1183 /*
1184 * Class: com_oracle_security_ucrypto_NativeRSASignature
1185 * Method: nativeFinal
1186 * Signature: (JZ[BII)I
1187 */
1188 jint JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal
1189 (jlong pCtxt, jboolean sign, int notUsed, jbyte* bufSig, jint sigOfs, jint jSigLen) {
1190
1191 crypto_ctx_t *context;
1192 int rv = 0;
1193 size_t sigLength = (size_t) jSigLen;
1194
1195 context = (crypto_ctx_t *) pCtxt;
1196 if (DEBUG) {
1197 printf("Signature final: context=%ld, sign=%d, bufSig=%ld, sigOfs=%d, sigLen=%d\n",
1198 context, sign, bufSig, sigOfs, jSigLen);
1199 printBytes("Before Final: SigBytes ", (unsigned char*) (bufSig + sigOfs), jSigLen);
1200 }
1201 if (sign) {
1202 rv = (*ftab->ucryptoSignFinal)(context, (uchar_t *) (bufSig + sigOfs), &sigLength);
1203 } else {
1204 rv = (*ftab->ucryptoVerifyFinal)(context, (uchar_t *) (bufSig + sigOfs), &sigLength);
1205 }
1206
1207 if (DEBUG) {
1208 printf("Signature nativeFinal, ret => 0x%x\n", rv);
1209 if (sigLength != jSigLen) {
1210 printf("SIG actual output len=%d\n", sigLength);
1211 }
1212 if (sign) {
1213 printBytes("After nativeFinal: ", (unsigned char*) (bufSig + sigOfs), jSigLen);
1214 }
1215 }
1216
1217 free(context);
1218 if (rv) {
1219 return -rv;
1220 } else return 0;
1221 }
1222
1223 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal
1224 (JNIEnv *env, jclass jCls, jlong pCtxt, jboolean sign, jbyteArray jSig, jint jSigOfs, jint jSigLen) {
1225 int rv = 0;
1226 jbyte* bufSig = NULL;
1227
1228 if (jSigLen != 0) {
1229 bufSig = calloc(jSigLen, sizeof(char));
1230 if (bufSig == NULL) {
1231 throwOutOfMemoryError(env, NULL);
1232 return 0;
1233 }
1234 if (!sign) {
1235 // need to copy over the to-be-verified signature bytes
1236 (*env)->GetByteArrayRegion(env, jSig, jSigOfs, jSigLen, (jbyte *)bufSig);
1237 }
1238 }
1239
1240 if (!(*env)->ExceptionCheck(env)) {
1241 // Frees context + converts rv to negative if error occurred
1242 rv = JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal
1243 (pCtxt, sign, jSigLen, bufSig, 0, jSigLen);
1244
1245 if (rv == 0 && sign) {
1246 // need to copy the generated signature bytes to the java bytearray
1247 (*env)->SetByteArrayRegion(env, jSig, jSigOfs, jSigLen, (jbyte *)bufSig);
1248 }
1249 } else {
1250 // set rv to negative to indicate error
1251 rv = -1;
1252 }
1253
1254 free(bufSig);
1255
1256 return rv;
1257 }
1258
1259 /*
1260 * Class: com_oracle_security_ucrypto_NativeRSACipher
1261 * Method: nativeAtomic
1262 * Signature: (IZJI[BI[BII)I
1263 */
1264 jint JavaCritical_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic
1265 (jint mech, jboolean encrypt, jlong keyValue, jint keyLength,
1266 int notUsed1, jbyte* bufIn, jint jInLen,
1267 int notUsed2, jbyte* bufOut, jint jOutOfs, jint jOutLen) {
1268
1269 uchar_t *pKey;
1270 crypto_object_attribute_t* pKey2;
1271 int rv = 0;
1272 size_t outLength = (size_t) jOutLen;
1273
1274 pKey = (uchar_t *) keyValue;
1275 if (DEBUG) {
1276 printf("Cipher nativeAtomic: mech=%d, encrypt=%d, pKey=%ld, keyLength=%d\n",
1277 mech, encrypt, pKey, keyLength);
1278 printBytes("Before nativeAtomic: in: ", (unsigned char*) bufIn, jInLen);
1279 printBytes("Before nativeAtomic: out: ", (unsigned char*) (bufOut + jOutOfs), jOutLen);
1280 }
1281
1282 if (encrypt) {
1283 rv = (*ftab->ucryptoEncrypt)((ucrypto_mech_t)mech, pKey, (size_t)keyLength,
1284 NULL, 0, (uchar_t *)bufIn, (size_t)jInLen,
1285 (uchar_t *)(bufOut + jOutOfs), &outLength);
1286 } else {
1287 rv = (*ftab->ucryptoDecrypt)((ucrypto_mech_t)mech, pKey, (size_t)keyLength,
1288 NULL, 0, (uchar_t *)bufIn, (size_t)jInLen,
1289 (uchar_t *)(bufOut + jOutOfs), &outLength);
1290 }
1291 if (DEBUG) {
1292 printf("Cipher nativeAtomic, ret => 0x%x\n", rv);
1293 if (outLength != jOutLen) {
1294 printf("CIP actual output len=%d\n", outLength);
1295 }
1296 printBytes("After nativeAtomic: ", (unsigned char*) (bufOut + jOutOfs), outLength);
1297 }
1298
1299 if (rv) {
1300 return -rv;
1301 } else return outLength;
1302 }
1303
1304 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic
1305 (JNIEnv *env, jclass jCls, jint mech, jboolean encrypt,
1306 jlong keyValue, jint keyLength, jbyteArray jIn, jint jInLen,
1307 jbyteArray jOut, jint jOutOfs, jint jOutLen) {
1308 int rv = 0;
1309 jbyte *bufIn = NULL;
1310 jbyte *bufOut = NULL;
1311
1312 if (jInLen != 0) {
1313 bufIn = (*env)->GetByteArrayElements(env, jIn, NULL);
1314 if (bufIn == NULL) {
1315 return 0;
1316 }
1317 }
1318 bufOut = calloc(jOutLen, sizeof(jbyte));
1319 if (bufOut == NULL) {
1320 (*env)->ReleaseByteArrayElements(env, jIn, bufIn, 0);
1321 throwOutOfMemoryError(env, NULL);
1322 return 0;
1323 }
1324
1325 // rv: output length or error code (if negative)
1326 rv = JavaCritical_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic
1327 (mech, encrypt, keyValue, keyLength, jInLen, bufIn, jInLen,
1328 jOutLen, bufOut, 0, jOutLen);
1329
1330 if (rv > 0) {
1331 (*env)->SetByteArrayRegion(env, jOut, jOutOfs, rv, (jbyte *)bufOut);
1332 }
1333
1334 if (bufIn != NULL) {
1335 (*env)->ReleaseByteArrayElements(env, jIn, bufIn, 0);
1336 }
1337 free(bufOut);
1338 return rv;
1339 }