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