diff --git a/mcapi/crypto.c b/mcapi/crypto.c
index 11eed51be..32aa43adf 100644
--- a/mcapi/crypto.c
+++ b/mcapi/crypto.c
@@ -37,6 +37,7 @@
 #include <cyassl/ctaocrypt/aes.h>
 #include <cyassl/ctaocrypt/rsa.h>
 #include <cyassl/ctaocrypt/ecc.h>
+#include <cyassl/ctaocrypt/error.h>
 
 
 /* Initialize MD5 */
@@ -45,6 +46,9 @@ int CRYPT_MD5_Initialize(CRYPT_MD5_CTX* md5)
     typedef char md5_test[sizeof(CRYPT_MD5_CTX) >= sizeof(Md5) ? 1 : -1];
     (void)sizeof(md5_test);
 
+    if (md5 == NULL)
+        return BAD_FUNC_ARG;
+
     InitMd5((Md5*)md5);
 
     return 0;
@@ -55,6 +59,9 @@ int CRYPT_MD5_Initialize(CRYPT_MD5_CTX* md5)
 int CRYPT_MD5_DataAdd(CRYPT_MD5_CTX* md5, const unsigned char* input,
                       unsigned int sz)
 {
+    if (md5 == NULL || input == NULL)
+        return BAD_FUNC_ARG;
+
     Md5Update((Md5*)md5, input, sz);
 
     return 0;
@@ -64,6 +71,9 @@ int CRYPT_MD5_DataAdd(CRYPT_MD5_CTX* md5, const unsigned char* input,
 /* Get MD5 Final into digest */
 int CRYPT_MD5_Finalize(CRYPT_MD5_CTX* md5, unsigned char* digest)
 {
+    if (md5 == NULL || digest == NULL)
+        return BAD_FUNC_ARG;
+
     Md5Final((Md5*)md5, digest);
 
     return 0;
@@ -76,6 +86,9 @@ int CRYPT_SHA_Initialize(CRYPT_SHA_CTX* sha)
     typedef char sha_test[sizeof(CRYPT_SHA_CTX) >= sizeof(Sha) ? 1 : -1];
     (void)sizeof(sha_test);
 
+    if (sha == NULL)
+        return BAD_FUNC_ARG;
+
     InitSha((Sha*)sha);
 
     return 0;
@@ -86,6 +99,9 @@ int CRYPT_SHA_Initialize(CRYPT_SHA_CTX* sha)
 int CRYPT_SHA_DataAdd(CRYPT_SHA_CTX* sha, const unsigned char* input,
                        unsigned int sz)
 {
+    if (sha == NULL || input == NULL)
+        return BAD_FUNC_ARG;
+
     ShaUpdate((Sha*)sha, input, sz);
 
     return 0;
@@ -95,6 +111,9 @@ int CRYPT_SHA_DataAdd(CRYPT_SHA_CTX* sha, const unsigned char* input,
 /* Get SHA Final into digest */
 int CRYPT_SHA_Finalize(CRYPT_SHA_CTX* sha, unsigned char* digest)
 {
+    if (sha == NULL || digest == NULL)
+        return BAD_FUNC_ARG;
+
     ShaFinal((Sha*)sha, digest);
 
     return 0;
@@ -107,6 +126,9 @@ int CRYPT_SHA256_Initialize(CRYPT_SHA256_CTX* sha256)
     typedef char sha_test[sizeof(CRYPT_SHA256_CTX) >= sizeof(Sha256) ? 1 : -1];
     (void)sizeof(sha_test);
 
+    if (sha256 == NULL)
+        return BAD_FUNC_ARG;
+
     InitSha256((Sha256*)sha256);
 
     return 0;
@@ -117,6 +139,9 @@ int CRYPT_SHA256_Initialize(CRYPT_SHA256_CTX* sha256)
 int CRYPT_SHA256_DataAdd(CRYPT_SHA256_CTX* sha256, const unsigned char* input,
                          unsigned int sz)
 {
+    if (sha256 == NULL || input == NULL)
+        return BAD_FUNC_ARG;
+
     Sha256Update((Sha256*)sha256, input, sz);
 
     return 0;
@@ -126,6 +151,9 @@ int CRYPT_SHA256_DataAdd(CRYPT_SHA256_CTX* sha256, const unsigned char* input,
 /* Get SHA-256 Final into digest */
 int CRYPT_SHA256_Finalize(CRYPT_SHA256_CTX* sha256, unsigned char* digest)
 {
+    if (sha256 == NULL || digest == NULL)
+        return BAD_FUNC_ARG;
+
     Sha256Final((Sha256*)sha256, digest);
 
     return 0;
@@ -138,6 +166,9 @@ int CRYPT_SHA384_Initialize(CRYPT_SHA384_CTX* sha384)
     typedef char sha_test[sizeof(CRYPT_SHA384_CTX) >= sizeof(Sha384) ? 1 : -1];
     (void)sizeof(sha_test);
 
+    if (sha384 == NULL)
+        return BAD_FUNC_ARG;
+
     InitSha384((Sha384*)sha384);
 
     return 0;
@@ -148,6 +179,9 @@ int CRYPT_SHA384_Initialize(CRYPT_SHA384_CTX* sha384)
 int CRYPT_SHA384_DataAdd(CRYPT_SHA384_CTX* sha384, const unsigned char* input,
                          unsigned int sz)
 {
+    if (sha384 == NULL || input == NULL)
+        return BAD_FUNC_ARG;
+
     Sha384Update((Sha384*)sha384, input, sz);
 
     return 0;
@@ -157,6 +191,9 @@ int CRYPT_SHA384_DataAdd(CRYPT_SHA384_CTX* sha384, const unsigned char* input,
 /* Get SHA-384 Final into digest */
 int CRYPT_SHA384_Finalize(CRYPT_SHA384_CTX* sha384, unsigned char* digest)
 {
+    if (sha384 == NULL || digest == NULL)
+        return BAD_FUNC_ARG;
+
     Sha384Final((Sha384*)sha384, digest);
 
     return 0;
@@ -169,6 +206,9 @@ int CRYPT_SHA512_Initialize(CRYPT_SHA512_CTX* sha512)
     typedef char sha_test[sizeof(CRYPT_SHA512_CTX) >= sizeof(Sha512) ? 1 : -1];
     (void)sizeof(sha_test);
 
+    if (sha512 == NULL)
+        return BAD_FUNC_ARG;
+
     InitSha512((Sha512*)sha512);
 
     return 0;
@@ -179,6 +219,9 @@ int CRYPT_SHA512_Initialize(CRYPT_SHA512_CTX* sha512)
 int CRYPT_SHA512_DataAdd(CRYPT_SHA512_CTX* sha512, const unsigned char* input,
                          unsigned int sz)
 {
+    if (sha512 == NULL || input == NULL)
+        return BAD_FUNC_ARG;
+
     Sha512Update((Sha512*)sha512, input, sz);
 
     return 0;
@@ -188,6 +231,9 @@ int CRYPT_SHA512_DataAdd(CRYPT_SHA512_CTX* sha512, const unsigned char* input,
 /* Get SHA-512 Final into digest */
 int CRYPT_SHA512_Finalize(CRYPT_SHA512_CTX* sha512, unsigned char* digest)
 {
+    if (sha512 == NULL || digest == NULL)
+        return BAD_FUNC_ARG;
+
     Sha512Final((Sha512*)sha512, digest);
 
     return 0;
@@ -201,9 +247,12 @@ int CRYPT_HMAC_SetKey(CRYPT_HMAC_CTX* hmac, int type, const unsigned char* key,
     typedef char hmac_test[sizeof(CRYPT_HMAC_CTX) >= sizeof(Hmac) ? 1 : -1];
     (void)sizeof(hmac_test);
 
+    if (hmac == NULL || key == NULL)
+        return BAD_FUNC_ARG;
+
     if (type != CRYPT_HMAC_SHA && type != CRYPT_HMAC_SHA256 &&
         type != CRYPT_HMAC_SHA384 && type != CRYPT_HMAC_SHA512) {
-        return -1;  /* bad hmac type */
+        return BAD_FUNC_ARG;  /* bad hmac type */
     }
 
     HmacSetKey((Hmac*)hmac, type, key, sz);
@@ -215,6 +264,9 @@ int CRYPT_HMAC_SetKey(CRYPT_HMAC_CTX* hmac, int type, const unsigned char* key,
 int CRYPT_HMAC_DataAdd(CRYPT_HMAC_CTX* hmac, const unsigned char* input,
                        unsigned int sz)
 {
+    if (hmac == NULL || input == NULL)
+        return BAD_FUNC_ARG;
+
     HmacUpdate((Hmac*)hmac, input, sz);
 
     return 0;
@@ -224,6 +276,9 @@ int CRYPT_HMAC_DataAdd(CRYPT_HMAC_CTX* hmac, const unsigned char* input,
 /* Get HMAC Final into digest */
 int CRYPT_HMAC_Finalize(CRYPT_HMAC_CTX* hmac, unsigned char* digest)
 {
+    if (hmac == NULL || digest == NULL)
+        return BAD_FUNC_ARG;
+
     HmacFinal((Hmac*)hmac, digest);
 
     return 0;
@@ -236,6 +291,9 @@ int CRYPT_HUFFMAN_Compress(unsigned char* out, unsigned int outSz,
                            const unsigned char* in, unsigned int inSz,
                            unsigned int flags)
 {
+    if (out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     return Compress(out, outSz, in, inSz, flags);
 }
 
@@ -245,6 +303,9 @@ int CRYPT_HUFFMAN_Compress(unsigned char* out, unsigned int outSz,
 int CRYPT_HUFFMAN_DeCompress(unsigned char* out, unsigned int outSz,
                              const unsigned char* in, unsigned int inSz)
 {
+    if (out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     return DeCompress(out, outSz, in, inSz);
 }
 
@@ -255,6 +316,9 @@ int CRYPT_RNG_Initialize(CRYPT_RNG_CTX* rng)
     typedef char rng_test[sizeof(CRYPT_RNG_CTX) >= sizeof(RNG) ? 1 : -1];
     (void)sizeof(rng_test);
 
+    if (rng == NULL)
+        return BAD_FUNC_ARG;
+
     return InitRng((RNG*)rng);
 }
 
@@ -262,6 +326,9 @@ int CRYPT_RNG_Initialize(CRYPT_RNG_CTX* rng)
 /* RNG Get single bytes, < 0 on error */
 int CRYPT_RNG_Get(CRYPT_RNG_CTX* rng, unsigned char* b)
 {
+    if (rng == NULL || b == NULL)
+        return BAD_FUNC_ARG;
+
     *b = RNG_GenerateByte((RNG*)rng);
 
     return 0;
@@ -272,6 +339,9 @@ int CRYPT_RNG_Get(CRYPT_RNG_CTX* rng, unsigned char* b)
 int CRYPT_RNG_BlockGenerate(CRYPT_RNG_CTX* rng, unsigned char* b,
                             unsigned int sz)
 {
+    if (rng == NULL || b == NULL)
+        return BAD_FUNC_ARG;
+
     RNG_GenerateBlock((RNG*)rng, b, sz);
 
     return 0;
@@ -285,6 +355,9 @@ int CRYPT_TDES_KeySet(CRYPT_TDES_CTX* tdes, const unsigned char* key,
     typedef char tdes_test[sizeof(CRYPT_TDES_CTX) >= sizeof(Des3) ? 1 : -1];
     (void)sizeof(tdes_test);
 
+    if (tdes == NULL || key == NULL)
+        return BAD_FUNC_ARG;
+
     Des3_SetKey((Des3*)tdes, key, iv, dir);
 
     return 0;
@@ -294,6 +367,9 @@ int CRYPT_TDES_KeySet(CRYPT_TDES_CTX* tdes, const unsigned char* key,
 /* Triple DES Iv Set, sometimes added later */
 int CRYPT_TDES_IvSet(CRYPT_TDES_CTX* tdes, const unsigned char* iv)
 {
+    if (tdes == NULL || iv == NULL)
+        return BAD_FUNC_ARG;
+
     Des3_SetIV((Des3*)tdes, iv);
 
     return 0;
@@ -304,6 +380,9 @@ int CRYPT_TDES_IvSet(CRYPT_TDES_CTX* tdes, const unsigned char* iv)
 int CRYPT_TDES_CBC_Encrypt(CRYPT_TDES_CTX* tdes, unsigned char* out,
                            const unsigned char* in, unsigned int inSz)
 {
+    if (tdes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     Des3_CbcEncrypt((Des3*)tdes, out, in, inSz);
 
     return 0;
@@ -314,6 +393,9 @@ int CRYPT_TDES_CBC_Encrypt(CRYPT_TDES_CTX* tdes, unsigned char* out,
 int CRYPT_TDES_CBC_Decrypt(CRYPT_TDES_CTX* tdes, unsigned char* out,
                            const unsigned char* in, unsigned int inSz)
 {
+    if (tdes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     Des3_CbcDecrypt((Des3*)tdes, out, in, inSz);
 
     return 0;
@@ -327,6 +409,9 @@ int CRYPT_AES_KeySet(CRYPT_AES_CTX* aes, const unsigned char* key,
     typedef char aes_test[sizeof(CRYPT_AES_CTX) >= sizeof(Aes) ? 1 : -1];
     (void)sizeof(aes_test);
 
+    if (aes == NULL || key == NULL)
+        return BAD_FUNC_ARG;
+
     return AesSetKey((Aes*)aes, key, keyLen, iv, dir);
 }
 
@@ -334,6 +419,9 @@ int CRYPT_AES_KeySet(CRYPT_AES_CTX* aes, const unsigned char* key,
 /* AES Iv Set, sometimes added later */
 int CRYPT_AES_IvSet(CRYPT_AES_CTX* aes, const unsigned char* iv)
 {
+    if (aes == NULL || iv == NULL)
+        return BAD_FUNC_ARG;
+
     AesSetIV((Aes*)aes, iv);
 
     return 0;
@@ -344,6 +432,9 @@ int CRYPT_AES_IvSet(CRYPT_AES_CTX* aes, const unsigned char* iv)
 int CRYPT_AES_CBC_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
                           const unsigned char* in, unsigned int inSz)
 {
+    if (aes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     AesCbcEncrypt((Aes*)aes, out, in, inSz);
 
     return 0;
@@ -354,6 +445,9 @@ int CRYPT_AES_CBC_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 int CRYPT_AES_CBC_Decrypt(CRYPT_AES_CTX* aes, unsigned char* out,
                           const unsigned char* in, unsigned int inSz)
 {
+    if (aes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     AesCbcDecrypt((Aes*)aes, out, in, inSz);
 
     return 0;
@@ -364,6 +458,9 @@ int CRYPT_AES_CBC_Decrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 int CRYPT_AES_CTR_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
                           const unsigned char* in, unsigned int inSz)
 {
+    if (aes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     AesCtrEncrypt((Aes*)aes, out, in, inSz);
 
     return 0;
@@ -374,6 +471,9 @@ int CRYPT_AES_CTR_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 int CRYPT_AES_DIRECT_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
                              const unsigned char* in)
 {
+    if (aes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     AesEncryptDirect((Aes*)aes, out, in);
 
     return 0;
@@ -384,6 +484,9 @@ int CRYPT_AES_DIRECT_Encrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 int CRYPT_AES_DIRECT_Decrypt(CRYPT_AES_CTX* aes, unsigned char* out,
                              const unsigned char* in)
 {
+    if (aes == NULL || out == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     AesDecryptDirect((Aes*)aes, out, in);
 
     return 0;
@@ -393,6 +496,9 @@ int CRYPT_AES_DIRECT_Decrypt(CRYPT_AES_CTX* aes, unsigned char* out,
 /* RSA Initialize */
 int CRYPT_RSA_Initialize(CRYPT_RSA_CTX* rsa)
 {
+    if (rsa == NULL)
+        return BAD_FUNC_ARG;
+
     rsa->holder = (RsaKey*)XMALLOC(sizeof(RsaKey), NULL, DYNAMIC_TYPE_RSA);
     if (rsa->holder == NULL)
         return -1;
@@ -406,6 +512,9 @@ int CRYPT_RSA_Initialize(CRYPT_RSA_CTX* rsa)
 /* RSA Free resources */
 int CRYPT_RSA_Free(CRYPT_RSA_CTX* rsa)
 {
+    if (rsa == NULL)
+        return BAD_FUNC_ARG;
+
     FreeRsaKey((RsaKey*)rsa->holder);
     XFREE(rsa->holder, NULL, DYNAMIC_TYPE_RSA);
     rsa->holder = NULL;
@@ -421,6 +530,9 @@ int CRYPT_RSA_PublicKeyDecode(CRYPT_RSA_CTX* rsa, const unsigned char* in,
     unsigned int idx = 0;
     (void)idx;
 
+    if (rsa == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     return RsaPublicKeyDecode(in, &idx, (RsaKey*)rsa->holder, inSz);
 }
 
@@ -432,6 +544,9 @@ int CRYPT_RSA_PrivateKeyDecode(CRYPT_RSA_CTX* rsa, const unsigned char* in,
     unsigned int idx = 0;
     (void)idx;
 
+    if (rsa == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     return RsaPrivateKeyDecode(in, &idx, (RsaKey*)rsa->holder, inSz);
 }
 
@@ -441,6 +556,9 @@ int CRYPT_RSA_PublicEncrypt(CRYPT_RSA_CTX* rsa, unsigned char* out,
                             unsigned int outSz, const unsigned char* in,
                             unsigned int inSz, CRYPT_RNG_CTX* rng)
 {
+    if (rsa == NULL || in == NULL || out == NULL || rng == NULL)
+        return BAD_FUNC_ARG;
+
     return RsaPublicEncrypt(in, inSz, out, outSz, (RsaKey*)rsa->holder,
                             (RNG*)rng);
 }
@@ -451,6 +569,9 @@ int CRYPT_RSA_PrivateDecrypt(CRYPT_RSA_CTX* rsa, unsigned char* out,
                              unsigned int outSz, const unsigned char* in,
                              unsigned int inSz)
 {
+    if (rsa == NULL || in == NULL || out == NULL)
+        return BAD_FUNC_ARG;
+
     return RsaPrivateDecrypt(in, inSz, out, outSz, (RsaKey*)rsa->holder);
 }
 
@@ -458,6 +579,9 @@ int CRYPT_RSA_PrivateDecrypt(CRYPT_RSA_CTX* rsa, unsigned char* out,
 /* RSA Get Encrypt size helper */
 int CRYPT_RSA_EncryptSizeGet(CRYPT_RSA_CTX* rsa) 
 {
+    if (rsa == NULL)
+        return BAD_FUNC_ARG;
+
     return RsaEncryptSize((RsaKey*)rsa->holder);
 }    
 
@@ -465,6 +589,9 @@ int CRYPT_RSA_EncryptSizeGet(CRYPT_RSA_CTX* rsa)
 /* ECC init */
 int CRYPT_ECC_Initialize(CRYPT_ECC_CTX* ecc)
 {
+    if (ecc == NULL)
+        return BAD_FUNC_ARG;
+
     ecc->holder = (ecc_key*)XMALLOC(sizeof(ecc_key), NULL, DYNAMIC_TYPE_ECC);
     if (ecc->holder == NULL)
         return -1;
@@ -478,6 +605,9 @@ int CRYPT_ECC_Initialize(CRYPT_ECC_CTX* ecc)
 /* ECC free resources */
 int CRYPT_ECC_Free(CRYPT_ECC_CTX* ecc)
 {
+    if (ecc == NULL)
+        return BAD_FUNC_ARG;
+
     ecc_free((ecc_key*)ecc->holder);
     XFREE(ecc->holder, NULL, DYNAMIC_TYPE_ECC);
     ecc->holder = NULL;
@@ -493,6 +623,9 @@ int CRYPT_ECC_PublicExport(CRYPT_ECC_CTX* ecc, unsigned char* out,
     int          ret;
     unsigned int inOut = outSz;
 
+    if (ecc == NULL || out == NULL)
+        return BAD_FUNC_ARG;
+
     ret = ecc_export_x963((ecc_key*)ecc->holder, out, &inOut);
     *usedSz = inOut;
 
@@ -504,6 +637,9 @@ int CRYPT_ECC_PublicExport(CRYPT_ECC_CTX* ecc, unsigned char* out,
 int CRYPT_ECC_PublicImport(CRYPT_ECC_CTX* ecc, const unsigned char* in,
                            unsigned int inSz)
 {
+    if (ecc == NULL || in == NULL)
+        return BAD_FUNC_ARG;
+
     return ecc_import_x963(in, inSz, (ecc_key*)ecc->holder);
 }
 
@@ -512,6 +648,9 @@ int CRYPT_ECC_PublicImport(CRYPT_ECC_CTX* ecc, const unsigned char* in,
 int CRYPT_ECC_PrivateImport(CRYPT_ECC_CTX* ecc, const unsigned char* priv,
          unsigned int privSz, const unsigned char* pub, unsigned int pubSz)
 {
+    if (ecc == NULL || priv == NULL || pub == NULL)
+        return BAD_FUNC_ARG;
+
     return ecc_import_private_key(priv, privSz, pub, pubSz,
                                  (ecc_key*)ecc->holder);
 }
@@ -520,6 +659,9 @@ int CRYPT_ECC_PrivateImport(CRYPT_ECC_CTX* ecc, const unsigned char* priv,
 /* ECC DHE Make key */
 int CRYPT_ECC_DHE_KeyMake(CRYPT_ECC_CTX* ecc, CRYPT_RNG_CTX* rng, int keySz)
 {
+    if (ecc == NULL || rng == NULL)
+        return BAD_FUNC_ARG;
+
     return ecc_make_key((RNG*)rng, keySz, (ecc_key*)ecc->holder);
 }
 
@@ -531,6 +673,9 @@ int CRYPT_ECC_DHE_SharedSecretMake(CRYPT_ECC_CTX* priv, CRYPT_ECC_CTX* pub,
     int ret;
     unsigned int inOut = outSz;
 
+    if (priv == NULL || pub == NULL || out == NULL || usedSz == NULL)
+        return BAD_FUNC_ARG;
+
     ret = ecc_shared_secret((ecc_key*)priv->holder, (ecc_key*)pub->holder,
                             out, &inOut);
     *usedSz = inOut;
@@ -548,6 +693,10 @@ int CRYPT_ECC_DSA_HashSign(CRYPT_ECC_CTX* ecc, CRYPT_RNG_CTX* rng,
     int ret;
     unsigned int inOut = sigSz;
 
+    if (ecc == NULL || rng == NULL || sig == NULL || usedSz == NULL ||
+                                                                in == NULL)
+        return BAD_FUNC_ARG;
+
     ret = ecc_sign_hash(in, inSz, sig, &inOut, (RNG*)rng,
                        (ecc_key*)ecc->holder);
     *usedSz = inOut;
@@ -561,6 +710,9 @@ int CRYPT_ECC_DSA_HashVerify(CRYPT_ECC_CTX* ecc, const unsigned char* sig,
                              unsigned int sigSz, unsigned char* hash,
                              unsigned int hashSz, int* status)
 {
+    if (ecc == NULL || sig == NULL || hash == NULL || status == NULL)
+        return BAD_FUNC_ARG;
+
     return ecc_verify_hash(sig, sigSz, hash, hashSz, status,
                           (ecc_key*)ecc->holder);
 }
@@ -569,6 +721,9 @@ int CRYPT_ECC_DSA_HashVerify(CRYPT_ECC_CTX* ecc, const unsigned char* sig,
 /* ECC get key size helper */
 int CRYPT_ECC_KeySizeGet(CRYPT_ECC_CTX* ecc)
 {
+    if (ecc == NULL)
+        return BAD_FUNC_ARG;
+
     return ecc_size((ecc_key*)ecc->holder);
 }
 
@@ -576,8 +731,21 @@ int CRYPT_ECC_KeySizeGet(CRYPT_ECC_CTX* ecc)
 /* ECC get signature size helper */
 int CRYPT_ECC_SignatureSizeGet(CRYPT_ECC_CTX* ecc)
 {
+    if (ecc == NULL)
+        return BAD_FUNC_ARG;
+
     return ecc_sig_size((ecc_key*)ecc->holder);
 }
 
 
+/* Save error string from err to str which needs to be >= 80 chars */
+int CRYPT_ERROR_StringGet(int err, char* str)
+{
+    if (str == NULL)
+        return BAD_FUNC_ARG;
+
+    CTaoCryptErrorString(err, str);
+
+    return 0;
+}
 
diff --git a/mcapi/crypto.h b/mcapi/crypto.h
index e77a6fef4..cff24bbdc 100644
--- a/mcapi/crypto.h
+++ b/mcapi/crypto.h
@@ -255,6 +255,10 @@ int CRYPT_ECC_KeySizeGet(CRYPT_ECC_CTX*);
 int CRYPT_ECC_SignatureSizeGet(CRYPT_ECC_CTX*);
 
 
+/* Error string helper, string needs to be >= 80 chars */
+int CRYPT_ERROR_StringGet(int, char*);
+
+
 #ifdef __cplusplus
     }  /* extern "C" */ 
 #endif