libqaeda

commit 8ec365dc32eb3ec1b0d8bfd322e5a5880df62cb4
parent 510a9e0ed465ebbf7aaa3902c141a56f755b8710
Author: lash <dev@holbrook.no>
Date:   Sat,  5 Apr 2025 02:10:08 +0100

WIP add asn struct frees to all asn1 code

Diffstat:
M
src/cli/main.c
 | 
7
++++++-
M
src/lq/cert.c
 | 
70
+++++++++++++++++++++++++++++++++++++++++-----------------------------
M
src/lq/msg.c
 | 
40
+++++++++++++++++++++++-----------------

3 files changed, 70 insertions(+), 47 deletions(-)
diff --git a/src/cli/main.c b/src/cli/main.c
@@ -150,8 +150,13 @@ int main(int argc, char **argv) {
 		lq_ui_free();
 		return 1;
 	}
-
 	lq_certificate_free(cert);
 
+	r = lq_certificate_deserialize(&cert, out, &out_len, NULL);
+	if (r != ERR_OK) {
+		lq_ui_free();
+		return 1;
+	}
+
 	lq_ui_free();
 }
diff --git a/src/lq/cert.c b/src/lq/cert.c
@@ -200,12 +200,24 @@ int lq_certificate_verify(LQCert *cert) {
 	return ERR_OK;
 }
 
