libqaeda

commit 9a590888fa48b9c17a156126c4de493cedff6b76
parent 730b8edd3e9dcf95a7fd9fcdbe8b95287853a524
Author: lash <dev@holbrook.no>
Date:   Sat,  5 Apr 2025 03:01:56 +0100

WIP use single instance of asn tree

Diffstat:
M
src/cli/main.c
 | 
6
++++++
M
src/lq/Makefile
 | 
2
+-
M
src/lq/base.c
 | 
21
+++++++++++++++++++++
M
src/lq/cert.c
 | 
98
++++++++++++++++++++++++++++++++++++-------------------------------------------
M
src/lq/err.h
 | 
3
++-
M
src/lq/msg.c
 | 
88
+++++++++++++++++++++++++++++++------------------------------------------------

6 files changed, 109 insertions(+), 109 deletions(-)
diff --git a/src/cli/main.c b/src/cli/main.c
@@ -120,26 +120,31 @@ int main(int argc, char **argv) {
 		lq_ui_free();
 		return 1;
 	}
+
 	cert = lq_certificate_new(NULL);
 	r = lq_certificate_request(cert, req, pk_alice);
 	if (r != ERR_OK) {
+		lq_certificate_free(cert);
 		lq_ui_free();
 		return 1;
 	}
 
 	res = lq_msg_new("foo", 4);
 	if (res == NULL) {
+		lq_certificate_free(cert);
 		lq_ui_free();
 		return 1;
 	}
 	r = lq_certificate_respond(cert, res, pk_bob);
 	if (r != ERR_OK) {
+		lq_certificate_free(cert);
 		lq_ui_free();
 		return 1;
 	}
 
 	r = lq_certificate_verify(cert);
 	if (r != ERR_OK) {
+		lq_certificate_free(cert);
 		lq_ui_free();
 		return 1;
 	}
