rev 14307 : 8155211: Ucrypto Library leaks native memory
Reviewed-by:

   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 
 654   context = (crypto_ctx_t *) contextID;
 655 
 656   // out is null when nativeFinal() is called solely for resource clean up
 657   if (out == NULL) {
 658     // Avoid null output buffer to workaround Solaris bug21481818 (fixed in S12)
 659     bufOut = (unsigned char *)(&outLen);
 660     outLen = 0;
 661   } else {
 662     outLen = (*env)->GetArrayLength(env, out) - outOfs;
 663     bufOut = calloc(outLen, sizeof(char));
 664     if (bufOut == NULL) {
 665       throwOutOfMemoryError(env, NULL);
 666       return 0;
 667     }
 668   }
 669   rv = CipherFinal(context, encrypt, bufOut, 0, &outLen);
 670   if (rv) {
 671     free(context);
 672     if (outLen != 0) {
 673       free(bufOut);
 674     }
 675     return -rv;
 676   } else {
 677     if (bufOut != NULL && outLen != 0) {
 678       (*env)->SetByteArrayRegion(env, out, outOfs, outLen, (jbyte *)bufOut);
 679       free(bufOut);

 680     }
 681     free(context);
 682     return outLen;

 683   }

 684 }
 685 
 686 
 687 /*
 688  * Class:     com_oracle_security_ucrypto_NativeKey
 689  * Method:    nativeFree
 690  * Signature: (JI)V
 691  */
 692 void JavaCritical_com_oracle_security_ucrypto_NativeKey_nativeFree
 693   (jlong id, jint numOfComponents) {
 694   crypto_object_attribute_t* pKey;
 695   int i;
 696 
 697   pKey = (crypto_object_attribute_t*) id;
 698   for (i = 0; i < numOfComponents; i++) {
 699     free(pKey[i].oa_value);
 700   }
 701   free(pKey);
 702 }
 703 
 704 JNIEXPORT void JNICALL Java_com_oracle_security_ucrypto_NativeKey_nativeFree
 705   (JNIEnv *env, jclass jCls, jlong id, jint numOfComponents) {
 706   JavaCritical_com_oracle_security_ucrypto_NativeKey_nativeFree(id, numOfComponents);
 707 }
 708 
 709 /*
 710  * Class:     com_oracle_security_ucrypto_NativeKey_RSAPrivate
 711  * Method:    nativeInit
 712  * Signature: ([B[B)J
 713  */
 714 jlong JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPrivate_nativeInit
 715 (int modLen, jbyte* jMod, int privLen, jbyte* jPriv) {
 716 
 717   unsigned char *mod, *priv;
 718   crypto_object_attribute_t* pKey = NULL;
 719 
 720   pKey = calloc(2, sizeof(crypto_object_attribute_t));
 721   if (pKey == NULL) {
 722     return 0L;
 723   }
 724   mod = priv = NULL;
 725   mod = malloc(modLen);
 726   priv = malloc(privLen);
 727   if (mod == NULL || priv == NULL) {
 728     free(pKey);
 729     free(mod);
 730     free(priv);
 731     return 0L;
 732   } else {
 733     memcpy(mod, jMod, modLen);
 734     memcpy(priv, jPriv, privLen);
 735   }
 736 
 737   // NOTE: numOfComponents should be 2
 738   pKey[0].oa_type = SUN_CKA_MODULUS;
 739   pKey[0].oa_value = (char*) mod;
 740   pKey[0].oa_value_len = (size_t) modLen;
 741   pKey[1].oa_type = SUN_CKA_PRIVATE_EXPONENT;
 742   pKey[1].oa_value = (char*) priv;
 743   pKey[1].oa_value_len = (size_t) privLen;
 744 
 745   return (jlong) pKey;
 746 }
 747 
 748 JNIEXPORT jlong JNICALL
 749 Java_com_oracle_security_ucrypto_NativeKey_00024RSAPrivate_nativeInit
 750   (JNIEnv *env, jclass jCls, jbyteArray jMod, jbyteArray jPriv) {
 751 
 752   int modLen, privLen;
 753   jbyte *bufMod, *bufPriv;
 754   crypto_object_attribute_t* pKey = NULL;
 755 
 756   bufMod = bufPriv = NULL;
 757 
 758   modLen = (*env)->GetArrayLength(env, jMod);
 759   bufMod = getBytes(env, jMod, 0, modLen);
 760   if ((*env)->ExceptionCheck(env)) goto cleanup;
 761 
 762   privLen = (*env)->GetArrayLength(env, jPriv);
 763   bufPriv = getBytes(env, jPriv, 0, privLen);
 764   if ((*env)->ExceptionCheck(env)) goto cleanup;
 765 
 766   // proceed if no error; otherwise free allocated memory
 767   pKey = calloc(2, sizeof(crypto_object_attribute_t));
 768   if (pKey == NULL) {
 769     throwOutOfMemoryError(env, NULL);
 770     goto cleanup;
 771   }
 772 
 773   // NOTE: numOfComponents should be 2
 774   pKey[0].oa_type = SUN_CKA_MODULUS;
 775   pKey[0].oa_value = (char*) bufMod;
 776   pKey[0].oa_value_len = (size_t) modLen;
 777   pKey[1].oa_type = SUN_CKA_PRIVATE_EXPONENT;
 778   pKey[1].oa_value = (char*) bufPriv;
 779   pKey[1].oa_value_len = (size_t) privLen;
 780   return (jlong) pKey;
 781 
 782 cleanup:
 783   free(bufMod);
 784   free(bufPriv);
 785 
 786   return 0L;
 787 }
 788 
 789 /*
 790  * Class:     com_oracle_security_ucrypto_NativeKey_RSAPrivateCrt
 791  * Method:    nativeInit
 792  * Signature: ([B[B[B[B[B[B[B[B)J
 793  */
 794 jlong JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPrivateCrt_nativeInit
 795 (int modLen, jbyte* jMod, int pubLen, jbyte* jPub, int privLen, jbyte* jPriv,
 796  int pLen, jbyte* jP, int qLen, jbyte* jQ, int expPLen, jbyte* jExpP,
 797  int expQLen, jbyte* jExpQ, int crtCoeffLen, jbyte* jCrtCoeff) {
 798 
 799   unsigned char *mod, *pub, *priv, *p, *q, *expP, *expQ, *crtCoeff;
 800   crypto_object_attribute_t* pKey = NULL;
 801 
 802   pKey = calloc(8, sizeof(crypto_object_attribute_t));
 803   if (pKey == NULL) {
 804     return 0L;
 805   }
 806   mod = pub = priv = p = q = expP = expQ = crtCoeff = NULL;
 807   mod = malloc(modLen);
 808   pub = malloc(pubLen);
 809   priv = malloc(privLen);
 810   p = malloc(pLen);
 811   q = malloc(qLen);
 812   expP = malloc(expPLen);
 813   expQ = malloc(expQLen);
 814   crtCoeff = malloc(crtCoeffLen);
 815   if (mod == NULL || pub == NULL || priv == NULL || p == NULL ||
 816       q == NULL || expP == NULL || expQ == NULL || crtCoeff == NULL) {
 817     free(pKey);
 818     free(mod);
 819     free(pub);
 820     free(priv);
 821     free(p);
 822     free(q);
 823     free(expP);
 824     free(expQ);
 825     free(crtCoeff);
 826     return 0L;
 827   } else {
 828     memcpy(mod, jMod, modLen);
 829     memcpy(pub, jPub, pubLen);
 830     memcpy(priv, jPriv, privLen);
 831     memcpy(p, jP, pLen);
 832     memcpy(q, jQ, qLen);
 833     memcpy(expP, jExpP, expPLen);
 834     memcpy(expQ, jExpQ, expQLen);
 835     memcpy(crtCoeff, jCrtCoeff, crtCoeffLen);
 836   }
 837 
 838   // NOTE: numOfComponents should be 8
 839   pKey[0].oa_type = SUN_CKA_MODULUS;
 840   pKey[0].oa_value = (char*) mod;
 841   pKey[0].oa_value_len = (size_t) modLen;
 842   pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
 843   pKey[1].oa_value = (char*) pub;
 844   pKey[1].oa_value_len = (size_t) pubLen;
 845   pKey[2].oa_type = SUN_CKA_PRIVATE_EXPONENT;
 846   pKey[2].oa_value = (char*) priv;
 847   pKey[2].oa_value_len = (size_t) privLen;
 848   pKey[3].oa_type = SUN_CKA_PRIME_1;
 849   pKey[3].oa_value = (char*) p;
 850   pKey[3].oa_value_len = (size_t) pLen;
 851   pKey[4].oa_type = SUN_CKA_PRIME_2;
 852   pKey[4].oa_value = (char*) q;
 853   pKey[4].oa_value_len = (size_t) qLen;
 854   pKey[5].oa_type = SUN_CKA_EXPONENT_1;
 855   pKey[5].oa_value = (char*) expP;
 856   pKey[5].oa_value_len = (size_t) expPLen;
 857   pKey[6].oa_type = SUN_CKA_EXPONENT_2;
 858   pKey[6].oa_value = (char*) expQ;
 859   pKey[6].oa_value_len = (size_t) expQLen;
 860   pKey[7].oa_type = SUN_CKA_COEFFICIENT;
 861   pKey[7].oa_value = (char*) crtCoeff;
 862   pKey[7].oa_value_len = (size_t) crtCoeffLen;
 863 
 864   return (jlong) pKey;
 865 }
 866 
 867 
 868 JNIEXPORT jlong JNICALL
 869 Java_com_oracle_security_ucrypto_NativeKey_00024RSAPrivateCrt_nativeInit
 870   (JNIEnv *env, jclass jCls, jbyteArray jMod, jbyteArray jPub, jbyteArray jPriv,
 871    jbyteArray jP, jbyteArray jQ, jbyteArray jExpP, jbyteArray jExpQ,
 872    jbyteArray jCrtCoeff) {
 873 
 874   int modLen, pubLen, privLen, pLen, qLen, expPLen, expQLen, crtCoeffLen;
 875   jbyte *bufMod, *bufPub, *bufPriv, *bufP, *bufQ, *bufExpP, *bufExpQ, *bufCrtCoeff;
 876   crypto_object_attribute_t* pKey = NULL;
 877 
 878   bufMod = bufPub = bufPriv = bufP = bufQ = bufExpP = bufExpQ = bufCrtCoeff = NULL;
 879 
 880   modLen = (*env)->GetArrayLength(env, jMod);
 881   bufMod = getBytes(env, jMod, 0, modLen);
 882   if ((*env)->ExceptionCheck(env)) goto cleanup;
 883 
 884   pubLen = (*env)->GetArrayLength(env, jPub);
 885   bufPub = getBytes(env, jPub, 0, pubLen);
 886   if ((*env)->ExceptionCheck(env)) goto cleanup;
 887 
 888   privLen = (*env)->GetArrayLength(env, jPriv);
 889   bufPriv = getBytes(env, jPriv, 0, privLen);
 890   if ((*env)->ExceptionCheck(env)) goto cleanup;
 891 
 892   pLen = (*env)->GetArrayLength(env, jP);
 893   bufP = getBytes(env, jP, 0, pLen);
 894   if ((*env)->ExceptionCheck(env)) goto cleanup;
 895 
 896   qLen = (*env)->GetArrayLength(env, jQ);
 897   bufQ = getBytes(env, jQ, 0, qLen);
 898   if ((*env)->ExceptionCheck(env)) goto cleanup;
 899 
 900   expPLen = (*env)->GetArrayLength(env, jExpP);
 901   bufExpP = getBytes(env, jExpP, 0, expPLen);
 902   if ((*env)->ExceptionCheck(env)) goto cleanup;
 903 
 904   expQLen = (*env)->GetArrayLength(env, jExpQ);
 905   bufExpQ = getBytes(env, jExpQ, 0, expQLen);
 906   if ((*env)->ExceptionCheck(env)) goto cleanup;
 907 
 908   crtCoeffLen = (*env)->GetArrayLength(env, jCrtCoeff);
 909   bufCrtCoeff = getBytes(env, jCrtCoeff, 0, crtCoeffLen);
 910   if ((*env)->ExceptionCheck(env)) goto cleanup;
 911 
 912   // proceed if no error; otherwise free allocated memory
 913   pKey = calloc(8, sizeof(crypto_object_attribute_t));
 914   if (pKey == NULL) {
 915     throwOutOfMemoryError(env, NULL);
 916     goto cleanup;
 917   }
 918 
 919   // NOTE: numOfComponents should be 8
 920   pKey[0].oa_type = SUN_CKA_MODULUS;
 921   pKey[0].oa_value = (char*) bufMod;
 922   pKey[0].oa_value_len = (size_t) modLen;
 923   pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
 924   pKey[1].oa_value = (char*) bufPub;
 925   pKey[1].oa_value_len = (size_t) pubLen;
 926   pKey[2].oa_type = SUN_CKA_PRIVATE_EXPONENT;
 927   pKey[2].oa_value = (char*) bufPriv;
 928   pKey[2].oa_value_len = (size_t) privLen;
 929   pKey[3].oa_type = SUN_CKA_PRIME_1;
 930   pKey[3].oa_value = (char*) bufP;
 931   pKey[3].oa_value_len = (size_t) pLen;
 932   pKey[4].oa_type = SUN_CKA_PRIME_2;
 933   pKey[4].oa_value = (char*) bufQ;
 934   pKey[4].oa_value_len = (size_t) qLen;
 935   pKey[5].oa_type = SUN_CKA_EXPONENT_1;
 936   pKey[5].oa_value = (char*) bufExpP;
 937   pKey[5].oa_value_len = (size_t) expPLen;
 938   pKey[6].oa_type = SUN_CKA_EXPONENT_2;
 939   pKey[6].oa_value = (char*) bufExpQ;
 940   pKey[6].oa_value_len = (size_t) expQLen;
 941   pKey[7].oa_type = SUN_CKA_COEFFICIENT;
 942   pKey[7].oa_value = (char*) bufCrtCoeff;
 943   pKey[7].oa_value_len = (size_t) crtCoeffLen;
 944   return (jlong) pKey;
 945 
 946 cleanup:
 947   free(bufMod);
 948   free(bufPub);
 949   free(bufPriv);
 950   free(bufP);
 951   free(bufQ);
 952   free(bufExpP);
 953   free(bufExpQ);
 954   free(bufCrtCoeff);
 955 
 956   return 0L;
 957 }
 958 
 959 /*
 960  * Class:     com_oracle_security_ucrypto_NativeKey_RSAPublic
 961  * Method:    nativeInit
 962  * Signature: ([B[B)J
 963  */
 964 
 965 jlong JavaCritical_com_oracle_security_ucrypto_NativeKey_00024RSAPublic_nativeInit
 966 (int modLen, jbyte* jMod, int pubLen, jbyte* jPub) {
 967   unsigned char *mod, *pub;
 968   crypto_object_attribute_t* pKey = NULL;
 969 
 970   pKey = calloc(2, sizeof(crypto_object_attribute_t));
 971   if (pKey == NULL) {
 972     return 0L;
 973   }
 974   mod = pub = NULL;
 975   mod = malloc(modLen);
 976   pub = malloc(pubLen);
 977   if (mod == NULL || pub == NULL) {
 978     free(pKey);
 979     free(mod);
 980     free(pub);
 981     return 0L;
 982   } else {
 983     memcpy(mod, jMod, modLen);
 984     memcpy(pub, jPub, pubLen);
 985   }
 986 
 987   if (DEBUG) {
 988     printf("RSAPublicKey Init: keyValue=%ld, keyLen=2\n", pKey);
 989     printBytes("RSA PublicKey mod: ", (unsigned char*) mod, modLen);
 990     printBytes("RSA PublicKey pubExp: ", (unsigned char*) pub, pubLen);
 991   }
 992 
 993   pKey[0].oa_type = SUN_CKA_MODULUS;
 994   pKey[0].oa_value = (char*) mod;
 995   pKey[0].oa_value_len = (size_t) modLen;
 996   pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
 997   pKey[1].oa_value = (char*) pub;
 998   pKey[1].oa_value_len = (size_t) pubLen;
 999 
1000   return (jlong) pKey;
1001 }
1002 
1003 JNIEXPORT jlong JNICALL
1004 Java_com_oracle_security_ucrypto_NativeKey_00024RSAPublic_nativeInit
1005 (JNIEnv *env, jclass jCls, jbyteArray jMod, jbyteArray jPub) {
1006   int modLen, pubLen;
1007   jbyte *bufMod, *bufPub;
1008   crypto_object_attribute_t* pKey = NULL;
1009 
1010   bufMod = bufPub = NULL;
1011 
1012   modLen = (*env)->GetArrayLength(env, jMod);
1013   bufMod = getBytes(env, jMod, 0, modLen);
1014   if ((*env)->ExceptionCheck(env)) {
1015     return 0L;
1016   }
1017 
1018   pubLen = (*env)->GetArrayLength(env, jPub);
1019   bufPub = getBytes(env, jPub, 0, pubLen);
1020   if ((*env)->ExceptionCheck(env)) {
1021     free(bufMod);
1022     return 0L;
1023   }
1024 
1025   // proceed if no error; otherwise free allocated memory
1026   pKey = calloc(2, sizeof(crypto_object_attribute_t));
1027   if (pKey != NULL) {
1028     // NOTE: numOfComponents should be 2
1029     pKey[0].oa_type = SUN_CKA_MODULUS;
1030     pKey[0].oa_value = (char*) bufMod;
1031     pKey[0].oa_value_len = (size_t) modLen;
1032     pKey[1].oa_type = SUN_CKA_PUBLIC_EXPONENT;
1033     pKey[1].oa_value = (char*) bufPub;
1034     pKey[1].oa_value_len = (size_t) pubLen;
1035     return (jlong) pKey;
1036   } else {
1037     free(bufMod);
1038     free(bufPub);
1039     throwOutOfMemoryError(env, NULL);
1040     return 0L;
1041   }
1042 }
1043 
1044 ////////////////////////
1045 // NativeRSASignature
1046 ////////////////////////
1047 
1048 int
1049 SignatureInit(crypto_ctx_t *context, jint mechVal, jboolean sign,
1050               uchar_t *pKey, size_t keyLength) {
1051   ucrypto_mech_t mech;
1052   int rv = 0;
1053 
1054   mech = (ucrypto_mech_t) mechVal;
1055 
1056   if (sign) {
1057     rv = (*ftab->ucryptoSignInit)(context, mech, pKey, keyLength,
1058                                   NULL, 0);
1059   } else {
1060     rv = (*ftab->ucryptoVerifyInit)(context, mech, pKey, keyLength,
1061                                     NULL, 0);
1062   }
1063   if (DEBUG) {
1064     printf("SignatureInit: context=%ld, mech=%d, sign=%d, keyValue=%ld, keyLength=%d\n",
1065            context, mech, sign, pKey, keyLength);
1066     printf("SignatureInit, ret =>  0x%x\n", rv);
1067   }
1068   return rv;
1069 }
1070 
1071 /*
1072  * Class:     com_oracle_security_ucrypto_NativeRSASignature
1073  * Method:    nativeInit
1074  * Signature: (IZJI[B)J
1075  */
1076 jlong JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeInit
1077 (jint mech, jboolean sign, jlong jKey, jint keyLength) {
1078   crypto_ctx_t *context;
1079   int rv;
1080   uchar_t *pKey;
1081 
1082   context = malloc(sizeof(crypto_ctx_t));
1083   if (context != NULL) {
1084     pKey = (uchar_t *) jKey;
1085     rv = SignatureInit(context, mech, sign, pKey, (size_t)keyLength);
1086     if (rv) {
1087       free(context);
1088       return 0L;
1089     }
1090   }
1091   return (jlong)context;
1092 }
1093 
1094 JNIEXPORT jlong JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeInit
1095 (JNIEnv *env, jclass jCls, jint mech, jboolean sign, jlong jKey, jint keyLength) {
1096   crypto_ctx_t *context;
1097   int rv = 0;
1098   uchar_t *pKey;
1099 
1100   context = malloc(sizeof(crypto_ctx_t));
1101   if (context == NULL) {
1102     throwOutOfMemoryError(env, NULL);
1103     return 0L;
1104   }
1105 
1106   pKey = (uchar_t *) jKey;
1107   rv = SignatureInit(context, mech, sign, pKey, (size_t)keyLength);
1108   if (rv) {
1109     free(context);
1110     throwUCExceptionUsingRV(env, rv);
1111     return 0L;
1112   }
1113 
1114   return (jlong)context;
1115 }
1116 
1117 /*
1118  * Class:     com_oracle_security_ucrypto_NativeRSASignature
1119  * Method:    nativeUpdate
1120  * Signature: (JZ[BII)I
1121  */
1122 jint JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1123 (jlong pCtxt, jboolean sign, int notUsed, jbyte* jIn, jint jInOfs, jint jInLen) {
1124   crypto_ctx_t *context;
1125   int rv = 0;
1126 
1127   context = (crypto_ctx_t *) pCtxt;
1128   if (DEBUG) {
1129     printf("Signature update: context=%ld, sign=%d, jIn=%ld, jInOfs=%d, jInLen=%d\n",
1130            context, sign, jIn, jInOfs, jInLen);
1131   }
1132   if (sign) {
1133     rv = (*ftab->ucryptoSignUpdate)(context, (uchar_t *) (jIn + jInOfs), (size_t) jInLen);
1134   } else {
1135     rv = (*ftab->ucryptoVerifyUpdate)(context, (uchar_t *) (jIn + jInOfs), (size_t) jInLen);
1136   }
1137   if (DEBUG) printf("Signature update, ret =>  0x%x\n", rv);
1138   if (rv) {
1139     free(context);
1140     return -rv; // use negative value to indicate error!
1141   }
1142 
1143   return 0;
1144 }
1145 
1146 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1147 (JNIEnv *env, jclass jCls, jlong pCtxt, jboolean sign, jbyteArray jIn, jint inOfs, jint inLen) {
1148   int rv = 0;
1149   jbyte* bufIn;
1150 
1151   bufIn = getBytes(env, jIn, inOfs, inLen);
1152   if ((*env)->ExceptionCheck(env)) {
1153     return -1; // use negative value to indicate error!
1154   }
1155 
1156   if (DEBUG) printBytes("Update w/ data: ", (unsigned char*)bufIn, (size_t) inLen);
1157 
1158   rv = JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1159     (pCtxt, sign, inLen, bufIn, 0, inLen);
1160 
1161   free(bufIn);
1162   return rv;
1163 }
1164 
1165 /*
1166  * Class:     com_oracle_security_ucrypto_NativeRSASignature
1167  * Method:    nativeUpdate
1168  * Signature: (JZJI)I
1169  */
1170 jint JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI
1171 (jlong pCtxt, jboolean sign, jlong inAddr, jint inLen) {
1172 
1173   return JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1174     (pCtxt, sign, inLen, (jbyte*)inAddr, 0, inLen);
1175 }
1176 
1177 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZJI
1178 (JNIEnv *env, jclass jCls, jlong pCtxt, jboolean sign, jlong inAddr, jint inLen) {
1179 
1180   return JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeUpdate__JZ_3BII
1181     (pCtxt, sign, inLen, (jbyte*)inAddr, 0, inLen);
1182 }
1183 
1184 /*
1185  * Class:     com_oracle_security_ucrypto_NativeRSASignature
1186  * Method:    nativeFinal
1187  * Signature: (JZ[BII)I
1188  */
1189 jint JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal
1190 (jlong pCtxt, jboolean sign, int notUsed, jbyte* bufSig, jint sigOfs, jint jSigLen) {
1191 
1192   crypto_ctx_t *context;
1193   int rv = 0;
1194   size_t sigLength = (size_t) jSigLen;
1195 
1196   context = (crypto_ctx_t *) pCtxt;
1197   if (DEBUG) {
1198       printf("Signature final: context=%ld, sign=%d, bufSig=%ld, sigOfs=%d, sigLen=%d\n",
1199              context, sign, bufSig, sigOfs, jSigLen);
1200       printBytes("Before Final: SigBytes ", (unsigned char*) (bufSig + sigOfs), jSigLen);
1201   }
1202   if (sign) {
1203     rv = (*ftab->ucryptoSignFinal)(context, (uchar_t *) (bufSig + sigOfs), &sigLength);
1204   } else {
1205     rv = (*ftab->ucryptoVerifyFinal)(context, (uchar_t *) (bufSig + sigOfs), &sigLength);
1206   }
1207 
1208   if (DEBUG) {
1209     printf("Signature nativeFinal, ret =>  0x%x\n", rv);
1210     if (sigLength != jSigLen) {
1211       printf("SIG actual output len=%d\n", sigLength);
1212     }
1213     if (sign) {
1214       printBytes("After nativeFinal: ", (unsigned char*) (bufSig + sigOfs), jSigLen);
1215     }
1216   }
1217 
1218   free(context);
1219   if (rv) {
1220     return -rv;
1221   } else return 0;
1222 }
1223 
1224 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal
1225 (JNIEnv *env, jclass jCls, jlong pCtxt, jboolean sign, jbyteArray jSig, jint jSigOfs, jint jSigLen) {
1226   int rv = 0;
1227   jbyte* bufSig = NULL;
1228 
1229   if (jSigLen != 0) {
1230     bufSig = calloc(jSigLen, sizeof(char));
1231     if (bufSig == NULL) {
1232       throwOutOfMemoryError(env, NULL);
1233       return 0;
1234     }
1235     if (!sign) {
1236       // need to copy over the to-be-verified signature bytes
1237       (*env)->GetByteArrayRegion(env, jSig, jSigOfs, jSigLen, (jbyte *)bufSig);
1238     }
1239   }
1240 
1241   if (!(*env)->ExceptionCheck(env)) {
1242     // Frees context + converts rv to negative if error occurred
1243     rv = JavaCritical_com_oracle_security_ucrypto_NativeRSASignature_nativeFinal
1244       (pCtxt, sign, jSigLen, bufSig, 0, jSigLen);
1245 
1246     if (rv == 0 && sign) {
1247       // need to copy the generated signature bytes to the java bytearray
1248       (*env)->SetByteArrayRegion(env, jSig, jSigOfs, jSigLen, (jbyte *)bufSig);
1249     }
1250   } else {
1251     // set rv to negative to indicate error
1252     rv = -1;
1253   }
1254 
1255   free(bufSig);
1256 
1257   return rv;
1258 }
1259 
1260 /*
1261  * Class:     com_oracle_security_ucrypto_NativeRSACipher
1262  * Method:    nativeAtomic
1263  * Signature: (IZJI[BI[BII)I
1264  */
1265 jint JavaCritical_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic
1266   (jint mech, jboolean encrypt, jlong keyValue, jint keyLength,
1267    int notUsed1, jbyte* bufIn, jint jInLen,
1268    int notUsed2, jbyte* bufOut, jint jOutOfs, jint jOutLen) {
1269 
1270   uchar_t *pKey;
1271   crypto_object_attribute_t* pKey2;
1272   int rv = 0;
1273   size_t outLength = (size_t) jOutLen;
1274 
1275   pKey = (uchar_t *) keyValue;
1276   if (DEBUG) {
1277     printf("Cipher nativeAtomic: mech=%d, encrypt=%d, pKey=%ld, keyLength=%d\n",
1278            mech, encrypt, pKey, keyLength);
1279     printBytes("Before nativeAtomic: in: ", (unsigned char*) bufIn, jInLen);
1280     printBytes("Before nativeAtomic: out: ", (unsigned char*) (bufOut + jOutOfs), jOutLen);
1281   }
1282 
1283   if (encrypt) {
1284     rv = (*ftab->ucryptoEncrypt)((ucrypto_mech_t)mech, pKey, (size_t)keyLength,
1285       NULL, 0, (uchar_t *)bufIn, (size_t)jInLen,
1286       (uchar_t *)(bufOut + jOutOfs), &outLength);
1287   } else {
1288     rv = (*ftab->ucryptoDecrypt)((ucrypto_mech_t)mech, pKey, (size_t)keyLength,
1289       NULL, 0, (uchar_t *)bufIn, (size_t)jInLen,
1290       (uchar_t *)(bufOut + jOutOfs), &outLength);
1291   }
1292   if (DEBUG) {
1293     printf("Cipher nativeAtomic, ret =>  0x%x\n", rv);
1294     if (outLength != jOutLen) {
1295       printf("CIP actual output len=%d\n", outLength);
1296     }
1297     printBytes("After nativeAtomic: ", (unsigned char*) (bufOut + jOutOfs), outLength);
1298   }
1299 
1300   if (rv) {
1301     return -rv;
1302   } else return outLength;
1303 }
1304 
1305 JNIEXPORT jint JNICALL Java_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic
1306   (JNIEnv *env, jclass jCls, jint mech, jboolean encrypt,
1307    jlong keyValue, jint keyLength, jbyteArray jIn, jint jInLen,
1308    jbyteArray jOut, jint jOutOfs, jint jOutLen) {
1309   int rv = 0;
1310   jbyte *bufIn = NULL;
1311   jbyte *bufOut = NULL;
1312 
1313   if (jInLen != 0) {
1314     bufIn = (*env)->GetByteArrayElements(env, jIn, NULL);
1315     if (bufIn == NULL) {
1316       return 0;
1317     }
1318   }
1319   bufOut = calloc(jOutLen, sizeof(jbyte));
1320   if (bufOut == NULL) {
1321     (*env)->ReleaseByteArrayElements(env, jIn, bufIn, 0);
1322     throwOutOfMemoryError(env, NULL);
1323     return 0;
1324   }
1325 
1326   // rv: output length or error code (if negative)
1327   rv = JavaCritical_com_oracle_security_ucrypto_NativeRSACipher_nativeAtomic
1328     (mech, encrypt, keyValue, keyLength, jInLen, bufIn, jInLen,
1329      jOutLen, bufOut, 0, jOutLen);
1330 
1331   if (rv > 0) {
1332     (*env)->SetByteArrayRegion(env, jOut, jOutOfs, rv, (jbyte *)bufOut);
1333   }
1334 
1335   if (bufIn != NULL) {
1336     (*env)->ReleaseByteArrayElements(env, jIn, bufIn, 0);
1337   }
1338   free(bufOut);
1339   return rv;
1340 }
--- EOF ---