libqaeda

commit 6796465aadfdbbbdcb1c4acce5b7407beef9bbdb
parent 6f1ce1d85c777ae3930081b5c2f9297482d26927
Author: lash <dev@holbrook.no>
Date:   Sat,  5 Apr 2025 15:14:07 +0100

All tests go

Diffstat:
M
src/lq/cert.c
 | 
11
+++--------
M
src/lq/msg.c
 | 
63
++++++++++++++++++++++++++++++++++++++-------------------------
M
src/lq/msg.h
 | 
2
+-
M
src/test/Makefile
 | 
6
+++---
M
src/test/test_cert.c
 | 
35
++++++++++++++++++++---------------
M
src/test/test_msg.c
 | 
5
++++-

6 files changed, 69 insertions(+), 53 deletions(-)
diff --git a/src/lq/cert.c b/src/lq/cert.c
@@ -20,6 +20,7 @@ static LQPubKey nokey = {
 };
 
 static LQMsg nomsg = {
+	.state = 0,
 	.data = "",
 	.len = 0,
 	.time.tv_sec = 0,
@@ -384,10 +385,7 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 	if (r != ERR_OK) {
 		return asn_except(&item, r);
 	}
-	if (!lq_cmp(p->request, &nomsg, sizeof(LQMsg))) {
-		lq_msg_free(p->request);
-		p->request = NULL;
-	} else {
+	if (p->request != NULL) {
 		c = LQ_BLOCKSIZE;
 		r = asn1_read_value(item, "request_sig", tmp, &c);
 		if (r != ASN1_SUCCESS) {
@@ -412,10 +410,7 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
 		lq_msg_free(p->request);
 		return asn_except(&item, r);
 	}
-	if (!lq_cmp(p->response, &nomsg, sizeof(LQMsg))) {
-		lq_msg_free(p->response);
-		p->response = NULL;
-	} else {
+	if (p->response != NULL) {
 		c = LQ_BLOCKSIZE;
 		r = asn1_read_value(item, "response_sig", tmp, &c);
 		if (r != ASN1_SUCCESS) {
diff --git a/src/lq/msg.c b/src/lq/msg.c
@@ -31,6 +31,7 @@ LQMsg* lq_msg_new(const char *msg_data, size_t msg_len) {
 	msg->data = lq_alloc(msg_len);
 	lq_cpy(msg->data, msg_data, msg_len);
 	msg->len = msg_len;
+	msg->state = LQ_MSG_INIT;
 
 	return msg;
 }
@@ -123,7 +124,9 @@ static int asn_except(asn1_node *node, int err) {
 	return err;
 }
 
+/// TODO check upper bound of data contents
 int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve) {
+	char *p;
 	char resolved;
 	size_t c;
 	int r;
@@ -136,11 +139,11 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 	asn1_node item;
 	char *keydata;
 
-	resolved = LQ_MSG_DIGESTONLY;
 	mx = *out_len;
 	*out_len = 0;
 	lq_set(&item, 0, sizeof(item));
 
+	msg->state &= ~((char)LQ_MSG_RESOLVED);
 	r = asn1_create_element(asn, "Qaeda", &item);
 	if (r != ASN1_SUCCESS) {
 		return ERR_READ;
@@ -151,24 +154,28 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 	if (*out_len > mx) {
 		return asn_except(&item, ERR_OVERFLOW);
 	}
-	if (msg->len > 0) {
+
+	if (msg->state & LQ_MSG_INIT) {
 		r = lq_digest(msg->data, msg->len, tmp);
 		if (r != ERR_OK) {
 			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(&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(&item, r);
+			}
+			resolve_active = resolve_active->next;
+			msg->state |= LQ_MSG_RESOLVED;
 		}
-		resolve_active = resolve_active->next;
-		resolved = LQ_MSG_RESOLVED;
+	} else {
+		tmp[0] = 0;
+		c = 1;
 	}
 
-	if (resolved & LQ_MSG_DIGESTONLY) {
+	if (!(msg->state & LQ_MSG_RESOLVED)) {
 		debug(LLOG_DEBUG, "msg", "no resolver");	
 	}
 
@@ -230,6 +237,7 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
 int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *resolve) {
 	int r;
 	size_t c;
+	size_t l;
 	char resolved;
 	char err[LQ_ERRSIZE];
 	char z[LQ_DIGEST_LEN];
@@ -237,7 +245,8 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 	asn1_node item;
 	LQResolve *resolve_active;
 
-	resolved = LQ_MSG_DIGESTONLY;
+	resolved = 0;
+
 	lq_zero(&item, sizeof(item));
 
 	r = asn1_create_element(asn, "Qaeda.Msg", &item);
@@ -256,6 +265,16 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 		debug_logerr(LLOG_WARNING, ERR_READ, asn1_strerror(r));
 		return asn_except(&item, ERR_READ);
 	}
+
+	if (c == 1) {
+		debug(LLOG_DEBUG, "msg", "empty message");
+		*msg = NULL;
+		return ERR_OK;
+	}
+
+	lq_cpy(tmp, z, c);
+	l = c;
+
 	c = LQ_BLOCKSIZE;
 	resolve_active = resolve;
 	while (resolve_active != NULL) {
@@ -263,26 +282,20 @@ int lq_msg_deserialize(LQMsg **msg, const char *in, size_t in_len, LQResolve *re
 		if (r != ERR_OK) {
 			return asn_except(&item, r);
 		}
-		resolved = LQ_MSG_RESOLVED;
 		resolve_active = resolve_active->next;
+		resolved = LQ_MSG_RESOLVED;
 	}
 
-	if (resolved & LQ_MSG_DIGESTONLY) {
-		lq_cpy(tmp, z, LQ_DIGEST_LEN);
-		c = LQ_DIGEST_LEN;
-	} else {
-		if (!(resolved & LQ_MSG_RESOLVED)) {
-			return asn_except(&item, ERR_RESOLVE);
-		}
+	if (!(resolved & LQ_MSG_RESOLVED)) {
+		debug(LLOG_DEBUG, "msg", "no resolver");
+		c = l;
 	}
+
 	*msg = lq_msg_new((const char*)tmp, c);
-	(*msg)->state = resolved;
-	(*msg)->data = lq_alloc(c);
-	if ((*msg)->data == NULL) {
+	if (*msg == NULL) {
 		return asn_except(&item, ERR_MEM);
 	}
-	(*msg)->len = c;
-	lq_cpy((*msg)->data, tmp, c);
+	(*msg)->state = resolved;
 
 	/// \todo document timestamp size
 	c = 8;
diff --git a/src/lq/msg.h b/src/lq/msg.h
@@ -8,7 +8,7 @@
 #include "lq/store.h"
 
 enum lq_msgstate_e {
-	LQ_MSG_DIGESTONLY = 1,
+	LQ_MSG_INIT = 1,
 	LQ_MSG_RESOLVED = 2,
 };
 
diff --git a/src/test/Makefile b/src/test/Makefile
@@ -7,8 +7,8 @@ LIBS := ../asn1/defs_asn1_tab.o `pkg-config --libs libtasn1 libgcrypt` -L.. -L..
 LDFLAGS := -lcheck $(LIBS)
 COMMONOBJS = ../mem/std.o ../lq/config.o ../lq/err.o ../lq/base.o ../debug.o
 
-#all: build all-tests
-all: build one-test
+all: build all-tests
+#all: build one-test
 
 all-tests:
 	cK_FORK=no LD_LIBRARY_PATH=`realpath ../aux/lib` ./test_test_bin
@@ -21,7 +21,7 @@ all-tests:
 	CK_FORK=no LD_LIBRARY_PATH=`realpath ../aux/lib` ./test_store_bin
 
 one-test: build
-	CK_FORK=no LD_LIBRARY_PATH=`realpath ../aux/lib` ./test_cert_bin
+	CK_FORK=no LD_LIBRARY_PATH=`realpath ../aux/lib` ./test_msg_bin
 
 test: all
 
diff --git a/src/test/test_cert.c b/src/test/test_cert.c
@@ -189,7 +189,7 @@ START_TEST(check_cert_symmetric_ser_rsp_onesig) {
 	LQPrivKey *pk;
 	char buf[4096];
 
-	pk = lq_privatekey_new(passphrase, 32);
+	pk = lq_privatekey_new(passphrase, strlen(passphrase));
 	ck_assert_ptr_nonnull(pk);
 	req = lq_msg_new(data, strlen(data) + 1);
 	ck_assert_ptr_nonnull(req);
@@ -222,24 +222,29 @@ START_TEST(check_cert_symmetric_ser_rsp_bothsig) {
 	LQCert *cert;
 	LQMsg *req;
 	LQMsg *res;
-	LQPrivKey *pk;
-	char buf[4096];
+	LQPrivKey *pk_alice;
+	LQPrivKey *pk_bob;
+	char buf[LQ_BLOCKSIZE];
 
-	pk = lq_privatekey_new(passphrase, 32);
-	ck_assert_ptr_nonnull(pk);
+	pk_alice = lq_privatekey_new(passphrase, strlen(passphrase));
+	ck_assert_ptr_nonnull(pk_alice);
+	pk_bob = lq_privatekey_new(passphrase, strlen(passphrase));
+	ck_assert_ptr_nonnull(pk_bob);
+	r = lq_privatekey_unlock(pk_alice, passphrase, strlen(passphrase));
+	ck_assert_int_eq(r, 0);
+	r = lq_privatekey_unlock(pk_bob, passphrase, strlen(passphrase));
+	ck_assert_int_eq(r, 0);
 	cert = lq_certificate_new(NULL);
 	ck_assert_ptr_nonnull(cert);
 
 	req = lq_msg_new(data, strlen(data) + 1);
 	ck_assert_ptr_nonnull(req);
-
-	lq_privatekey_unlock(pk, passphrase, 32);
-	r = lq_certificate_request(cert, req, NULL);
+	r = lq_certificate_request(cert, req, pk_alice);
 	ck_assert_int_eq(r, 0);
 
 	res = lq_msg_new(data_two, strlen(data_two) + 1);
 	ck_assert_ptr_nonnull(res);
-	r = lq_certificate_respond(cert, res, NULL);
+	r = lq_certificate_respond(cert, res, pk_bob);
 	ck_assert_int_eq(r, 0);
 
 	c = LQ_BLOCKSIZE; 
@@ -259,16 +264,16 @@ Suite * common_suite(void) {
 
 	s = suite_create("cert");
 	tc = tcase_create("sign");
-//	tcase_add_test(tc, check_cert_sig_req);
-//	tcase_add_test(tc, check_cert_sig_res);
+	tcase_add_test(tc, check_cert_sig_req);
+	tcase_add_test(tc, check_cert_sig_res);
 	suite_add_tcase(s, tc);
 
 	tc = tcase_create("serialize");
-//	tcase_add_test(tc, check_cert_symmetric_ser_nomsg);
-//	tcase_add_test(tc, check_cert_symmetric_ser_req_nosig);
-//	tcase_add_test(tc, check_cert_symmetric_ser_req_sig);
+	tcase_add_test(tc, check_cert_symmetric_ser_nomsg);
+	tcase_add_test(tc, check_cert_symmetric_ser_req_nosig);
+	tcase_add_test(tc, check_cert_symmetric_ser_req_sig);
 	tcase_add_test(tc, check_cert_symmetric_ser_rsp_onesig);
-//	tcase_add_test(tc, check_cert_symmetric_ser_rsp_bothsig);
+	tcase_add_test(tc, check_cert_symmetric_ser_rsp_bothsig);
 	suite_add_tcase(s, tc);
 
 	return s;
diff --git a/src/test/test_msg.c b/src/test/test_msg.c
@@ -6,6 +6,7 @@
 #include "lq/crypto.h"
 #include "lq/io.h"
 #include "lq/mem.h"
+#include "lq/base.h"
 
 extern LQStore LQDummyContent;
 extern LQStore LQFileContent;
@@ -37,7 +38,7 @@ START_TEST(check_msg_symmetric) {
 	msg = lq_msg_new(data, strlen(data) + 1);
 	msg->pubkey = lq_publickey_new(data);
 
-	c = 4096;
+	c = LQ_BLOCKSIZE;
 	r = lq_msg_serialize(msg, buf, &c, &resolve);
 	ck_assert_int_eq(r, 0);
 	lq_msg_free(msg);
@@ -69,6 +70,8 @@ int main(void) {
 	Suite *s;
 	SRunner *sr;
 
+	lq_init();
+
 	s = common_suite();	
 	sr = srunner_create(s);