+// TODO: DRY
+static int asn_except(asn1_node *node, int err) {
+	int r;
+
+	r = asn1_delete_structure(node);
+	if (r != ASN1_SUCCESS) {
+		debug_logerr(LLOG_ERROR, ERR_FAIL, "free asn");
+	}
+
+	return err;
+}
+
 int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve *resolve) {
 	size_t c;
 	int r;
 	size_t mx;
-	char err[1024];
-	char buf[4096];
+	char err[LQ_ERRLEN];
+	char buf[LQ_BLOCKLEN];
 	LQMsg *msg;
 	LQSig *sig;
 	asn1_node node;
@@ -222,11 +234,11 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
 	c = LQ_CERT_DOMAIN_LEN;
 	*out_len += c;
 	if (*out_len > mx) {
-		return ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Cert.domain", cert->domain, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 
 	// Set request message if exists
@@ -237,15 +249,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 r;
+		return asn_except(&node, r);
 	}
 	*out_len += c;
 	if (*out_len > mx) {
-		return ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Cert.request", buf, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 
 	// Set request signature if exists
@@ -257,11 +269,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 ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Cert.request_sig", sigdata, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 	
 	msg = cert->response;
@@ -271,15 +283,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 r;
+		return asn_except(&node, r);
 	}
 	*out_len += c;
 	if (*out_len > mx) {
-		return ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Cert.response", buf, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 
 	// Set response signature if exists
@@ -291,40 +303,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 ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Cert.response_sig", sigdata, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 
 	if (cert->parent == NULL) {
 		c = 0;
 		r = asn1_write_value(node, "Qaeda.Cert.parent", &c, 1);
 		if (r != ASN1_SUCCESS) {
-			return ERR_WRITE;
+			return asn_except(&node, ERR_WRITE);
 		}
 	} else {
 		r = state_digest(cert, cert->parent_hash, 1);
 		if (r != ERR_OK) {
-			return r;
+			return asn_except(&node, r);
 		}
 		c = LQ_DIGEST_LEN;
 		r = asn1_write_value(node, "Qaeda.Cert.parent", cert->parent_hash, c);
 		if (r != ASN1_SUCCESS) {
-			return ERR_WRITE;
+			return asn_except(&node, ERR_WRITE);
 		}
 	}
 
 	*out_len = mx;
 	r = asn1_der_coding(node, "Qaeda.Cert", out, (int*)out_len, err);
 	if (r != ASN1_SUCCESS) {
-		return ERR_ENCODING;
+		return asn_except(&node, ERR_ENCODING);
 	}
 
 	r = asn1_delete_structure(&node);
 	if (r != ASN1_SUCCESS) {
-		return ERR_FAIL;
+		return asn_except(&node, ERR_FAIL);
 	}
 
 	return ERR_OK;
@@ -348,18 +360,18 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 
 	r = asn1_create_element(node, "Qaeda.Cert", &item);
 	if (r != ASN1_SUCCESS) {
-		return ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 
 	r = asn1_der_decoding(&item, in, in_len, err);
 	if (r != ASN1_SUCCESS) {
-		return ERR_ENCODING;
+		return asn_except(&node, ERR_ENCODING);
 	}
 
 	c = LQ_CERT_DOMAIN_LEN;
 	r = asn1_read_value(item, "domain", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 
 	p = lq_certificate_new(NULL);
@@ -368,17 +380,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 ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 	r = lq_msg_deserialize(&p->request, tmp, c, resolve);
 	if (r != ERR_OK) {
-		return r;
+		return asn_except(&node, r);
 	}
 
 	c = LQ_BLOCKSIZE;
 	r = asn1_read_value(item, "request_sig", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 	if (c > 0) {
 		p->request_sig = lq_signature_from_bytes(tmp, c, NULL);
@@ -387,17 +399,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 ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 	r = lq_msg_deserialize(&p->response, tmp, c, resolve);
 	if (r != ERR_OK) {
-		return r;
+		return asn_except(&node, r);
 	}
 
 	c = 4096;
 	r = asn1_read_value(item, "response_sig", tmp, &c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 	if (c > 0) {
 		p->response_sig = lq_signature_from_bytes(tmp, c, NULL);
@@ -406,7 +418,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 ERR_READ;
+		return asn_except(&node, ERR_READ);
 	}
 	p->parent = NULL;
 	if (c == 1) {
diff --git a/src/lq/msg.c b/src/lq/msg.c
@@ -103,7 +103,6 @@ int lq_msg_verify_extra(LQMsg *msg, LQSig *sig, const char *salt, const char *ex
 }
 
 void lq_msg_free(LQMsg *msg) {
-	//if (msg->pubkey->pk = NULL) {
 	if (msg->pubkey != NULL) {
 		lq_publickey_free(msg->pubkey);
 	}
@@ -111,6 +110,17 @@ void lq_msg_free(LQMsg *msg) {
 	lq_free(msg);
 }
 
+static int asn_except(asn1_node *node, int err) {
+	int r;
+
+	r = asn1_delete_structure(node);
+	if (r != ASN1_SUCCESS) {
+		debug_logerr(LLOG_ERROR, ERR_FAIL, "free asn");
+	}
+
+	return err;
+}
+
 int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve) {
 	char resolved;
 	size_t c;
@@ -136,18 +146,18 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 	c = LQ_DIGEST_LEN;
 	*out_len += c;
 	if (*out_len > mx) {
-		return ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = lq_digest(msg->data, msg->len, tmp);
 	if (r != ERR_OK) {
-		return r;
+		return asn_except(&node, 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 r;
+			return asn_except(&node, r);
 		}
 		resolve_active = resolve_active->next;
 		resolved = LQ_MSG_RESOLVED;
@@ -159,28 +169,28 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 
 	r = asn1_write_value(node, "Qaeda.Msg.data", tmp, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, 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 ERR_BYTEORDER;
+		return asn_except(&node, ERR_BYTEORDER);
 	}
 	r = to_endian(TO_ENDIAN_BIG, 4, ((char*)timedata)+4);
 	if (r) {
-		return ERR_BYTEORDER;
+		return asn_except(&node, ERR_BYTEORDER);
 	}
 
 	c = sizeof(int);
 	*out_len += c;
 	if (*out_len > mx) {
-		return ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Msg.timestamp", &timedata, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 
 	pubkey = msg->pubkey;
@@ -190,22 +200,22 @@ 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 ERR_OVERFLOW;
+		return asn_except(&node, ERR_OVERFLOW);
 	}
 	r = asn1_write_value(node, "Qaeda.Msg.pubkey", keydata, c);
 	if (r != ASN1_SUCCESS) {
-		return ERR_WRITE;
+		return asn_except(&node, ERR_WRITE);
 	}
 
 	*out_len = mx;
 	r = asn1_der_coding(node, "Qaeda.Msg", out, (int*)out_len, err);
 	if (r != ASN1_SUCCESS) {
-		return ERR_ENCODING;
+		return asn_except(&node, ERR_ENCODING);
 	}
 
 	r = asn1_delete_structure(&node);
 	if (r != ASN1_SUCCESS) {
-		return ERR_FAIL;
+		return asn_except(&node, ERR_FAIL);
 	}
 
 	return ERR_OK;
@@ -293,10 +303,6 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 	}
 	(*msg)->pubkey = lq_publickey_new(tmp);
 
-	r = asn1_delete_structure(&node);
-	if (r != ASN1_SUCCESS) {
-		return ERR_FAIL;
-	}
 
 	return ERR_OK;
 }