/* * loader.c - load platform dependent DSO containing freebl implementation. * * ***** BEGIN LICENSE BLOCK ***** * Version: MPL 1.1/GPL 2.0/LGPL 2.1 * * The contents of this file are subject to the Mozilla Public License Version * 1.1 (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * http://www.mozilla.org/MPL/ * * Software distributed under the License is distributed on an "AS IS" basis, * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License * for the specific language governing rights and limitations under the * License. * * The Original Code is the Netscape security libraries. * * The Initial Developer of the Original Code is * Netscape Communications Corporation. * Portions created by the Initial Developer are Copyright (C) 2000 * the Initial Developer. All Rights Reserved. * * Contributor(s): * Dr Vipul Gupta , Sun Microsystems Laboratories * * Alternatively, the contents of this file may be used under the terms of * either the GNU General Public License Version 2 or later (the "GPL"), or * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), * in which case the provisions of the GPL or the LGPL are applicable instead * of those above. If you wish to allow use of your version of this file only * under the terms of either the GPL or the LGPL, and not to allow others to * use your version of this file under the terms of the MPL, indicate your * decision by deleting the provisions above and replace them with the notice * and other provisions required by the GPL or the LGPL. If you do not delete * the provisions above, a recipient may use your version of this file under * the terms of any one of the MPL, the GPL or the LGPL. * * ***** END LICENSE BLOCK ***** */ /* $Id: loader.c,v 1.35 2007/07/24 14:36:57 slavomir.katuscak%sun.com Exp $ */ #include "loader.h" #include "prmem.h" #include "prerror.h" #include "prinit.h" #include "prenv.h" static const char* default_name = SHLIB_PREFIX"freebl"SHLIB_VERSION"."SHLIB_SUFFIX; /* getLibName() returns the name of the library to load. */ #if defined(SOLARIS) && defined(__sparc) #include #include #include #if defined(NSS_USE_64) const static char fpu_hybrid_shared_lib[] = "libfreebl_64fpu_3.so"; const static char int_hybrid_shared_lib[] = "libfreebl_64int_3.so"; const static char non_hybrid_shared_lib[] = "libfreebl_64fpu_3.so"; const static char int_hybrid_isa[] = "sparcv9"; const static char fpu_hybrid_isa[] = "sparcv9+vis"; #else const static char fpu_hybrid_shared_lib[] = "libfreebl_32fpu_3.so"; const static char int_hybrid_shared_lib[] = "libfreebl_32int64_3.so"; const static char non_hybrid_shared_lib[] = "libfreebl_32int_3.so"; const static char int_hybrid_isa[] = "sparcv8plus"; const static char fpu_hybrid_isa[] = "sparcv8plus+vis"; #endif static const char * getLibName(void) { char * found_int_hybrid; char * found_fpu_hybrid; long buflen; char buf[256]; 8431 -> buflen = sysinfo(SI_ISALIST, buf, sizeof buf); 8431 -> if (buflen <= 0) ##### -> return NULL; /* The ISA list is a space separated string of names of ISAs and * ISA extensions, in order of decreasing performance. * There are two different ISAs with which NSS's crypto code can be * accelerated. If both are in the list, we take the first one. * If one is in the list, we use it, and if neither then we use * the base unaccelerated code. */ 8431 -> found_int_hybrid = strstr(buf, int_hybrid_isa); 8431 -> found_fpu_hybrid = strstr(buf, fpu_hybrid_isa); if (found_fpu_hybrid && (!found_int_hybrid || 8431 -> (found_int_hybrid - found_fpu_hybrid) >= 0)) { 8431 -> return fpu_hybrid_shared_lib; } ##### -> if (found_int_hybrid) { ##### -> return int_hybrid_shared_lib; } ##### -> return non_hybrid_shared_lib; } #elif defined(HPUX) && !defined(NSS_USE_64) && !defined(__ia64) /* This code tests to see if we're running on a PA2.x CPU. ** It returns true (1) if so, and false (0) otherwise. */ static const char * getLibName(void) { long cpu = sysconf(_SC_CPU_VERSION); return (cpu == CPU_PA_RISC2_0) ? "libfreebl_32fpu_3.sl" : "libfreebl_32int32_3.sl" ; } #else /* default case, for platforms/ABIs that have only one freebl shared lib. */ static const char * getLibName(void) { return default_name; } #endif #include "prio.h" #include "prprf.h" #include #include "prsystem.h" static const char *NameOfThisSharedLib = SHLIB_PREFIX"softokn"SOFTOKEN_SHLIB_VERSION"."SHLIB_SUFFIX; static PRLibrary* blLib; #define LSB(x) ((x)&0xff) #define MSB(x) ((x)>>8) static const FREEBLVector *vector; static const char *libraryName = NULL; #include "genload.c" /* This function must be run only once. */ /* determine if hybrid platform, then actually load the DSO. */ static PRStatus freebl_LoadDSO( void ) { PRLibrary * handle; 8431 -> const char * name = getLibName(); 8431 -> if (!name) { ##### -> PR_SetError(PR_LOAD_LIBRARY_ERROR, 0); ##### -> return PR_FAILURE; } 8431 -> handle = loader_LoadLibrary(name); 8431 -> if (handle) { 8431 -> PRFuncPtr address = PR_FindFunctionSymbol(handle, "FREEBL_GetVector"); PRStatus status; 8431 -> if (address) { 8431 -> FREEBLGetVectorFn * getVector = (FREEBLGetVectorFn *)address; 8431 -> const FREEBLVector * dsoVector = getVector(); 8431 -> if (dsoVector) { 8431 -> unsigned short dsoVersion = dsoVector->version; 8431 -> unsigned short myVersion = FREEBL_VERSION; if (MSB(dsoVersion) == MSB(myVersion) && LSB(dsoVersion) >= LSB(myVersion) && 8431 -> dsoVector->length >= sizeof(FREEBLVector)) { 8431 -> vector = dsoVector; 8431 -> libraryName = name; 8431 -> blLib = handle; 8431 -> return PR_SUCCESS; } } } ##### -> status = PR_UnloadLibrary(handle); ##### -> PORT_Assert(PR_SUCCESS == status); } ##### -> return PR_FAILURE; } static const PRCallOnceType pristineCallOnce; static PRCallOnceType loadFreeBLOnce; static PRStatus freebl_RunLoaderOnce( void ) { PRStatus status; 8440 -> status = PR_CallOnce(&loadFreeBLOnce, &freebl_LoadDSO); 8440 -> return status; } RSAPrivateKey * RSA_NewKey(int keySizeInBits, SECItem * publicExponent) { 590 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 590 -> return (vector->p_RSA_NewKey)(keySizeInBits, publicExponent); } SECStatus RSA_PublicKeyOp(RSAPublicKey * key, unsigned char * output, const unsigned char * input) { 17082 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 17082 -> return (vector->p_RSA_PublicKeyOp)(key, output, input); } SECStatus RSA_PrivateKeyOp(RSAPrivateKey * key, unsigned char * output, const unsigned char * input) { 3774 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 3774 -> return (vector->p_RSA_PrivateKeyOp)(key, output, input); } SECStatus RSA_PrivateKeyOpDoubleChecked(RSAPrivateKey *key, unsigned char *output, const unsigned char *input) { 3254 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 3254 -> return (vector->p_RSA_PrivateKeyOpDoubleChecked)(key, output, input); } SECStatus RSA_PrivateKeyCheck(RSAPrivateKey *key) { 50 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 50 -> return (vector->p_RSA_PrivateKeyCheck)(key); } SECStatus DSA_NewKey(const PQGParams * params, DSAPrivateKey ** privKey) { 9 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 9 -> return (vector->p_DSA_NewKey)(params, privKey); } SECStatus DSA_SignDigest(DSAPrivateKey * key, SECItem * signature, const SECItem * digest) { 35 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 35 -> return (vector->p_DSA_SignDigest)( key, signature, digest); } SECStatus DSA_VerifyDigest(DSAPublicKey * key, const SECItem * signature, const SECItem * digest) { 256 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 256 -> return (vector->p_DSA_VerifyDigest)( key, signature, digest); } SECStatus DSA_NewKeyFromSeed(const PQGParams *params, const unsigned char * seed, DSAPrivateKey **privKey) { 155 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 155 -> return (vector->p_DSA_NewKeyFromSeed)(params, seed, privKey); } SECStatus DSA_SignDigestWithSeed(DSAPrivateKey * key, SECItem * signature, const SECItem * digest, const unsigned char * seed) { 219 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 219 -> return (vector->p_DSA_SignDigestWithSeed)( key, signature, digest, seed); } SECStatus DH_GenParam(int primeLen, DHParams ** params) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_DH_GenParam)(primeLen, params); } SECStatus DH_NewKey(DHParams * params, DHPrivateKey ** privKey) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_DH_NewKey)( params, privKey); } SECStatus DH_Derive(SECItem * publicValue, SECItem * prime, SECItem * privateValue, SECItem * derivedSecret, unsigned int maxOutBytes) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_DH_Derive)( publicValue, prime, privateValue, ##### -> derivedSecret, maxOutBytes); } SECStatus KEA_Derive(SECItem *prime, SECItem *public1, SECItem *public2, SECItem *private1, SECItem *private2, SECItem *derivedSecret) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_KEA_Derive)(prime, public1, public2, ##### -> private1, private2, derivedSecret); } PRBool KEA_Verify(SECItem *Y, SECItem *prime, SECItem *subPrime) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return PR_FALSE; ##### -> return (vector->p_KEA_Verify)(Y, prime, subPrime); } RC4Context * RC4_CreateContext(const unsigned char *key, int len) { 49362 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 49362 -> return (vector->p_RC4_CreateContext)(key, len); } void RC4_DestroyContext(RC4Context *cx, PRBool freeit) { 67520 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 67522 -> (vector->p_RC4_DestroyContext)(cx, freeit); } SECStatus RC4_Encrypt(RC4Context *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 98349 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC4_Encrypt)(cx, output, outputLen, maxOutputLen, input, 98349 -> inputLen); } SECStatus RC4_Decrypt(RC4Context *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 85205 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC4_Decrypt)(cx, output, outputLen, maxOutputLen, input, 85205 -> inputLen); } RC2Context * RC2_CreateContext(const unsigned char *key, unsigned int len, const unsigned char *iv, int mode, unsigned effectiveKeyLen) { 929 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 929 -> return (vector->p_RC2_CreateContext)(key, len, iv, mode, effectiveKeyLen); } void RC2_DestroyContext(RC2Context *cx, PRBool freeit) { 945 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 945 -> (vector->p_RC2_DestroyContext)(cx, freeit); } SECStatus RC2_Encrypt(RC2Context *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 518 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC2_Encrypt)(cx, output, outputLen, maxOutputLen, input, 518 -> inputLen); } SECStatus RC2_Decrypt(RC2Context *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 539 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC2_Decrypt)(cx, output, outputLen, maxOutputLen, input, 539 -> inputLen); } RC5Context * RC5_CreateContext(const SECItem *key, unsigned int rounds, unsigned int wordSize, const unsigned char *iv, int mode) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_RC5_CreateContext)(key, rounds, wordSize, iv, mode); } void RC5_DestroyContext(RC5Context *cx, PRBool freeit) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; ##### -> (vector->p_RC5_DestroyContext)(cx, freeit); } SECStatus RC5_Encrypt(RC5Context *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC5_Encrypt)(cx, output, outputLen, maxOutputLen, input, ##### -> inputLen); } SECStatus RC5_Decrypt(RC5Context *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC5_Decrypt)(cx, output, outputLen, maxOutputLen, input, ##### -> inputLen); } DESContext * DES_CreateContext(const unsigned char *key, const unsigned char *iv, int mode, PRBool encrypt) { 223295 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 223295 -> return (vector->p_DES_CreateContext)(key, iv, mode, encrypt); } void DES_DestroyContext(DESContext *cx, PRBool freeit) { 223439 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 223439 -> (vector->p_DES_DestroyContext)(cx, freeit); } SECStatus DES_Encrypt(DESContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 58190 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_DES_Encrypt)(cx, output, outputLen, maxOutputLen, input, 58190 -> inputLen); } SECStatus DES_Decrypt(DESContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 166008 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_DES_Decrypt)(cx, output, outputLen, maxOutputLen, input, 166009 -> inputLen); } AESContext * AES_CreateContext(const unsigned char *key, const unsigned char *iv, int mode, int encrypt, unsigned int keylen, unsigned int blocklen) { 43127 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; return (vector->p_AES_CreateContext)(key, iv, mode, encrypt, keylen, 43118 -> blocklen); } void AES_DestroyContext(AESContext *cx, PRBool freeit) { 63527 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 63528 -> (vector->p_AES_DestroyContext)(cx, freeit); } SECStatus AES_Encrypt(AESContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 77858 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_AES_Encrypt)(cx, output, outputLen, maxOutputLen, 77858 -> input, inputLen); } SECStatus AES_Decrypt(AESContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 77866 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_AES_Decrypt)(cx, output, outputLen, maxOutputLen, 77870 -> input, inputLen); } SECStatus MD5_Hash(unsigned char *dest, const char *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_MD5_Hash)(dest, src); } SECStatus MD5_HashBuf(unsigned char *dest, const unsigned char *src, uint32 src_length) { 1155 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 1155 -> return (vector->p_MD5_HashBuf)(dest, src, src_length); } MD5Context * MD5_NewContext(void) { 295554 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 295283 -> return (vector->p_MD5_NewContext)(); } void MD5_DestroyContext(MD5Context *cx, PRBool freeit) { 332968 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 332972 -> (vector->p_MD5_DestroyContext)(cx, freeit); } void MD5_Begin(MD5Context *cx) { 532607 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 532601 -> (vector->p_MD5_Begin)(cx); } void MD5_Update(MD5Context *cx, const unsigned char *input, unsigned int inputLen) { 2398913 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 2398752 -> (vector->p_MD5_Update)(cx, input, inputLen); } void MD5_End(MD5Context *cx, unsigned char *digest, unsigned int *digestLen, unsigned int maxDigestLen) { 492894 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 492906 -> (vector->p_MD5_End)(cx, digest, digestLen, maxDigestLen); } unsigned int MD5_FlattenSize(MD5Context *cx) { 200426 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return 0; 200426 -> return (vector->p_MD5_FlattenSize)(cx); } SECStatus MD5_Flatten(MD5Context *cx,unsigned char *space) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_MD5_Flatten)(cx, space); } MD5Context * MD5_Resurrect(unsigned char *space, void *arg) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_MD5_Resurrect)(space, arg); } void MD5_TraceState(MD5Context *cx) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; ##### -> (vector->p_MD5_TraceState)(cx); } SECStatus MD2_Hash(unsigned char *dest, const char *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_MD2_Hash)(dest, src); } MD2Context * MD2_NewContext(void) { 235 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 235 -> return (vector->p_MD2_NewContext)(); } void MD2_DestroyContext(MD2Context *cx, PRBool freeit) { 235 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 235 -> (vector->p_MD2_DestroyContext)(cx, freeit); } void MD2_Begin(MD2Context *cx) { 235 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 235 -> (vector->p_MD2_Begin)(cx); } void MD2_Update(MD2Context *cx, const unsigned char *input, unsigned int inputLen) { 235 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 235 -> (vector->p_MD2_Update)(cx, input, inputLen); } void MD2_End(MD2Context *cx, unsigned char *digest, unsigned int *digestLen, unsigned int maxDigestLen) { 235 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 235 -> (vector->p_MD2_End)(cx, digest, digestLen, maxDigestLen); } unsigned int MD2_FlattenSize(MD2Context *cx) { 16 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return 0; 16 -> return (vector->p_MD2_FlattenSize)(cx); } SECStatus MD2_Flatten(MD2Context *cx,unsigned char *space) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_MD2_Flatten)(cx, space); } MD2Context * MD2_Resurrect(unsigned char *space, void *arg) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_MD2_Resurrect)(space, arg); } SECStatus SHA1_Hash(unsigned char *dest, const char *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA1_Hash)(dest, src); } SECStatus SHA1_HashBuf(unsigned char *dest, const unsigned char *src, uint32 src_length) { 108285 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 108285 -> return (vector->p_SHA1_HashBuf)(dest, src, src_length); } SHA1Context * SHA1_NewContext(void) { 388889 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 388886 -> return (vector->p_SHA1_NewContext)(); } void SHA1_DestroyContext(SHA1Context *cx, PRBool freeit) { 426304 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 426303 -> (vector->p_SHA1_DestroyContext)(cx, freeit); } void SHA1_Begin(SHA1Context *cx) { 625033 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 625053 -> (vector->p_SHA1_Begin)(cx); } void SHA1_Update(SHA1Context *cx, const unsigned char *input, unsigned int inputLen) { 2599708 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 2599179 -> (vector->p_SHA1_Update)(cx, input, inputLen); } void SHA1_End(SHA1Context *cx, unsigned char *digest, unsigned int *digestLen, unsigned int maxDigestLen) { 585475 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 585491 -> (vector->p_SHA1_End)(cx, digest, digestLen, maxDigestLen); } void SHA1_TraceState(SHA1Context *cx) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; ##### -> (vector->p_SHA1_TraceState)(cx); } unsigned int SHA1_FlattenSize(SHA1Context *cx) { 286105 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return 0; 286105 -> return (vector->p_SHA1_FlattenSize)(cx); } SECStatus SHA1_Flatten(SHA1Context *cx,unsigned char *space) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA1_Flatten)(cx, space); } SHA1Context * SHA1_Resurrect(unsigned char *space, void *arg) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_SHA1_Resurrect)(space, arg); } SECStatus RNG_RNGInit(void) { 5384 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 5384 -> return (vector->p_RNG_RNGInit)(); } SECStatus RNG_RandomUpdate(const void *data, size_t bytes) { 726 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 726 -> return (vector->p_RNG_RandomUpdate)(data, bytes); } SECStatus RNG_GenerateGlobalRandomBytes(void *dest, size_t len) { 446271 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 446266 -> return (vector->p_RNG_GenerateGlobalRandomBytes)(dest, len); } void RNG_RNGShutdown(void) { 3322 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 3322 -> (vector->p_RNG_RNGShutdown)(); } SECStatus PQG_ParamGen(unsigned int j, PQGParams **pParams, PQGVerify **pVfy) { 8 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 8 -> return (vector->p_PQG_ParamGen)(j, pParams, pVfy); } SECStatus PQG_ParamGenSeedLen( unsigned int j, unsigned int seedBytes, PQGParams **pParams, PQGVerify **pVfy) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_PQG_ParamGenSeedLen)(j, seedBytes, pParams, pVfy); } SECStatus PQG_VerifyParams(const PQGParams *params, const PQGVerify *vfy, SECStatus *result) { 8 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 8 -> return (vector->p_PQG_VerifyParams)(params, vfy, result); } void BL_Cleanup(void) { 3322 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 3322 -> (vector->p_BL_Cleanup)(); } void BL_Unload(void) { /* This function is not thread-safe, but doesn't need to be, because it is * only called from functions that are also defined as not thread-safe, * namely C_Finalize in softoken, and the SSL bypass shutdown callback called * from NSS_Shutdown. */ 3694 -> char *disableUnload = NULL; 3694 -> vector = NULL; /* If an SSL socket is configured with SSL_BYPASS_PKCS11, but the application * never does a handshake on it, BL_Unload will be called even though freebl * was never loaded. So, don't assert blLib. */ 3694 -> if (blLib) { #ifdef DEBUG 3694 -> disableUnload = PR_GetEnv("NSS_DISABLE_UNLOAD"); #endif 3694 -> if (!disableUnload) { 3694 -> PRStatus status = PR_UnloadLibrary(blLib); 3694 -> PORT_Assert(PR_SUCCESS == status); } 3694 -> blLib = NULL; } 3694 -> loadFreeBLOnce = pristineCallOnce; } /* ============== New for 3.003 =============================== */ SECStatus SHA256_Hash(unsigned char *dest, const char *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA256_Hash)(dest, src); } SECStatus SHA256_HashBuf(unsigned char *dest, const unsigned char *src, uint32 src_length) { 438 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 438 -> return (vector->p_SHA256_HashBuf)(dest, src, src_length); } SHA256Context * SHA256_NewContext(void) { 68 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 68 -> return (vector->p_SHA256_NewContext)(); } void SHA256_DestroyContext(SHA256Context *cx, PRBool freeit) { 68 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 68 -> (vector->p_SHA256_DestroyContext)(cx, freeit); } void SHA256_Begin(SHA256Context *cx) { 68 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 68 -> (vector->p_SHA256_Begin)(cx); } void SHA256_Update(SHA256Context *cx, const unsigned char *input, unsigned int inputLen) { 74 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 74 -> (vector->p_SHA256_Update)(cx, input, inputLen); } void SHA256_End(SHA256Context *cx, unsigned char *digest, unsigned int *digestLen, unsigned int maxDigestLen) { 64 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 64 -> (vector->p_SHA256_End)(cx, digest, digestLen, maxDigestLen); } void SHA256_TraceState(SHA256Context *cx) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; ##### -> (vector->p_SHA256_TraceState)(cx); } unsigned int SHA256_FlattenSize(SHA256Context *cx) { 44 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return 0; 44 -> return (vector->p_SHA256_FlattenSize)(cx); } SECStatus SHA256_Flatten(SHA256Context *cx,unsigned char *space) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA256_Flatten)(cx, space); } SHA256Context * SHA256_Resurrect(unsigned char *space, void *arg) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_SHA256_Resurrect)(space, arg); } SECStatus SHA512_Hash(unsigned char *dest, const char *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA512_Hash)(dest, src); } SECStatus SHA512_HashBuf(unsigned char *dest, const unsigned char *src, uint32 src_length) { 438 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 438 -> return (vector->p_SHA512_HashBuf)(dest, src, src_length); } SHA512Context * SHA512_NewContext(void) { 62 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 62 -> return (vector->p_SHA512_NewContext)(); } void SHA512_DestroyContext(SHA512Context *cx, PRBool freeit) { 62 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 62 -> (vector->p_SHA512_DestroyContext)(cx, freeit); } void SHA512_Begin(SHA512Context *cx) { 62 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 62 -> (vector->p_SHA512_Begin)(cx); } void SHA512_Update(SHA512Context *cx, const unsigned char *input, unsigned int inputLen) { 66 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 66 -> (vector->p_SHA512_Update)(cx, input, inputLen); } void SHA512_End(SHA512Context *cx, unsigned char *digest, unsigned int *digestLen, unsigned int maxDigestLen) { 60 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 60 -> (vector->p_SHA512_End)(cx, digest, digestLen, maxDigestLen); } void SHA512_TraceState(SHA512Context *cx) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; ##### -> (vector->p_SHA512_TraceState)(cx); } unsigned int SHA512_FlattenSize(SHA512Context *cx) { 38 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return 0; 38 -> return (vector->p_SHA512_FlattenSize)(cx); } SECStatus SHA512_Flatten(SHA512Context *cx,unsigned char *space) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA512_Flatten)(cx, space); } SHA512Context * SHA512_Resurrect(unsigned char *space, void *arg) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_SHA512_Resurrect)(space, arg); } SECStatus SHA384_Hash(unsigned char *dest, const char *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA384_Hash)(dest, src); } SECStatus SHA384_HashBuf(unsigned char *dest, const unsigned char *src, uint32 src_length) { 438 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 438 -> return (vector->p_SHA384_HashBuf)(dest, src, src_length); } SHA384Context * SHA384_NewContext(void) { 62 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 62 -> return (vector->p_SHA384_NewContext)(); } void SHA384_DestroyContext(SHA384Context *cx, PRBool freeit) { 62 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 62 -> (vector->p_SHA384_DestroyContext)(cx, freeit); } void SHA384_Begin(SHA384Context *cx) { 62 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 62 -> (vector->p_SHA384_Begin)(cx); } void SHA384_Update(SHA384Context *cx, const unsigned char *input, unsigned int inputLen) { 66 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 66 -> (vector->p_SHA384_Update)(cx, input, inputLen); } void SHA384_End(SHA384Context *cx, unsigned char *digest, unsigned int *digestLen, unsigned int maxDigestLen) { 60 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 60 -> (vector->p_SHA384_End)(cx, digest, digestLen, maxDigestLen); } void SHA384_TraceState(SHA384Context *cx) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; ##### -> (vector->p_SHA384_TraceState)(cx); } unsigned int SHA384_FlattenSize(SHA384Context *cx) { 38 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return 0; 38 -> return (vector->p_SHA384_FlattenSize)(cx); } SECStatus SHA384_Flatten(SHA384Context *cx,unsigned char *space) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; ##### -> return (vector->p_SHA384_Flatten)(cx, space); } SHA384Context * SHA384_Resurrect(unsigned char *space, void *arg) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_SHA384_Resurrect)(space, arg); } AESKeyWrapContext * AESKeyWrap_CreateContext(const unsigned char *key, const unsigned char *iv, int encrypt, unsigned int keylen) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return vector->p_AESKeyWrap_CreateContext(key, iv, encrypt, keylen); } void AESKeyWrap_DestroyContext(AESKeyWrapContext *cx, PRBool freeit) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; ##### -> vector->p_AESKeyWrap_DestroyContext(cx, freeit); } SECStatus AESKeyWrap_Encrypt(AESKeyWrapContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return vector->p_AESKeyWrap_Encrypt(cx, output, outputLen, maxOutputLen, ##### -> input, inputLen); } SECStatus AESKeyWrap_Decrypt(AESKeyWrapContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return vector->p_AESKeyWrap_Decrypt(cx, output, outputLen, maxOutputLen, ##### -> input, inputLen); } PRBool BLAPI_SHVerify(const char *name, PRFuncPtr addr) { 155 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return PR_FALSE; 155 -> return vector->p_BLAPI_SHVerify(name, addr); } /* * The Caller is expected to pass NULL as the name, which will * trigger the p_BLAPI_VerifySelf() to return 'TRUE'. If we really loaded * from a shared library, BLAPI_VerifySelf will get pick up the real name * from the static set in freebl_LoadDSO( void ) */ PRBool BLAPI_VerifySelf(const char *name) { 155 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return PR_FALSE; 155 -> return vector->p_BLAPI_VerifySelf(libraryName); } /* ============== New for 3.006 =============================== */ SECStatus EC_NewKey(ECParams * params, ECPrivateKey ** privKey) { 2477 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 2477 -> return (vector->p_EC_NewKey)( params, privKey ); } SECStatus EC_NewKeyFromSeed(ECParams * params, ECPrivateKey ** privKey, const unsigned char *seed, int seedlen) { 310 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 310 -> return (vector->p_EC_NewKeyFromSeed)( params, privKey, seed, seedlen ); } SECStatus EC_ValidatePublicKey(ECParams * params, SECItem * publicValue) { 5148 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 5148 -> return (vector->p_EC_ValidatePublicKey)( params, publicValue ); } SECStatus ECDH_Derive(SECItem * publicValue, ECParams * params, SECItem * privateValue, PRBool withCofactor, SECItem * derivedSecret) { 4528 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_ECDH_Derive)( publicValue, params, privateValue, 4528 -> withCofactor, derivedSecret ); } SECStatus ECDSA_SignDigest(ECPrivateKey * key, SECItem * signature, const SECItem * digest) { 3940 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 3940 -> return (vector->p_ECDSA_SignDigest)( key, signature, digest ); } SECStatus ECDSA_VerifyDigest(ECPublicKey * key, const SECItem * signature, const SECItem * digest) { 7638 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 7638 -> return (vector->p_ECDSA_VerifyDigest)( key, signature, digest ); } SECStatus ECDSA_SignDigestWithSeed(ECPrivateKey * key, SECItem * signature, const SECItem * digest, const unsigned char *seed, const int seedlen) { 310 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_ECDSA_SignDigestWithSeed)( key, signature, digest, 310 -> seed, seedlen ); } /* ============== New for 3.008 =============================== */ AESContext * AES_AllocateContext(void) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_AES_AllocateContext)(); } AESKeyWrapContext * AESKeyWrap_AllocateContext(void) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_AESKeyWrap_AllocateContext)(); } DESContext * DES_AllocateContext(void) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_DES_AllocateContext)(); } RC2Context * RC2_AllocateContext(void) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_RC2_AllocateContext)(); } RC4Context * RC4_AllocateContext(void) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_RC4_AllocateContext)(); } SECStatus AES_InitContext(AESContext *cx, const unsigned char *key, unsigned int keylen, const unsigned char *iv, int mode, unsigned int encrypt, unsigned int blocklen) { 20398 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_AES_InitContext)(cx, key, keylen, iv, mode, encrypt, 20399 -> blocklen); } SECStatus AESKeyWrap_InitContext(AESKeyWrapContext *cx, const unsigned char *key, unsigned int keylen, const unsigned char *iv, int mode, unsigned int encrypt, unsigned int blocklen) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_AESKeyWrap_InitContext)(cx, key, keylen, iv, mode, ##### -> encrypt, blocklen); } SECStatus DES_InitContext(DESContext *cx, const unsigned char *key, unsigned int keylen, const unsigned char *iv, int mode, unsigned int encrypt, unsigned int xtra) { 144 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 144 -> return (vector->p_DES_InitContext)(cx, key, keylen, iv, mode, encrypt, xtra); } SECStatus RC2_InitContext(RC2Context *cx, const unsigned char *key, unsigned int keylen, const unsigned char *iv, int mode, unsigned int effectiveKeyLen, unsigned int xtra) { 16 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_RC2_InitContext)(cx, key, keylen, iv, mode, 16 -> effectiveKeyLen, xtra); } SECStatus RC4_InitContext(RC4Context *cx, const unsigned char *key, unsigned int keylen, const unsigned char *x1, int x2, unsigned int x3, unsigned int x4) { 18159 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 18159 -> return (vector->p_RC4_InitContext)(cx, key, keylen, x1, x2, x3, x4); } void MD2_Clone(MD2Context *dest, MD2Context *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; ##### -> (vector->p_MD2_Clone)(dest, src); } void MD5_Clone(MD5Context *dest, MD5Context *src) { 39784 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 39784 -> (vector->p_MD5_Clone)(dest, src); } void SHA1_Clone(SHA1Context *dest, SHA1Context *src) { 39783 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 39784 -> (vector->p_SHA1_Clone)(dest, src); } void SHA256_Clone(SHA256Context *dest, SHA256Context *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; ##### -> (vector->p_SHA256_Clone)(dest, src); } void SHA384_Clone(SHA384Context *dest, SHA384Context *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; ##### -> (vector->p_SHA384_Clone)(dest, src); } void SHA512_Clone(SHA512Context *dest, SHA512Context *src) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; ##### -> (vector->p_SHA512_Clone)(dest, src); } SECStatus TLS_PRF(const SECItem *secret, const char *label, SECItem *seed, SECItem *result, PRBool isFIPS) { 98158 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 98158 -> return (vector->p_TLS_PRF)(secret, label, seed, result, isFIPS); } const SECHashObject * HASH_GetRawHashObject(HASH_HashType hashType) { 386733 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 386736 -> return (vector->p_HASH_GetRawHashObject)(hashType); } void HMAC_Destroy(HMACContext *cx, PRBool freeit) { 336018 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 336021 -> (vector->p_HMAC_Destroy)(cx, freeit); } HMACContext * HMAC_Create(const SECHashObject *hashObj, const unsigned char *secret, unsigned int secret_len, PRBool isFIPS) { 286311 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 286310 -> return (vector->p_HMAC_Create)(hashObj, secret, secret_len, isFIPS); } SECStatus HMAC_Init(HMACContext *cx, const SECHashObject *hashObj, const unsigned char *secret, unsigned int secret_len, PRBool isFIPS) { 49710 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 49710 -> return (vector->p_HMAC_Init)(cx, hashObj, secret, secret_len, isFIPS); } void HMAC_Begin(HMACContext *cx) { 863992 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 864003 -> (vector->p_HMAC_Begin)(cx); } void HMAC_Update(HMACContext *cx, const unsigned char *data, unsigned int data_len) { 1375098 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return; 1375100 -> (vector->p_HMAC_Update)(cx, data, data_len); } SECStatus HMAC_Finish(HMACContext *cx, unsigned char *result, unsigned int *result_len, unsigned int max_result_len) { 863826 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 863829 -> return (vector->p_HMAC_Finish)(cx, result, result_len, max_result_len); } HMACContext * HMAC_Clone(HMACContext *cx) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_HMAC_Clone)(cx); } void RNG_SystemInfoForRNG(void) { 5384 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 5384 -> (vector->p_RNG_SystemInfoForRNG)(); } SECStatus FIPS186Change_GenerateX(unsigned char *XKEY, const unsigned char *XSEEDj, unsigned char *x_j) { 155 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 155 -> return (vector->p_FIPS186Change_GenerateX)(XKEY, XSEEDj, x_j); } SECStatus FIPS186Change_ReduceModQForDSA(const unsigned char *w, const unsigned char *q, unsigned char *xj) { 155 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; 155 -> return (vector->p_FIPS186Change_ReduceModQForDSA)(w, q, xj); } /* === new for Camellia === */ SECStatus Camellia_InitContext(CamelliaContext *cx, const unsigned char *key, unsigned int keylen, const unsigned char *iv, int mode, unsigned int encrypt, unsigned int unused) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_Camellia_InitContext)(cx, key, keylen, iv, mode, encrypt, ##### -> unused); } CamelliaContext * Camellia_AllocateContext(void) { ##### -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; ##### -> return (vector->p_Camellia_AllocateContext)(); } CamelliaContext * Camellia_CreateContext(const unsigned char *key, const unsigned char *iv, int mode, int encrypt, unsigned int keylen) { 768 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return NULL; 768 -> return (vector->p_Camellia_CreateContext)(key, iv, mode, encrypt, keylen); } void Camellia_DestroyContext(CamelliaContext *cx, PRBool freeit) { 768 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return ; 768 -> (vector->p_Camellia_DestroyContext)(cx, freeit); } SECStatus Camellia_Encrypt(CamelliaContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 384 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_Camellia_Encrypt)(cx, output, outputLen, maxOutputLen, 384 -> input, inputLen); } SECStatus Camellia_Decrypt(CamelliaContext *cx, unsigned char *output, unsigned int *outputLen, unsigned int maxOutputLen, const unsigned char *input, unsigned int inputLen) { 384 -> if (!vector && PR_SUCCESS != freebl_RunLoaderOnce()) ##### -> return SECFailure; return (vector->p_Camellia_Decrypt)(cx, output, outputLen, maxOutputLen, 384 -> input, inputLen); } Top 10 Blocks Line Count 733 2599708 735 2599179 569 2398913 571 2398752 1469 1375100 1467 1375098 1461 864003 1459 863992 1478 863829 1476 863826 504 Basic blocks in this file 241 Basic blocks executed 47.82 Percent of the file executed 31054382 Total basic block executions 61615.84 Average executions per basic block