assertions and compiler warnings

Author: vesvault-jz

ChangeLog

@@ -1,3 +1,7 @@
 2019-01-01  Jim Zubov <jz@vesvault.com>
     * * Usage of RAND_bytes() and OPENSSL_cleanup()
     credits: https://reddit.com/u/skeeto
+2019-01-03  Jim Zubov <jz@vesvault.com>
+    * * Assertions for malloc() returning NULL
+    Compiler warnings cleaned up
+    credits: https://reddit.com/u/hillbull

aclocal.m4

@@ -3,7 +3,7 @@
 
 
 AC_PREREQ([2.69])
-AC_INIT([VES], [0.901b], [bugs@vesvault.com])
+AC_INIT([VES], [0.902b], [bugs@vesvault.com])
 AC_CONFIG_SRCDIR([src/ves-util.c])
 AC_CONFIG_HEADERS([src/config.h])
 

configure.ac

@@ -33,6 +33,7 @@
 #include <stdlib.h>
 #include <string.h>
 #include <stdio.h>
+#include <assert.h>
 #include "jVar.h"
 
 
@@ -41,6 +42,7 @@ void jVar_chkMem(jVar *val, size_t len) {
 	if (val->memSize < 256) val->memSize = 256;
 	while (val->memSize < len) val->memSize <<= 1;
 	val->vBuf = val->vBuf ? realloc(val->vBuf, val->memSize) : malloc(val->memSize);
+	assert(val->vBuf);
     }
 }
 
