commit 7ca873dbe6dbc0c18faf0f904e148afd714eae48
parent 471a60ed3eafb7e31b83814fc3e465785641ba6a
Author: lash <dev@holbrook.no>
Date: Tue, 11 Mar 2025 14:59:34 +0000
Merge branch 'lash/kali-build' into HEAD
Diffstat:
8 files changed, 260 insertions(+), 66 deletions(-)
diff --git a/src/crypto/dummy.c b/src/crypto/dummy.c
@@ -1,7 +1,7 @@
#include "lq/crypto.h"
#include "lq/mem.h"
-// sha256sum "foo" 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae
+// sha512sum "foo" 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae
static const char pubkey_dummy_transform[64] = {
0xf7, 0xfb, 0xba, 0x6e, 0x06, 0x36, 0xf8, 0x90,
0xe5, 0x6f, 0xbb, 0xf3, 0x28, 0x3e, 0x52, 0x4c,
@@ -25,6 +25,14 @@ static const char sig_dummy_transform[64] = {
0x5b, 0xe3, 0xaa, 0x2f, 0xc1, 0xe6, 0xc1, 0x81,
};
+// sha256sum "foo" 2c26b46b68ffc68ff99b453c1d30413413422d706483bfa0f98a5e886266e7ae
+static const char encrypt_dummy_transport[32] = {
+ 0x2c, 0x26, 0xb4, 0x6b, 0x68, 0xff, 0xc6, 0x8f,
+ 0xf9, 0x9b, 0x45, 0x3c, 0x1d, 0x30, 0x41, 0x34,
+ 0x13, 0x42, 0x2d, 0x70, 0x64, 0x83, 0xbf, 0xa0,
+ 0xf9, 0x8a, 0x5e, 0x88, 0x62, 0x66, 0xe7, 0xae,
+};
+
// sha256sum "baz" baa5a0964d3320fbc0c6a922140453c8513ea24ab8fd0577034804a967248096
static const char digest_dummy_transform[32] = {
0xba, 0xa5, 0xa0, 0x96, 0x4d, 0x33, 0x20, 0xfb,
@@ -33,24 +41,79 @@ static const char digest_dummy_transform[32] = {
0x03, 0x48, 0x04, 0xa9, 0x67, 0x24, 0x80, 0x96
};
+struct dummycrypto {
+ char *data; ///< Literal private key data.
+ size_t len; ///< Length of private key data.
+};
+
+void keylock_xor(LQPrivKey *pk) {
+ int i;
+ struct dummycrypto *o;
+
+ o = (struct dummycrypto*)pk->impl;
+ for (i = 0; i < 32; i++) {
+ *((char*)o->data+i) ^= encrypt_dummy_transport[i];
+ }
+}
+
+int lq_privatekey_unlock(LQPrivKey *pk, const char *passphrase) {
+ char b;
+
+ if ((pk->key_state & LQ_KEY_LOCK) == 0) {
+ return 1;
+ }
+ keylock_xor(pk);
+ b = LQ_KEY_LOCK;
+ pk->key_state &= ~b;
+ return 0;
+}
+
+int lq_privatekey_lock(LQPrivKey *pk) {
+ char b;
+
+ if ((pk->key_state & LQ_KEY_LOCK) == 0) {
+ return 1;
+ }
+ keylock_xor(pk);
+ pk->key_state |= LQ_KEY_LOCK;
+ return 0;
+}
+
LQPrivKey* lq_privatekey_new(const char *seed, size_t seed_len) {
LQPrivKey *pk;
+ struct dummycrypto *o;
+ o = lq_alloc(sizeof(struct dummycrypto));
pk = lq_alloc(sizeof(LQPrivKey));
- pk->lokey = lq_alloc(seed_len);
- lq_cpy(pk->lokey, seed, seed_len);
- pk->lolen = seed_len;
+ o->data = lq_alloc(seed_len);
+ lq_cpy(o->data, seed, seed_len);
+ o->len = seed_len;
+ pk->impl = o;
+ pk->key_state = LQ_KEY_LOCK;
+ pk->key_typ = 0;
return pk;
}
+size_t lq_privatekey_bytes(LQPrivKey *pk, char **out) {
+ struct dummycrypto *o;
+
+ o = (struct dummycrypto*)pk->impl;
+ *out = o->data;
+ return o->len;
+}
+
LQPubKey* lq_publickey_new(const char *full) {
LQPubKey *pubk;
+ struct dummycrypto *o;
+ o = lq_alloc(sizeof(struct dummycrypto));
pubk = lq_alloc(sizeof(LQPubKey));
pubk->pk = 0;
- pubk->lokey = lq_alloc(65);
- lq_cpy(pubk->lokey, full, 65);
- pubk->lolen = 65;
+ o->data = lq_alloc(65);
+ lq_cpy(o->data, full, 65);
+ o->len = 65;
+ pubk->impl = o;
+ pubk->key_typ = 0;
return pubk;
}
@@ -61,40 +124,64 @@ LQPubKey* lq_publickey_from_privatekey(LQPrivKey *pk) {
char *src;
char *dst;
LQPubKey *pubk;
+ struct dummycrypto *o;
+ struct dummycrypto *opk;
+ o = lq_alloc(sizeof(struct dummycrypto));
pubk = lq_alloc(sizeof(LQPubKey));
pubk->pk = pk;
- pubk->lokey = lq_alloc(65);
- pubk->lolen = 65;
+ o->data = lq_alloc(65);
+ o->len = 65;
+ opk = (struct dummycrypto*)pubk->pk->impl;
for (i = 0; i < 64; i++) {
ii = i % 32;
- src = pk->lokey + ii;
- dst = pubk->lokey + i + 1;
+ src = opk->data + ii;
+ dst = o->data + i + 1;
*dst = *src ^ pubkey_dummy_transform[i];
}
- *((char*)pubk->lokey) = 0x04;
+ *((char*)o->data) = 0x04;
+ pubk->impl = o;
+ pubk->key_typ = 0;
return pubk;
}
+size_t lq_publickey_bytes(LQPubKey *pubk, char **out) {
+ struct dummycrypto *o;
+
+ if (pubk->impl == NULL) {
+ *out = "";
+ return 0;
+ }
+ o = (struct dummycrypto*)pubk->impl;
+ *out = o->data;
+ return o->len;
+}
+
LQSig* lq_privatekey_sign(LQPrivKey *pk, const char *msg, size_t msg_len, const char *salt) {
int i;
const char *src;
char *dst;
LQSig *sig;
+ struct dummycrypto *o;
+ if ((pk->key_state & LQ_KEY_LOCK) > 0) {
+ return NULL;
+ }
if (msg_len != LQ_DIGEST_LEN) {
return NULL;
}
sig = lq_alloc(sizeof(LQSig));
sig->pubkey = lq_publickey_from_privatekey(pk);
- sig->lolen = msg_len * 2 + 1;
- sig->losig = lq_alloc(sig->lolen);
+
+ o = lq_alloc(sizeof(struct dummycrypto));
+ o->len = msg_len * 2 + 1;
+ o->data = lq_alloc(o->len);
for (i = 0; i < msg_len; i++) {
src = msg + i;
- dst = sig->losig + i;
+ dst = o->data + i;
*dst = *src ^ sig_dummy_transform[i];
if (salt != NULL) {
*dst ^= *(salt + (i % LQ_SALT_LEN));
@@ -108,24 +195,68 @@ LQSig* lq_privatekey_sign(LQPrivKey *pk, const char *msg, size_t msg_len, const
}
}
- *(((char*)sig->losig) + sig->lolen) = 0x2a;
+ *(((char*)o->data) + o->len) = 0x2a;
+ sig->impl = o;
+
+ return sig;
+}
+
+LQSig* lq_signature_from_bytes(const char *sig_data, size_t sig_len, LQPubKey *pubkey) {
+ struct dummycrypto *o;
+ LQSig *sig;
+ if (sig_data == NULL) {
+ return NULL;
+ }
+ if (sig_len != 65) {
+ return NULL;
+ }
+ o = lq_alloc(sizeof(struct dummycrypto));
+ sig = lq_alloc(sizeof(LQSig));
+ o->data = lq_alloc(sig_len);
+ lq_cpy(o, sig_data, sig_len);
+ sig->impl = o;
+ sig->pubkey = pubkey;
return sig;
}
+size_t lq_signature_bytes(LQSig *sig, char **out) {
+ struct dummycrypto *o;
+
+ if (sig->impl == NULL) {
+ *out = "";
+ return 0;
+ }
+ o = (struct dummycrypto*)sig->impl;
+ *out = o->data;
+ return o->len;
+}
+
void lq_privatekey_free(LQPrivKey *pk) {
- lq_free(pk->lokey);
+ struct dummycrypto *o;
+
+ o = (struct dummycrypto *)pk->impl;
+ lq_free(o->data);
+ lq_free(o);
lq_free(pk);
}
void lq_publickey_free(LQPubKey *pubk) {
- lq_free(pubk->lokey);
+ struct dummycrypto *o;
+
+ o = (struct dummycrypto *)pubk->impl;
+ lq_free(o->data);
+ lq_free(o);
lq_free(pubk);
}
void lq_signature_free(LQSig *sig) {
+ struct dummycrypto *o;
+
+ o = (struct dummycrypto *)sig->impl;
lq_publickey_free(sig->pubkey);
- lq_free(sig->losig);
+ lq_free(o->data);
+ lq_free(o);
lq_free(sig);
}
diff --git a/src/lq/cert.c b/src/lq/cert.c
@@ -9,8 +9,7 @@
static LQPubKey nokey = {
.pk = 0,
- .lokey = "",
- .lolen = 0,
+ .impl = 0;
};
static LQMsg nomsg = {
.data = "",
@@ -20,8 +19,7 @@ static LQMsg nomsg = {
};
static LQSig nosig = {
.pubkey = &nokey,
- .losig = "",
- .lolen = 0,
+ .impl = 0;
};
LQCert* lq_certificate_new(LQCert *parent, LQCtx *ctx, LQMsg *req, LQMsg *rsp) {
@@ -52,6 +50,8 @@ static int state_digest(LQCert *cert, char *out, int final) {
int c;
char data[1024];
char *p;
+ char *sigdata;
+ size_t siglen;
c = LQ_CERT_DOMAIN_LEN;
p = data;
@@ -69,15 +69,17 @@ static int state_digest(LQCert *cert, char *out, int final) {
}
if (cert->request_sig != NULL) {
- lq_cpy(p, cert->request_sig->losig, cert->request_sig->lolen);
- c += cert->request_sig->lolen;
- p += cert->request_sig->lolen;
+ siglen = lq_signature_bytes(cert->request_sig, &sigdata);
+ lq_cpy(p, sigdata, siglen);
+ c += siglen;
+ p += siglen;
}
if (cert->response_sig != NULL) {
- lq_cpy(p, cert->response_sig->losig, cert->response_sig->lolen);
- c += cert->response_sig->lolen;
- p += cert->response_sig->lolen;
+ siglen = lq_signature_bytes(cert->response_sig, &sigdata);
+ lq_cpy(p, sigdata, siglen);
+ c += siglen;
+ p += siglen;
} else if (final) {
return ERR_RESPONSE;
}
@@ -128,6 +130,7 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
LQMsg *msg;
LQSig *sig;
asn1_node node;
+ char *sigdata;
mx = *out_len;
*out_len = 0;
@@ -172,12 +175,12 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
sig = &nosig;
}
// \todo proper sig serialize
- c = sig->lolen;
+ c = lq_signature_bytes(sig, &sigdata);
*out_len += c;
if (*out_len > mx) {
return ERR_OVERFLOW;
}
- r = asn1_write_value(node, "Qaeda.Cert.request_sig", sig->losig, c);
+ r = asn1_write_value(node, "Qaeda.Cert.request_sig", sigdata, c);
if (r != ASN1_SUCCESS) {
return ERR_WRITE;
}
@@ -206,12 +209,12 @@ int lq_certificate_serialize(LQCert *cert, char *out, size_t *out_len, LQResolve
sig = &nosig;
}
// \todo proper sig serialize
- c = sig->lolen;
+ c = lq_signature_bytes(sig, &sigdata);
*out_len += c;
if (*out_len > mx) {
return ERR_OVERFLOW;
}
- r = asn1_write_value(node, "Qaeda.Cert.response_sig", sig->losig, c);
+ r = asn1_write_value(node, "Qaeda.Cert.response_sig", sigdata, c);
if (r != ASN1_SUCCESS) {
return ERR_WRITE;
}
@@ -298,10 +301,7 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
return ERR_READ;
}
if (c > 0) {
- p->request_sig = lq_alloc(sizeof(LQSig));
- p->request_sig->losig = tmp;
- p->request_sig->lolen = c;
- // \todo deserialize pubkey from msg and insert
+ p->request_sig = lq_signature_from_bytes(tmp, c, NULL);
}
c = 4096;
@@ -321,10 +321,7 @@ int lq_certificate_deserialize(LQCert **cert, char *in, size_t in_len, LQResolve
return ERR_READ;
}
if (c > 0) {
- p->response_sig = lq_alloc(sizeof(LQSig));
- p->response_sig->losig = tmp;
- p->response_sig->lolen = c;
- // \todo deserialize pubkey from msg and insert
+ p->response_sig = lq_signature_from_bytes(tmp, c, NULL);
}
c = 4096;
diff --git a/src/lq/crypto.h b/src/lq/crypto.h
@@ -19,6 +19,10 @@
#define LQ_SALT_LEN 32
#endif
+enum lq_keystate_e {
+ LQ_KEY_LOCK,
+};
+
/**
* \struct LQPrivKey
@@ -28,9 +32,9 @@
* \see lq_privatekey_t
*/
struct lq_privatekey_t {
- void *lokey; ///< Literal private key data.
- size_t lolen; ///< Length of private key data.
- int key_typ; ///< Key type identifier. Unused for now.
+ short key_typ; ///< Key type identifier. Unused for now.
+ char key_state; ///< Key state flags.
+ void *impl; ///< Private key implementation object
};
typedef struct lq_privatekey_t LQPrivKey;
@@ -40,12 +44,12 @@ typedef struct lq_privatekey_t LQPrivKey;
* \brief Represents a public key embedded in private keys, certificates and signatures data.
*
* \see lq_publickey_t
+ * \todo add serialization
*/
struct lq_publickey_t {
- void *lokey; ///< Literal uncompressed public key data.
- size_t lolen; ///< Length of public key data.
- int key_typ; ///< Key type identifier. Unused for now.
+ short key_typ; ///< Key type identifier. Unused for now.
LQPrivKey *pk; ///< Corresponding private key. Optional, and set to NULL if not available.
+ void *impl; ///< Public key implementation object
};
typedef struct lq_publickey_t LQPubKey;
@@ -55,12 +59,11 @@ typedef struct lq_publickey_t LQPubKey;
* \brief Represents a cryptographic signature over a message digest.
*
* \see lq_signature_t
- *
+ * \todo add serialization
*/
struct lq_signature_t {
- void *losig; ///< Literal signature data.
- size_t lolen; ///< Length of signature data.
LQPubKey *pubkey; ///< Public key corresponding to the signature, used for verification. Optional (if public key can be recovered from signature)
+ void *impl; ///< Signature implementation object
};
typedef struct lq_signature_t LQSig;
@@ -75,6 +78,15 @@ typedef struct lq_signature_t LQSig;
LQPrivKey* lq_privatekey_new(const char *seed, size_t seed_len);
/**
+ * @brief Get raw private key bytes
+ *
+ * @param[in] Private key object.
+ * @param[out] Pointer to start of data.
+ * @return Length of key. If 0, no key could be found.
+ */
+size_t lq_privatekey_bytes(LQPrivKey *pk, char **out);
+
+/**
* @brief Create a new public key object.
*
* @param[in] Uncompressed public key data.
@@ -92,6 +104,14 @@ LQPubKey* lq_publickey_new(const char *full);
*/
LQPubKey* lq_publickey_from_privatekey(LQPrivKey *pk);
+/**
+ * @brief Get raw public key bytes
+ *
+ * @param[in] Public key object.
+ * @param[out] Pointer to start of data.
+ * @return Length of key. If 0, no key could be found.
+ */
+size_t lq_publickey_bytes(LQPubKey *pubk, char **out);
/**
* @brief Sign digest data using a private key.
@@ -100,11 +120,29 @@ LQPubKey* lq_publickey_from_privatekey(LQPrivKey *pk);
* @param[in] Message digest to sign.
* @param[in] Length of message to sign.
* @param[in] Salt data to use for the signature. Set to NULL if salt is not to be used. If not null, must be LQ_SALT_LEN long.
- * @return Signature object if signing was successful. Returns NULL if signature failed.
+ * @return Signature object if signing was successful. Returns NULL if signature failed. It is the caller's responsiblity to free the signature.
* @see lq_signature_free
*/
LQSig* lq_privatekey_sign(LQPrivKey *pk, const char *msg, size_t msg_len, const char *salt);
+/**
+ * @brief Create a signature object from byte data.
+ *
+ * @param[in] Signature byte data.
+ * @param[in] Length of data.
+ * @param[in] Public key used in signature. Can be NULL for recoverable signatures.
+ * @return Signature object if parse was successful. Returns NULL if parsing failed. It is the caller's responsiblity to free the signature.
+ */
+LQSig* lq_signature_from_bytes(const char *sig_data, size_t sig_len, LQPubKey *pubkey);
+
+/**
+ * @brief Get raw signature bytes
+ *
+ * @param[in] Signature object.
+ * @param[out] Pointer to start of data.
+ * @return Length of signature. If 0, no signature data could be found.
+ */
+size_t lq_signature_bytes(LQSig *sig, char **out);
/**
* @brief Free an allocated public key.
diff --git a/src/lq/msg.c b/src/lq/msg.c
@@ -12,8 +12,7 @@
static LQPubKey nokey = {
.pk = 0,
- .lokey = "",
- .lolen = 0,
+ .impl = 0,
};
LQMsg* lq_msg_new(const char *msg_data, size_t msg_len) {
@@ -79,6 +78,7 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
LQPubKey *pubkey;
LQResolve *resolve_active;
asn1_node node;
+ char *keydata;
mx = *out_len;
*out_len = 0;
@@ -137,12 +137,12 @@ int lq_msg_serialize(LQMsg *msg, char *out, size_t *out_len, LQResolve *resolve)
if (pubkey == NULL) {
pubkey = &nokey;
}
- c = pubkey->lolen;
+ c = lq_publickey_bytes(pubkey, &keydata);
*out_len += c;
if (*out_len > mx) {
return ERR_OVERFLOW;
}
- r = asn1_write_value(node, "Qaeda.Msg.pubkey", pubkey->lokey, c);
+ r = asn1_write_value(node, "Qaeda.Msg.pubkey", keydata, c);
if (r != ASN1_SUCCESS) {
return ERR_WRITE;
}
diff --git a/src/lq/trust.c b/src/lq/trust.c
@@ -17,10 +17,14 @@ int lq_trust_check(LQPubKey *pubkey, LQStore *store, enum trust_mode_e mode, con
unsigned char v[3];
double z;
unsigned char key_flags[(int)((LQ_TRUST_FLAG_BITS - 1)/8+1)];
+ char *keydata;
+ size_t keylen;
lq_set(v, 0, 3);
l = (int)((LQ_TRUST_FLAG_BITS - 1)/8+1);
- r = store->get(LQ_CONTENT_KEY, store, pubkey->lokey, pubkey->lolen, key_flags, &l);
+ //r = store->get(LQ_CONTENT_KEY, store, pubkey->lokey, pubkey->lolen, key_flags, &l);
+ keylen = lq_publickey_bytes(pubkey, &keydata);
+ r = store->get(LQ_CONTENT_KEY, store, keydata, keylen, (char*)key_flags, &l);
if (r != ERR_OK) {
return -1;
}
diff --git a/src/test/Makefile b/src/test/Makefile
@@ -22,4 +22,4 @@ clean:
rm -vf test_*_bin
rm -vf *.o
-.PHONY: clean
-\ No newline at end of file
+.PHONY: clean
diff --git a/src/test/test_crypto.c b/src/test/test_crypto.c
@@ -8,6 +8,12 @@
const char *data = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea commodo consequat. Duis aute irure dolor in reprehenderit in voluptate velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint occaecat cupidatat non proident, sunt in culpa qui officia deserunt mollit anim id est laborum.";
const char *salt = "spamspamspamspamspamspamspamspam";
+struct dummycrypto {
+ void *data; ///< Literal private key data.
+ size_t len; ///< Length of private key data.
+};
+
+
START_TEST(check_digest) {
int r;
char out[32];
@@ -21,11 +27,15 @@ START_TEST(check_publickey) {
LQPrivKey *pk;
LQPubKey *pubk;
LQPubKey *pubk_manual;
+ char *keydata;
+ char *keydata_manual;
pk = lq_privatekey_new(data, 32);
pubk = lq_publickey_from_privatekey(pk);
- pubk_manual = lq_publickey_new(pubk->lokey);
- ck_assert_mem_eq(pubk_manual->lokey, pubk->lokey, 65);
+ lq_publickey_bytes(pubk, &keydata);
+ pubk_manual = lq_publickey_new(keydata);
+ lq_publickey_bytes(pubk_manual, &keydata_manual);
+ ck_assert_mem_eq(keydata_manual, keydata, 65);
lq_publickey_free(pubk_manual);
lq_publickey_free(pubk);
lq_privatekey_free(pk);
@@ -37,13 +47,15 @@ START_TEST(check_signature) {
char digest[32];
LQPrivKey *pk;
LQSig *sig;
+ char *sigdata;
pk = lq_privatekey_new(data, 32);
lq_digest(data, strlen(data), (char*)digest);
sig = lq_privatekey_sign(pk, digest, 32, salt);
+ lq_signature_bytes(sig, &sigdata);
r = 42;
- ck_assert_mem_eq((sig->losig)+65, &r, 1);
+ ck_assert_mem_eq(sigdata+65, &r, 1);
lq_signature_free(sig);
lq_privatekey_free(pk);
diff --git a/src/test/test_trust.c b/src/test/test_trust.c
@@ -46,13 +46,16 @@ START_TEST(check_trust_none) {
LQPubKey *pubkey_alice;
LQPubKey *pubkey_bob;
LQStore *store;
+ char *lodata;
+ size_t lolen;
store = &LQMemContent;
pubkey_alice = lq_publickey_new(pubkey_data_alice);
pubkey_bob = lq_publickey_new(pubkey_data_bob);
- store->put(LQ_CONTENT_KEY, store, pubkey_alice->lokey, &pubkey_alice->lolen, (char*)trust_alice, 2);
+ lolen = lq_publickey_bytes(pubkey_alice, &lodata);
+ store->put(LQ_CONTENT_KEY, store, lodata, &lolen, (char*)trust_alice, 2);
lq_set(flag_test, 0, 2);
r = lq_trust_check(pubkey_alice, store, TRUST_MATCH_NONE, flag_test);
@@ -61,7 +64,8 @@ START_TEST(check_trust_none) {
r = lq_trust_check(pubkey_bob, store, TRUST_MATCH_NONE, flag_test);
ck_assert_int_eq(r, -1);
- store->put(LQ_CONTENT_KEY, store, pubkey_bob->lokey, &pubkey_bob->lolen, (char*)trust_bob, 2);
+ lolen = lq_publickey_bytes(pubkey_bob, &lodata);
+ store->put(LQ_CONTENT_KEY, store, lodata, &lolen, (char*)trust_bob, 2);
r = lq_trust_check(pubkey_bob, store, TRUST_MATCH_NONE, flag_test);
ck_assert_int_eq(r, 1000000);
@@ -74,12 +78,15 @@ START_TEST(check_trust_one) {
unsigned char flag_test[2];
LQPubKey *pubkey_alice;
LQStore *store;
+ char *lodata;
+ size_t lolen;
store = &LQMemContent;
pubkey_alice = lq_publickey_new(pubkey_data_alice);
- store->put(LQ_CONTENT_KEY, store, pubkey_alice->lokey, &pubkey_alice->lolen, (char*)trust_alice, 2);
+ lolen = lq_publickey_bytes(pubkey_alice, &lodata);
+ store->put(LQ_CONTENT_KEY, store, lodata, &lolen, (char*)trust_alice, 2);
flag_test[0] = 0;
flag_test[1] = 0x40;
@@ -95,12 +102,15 @@ START_TEST(check_trust_best) {
unsigned char flag_test[2];
LQPubKey *pubkey_alice;
LQStore *store;
+ char *lodata;
+ size_t lolen;
store = &LQMemContent;
pubkey_alice = lq_publickey_new(pubkey_data_alice);
- store->put(LQ_CONTENT_KEY, store, pubkey_alice->lokey, &pubkey_alice->lolen, (char*)trust_alice, 2);
+ lolen = lq_publickey_bytes(pubkey_alice, &lodata);
+ store->put(LQ_CONTENT_KEY, store, lodata, &lolen, (char*)trust_alice, 2);
flag_test[0] = 0x13;
flag_test[1] = 0x60;
@@ -116,12 +126,15 @@ START_TEST(check_trust_all) {
unsigned char flag_test[2];
LQPubKey *pubkey_alice;
LQStore *store;
+ char *lodata;
+ size_t lolen;
store = &LQMemContent;
pubkey_alice = lq_publickey_new(pubkey_data_alice);
- store->put(LQ_CONTENT_KEY, store, pubkey_alice->lokey, &pubkey_alice->lolen, (char*)trust_alice, 2);
+ lolen = lq_publickey_bytes(pubkey_alice, &lodata);
+ store->put(LQ_CONTENT_KEY, store, lodata, &lolen, (char*)trust_alice, 2);
flag_test[0] = 0x13;
flag_test[1] = 0x60;