@@ -147,6 +152,7 @@ int main(int argc, char **argv) {
 	out_len = LQ_BLOCKSIZE;
 	r = lq_certificate_serialize(cert, out, &out_len, NULL);
 	if (r != ERR_OK) {
+		lq_certificate_free(cert);
 		lq_ui_free();
 		return 1;
 	}
diff --git a/src/lq/Makefile b/src/lq/Makefile
@@ -1,7 +1,7 @@
 OBJS := $(patsubst %.c,%.o,$(filter-out main.c,$(wildcard *.c)))
 INCLUDES := -I.. -I../aux/include
 CFLAGS +=  $(INCLUDES) -Wall
-LIBS := `pkg-config --libs libtasn1` -L../aux/lib -llash
+LIBS := ../asn1/defs_asn1_tab.o `pkg-config --libs libtasn1` -L../aux/lib -llash
 
 LDFLAGS += $(LIBS)
 
diff --git a/src/lq/base.c b/src/lq/base.c
@@ -1,14 +1,35 @@
+#include <libtasn1.h>
+#include <llog.h>
+
+#include "lq/wire.h"
 #include "err.h"
 #include "config.h"
+#include "debug.h"
+
 
+asn1_node asn;
 
 char zeros[65];
 
 int lq_init() {
+	int r;
+
+	r = asn1_array2tree(defs_asn1_tab, &asn, NULL);
+	if (r != ASN1_SUCCESS) {
+		return debug_logerr(LLOG_ERROR, ERR_INIT, "asn init");
+	}
+
 	lq_err_init();
 	return lq_config_init();
 }
 
 void lq_finish() {
+	int r;
+
+	r = asn1_delete_structure(&asn);
+	if (r != ASN1_SUCCESS) {
+		debug_logerr(LLOG_ERROR, ERR_UNCLEAN, "asn exit");
+	}
+
 	lq_config_free();
 }
diff --git a/src/lq/cert.c b/src/lq/cert.c
@@ -11,6 +11,8 @@
 #include "debug.h"
 
 
+extern asn1_node asn;
+
 extern char zeros[65];
 static LQPubKey nokey = {
 	.pk = 0,
@@ -220,26 +222,26 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
 	char buf[LQ_BLOCKSIZE];
 	LQMsg *msg;
 	LQSig *sig;
-	asn1_node node;
+	asn1_node item;
 	char *sigdata;
 
 	mx = *out_len;
 	*out_len = 0;
-	lq_zero(&node, sizeof(node));
+	lq_zero(&item, sizeof(item));
 
-	r = asn1_array2tree(defs_asn1_tab, &node, err);
+	r = asn1_create_element(asn, "Qaeda.Cert", &item);
 	if (r != ASN1_SUCCESS) {
-		return ERR_INIT;
+		return ERR_READ;
 	}
 
 	c = LQ_CERT_DOMAIN_LEN;
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Cert.domain", cert->domain, c);
+	r = asn1_write_value(item, "domain", cert->domain, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	// Set request message if exists
@@ -250,15 +252,15 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
 	c = mx - LQ_CERT_DOMAIN_LEN; 
 	r = lq_msg_serialize(msg, buf, &c, resolve);
 	if (r != ERR_OK) {
-		return asn_except(&node, r);
+		return asn_except(&item, r);
 	}
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Cert.request", buf, c);
+	r = asn1_write_value(item, "request", buf, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	// Set request signature if exists
@@ -270,11 +272,11 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
 	c = lq_signature_bytes(sig, &sigdata);
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Cert.request_sig", sigdata, c);
+	r = asn1_write_value(item, "request_sig", sigdata, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 	
 	msg = cert->response;
@@ -284,15 +286,15 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
 	c = mx - LQ_CERT_DOMAIN_LEN; 
 	r = lq_msg_serialize(msg, buf, &c, resolve);
 	if (r != ERR_OK) {
-		return asn_except(&node, r);
+		return asn_except(&item, r);
 	}
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Cert.response", buf, c);
+	r = asn1_write_value(item, "response", buf, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	// Set response signature if exists
@@ -304,40 +306,40 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
 	c = lq_signature_bytes(sig, &sigdata);
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Cert.response_sig", sigdata, c);
+	r = asn1_write_value(item, "response_sig", sigdata, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	if (cert->parent == NULL) {
 		c = 0;
-		r = asn1_write_value(node, "Qaeda.Cert.parent", &c, 1);
+		r = asn1_write_value(item, "parent", &c, 1);
 		if (r != ASN1_SUCCESS) {
-			return asn_except(&node, ERR_WRITE);
+			return asn_except(&item, ERR_WRITE);
 		}
 	} else {
 		r = state_digest(cert, cert->parent_hash, 1);
 		if (r != ERR_OK) {
-			return asn_except(&node, r);
+			return asn_except(&item, r);
 		}
 		c = LQ_DIGEST_LEN;
-		r = asn1_write_value(node, "Qaeda.Cert.parent", cert->parent_hash, c);
+		r = asn1_write_value(item, "parent", cert->parent_hash, c);
 		if (r != ASN1_SUCCESS) {
-			return asn_except(&node, ERR_WRITE);
+			return asn_except(&item, ERR_WRITE);
 		}
 	}
 
 	*out_len = mx;
-	r = asn1_der_coding(node, "Qaeda.Cert", out, (int*)out_len, err);
+	r = asn1_der_coding(item, "Cert", out, (int*)out_len, err);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_ENCODING);
+		return asn_except(&item, ERR_ENCODING);
 	}
 
-	r = asn1_delete_structure(&node);
+	r = asn1_delete_structure(&item);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_FAIL);
+		return ERR_FAIL;
 	}
 
 	return ERR_OK;
@@ -348,31 +350,25 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 	int c;
 	char err[LQ_ERRSIZE];
 	char tmp[LQ_BLOCKSIZE];
-	asn1_node node;
 	asn1_node item;
 	LQCert *p;
 
-	lq_zero(&node, sizeof(node));
 	lq_zero(&item, sizeof(item));
-	r = asn1_array2tree(defs_asn1_tab, &node, err);
-	if (r != ASN1_SUCCESS) {
-		return ERR_INIT;
-	}
-
-	r = asn1_create_element(node, "Qaeda.Cert", &item);
+	
+	r = asn1_create_element(asn, "Qaeda.Cert", &item);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return ERR_READ;
 	}
 
 	r = asn1_der_decoding(&item, in, in_len, err);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_ENCODING);
+		return asn_except(&item, ERR_ENCODING);
 	}
 
 	c = LQ_CERT_DOMAIN_LEN;
 	r = asn1_read_value(item, "domain", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return asn_except(&item, ERR_READ);
 	}
 
 	p = lq_certificate_new(NULL);