@@ -98,6 +100,7 @@ jVar *jVar_detach(jVar *val) {
 	case JVAR_STRING:
 	case JVAR_JSON: {
 	    jVar *res = malloc(sizeof(jVar));
+	    if (!res) return NULL;
 	    memcpy(res, val, sizeof(jVar));
 	    val->vBuf = NULL;
 	    val->len = 0;
@@ -220,6 +223,7 @@ char *jVar_getString(jVar *val) {
     int len = jVar_cpString(val, NULL, -1);
     if (len < 0) return NULL;
     char *str = malloc(len + 1);
+    if (!str) return NULL;
     str[jVar_cpString(val, str, len)] = 0;
     return str;
 }
@@ -325,40 +329,45 @@ void jVar_setString0(jVar *val, char *str) {
 
 jVar *jVar_null() {
     jVar *val = malloc(offsetof(jVar,vInt));
-    val->type = JVAR_NULL;
+    if (val) val->type = JVAR_NULL;
     return val;
 }
 
 jVar *jVar_bool(jVar_TBool v) {
     jVar *val = malloc(offsetof(jVar,vBool) + sizeof(val->vBool));
+    if (!val) return NULL;
     val->type = JVAR_BOOL;
     val->vBool = v != 0;
     return val;
 }
 
 jVar *jVar_int(jVar_TInt v) {
     jVar *val = malloc(offsetof(jVar,vInt) + sizeof(val->vInt));
+    if (!val) return NULL;
     val->type = JVAR_INT;
     val->vInt = v;
     return val;
 }
 
 jVar *jVar_float(jVar_TFloat v) {
     jVar *val = malloc(offsetof(jVar,vFloat) + sizeof(val->vFloat));
+    if (!val) return NULL;
     val->type = JVAR_FLOAT;
     val->vFloat = v;
     return val;
 }
 
 jVar *jVar_stringl(const char *v, size_t len) {
     char *buf = malloc(len + 16);
+    if (!buf) return NULL;
     if (v) memcpy(buf, v, len);
     return jVar_stringl0(buf, len, 16);
 }
 
 jVar *jVar_stringl0(char *v, size_t len, size_t extra) {
     if (!v) return NULL;
     jVar *val = malloc(sizeof(jVar));
+    if (!val) return NULL;
     val->type = JVAR_STRING;
     val->len = len;
     val->vString = v;
@@ -378,6 +387,7 @@ jVar *jVar_string0(char *v) {
 
 jVar *jVar_JSON(const char *json) {
     jVar *val = jVar_string(json);
+    if (!val) return NULL;
     val->type = JVAR_JSON;
     jVar_chkMem(val, val->len + 1);
     val->vString[val->len] = 0;
@@ -386,6 +396,7 @@ jVar *jVar_JSON(const char *json) {
 
 jVar *jVar_array() {
     jVar *val = malloc(sizeof(jVar));
+    if (!val) return NULL;
     val->type = JVAR_ARRAY;
     val->len = 0;
     val->memSize = 0;
@@ -395,6 +406,7 @@ jVar *jVar_array() {
 
 jVar *jVar_object() {
     jVar *val = malloc(sizeof(jVar));
+    if (!val) return NULL;
     val->type = JVAR_OBJECT;
     val->len = 0;
     val->memSize = 0;
@@ -530,6 +542,7 @@ char *jVar_toJSON(jVar *val) {
 
 jVarParser *jVarParser_new(jVarParser *parent) {
     jVarParser *p = malloc(sizeof(jVarParser));
+    if (!p) return NULL;
     p->state = JVAR_PARSE_INITIAL;
     p->result = NULL;
     p->key = NULL;
@@ -645,7 +658,6 @@ jVarParser *jVarParser_proceed(jVarParser *p,jVarParser *child) {
 	    const char *h = p->head;
 	    const char *t = p->tail;
 	    char c;
-	    int expf = 0;
 	    if (p->state == JVAR_PARSE_INITIAL) p->state = JVAR_PARSE_INCOMPLETE;
 	    while (++h < t) {
 		switch (c = *h) {

lib/jVar.c

@@ -47,7 +47,7 @@
 
 libVES_List_STATIC0(libVES_unlockedKeys, &libVES_VaultKey_ListCtlU);
 
-const char *libVES_errorMsgs[11] = {
+const char *libVES_errorMsgs[12] = {
     NULL,
     "Bad parameters",
     "Communication with the API server failed",
@@ -59,6 +59,7 @@ const char *libVES_errorMsgs[11] = {
     "API server error",
     "Unsupported algorithm",
     "Incorrect operation",
+    "Internal assertion failed",
 };
 
 const char *libVES_appName = "(unspecified app)";
@@ -77,6 +78,7 @@ libVES *libVES_new(const char *vaultURI) {
 libVES *libVES_fromRef(libVES_Ref *ref) {
     libVES_init(NULL);
     libVES *ves = malloc(sizeof(libVES));
+    if (!ves) return NULL;
     ves->external = ref;
     ves->apiUrl = LIBVES_API_URL;
     ves->appName = libVES_appName;

lib/libVES.c

@@ -28,8 +28,8 @@
  * libVES.h                   libVES: Main header
  *
  ***************************************************************************/
-#define LIBVES_VERSION_NUMBER	0x00090001L
-#define LIBVES_VERSION_CODE	"0.901b"
+#define LIBVES_VERSION_NUMBER	0x00090002L
+#define LIBVES_VERSION_CODE	"0.902b"
 #define LIBVES_VERSION_STR	"libVES.c " LIBVES_VERSION_CODE " (c) 2018 VESvault Corp"
 #define LIBVES_VERSION_SHORT	"libVES/" LIBVES_VERSION_CODE
 
@@ -69,6 +69,7 @@ typedef struct libVES {
 #define LIBVES_E_SERVER		8
 #define LIBVES_E_UNSUPPORTED	9
 #define LIBVES_E_INCORRECT	10
+#define LIBVES_E_ASSERT		11
 
 #define LIBVES_O_FILE		0x01
 #define LIBVES_O_VKEY		0x02

lib/libVES.h

@@ -38,6 +38,7 @@
 #include <openssl/pem.h>
 #include <openssl/engine.h>
 #include <openssl/crypto.h>
+#include <assert.h>
 #include "Cipher.h"
 #include "CiAlgo_AES.h"
 #include "Util.h"
@@ -47,6 +48,7 @@
 #define libVES_CiAlgo_AESSETKEY(alg, algname) \
 	    if (key && keylen < sizeof(ci->alg.key)) libVES_throw(ves, LIBVES_E_PARAM, algname " cipher key is too short", NULL); \
 	    ci = malloc(offsetof(libVES_Cipher, alg.end)); \
+	    assert(ci); \
 	    if (key) { \
 		memcpy(ci->alg.key, key, sizeof(ci->alg.key)); \
 		memcpy(ci->alg.seed, key + (keylen <= sizeof(ci->alg.key) + sizeof(ci->alg.seed) ? keylen - sizeof(ci->alg.seed) : sizeof(ci->alg.key)), sizeof(ci->alg.seed)); \

lib/libVES/CiAlgo_AES.c

@@ -97,7 +97,7 @@ int libVES_Cipher_proceed(libVES_Cipher *ci, int final, const char *srctext, siz
 	int len = func(ci, final, srctext, srclen, NULL);
 	if (len < 0) libVES_throw(ci->ves, LIBVES_E_CRYPTO, "Cannot determine the cipher buffer size", -1);
 	if (!dsttext) return len;
-	*dsttext = malloc(len);
+	libVES_assert(ci->ves, (*dsttext = malloc(len)), -1);
     }
     int res = func(ci, final, srctext, srclen, *dsttext);
     if (res < 0) libVES_throw(ci->ves, LIBVES_E_CRYPTO, "Cipher error", -1);
@@ -115,6 +115,7 @@ int libVES_Cipher_encrypt(libVES_Cipher *ci, int final, const char *plaintext, s
 libVES_Seek *libVES_Cipher_seek(libVES_Cipher *ci, libVES_Seek *sk) {
     if (!sk) {
 	sk = malloc(sizeof(*sk));
+	if (!sk) return NULL;
 	sk->plainPos = sk->cipherPos = sk->cipherFbPos = -1;
 	sk->cipherFbLen = 0;
 	sk->cipherFb = NULL;

lib/libVES/Cipher.c

@@ -41,6 +41,7 @@
 
 libVES_File *libVES_File_new(libVES_Ref *ref) {
     libVES_File *file = malloc(sizeof(libVES_File));
+    if (!file) return NULL;
     file->id = 0;
     file->name = file->path = file->mime = NULL;
     file->external = ref;
@@ -51,6 +52,7 @@ libVES_File *libVES_File_new(libVES_Ref *ref) {
 libVES_File *libVES_File_fromJVar(jVar *data) {
     if (!data) return NULL;
     libVES_File *file = malloc(sizeof(libVES_File));
+    if (!file) return NULL;
     file->id = jVar_getInt(jVar_get(data, "id"));
     file->name = jVar_getString0(jVar_get(data, "name"));
     file->path = jVar_getString0(jVar_get(data, "path"));

lib/libVES/File.c

@@ -77,9 +77,10 @@ char *libVES_KeyAlgo_EVP_pub2str(libVES_VaultKey *vkey, void *pkey) {
     BIO *mem = BIO_new(BIO_s_mem());
     if (PEM_write_bio_PUBKEY(mem, (EVP_PKEY *) pkey) > 0) {
 	len = BIO_get_mem_data(mem, &buf);
-	str = malloc(len + 1);
-	memcpy(str, buf, len);
-	str[len] = 0;
+	if ((str = malloc(len + 1))) {
+	    memcpy(str, buf, len);
+	    str[len] = 0;
+	}
     } else str = NULL;
     BIO_free(mem);
     return str;
@@ -138,9 +139,10 @@ char *libVES_KeyAlgo_EVP_toPEM(libVES_veskey *veskey, struct evp_pkey_st *pkey)
     if (PEM_write_bio_PKCS8PrivateKey(mem, pkey, (veskey ? EVP_aes_256_cbc() : NULL), (veskey ? veskey->veskey : NULL), (veskey ? veskey->keylen : 0), NULL, NULL) > 0) {
 	char *buf;
 	int len = BIO_get_mem_data(mem, &buf);
-	res = malloc(len + 1);
-	memcpy(res, buf, len);
-	res[len] = 0;
+	if ((res = malloc(len + 1))) {
+	    memcpy(res, buf, len);
+	    res[len] = 0;
+	}
     } else res = NULL;
     BIO_free(mem);
     return res;
@@ -165,6 +167,7 @@ libVES_VaultKey *libVES_KeyAlgo_RSA_new(const libVES_KeyAlgo *algo, void *pkey,
 	return NULL;
     }
     libVES_VaultKey *vkey = malloc(sizeof(libVES_VaultKey));
+    if (!vkey) return NULL;
     vkey->algo = algo;
     vkey->pPriv = pkey;
     vkey->pPub = NULL;
@@ -179,6 +182,7 @@ int libVES_KeyAlgo_RSA_decrypt(libVES_VaultKey *vkey, const char *ciphertext, si
     if (*ctlen > len) {
 	*ctlen = len;
 	d = keybuf = malloc(len);
+	libVES_assert(vkey->ves, d, -1);
     } else {
 	if (!plaintext) return len;
 	d = (unsigned char *) plaintext;
@@ -257,6 +261,7 @@ libVES_VaultKey *libVES_KeyAlgo_ECDH_new(const libVES_KeyAlgo *algo, void *pkey,
 	return NULL;
     }
     libVES_VaultKey *vkey = malloc(sizeof(libVES_VaultKey));
+    if (!vkey) return NULL;
     vkey->algo = algo;
     vkey->pPriv = pkey;
     vkey->pPub = NULL;