@@ -381,17 +377,17 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 	c = LQ_BLOCKSIZE;
 	r = asn1_read_value(item, "request", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return asn_except(&item, ERR_READ);
 	}
 	r = lq_msg_deserialize(&p->request, tmp, c, resolve);
 	if (r != ERR_OK) {
-		return asn_except(&node, r);
+		return asn_except(&item, r);
 	}
 
 	c = LQ_BLOCKSIZE;
 	r = asn1_read_value(item, "request_sig", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return asn_except(&item, ERR_READ);
 	}
 	if (c > 0) {
 		p->request_sig = lq_signature_from_bytes(tmp, c, NULL);
@@ -400,17 +396,17 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 	c = LQ_BLOCKSIZE;
 	r = asn1_read_value(item, "response", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return asn_except(&item, ERR_READ);
 	}
 	r = lq_msg_deserialize(&p->response, tmp, c, resolve);
 	if (r != ERR_OK) {
-		return asn_except(&node, r);
+		return asn_except(&item, r);
 	}
 
 	c = 4096;
 	r = asn1_read_value(item, "response_sig", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return asn_except(&item, ERR_READ);
 	}
 	if (c > 0) {
 		p->response_sig = lq_signature_from_bytes(tmp, c, NULL);
@@ -419,7 +415,7 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 	c = 4096;
 	r = asn1_read_value(item, "parent", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return asn_except(&item, ERR_READ);
 	}
 	p->parent = NULL;
 	if (c == 1) {
@@ -433,11 +429,7 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 
 	r = asn1_delete_structure(&item);
 	if (r != ASN1_SUCCESS) {
-		debug(LLOG_WARNING, "cert", "delete cert asn item");
-	}
-	r = asn1_delete_structure(&node);
-	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_FAIL);
+		return ERR_FAIL;
 	}
 
 	return ERR_OK;
diff --git a/src/lq/err.h b/src/lq/err.h
@@ -13,7 +13,8 @@ enum err_e {
 	ERR_REQUEST = 0x102, ///< Error related to certificate request messages
 	ERR_RESPONSE = 0x103, ///< Error related to certificate response messages
 	ERR_RESOLVE = 0x104, ///< Error related to resolving message hashes
-
+	ERR_UNCLEAN = 0x105, ///< Indicates that not everything could be cleaned up on exit
+			     
 	RERR_PFX_CRYPTO = 0x200,
 	ERR_NOCRYPTO = 0x201,
 	ERR_KEYFAIL = 0x202,
diff --git a/src/lq/msg.c b/src/lq/msg.c
@@ -13,6 +13,8 @@
 #include "debug.h"
 
 
+extern asn1_node asn;
+
 extern char zeros[65];
 static LQPubKey nokey = {
 	.pk = NULL,
@@ -131,33 +133,34 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 	char err[1024];
 	LQPubKey *pubkey;
 	LQResolve *resolve_active;
-	asn1_node node;
+	asn1_node item;
 	char *keydata;
 
 	resolved = LQ_MSG_DIGESTONLY;
 	mx = *out_len;
 	*out_len = 0;
-	lq_set(&node, 0, sizeof(node));
-	r = asn1_array2tree(defs_asn1_tab, &node, err);
+	lq_set(&item, 0, sizeof(item));
+
+	r = asn1_create_element(asn, "Qaeda.Msg", &item);
 	if (r != ASN1_SUCCESS) {
-		return ERR_INIT;
+		return ERR_READ;
 	}
 
 	c = LQ_DIGEST_LEN;
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
 	r = lq_digest(msg->data, msg->len, tmp);
 	if (r != ERR_OK) {
-		return asn_except(&node, r);
+		return asn_except(&item, r);
 	}
 
 	resolve_active = resolve;
 	while (resolve_active != NULL) {
 		r = resolve_active->store->put(LQ_CONTENT_MSG, resolve_active->store, tmp, &c, msg->data, msg->len);
 		if (r != ERR_OK) {
-			return asn_except(&node, r);
+			return asn_except(&item, r);
 		}
 		resolve_active = resolve_active->next;
 		resolved = LQ_MSG_RESOLVED;
@@ -167,30 +170,30 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 		debug(LLOG_DEBUG, "msg", "no resolver");	
 	}
 
-	r = asn1_write_value(node, "Qaeda.Msg.data", tmp, c);
+	r = asn1_write_value(item, "data", tmp, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	lq_cpy(timedata, &msg->time.tv_sec, 4);
 	lq_cpy(((char*)timedata)+4, &msg->time.tv_nsec, 4);
 	r = to_endian(TO_ENDIAN_BIG, 4, timedata);
 	if (r) {
-		return asn_except(&node, ERR_BYTEORDER);
+		return asn_except(&item, ERR_BYTEORDER);
 	}
 	r = to_endian(TO_ENDIAN_BIG, 4, ((char*)timedata)+4);
 	if (r) {
-		return asn_except(&node, ERR_BYTEORDER);
+		return asn_except(&item, ERR_BYTEORDER);
 	}
 
 	c = sizeof(int);
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Msg.timestamp", &timedata, c);
+	r = asn1_write_value(item, "timestamp", &timedata, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	pubkey = msg->pubkey;
@@ -200,20 +203,20 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 	c = lq_publickey_bytes(pubkey, &keydata);
 	*out_len += c;
 	if (*out_len > mx) {
-		return asn_except(&node, ERR_OVERFLOW);
+		return asn_except(&item, ERR_OVERFLOW);
 	}
-	r = asn1_write_value(node, "Qaeda.Msg.pubkey", keydata, c);
+	r = asn1_write_value(item, "pubkey", keydata, c);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_WRITE);
+		return asn_except(&item, ERR_WRITE);
 	}
 
 	*out_len = mx;
-	r = asn1_der_coding(node, "Qaeda.Msg", out, (int*)out_len, err);
+	r = asn1_der_coding(item, "Qaeda.Msg", out, (int*)out_len, err);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_ENCODING);
+		return asn_except(&item, ERR_ENCODING);
 	}
 
-	r = asn1_delete_structure(&node);
+	r = asn1_delete_structure(&item);
 	if (r != ASN1_SUCCESS) {
 		return r;
 	}
@@ -228,44 +231,33 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 	char err[LQ_ERRSIZE];
 	char z[LQ_DIGEST_LEN];
 	char tmp[LQ_BLOCKSIZE];
-	asn1_node node;
 	asn1_node item;
 	LQResolve *resolve_active;
 
 	resolved = LQ_MSG_DIGESTONLY;
-	lq_zero(&node, sizeof(node));
 	lq_zero(&item, sizeof(item));
-	r = asn1_array2tree(defs_asn1_tab, &node, err);
-	if (r != ASN1_SUCCESS) {
-		return ERR_INIT;
-	}
 
-	r = asn1_create_element(node, "Qaeda.Msg", &item);
+	r = asn1_create_element(asn, "Qaeda.Msg", &item);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_READ);
+		return ERR_READ;
 	}
 
 	r = asn1_der_decoding(&item, in, in_len, err);
 	if (r != ASN1_SUCCESS) {
-		asn_except(&item, r);
-		return asn_except(&node, r);
+		return asn_except(&item, ERR_ENCODING);
 	}
 
 	c = LQ_DIGEST_LEN;
 	r = asn1_read_value(item, "data", z, (int*)&c);
 	if (r != ASN1_SUCCESS) {
-		r = ERR_READ;
-		asn_except(&item, r);
-		asn_except(&node, r);
-		return r;
+		return asn_except(&item, ERR_READ);
 	}
 	c = LQ_BLOCKSIZE;
 	resolve_active = resolve;
 	while (resolve_active != NULL) {
 		r = resolve_active->store->get(LQ_CONTENT_MSG, resolve_active->store, z, LQ_DIGEST_LEN, tmp, &c);
 		if (r != ERR_OK) {
-			asn_except(&item, r);
-			return asn_except(&node, r);
+			return asn_except(&item, r);
 		}
 		resolved = LQ_MSG_RESOLVED;
 		resolve_active = resolve_active->next;
@@ -276,20 +268,14 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 		c = LQ_DIGEST_LEN;
 	} else {
 		if (!(resolved & LQ_MSG_RESOLVED)) {
-			r = ERR_RESOLVE;
-			asn_except(&item, r);
-			asn_except(&node, r);
-			return r;
+			return asn_except(&item, ERR_RESOLVE);
 		}
 	}
 	*msg = lq_msg_new((const char*)tmp, c);
 	(*msg)->state = resolved;
 	(*msg)->data = lq_alloc(c);
 	if ((*msg)->data == NULL) {
-		r = ERR_MEM;
-		asn_except(&item, r);
-		asn_except(&node, r);
-		return r;
+		return asn_except(&item, ERR_MEM);
 	}
 	(*msg)->len = c;
 	lq_cpy((*msg)->data, tmp, c);
@@ -298,10 +284,7 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 	c = 8;
 	r = asn1_read_value(item, "timestamp", tmp, (int*)&c);
 	if (r != ASN1_SUCCESS) {
-		r = ERR_READ;
-		asn_except(&item, r);
-		asn_except(&node, r);
-		return r;
+		return asn_except(&item, ERR_READ);
 	}
 	if (is_le()) {
 		flip_endian(4, (char*)tmp);
@@ -313,10 +296,7 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 	c = LQ_PUBKEY_LEN;
 	r = asn1_read_value(item, "pubkey", tmp, (int*)&c);
 	if (r != ASN1_SUCCESS) {
-		r = ERR_READ;
-		asn_except(&item, r);
-		asn_except(&node, r);
-		return r;
+		return asn_except(&item, ERR_READ);
 	}
 	(*msg)->pubkey = lq_publickey_new(tmp);
 
@@ -324,9 +304,9 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 	if (r != ASN1_SUCCESS) {
 		debug(LLOG_WARNING, "cert", "delete msg asn item");
 	}
-	r = asn1_delete_structure(&node);
+	r = asn1_delete_structure(&item);
 	if (r != ASN1_SUCCESS) {
-		return asn_except(&node, ERR_FAIL);
+		return ERR_FAIL;
 	};
 
 	return ERR_OK;