Add some utilities to make examples nicerHEADmasterbugfixes

4 files changed, 517 insertions, 1147 deletions

diff --git a/tests/ncr.c b/tests/ncr.c
index 13ee298..0e469d6 100644
--- a/tests/ncr.c
+++ b/tests/ncr.c
@@ -17,11 +17,10 @@
 #include <linux/netlink.h>
 #include "../ncr.h"
 #include <stdlib.h>
+#include "utils.h"
 
 #define DATA_SIZE 4096
 
-#define ALIGN_NL __attribute__((aligned(NLA_ALIGNTO)))
-
 #define ALG_AES_CBC "cbc(aes)"
 #define ALG_AES_ECB "ecb(aes)"
 
@@ -39,37 +38,11 @@ static void randomize_data(uint8_t * data, size_t data_size)
 #define WRAPPED_KEY_DATA_SIZE 32
 static int test_ncr_key(int cfd)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_key_generate f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr bits_head ALIGN_NL;
-		uint32_t bits ALIGN_NL;
-	} kgen;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_get_info f;
-		/* This union is only here to stop gcc from complaining about
-		   aliasing. */
-		union {
-			unsigned char __reserve[DATA_SIZE];
-			struct nlattr first_header;
-		} u ALIGN_NL;
-	} kinfo;
+	NCR_STRUCT(ncr_key_generate) kgen;
+	NCR_STRUCT(ncr_key_get_info) kinfo;
 	struct nlattr *nla;
 	ncr_key_t key;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kimport;
+	NCR_STRUCT(ncr_key_import) kimport;
 	struct ncr_key_export kexport;
 	uint8_t data[KEY_DATA_SIZE];
 	uint8_t data_bak[KEY_DATA_SIZE];
@@ -94,24 +67,15 @@ static int test_ncr_key(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key;
 	kimport.f.data = data;
 	kimport.f.data_size = sizeof(data);
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'a';
-	kimport.id[1] = 'b';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+	NCR_FINISH(kimport, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -159,18 +123,12 @@ static int test_ncr_key(int cfd)
 		return 1;
 	}
 
-	memset(&kgen.f, 0, sizeof(kgen.f));
-	kgen.f.input_size = sizeof(kgen);
+	nla = NCR_INIT(kgen);
 	kgen.f.key = key;
-	kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-	kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kgen.algo, ALG_AES_CBC);
-	kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-	kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kgen.flags = NCR_KEY_FLAG_EXPORTABLE;
-	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
-	kgen.bits_head.nla_type = NCR_ATTR_SECRET_KEY_BITS;
-	kgen.bits = 128;	/* 16 bytes */
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+	ncr_put_u32(&nla, NCR_ATTR_SECRET_KEY_BITS, 128); /* 16 bytes */
+	NCR_FINISH(kgen, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE, &kgen)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -202,17 +160,14 @@ static int test_ncr_key(int cfd)
 		return 1;
 	}
 
-	memset(&kinfo.f, 0, sizeof(kinfo.f));
+	nla = NCR_INIT(kinfo);
 	kinfo.f.output_size = sizeof(kinfo);
 	kinfo.f.key = key;
-	nla = &kinfo.u.first_header;
-	nla->nla_type = NCR_ATTR_WANTED_ATTRS;
-	attr_p = (uint16_t *) ((char *)nla + NLA_HDRLEN);
+	attr_p = ncr_reserve(&nla, NCR_ATTR_WANTED_ATTRS, 3 * sizeof(*attr_p));
 	*attr_p++ = NCR_ATTR_ALGORITHM;
 	*attr_p++ = NCR_ATTR_KEY_FLAGS;
 	*attr_p++ = NCR_ATTR_KEY_TYPE;
-	nla->nla_len = (char *)attr_p - (char *)nla;
-	kinfo.f.input_size = (char *)attr_p - (char *)&kinfo;
+	NCR_FINISH(kinfo, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_GET_INFO, &kinfo)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -221,12 +176,11 @@ static int test_ncr_key(int cfd)
 	}
 
 	got_algo = got_flags = got_type = 0;
-	if (kinfo.f.output_size <
-	    (char *)&kinfo.u.first_header - (char *)&kinfo) {
+	if (kinfo.f.output_size < sizeof (kinfo.f)) {
 		fprintf(stderr, "No nlattr returned\n");
 		return 1;
 	}
-	nla = &kinfo.u.first_header;
+	nla = (struct nlattr *)(&kinfo.f + 1);
 	for (;;) {
 		void *data;
 
@@ -305,18 +259,12 @@ static int test_ncr_key(int cfd)
 		return 1;
 	}
 
-	memset(&kgen.f, 0, sizeof(kgen.f));
-	kgen.f.input_size = sizeof(kgen);
+	nla = NCR_INIT(kgen);
 	kgen.f.key = key;
-	kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-	kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kgen.algo, ALG_AES_CBC);
-	kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-	kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kgen.flags = 0;
-	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-	kgen.bits_head.nla_type = NCR_ATTR_SECRET_KEY_BITS;
-	kgen.bits = 128;	/* 16 bytes */
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, 0);
+	ncr_put_u32(&nla, NCR_ATTR_SECRET_KEY_BITS, 128); /* 16 bytes */
+	NCR_FINISH(kgen, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE, &kgen)) {
 		perror("ioctl(NCRIO_KEY_GENERATE)");
@@ -352,30 +300,10 @@ static int test_ncr_wrap_key(int cfd)
 {
 	int i, ret;
 	ncr_key_t key, key2;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kimport;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_wrap f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_WALG_AES_RFC3394)] ALIGN_NL;
-	}
-	kwrap;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_unwrap f;
-		struct nlattr wrap_algo_head ALIGN_NL;
-		char wrap_algo[sizeof(NCR_WALG_AES_RFC3394)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kunwrap;
+	NCR_STRUCT(ncr_key_import) kimport;
+	NCR_STRUCT(ncr_key_wrap) kwrap;
+	NCR_STRUCT(ncr_key_unwrap) kunwrap;
+	struct nlattr *nla;
 	uint8_t data[WRAPPED_KEY_DATA_SIZE];
 	int data_size;
 
@@ -394,27 +322,18 @@ static int test_ncr_wrap_key(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key;
 	kimport.f.data =
 	    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
 	kimport.f.data_size = 16;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'a';
-	kimport.id[1] = 'b';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags =
-	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING |
-	    NCR_KEY_FLAG_UNWRAPPING;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING
+		    | NCR_KEY_FLAG_UNWRAPPING);
+	NCR_FINISH(kimport, nla);
 
 	ret = ioctl(cfd, NCRIO_KEY_IMPORT, &kimport);
 	if (geteuid() == 0 && ret) {
@@ -437,25 +356,17 @@ static int test_ncr_wrap_key(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key2;
 #define DKEY "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
 	kimport.f.data = DKEY;
 	kimport.f.data_size = 16;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'b';
-	kimport.id[1] = 'a';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ba", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE);
+	NCR_FINISH(kimport, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -464,15 +375,13 @@ static int test_ncr_wrap_key(int cfd)
 	}
 
 	/* now try wrapping key2 using key */
-	memset(&kwrap.f, 0, sizeof(kwrap.f));
-	kwrap.f.input_size = sizeof(kwrap);
+	nla = NCR_INIT(kwrap);
 	kwrap.f.wrapping_key = key;
 	kwrap.f.source_key = key2;
 	kwrap.f.buffer = data;
 	kwrap.f.buffer_size = sizeof(data);
-	kwrap.algo_head.nla_len = NLA_HDRLEN + sizeof(kwrap.algo);
-	kwrap.algo_head.nla_type = NCR_ATTR_WRAPPING_ALGORITHM;
-	strcpy(kwrap.algo, NCR_WALG_AES_RFC3394);
+	ncr_put_string(&nla, NCR_ATTR_WRAPPING_ALGORITHM, NCR_WALG_AES_RFC3394);
+	NCR_FINISH(kwrap, nla);
 
 	data_size = ioctl(cfd, NCRIO_KEY_WRAP, &kwrap);
 	if (data_size < 0) {
@@ -508,18 +417,15 @@ static int test_ncr_wrap_key(int cfd)
 		return 1;
 	}
 
-	memset(&kunwrap.f, 0, sizeof(kunwrap.f));
-	kunwrap.f.input_size = sizeof(kunwrap);
+	nla = NCR_INIT(kunwrap);
 	kunwrap.f.wrapping_key = key;
 	kunwrap.f.dest_key = key2;
 	kunwrap.f.data = data;
 	kunwrap.f.data_size = data_size;
-	kunwrap.wrap_algo_head.nla_len = NLA_HDRLEN + sizeof(kunwrap.wrap_algo);
-	kunwrap.wrap_algo_head.nla_type = NCR_ATTR_WRAPPING_ALGORITHM;
-	strcpy(kunwrap.wrap_algo, NCR_WALG_AES_RFC3394);
-	kunwrap.flags_head.nla_len = NLA_HDRLEN + sizeof(kunwrap.flags);
-	kunwrap.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kunwrap.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
+	ncr_put_string(&nla, NCR_ATTR_WRAPPING_ALGORITHM, NCR_WALG_AES_RFC3394);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE);
+	NCR_FINISH(kunwrap, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_UNWRAP, &kunwrap)) {
 		perror("ioctl(NCRIO_KEY_UNWRAP)");
@@ -567,23 +473,9 @@ static int test_ncr_wrap_key2(int cfd)
 {
 	int ret;
 	ncr_key_t key, key2;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kimport;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_wrap f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_WALG_AES_RFC3394)] ALIGN_NL;
-	}
-	kwrap;
+	NCR_STRUCT(ncr_key_import) kimport;
+	NCR_STRUCT(ncr_key_wrap) kwrap;
+	struct nlattr *nla;
 	uint8_t data[WRAPPED_KEY_DATA_SIZE];
 
 	/* test 1: generate a key in userspace import it
@@ -606,27 +498,18 @@ static int test_ncr_wrap_key2(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key;
 	kimport.f.data =
 	    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
 	kimport.f.data_size = 16;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'a';
-	kimport.id[1] = 'b';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags =
-	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING |
-	    NCR_KEY_FLAG_UNWRAPPING;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING
+		    | NCR_KEY_FLAG_UNWRAPPING);
+	NCR_FINISH(kimport, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -641,25 +524,17 @@ static int test_ncr_wrap_key2(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key2;
 	kimport.f.data =
 	    "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF";
 	kimport.f.data_size = 32;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'b';
-	kimport.id[1] = 'a';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ba", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE);
+	NCR_FINISH(kimport, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -668,15 +543,13 @@ static int test_ncr_wrap_key2(int cfd)
 	}
 
 	/* now try wrapping key2 using key */
-	memset(&kwrap.f, 0, sizeof(kwrap.f));
-	kwrap.f.input_size = sizeof(kwrap);
+	nla = NCR_INIT(kwrap);
 	kwrap.f.wrapping_key = key;
 	kwrap.f.source_key = key2;
 	kwrap.f.buffer = data;
 	kwrap.f.buffer_size = sizeof(data);
-	kwrap.algo_head.nla_len = NLA_HDRLEN + sizeof(kwrap.algo);
-	kwrap.algo_head.nla_type = NCR_ATTR_WRAPPING_ALGORITHM;
-	strcpy(kwrap.algo, NCR_WALG_AES_RFC3394);
+	ncr_put_string(&nla, NCR_ATTR_WRAPPING_ALGORITHM, NCR_WALG_AES_RFC3394);
+	NCR_FINISH(kwrap, nla);
 
 	ret = ioctl(cfd, NCRIO_KEY_WRAP, &kwrap);
 	if (ret >= 0) {
@@ -692,20 +565,11 @@ static int test_ncr_store_wrap_key(int cfd)
 {
 	int i;
 	ncr_key_t key2;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kimport;
+	NCR_STRUCT(ncr_key_import) kimport;
 	struct ncr_key_export kexport;
 	struct ncr_key_storage_wrap kwrap;
 	struct ncr_key_storage_unwrap kunwrap;
+	struct nlattr *nla;
 	uint8_t data[DATA_SIZE];
 	int data_size;
 
@@ -724,25 +588,17 @@ static int test_ncr_store_wrap_key(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key2;
 #define DKEY "\x00\x11\x22\x33\x44\x55\x66\x77\x88\x99\xAA\xBB\xCC\xDD\xEE\xFF"
 	kimport.f.data = DKEY;
 	kimport.f.data_size = 16;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'b';
-	kimport.id[1] = 'a';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ba", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE);
+	NCR_FINISH(kimport, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -877,30 +733,11 @@ struct aes_vectors_st {
 static int test_ncr_aes(int cfd)
 {
 	ncr_key_t key;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_ECB)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kimport;
+	NCR_STRUCT(ncr_key_import) kimport;
 	uint8_t data[KEY_DATA_SIZE];
 	int i, j;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_ECB)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-	} op;
+	NCR_STRUCT(ncr_session_once) op;
+	struct nlattr *nla;
 	size_t data_size;
 
 	/* convert it to key */
@@ -913,24 +750,15 @@ static int test_ncr_aes(int cfd)
 	fprintf(stdout, "Tests on AES Encryption\n");
 	for (i = 0; i < sizeof(aes_vectors) / sizeof(aes_vectors[0]); i++) {
 
-		memset(&kimport.f, 0, sizeof(kimport.f));
-		kimport.f.input_size = sizeof(kimport);
+		nla = NCR_INIT(kimport);
 		kimport.f.key = key;
 		kimport.f.data = aes_vectors[i].key;
 		kimport.f.data_size = 16;
-		kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-		kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-		kimport.id[0] = 'a';
-		kimport.id[1] = 'b';
-		kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-		kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-		kimport.type = NCR_KEY_TYPE_SECRET;
-		kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-		kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(kimport.algo, ALG_AES_ECB);
-		kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-		kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
+		ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_ECB);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+		NCR_FINISH(kimport, nla);
 		if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 			perror("ioctl(NCRIO_KEY_IMPORT)");
@@ -938,24 +766,16 @@ static int test_ncr_aes(int cfd)
 		}
 
 		/* encrypt */
-		memset(&op.f, 0, sizeof(op.f));
-		op.f.input_size = sizeof(op);
+		nla = NCR_INIT(op);
 		op.f.op = NCR_OP_ENCRYPT;
-		op.algo_head.nla_len = NLA_HDRLEN + sizeof(op.algo);
-		op.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(op.algo, ALG_AES_ECB);
-		op.key_head.nla_len = NLA_HDRLEN + sizeof(op.key);
-		op.key_head.nla_type = NCR_ATTR_KEY;
-		op.key = key;
-		op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
-		op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		op.input.data = aes_vectors[i].plaintext;
-		op.input.data_size = 16;
-		op.output_head.nla_len = NLA_HDRLEN + sizeof(op.output);
-		op.output_head.nla_type = NCR_ATTR_UPDATE_OUTPUT_BUFFER;
-		op.output.buffer = data;
-		op.output.buffer_size = sizeof(data);
-		op.output.result_size_ptr = &data_size;
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_ECB);
+		ncr_put_u32(&nla, NCR_ATTR_KEY, key);
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   aes_vectors[i].plaintext, 16);
+		ncr_put_session_output_buffer(&nla,
+					      NCR_ATTR_UPDATE_OUTPUT_BUFFER,
+					      data, sizeof(data), &data_size);
+		NCR_FINISH(op, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_ONCE, &op)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -985,24 +805,15 @@ static int test_ncr_aes(int cfd)
 	fprintf(stdout, "Tests on AES Decryption\n");
 	for (i = 0; i < sizeof(aes_vectors) / sizeof(aes_vectors[0]); i++) {
 
-		memset(&kimport.f, 0, sizeof(kimport.f));
-		kimport.f.input_size = sizeof(kimport);
+		nla = NCR_INIT(kimport);
 		kimport.f.key = key;
 		kimport.f.data = aes_vectors[i].key;
 		kimport.f.data_size = 16;
-		kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-		kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-		kimport.id[0] = 'a';
-		kimport.id[1] = 'b';
-		kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-		kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-		kimport.type = NCR_KEY_TYPE_SECRET;
-		kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-		kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(kimport.algo, ALG_AES_CBC);
-		kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-		kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
+		ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+		NCR_FINISH(kimport, nla);
 		if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 			perror("ioctl(NCRIO_KEY_IMPORT)");
@@ -1010,24 +821,16 @@ static int test_ncr_aes(int cfd)
 		}
 
 		/* decrypt */
-		memset(&op.f, 0, sizeof(op.f));
-		op.f.input_size = sizeof(op);
+		nla = NCR_INIT(op);
 		op.f.op = NCR_OP_DECRYPT;
-		op.algo_head.nla_len = NLA_HDRLEN + sizeof(op.algo);
-		op.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(op.algo, ALG_AES_ECB);
-		op.key_head.nla_len = NLA_HDRLEN + sizeof(op.key);
-		op.key_head.nla_type = NCR_ATTR_KEY;
-		op.key = key;
-		op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
-		op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		op.input.data = aes_vectors[i].ciphertext;
-		op.input.data_size = 16;
-		op.output_head.nla_len = NLA_HDRLEN + sizeof(op.output);
-		op.output_head.nla_type = NCR_ATTR_UPDATE_OUTPUT_BUFFER;
-		op.output.buffer = data;
-		op.output.buffer_size = sizeof(data);
-		op.output.result_size_ptr = &data_size;
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_ECB);
+		ncr_put_u32(&nla, NCR_ATTR_KEY, key);
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   aes_vectors[i].ciphertext, 16);
+		ncr_put_session_output_buffer(&nla,
+					      NCR_ATTR_UPDATE_OUTPUT_BUFFER,
+					      data, sizeof(data), &data_size);
+		NCR_FINISH(op, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_ONCE, &op)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1136,31 +939,12 @@ struct hash_vectors_st {
 static int test_ncr_hash(int cfd)
 {
 	ncr_key_t key;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} kimport;
+	NCR_STRUCT(ncr_key_import) kimport;
 	uint8_t data[HASH_DATA_SIZE];
 	int i, j;
 	size_t data_size;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} op;
+	NCR_STRUCT(ncr_session_once) op;
+	struct nlattr *nla;
 
 	/* convert it to key */
 	key = ioctl(cfd, NCRIO_KEY_INIT);
@@ -1178,29 +962,18 @@ static int test_ncr_hash(int cfd)
 		/* import key */
 		if (hash_vectors[i].key != NULL) {
 
-			memset(&kimport.f, 0, sizeof(kimport.f));
+			nla = NCR_INIT(kimport);
 			kimport.f.key = key;
 			kimport.f.data = hash_vectors[i].key;
 			kimport.f.data_size = hash_vectors[i].key_size;
-			kimport.id_head.nla_len
-			    = NLA_HDRLEN + sizeof(kimport.id);
-			kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-			kimport.id[0] = 'a';
-			kimport.id[1] = 'b';
-			kimport.type_head.nla_len
-			    = NLA_HDRLEN + sizeof(kimport.type);
-			kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-			kimport.type = NCR_KEY_TYPE_SECRET;
-			kimport.flags_head.nla_len
-			    = NLA_HDRLEN + sizeof(kimport.flags);
-			kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-			kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
-			kimport.algo_head.nla_len = NLA_HDRLEN + algo_size;
-			kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-			memcpy(kimport.algo, hash_vectors[i].algorithm,
-			       algo_size);
-			kimport.f.input_size
-			    = kimport.algo + algo_size - (char *)&kimport;
+			ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+			ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE,
+				    NCR_KEY_TYPE_SECRET);
+			ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+				    NCR_KEY_FLAG_EXPORTABLE);
+			ncr_put(&nla, NCR_ATTR_ALGORITHM,
+				hash_vectors[i].algorithm, algo_size);
+			NCR_FINISH(kimport, nla);
 			if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 				fprintf(stderr, "Error: %s:%d\n", __func__,
 					__LINE__);
@@ -1209,24 +982,19 @@ static int test_ncr_hash(int cfd)
 			}
 		}
 
-		memset(&op.f, 0, sizeof(op.f));
+		nla = NCR_INIT(op);
 		op.f.op = hash_vectors[i].op;
-		op.key_head.nla_len = NLA_HDRLEN + sizeof(op.key);
-		op.key_head.nla_type = NCR_ATTR_KEY;
-		op.key = hash_vectors[i].key != NULL ? key : NCR_KEY_INVALID;
-		op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
-		op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		op.input.data = hash_vectors[i].plaintext;
-		op.input.data_size = hash_vectors[i].plaintext_size;
-		op.output_head.nla_len = NLA_HDRLEN + sizeof(op.output);
-		op.output_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-		op.output.buffer = data;
-		op.output.buffer_size = sizeof(data);
-		op.output.result_size_ptr = &data_size;
-		op.algo_head.nla_len = NLA_HDRLEN + algo_size;
-		op.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		memcpy(op.algo, hash_vectors[i].algorithm, algo_size);
-		op.f.input_size = op.algo + algo_size - (char *)&op;
+		ncr_put_u32(&nla, NCR_ATTR_KEY, hash_vectors[i].key != NULL
+			    ? key : NCR_KEY_INVALID);
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   hash_vectors[i].plaintext,
+					   hash_vectors[i].plaintext_size);
+		ncr_put_session_output_buffer(&nla,
+					      NCR_ATTR_FINAL_OUTPUT_BUFFER,
+					      data, sizeof(data), &data_size);
+		ncr_put(&nla, NCR_ATTR_ALGORITHM, hash_vectors[i].algorithm,
+			algo_size);
+		NCR_FINISH(op, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_ONCE, &op)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1263,49 +1031,16 @@ static int test_ncr_hash(int cfd)
 static int test_ncr_hash_clone(int cfd)
 {
 	ncr_key_t key;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} kimport;
+	NCR_STRUCT(ncr_key_import) kimport;
 	uint8_t data[HASH_DATA_SIZE];
 	const struct hash_vectors_st *hv;
 	int j;
 	size_t data_size;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_init f;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} kinit;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_update f;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-	} kupdate;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_final f;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-	} kfinal;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr clone_head ALIGN_NL;
-		uint32_t clone ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-	} kclone;
+	NCR_STRUCT(ncr_session_init) kinit;
+	NCR_STRUCT(ncr_session_update) kupdate;
+	NCR_STRUCT(ncr_session_final) kfinal;
+	NCR_STRUCT(ncr_session_once) kclone;
+	struct nlattr *nla;
 	ncr_session_t ses;
 
 	/* convert it to key */
@@ -1326,28 +1061,18 @@ static int test_ncr_hash_clone(int cfd)
 		/* import key */
 		if (hv->key != NULL) {
 
-			memset(&kimport.f, 0, sizeof(kimport.f));
+			nla = NCR_INIT(kimport);
 			kimport.f.key = key;
 			kimport.f.data = hv->key;
 			kimport.f.data_size = hv->key_size;
-			kimport.id_head.nla_len
-			    = NLA_HDRLEN + sizeof(kimport.id);
-			kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-			kimport.id[0] = 'a';
-			kimport.id[1] = 'b';
-			kimport.type_head.nla_len
-			    = NLA_HDRLEN + sizeof(kimport.type);
-			kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-			kimport.type = NCR_KEY_TYPE_SECRET;
-			kimport.flags_head.nla_len
-			    = NLA_HDRLEN + sizeof(kimport.flags);
-			kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-			kimport.flags = NCR_KEY_FLAG_EXPORTABLE;
-			kimport.algo_head.nla_len = NLA_HDRLEN + algo_size;
-			kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-			memcpy(kimport.algo, hv->algorithm, algo_size);
-			kimport.f.input_size
-			    = kimport.algo + algo_size - (char *)&kimport;
+			ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+			ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE,
+				    NCR_KEY_TYPE_SECRET);
+			ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+				    NCR_KEY_FLAG_EXPORTABLE);
+			ncr_put(&nla, NCR_ATTR_ALGORITHM, hv->algorithm,
+				algo_size);
+			NCR_FINISH(kimport, nla);
 			if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 				fprintf(stderr, "Error: %s:%d\n", __func__,
 					__LINE__);
@@ -1357,15 +1082,12 @@ static int test_ncr_hash_clone(int cfd)
 		}
 
 		/* Initialize a session */
-		memset(&kinit.f, 0, sizeof(kinit.f));
+		nla = NCR_INIT(kinit);
 		kinit.f.op = hv->op;
-		kinit.key_head.nla_len = NLA_HDRLEN + sizeof(kinit.key);
-		kinit.key_head.nla_type = NCR_ATTR_KEY;
-		kinit.key = hv->key != NULL ? key : NCR_KEY_INVALID;
-		kinit.algo_head.nla_len = NLA_HDRLEN + algo_size;
-		kinit.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		memcpy(kinit.algo, hv->algorithm, algo_size);
-		kinit.f.input_size = kinit.algo + algo_size - (char *)&kinit;
+		ncr_put_u32(&nla, NCR_ATTR_KEY,
+			    hv->key != NULL ? key : NCR_KEY_INVALID);
+		ncr_put(&nla, NCR_ATTR_ALGORITHM, hv->algorithm, algo_size);
+		NCR_FINISH(kinit, nla);
 
 		ses = ioctl(cfd, NCRIO_SESSION_INIT, &kinit);
 		if (ses < 0) {
@@ -1375,13 +1097,12 @@ static int test_ncr_hash_clone(int cfd)
 		}
 
 		/* Submit half of the data */
-		memset(&kupdate.f, 0, sizeof(kupdate.f));
-		kupdate.f.input_size = sizeof(kupdate);
+		nla = NCR_INIT(kupdate);
 		kupdate.f.ses = ses;
-		kupdate.input_head.nla_len = NLA_HDRLEN + sizeof(kupdate.input);
-		kupdate.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		kupdate.input.data = hv->plaintext;
-		kupdate.input.data_size = hv->plaintext_size / 2;
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   hv->plaintext,
+					   hv->plaintext_size / 2);
+		NCR_FINISH(kupdate, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_UPDATE, &kupdate)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1390,22 +1111,18 @@ static int test_ncr_hash_clone(int cfd)
 		}
 
 		/* Clone a session, submit the other half, verify. */
-		memset(&kclone.f, 0, sizeof(kclone.f));
-		kclone.f.input_size = sizeof(kclone);
+		nla = NCR_INIT(kclone);
 		kclone.f.op = hv->op;
-		kclone.clone_head.nla_len = NLA_HDRLEN + sizeof(kclone.clone);
-		kclone.clone_head.nla_type = NCR_ATTR_SESSION_CLONE_FROM;
-		kclone.clone = ses;
-		kclone.input_head.nla_len = NLA_HDRLEN + sizeof(kclone.input);
-		kclone.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		kclone.input.data = hv->plaintext + hv->plaintext_size / 2;
-		kclone.input.data_size
-		    = hv->plaintext_size - hv->plaintext_size / 2;
-		kclone.output_head.nla_len = NLA_HDRLEN + sizeof(kclone.output);
-		kclone.output_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-		kclone.output.buffer = data;
-		kclone.output.buffer_size = sizeof(data);
-		kclone.output.result_size_ptr = &data_size;
+		ncr_put_u32(&nla, NCR_ATTR_SESSION_CLONE_FROM, ses);
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   hv->plaintext
+					   + hv->plaintext_size / 2,
+					   hv->plaintext_size
+					   - hv->plaintext_size / 2);
+		ncr_put_session_output_buffer(&nla,
+					      NCR_ATTR_FINAL_OUTPUT_BUFFER,
+					      data, sizeof(data), &data_size);
+		NCR_FINISH(kclone, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_ONCE, &kclone)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1431,19 +1148,17 @@ static int test_ncr_hash_clone(int cfd)
 		}
 
 		/* Submit the other half to the original session, verify. */
-		memset(&kfinal.f, 0, sizeof(kfinal.f));
-		kfinal.f.input_size = sizeof(kfinal);
+		nla = NCR_INIT(kfinal);
 		kfinal.f.ses = ses;
-		kfinal.input_head.nla_len = NLA_HDRLEN + sizeof(kfinal.input);
-		kfinal.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		kfinal.input.data = hv->plaintext + hv->plaintext_size / 2;
-		kfinal.input.data_size
-		    = hv->plaintext_size - hv->plaintext_size / 2;
-		kfinal.output_head.nla_len = NLA_HDRLEN + sizeof(kfinal.output);
-		kfinal.output_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-		kfinal.output.buffer = data;
-		kfinal.output.buffer_size = sizeof(data);
-		kfinal.output.result_size_ptr = &data_size;
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   hv->plaintext
+					   + hv->plaintext_size / 2,
+					   hv->plaintext_size
+					   - hv->plaintext_size / 2);
+		ncr_put_session_output_buffer(&nla,
+					      NCR_ATTR_FINAL_OUTPUT_BUFFER,
+					      data, sizeof(data), &data_size);
+		NCR_FINISH(kfinal, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_FINAL, &kfinal)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1479,40 +1194,15 @@ static int test_ncr_hash_key(int cfd)
 {
 	ncr_key_t key;
 	ncr_session_t ses;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} kimport;
+	NCR_STRUCT(ncr_key_import) kimport;
 	uint8_t data[HASH_DATA_SIZE];
 	int j;
 	size_t data_size, algo_size;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_init f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} op_init;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_update f;
-		struct nlattr data_head ALIGN_NL;
-		struct ncr_session_input_data data ALIGN_NL;
-	} op_up_data;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_update f;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key;
-	} op_up_key;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_final f;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-	} op_final;
+	NCR_STRUCT(ncr_session_init) op_init;
+	NCR_STRUCT(ncr_session_update) op_up_data;
+	NCR_STRUCT(ncr_session_update) op_up_key;
+	NCR_STRUCT(ncr_session_final) op_final;
+	struct nlattr *nla;
 	const uint8_t *output =
 	    (void *)
 	    "\xe2\xd7\x2c\x2e\x14\xad\x97\xc8\xd2\xdb\xce\xd8\xb3\x52\x9f\x1c\xb3\x2c\x5c\xec";
@@ -1529,36 +1219,26 @@ static int test_ncr_hash_key(int cfd)
 	fprintf(stdout, "\t%s:\n", hash_vectors[0].algorithm);
 	algo_size = strlen(hash_vectors[0].algorithm) + 1;
 	/* import key */
-	memset(&kimport.f, 0, sizeof(kimport.f));
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key;
 	kimport.f.data = hash_vectors[0].plaintext;
 	kimport.f.data_size = hash_vectors[0].plaintext_size;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'a';
-	kimport.id[1] = 'b';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_HASHABLE;
-	kimport.algo_head.nla_len = NLA_HDRLEN + algo_size;
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	memcpy(kimport.algo, hash_vectors[0].algorithm, algo_size);
-	kimport.f.input_size = kimport.algo + algo_size - (char *)&kimport;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_HASHABLE);
+	ncr_put(&nla, NCR_ATTR_ALGORITHM, hash_vectors[0].algorithm, algo_size);
+	NCR_FINISH(kimport, nla);
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
 		perror("ioctl(NCRIO_KEY_IMPORT)");
 		return 1;
 	}
 
-	memset(&op_init.f, 0, sizeof(op_init.f));
+	nla = NCR_INIT(op_init);
 	op_init.f.op = hash_vectors[0].op;
-	op_init.algo_head.nla_len = NLA_HDRLEN + algo_size;
-	op_init.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	memcpy(op_init.algo, hash_vectors[0].algorithm, algo_size);
-	op_init.f.input_size = op_init.algo + algo_size - (char *)&op_init;
+	ncr_put(&nla, NCR_ATTR_ALGORITHM, hash_vectors[0].algorithm, algo_size);
+	NCR_FINISH(op_init, nla);
 
 	ses = ioctl(cfd, NCRIO_SESSION_INIT, &op_init);
 	if (ses < 0) {
@@ -1567,13 +1247,12 @@ static int test_ncr_hash_key(int cfd)
 		return 1;
 	}
 
-	memset(&op_up_data.f, 0, sizeof(op_up_data.f));
-	op_up_data.f.input_size = sizeof(op_up_data);
+	nla = NCR_INIT(op_up_data);
 	op_up_data.f.ses = ses;
-	op_up_data.data_head.nla_len = NLA_HDRLEN + sizeof(op_up_data.data);
-	op_up_data.data_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	op_up_data.data.data = hash_vectors[0].plaintext;
-	op_up_data.data.data_size = hash_vectors[0].plaintext_size;
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+				   hash_vectors[0].plaintext,
+				   hash_vectors[0].plaintext_size);
+	NCR_FINISH(op_up_data, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_UPDATE, &op_up_data)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1581,12 +1260,10 @@ static int test_ncr_hash_key(int cfd)
 		return 1;
 	}
 
-	memset(&op_up_key.f, 0, sizeof(op_up_key.f));
-	op_up_key.f.input_size = sizeof(op_up_key);
+	nla = NCR_INIT(op_up_key);
 	op_up_key.f.ses = ses;
-	op_up_key.key_head.nla_len = NLA_HDRLEN + sizeof(op_up_key.key);
-	op_up_key.key_head.nla_type = NCR_ATTR_UPDATE_INPUT_KEY_AS_DATA;
-	op_up_key.key = key;
+	ncr_put_u32(&nla, NCR_ATTR_UPDATE_INPUT_KEY_AS_DATA, key);
+	NCR_FINISH(op_up_key, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_UPDATE, &op_up_key)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1594,14 +1271,11 @@ static int test_ncr_hash_key(int cfd)
 		return 1;
 	}
 
-	memset(&op_final.f, 0, sizeof(op_final.f));
-	op_final.f.input_size = sizeof(op_final);
+	nla = NCR_INIT(op_final);
 	op_final.f.ses = ses;
-	op_final.output_head.nla_len = NLA_HDRLEN + sizeof(op_final.output);
-	op_final.output_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-	op_final.output.buffer = data;
-	op_final.output.buffer_size = sizeof(data);
-	op_final.output.result_size_ptr = &data_size;
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_FINAL_OUTPUT_BUFFER, data,
+				      sizeof(data), &data_size);
+	NCR_FINISH(op_final, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_FINAL, &op_final)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
diff --git a/tests/pk.c b/tests/pk.c
index b2cae68..b1bdbe5 100644
--- a/tests/pk.c
+++ b/tests/pk.c
@@ -23,11 +23,10 @@
 #if GNUTLS_VERSION_NUMBER >= 0x020b00
 # include <gnutls/abstract.h>
 #endif
+#include "utils.h"
 
 #define DATA_SIZE 4096
 
-#define ALIGN_NL __attribute__((aligned(NLA_ALIGNTO)))
-
 #define SIGNATURE_HASH "sha1"
 #define SIGNATURE_HASH_SIZE 20
 
@@ -335,14 +334,7 @@ const char dh_params_txt[] = "-----BEGIN DH PARAMETERS-----\n"
 
 static int test_ncr_dh(int cfd)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_key_generate_pair f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_DH)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		unsigned char buffer[DATA_SIZE] ALIGN_NL;
-	} kgen;
+	NCR_STRUCT(ncr_key_generate_pair) kgen;
 	struct nlattr *nla;
 	ncr_key_t private1, public1, public2, private2;
 	ncr_key_t z1, z2;
@@ -352,15 +344,7 @@ static int test_ncr_dh(int cfd)
 	unsigned char y1[1024], y2[1024];
 	ssize_t y1_size, y2_size;
 	struct ncr_key_export kexport;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_derive f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_DERIVE_DH)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr public_head ALIGN_NL;
-		unsigned char public[DATA_SIZE] ALIGN_NL;
-	} kderive;
+	NCR_STRUCT(ncr_key_derive) kderive;
 
 	fprintf(stdout, "Tests on DH key exchange:");
 	fflush(stdout);
@@ -405,25 +389,14 @@ static int test_ncr_dh(int cfd)
 			return 1;
 		}
 
-		memset(&kgen.f, 0, sizeof(kgen.f));
+		nla = NCR_INIT(kgen);
 		kgen.f.private_key = private1;
 		kgen.f.public_key = public1;
-		kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-		kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(kgen.algo, ALG_DH);
-		kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-		kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kgen.flags = NCR_KEY_FLAG_EXPORTABLE;
-		nla = (struct nlattr *)kgen.buffer;
-		nla->nla_len = NLA_HDRLEN + p.size;
-		nla->nla_type = NCR_ATTR_DH_PRIME;
-		memcpy((char *)nla + NLA_HDRLEN, p.data, p.size);
-		nla = (struct nlattr *)((char *)nla + NLA_ALIGN(nla->nla_len));
-		nla->nla_len = NLA_HDRLEN + g.size;
-		nla->nla_type = NCR_ATTR_DH_BASE;
-		memcpy((char *)nla + NLA_HDRLEN, g.data, g.size);
-		nla = (struct nlattr *)((char *)nla + NLA_ALIGN(nla->nla_len));
-		kgen.f.input_size = (char *)nla - (char *)&kgen;
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_DH);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+		ncr_put(&nla, NCR_ATTR_DH_PRIME, p.data, p.size);
+		ncr_put(&nla, NCR_ATTR_DH_BASE, g.data, g.size);
+		NCR_FINISH(kgen, nla);
 		assert(kgen.f.input_size <= sizeof(kgen));
 
 		if (ioctl(cfd, NCRIO_KEY_GENERATE_PAIR, &kgen)) {
@@ -447,25 +420,14 @@ static int test_ncr_dh(int cfd)
 			return 1;
 		}
 
-		memset(&kgen.f, 0, sizeof(kgen.f));
+		nla = NCR_INIT(kgen);
 		kgen.f.private_key = private2;
 		kgen.f.public_key = public2;
-		kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-		kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(kgen.algo, ALG_DH);
-		kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-		kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kgen.flags = NCR_KEY_FLAG_EXPORTABLE;
-		nla = (struct nlattr *)kgen.buffer;
-		nla->nla_len = NLA_HDRLEN + p.size;
-		nla->nla_type = NCR_ATTR_DH_PRIME;
-		memcpy((char *)nla + NLA_HDRLEN, p.data, p.size);
-		nla = (struct nlattr *)((char *)nla + NLA_ALIGN(nla->nla_len));
-		nla->nla_len = NLA_HDRLEN + g.size;
-		nla->nla_type = NCR_ATTR_DH_BASE;
-		memcpy((char *)nla + NLA_HDRLEN, g.data, g.size);
-		nla = (struct nlattr *)((char *)nla + NLA_ALIGN(nla->nla_len));
-		kgen.f.input_size = (char *)nla - (char *)&kgen;
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_DH);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+		ncr_put(&nla, NCR_ATTR_DH_PRIME, p.data, p.size);
+		ncr_put(&nla, NCR_ATTR_DH_BASE, g.data, g.size);
+		NCR_FINISH(kgen, nla);
 		assert(kgen.f.input_size <= sizeof(kgen));
 
 		if (ioctl(cfd, NCRIO_KEY_GENERATE_PAIR, &kgen)) {
@@ -508,22 +470,14 @@ static int test_ncr_dh(int cfd)
 			return 1;
 		}
 
-		memset(&kderive.f, 0, sizeof(kderive.f));
+		nla = NCR_INIT(kderive);
 		kderive.f.input_key = private1;
 		kderive.f.new_key = z1;
-		kderive.algo_head.nla_len = NLA_HDRLEN + sizeof(kderive.algo);
-		kderive.algo_head.nla_type = NCR_ATTR_DERIVATION_ALGORITHM;
-		strcpy(kderive.algo, NCR_DERIVE_DH);
-		kderive.flags_head.nla_len = NLA_HDRLEN + sizeof(kderive.flags);
-		kderive.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kderive.flags = NCR_KEY_FLAG_EXPORTABLE;
-		kderive.public_head.nla_len = NLA_HDRLEN + y2_size;
-		kderive.public_head.nla_type = NCR_ATTR_DH_PUBLIC;
-		memcpy(kderive.public, y2, y2_size);
-		nla = (struct nlattr *)((char *)&kderive.public_head
-					+
-					NLA_ALIGN(kderive.public_head.nla_len));
-		kderive.f.input_size = (char *)nla - (char *)&kderive;
+		ncr_put_string(&nla, NCR_ATTR_DERIVATION_ALGORITHM,
+			       NCR_DERIVE_DH);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+		ncr_put(&nla, NCR_ATTR_DH_PUBLIC, y2, y2_size);
+		NCR_FINISH(kderive, nla);
 		assert(kderive.f.input_size <= sizeof(kderive));
 
 		if (ioctl(cfd, NCRIO_KEY_DERIVE, &kderive)) {
@@ -540,22 +494,14 @@ static int test_ncr_dh(int cfd)
 			return 1;
 		}
 
-		memset(&kderive.f, 0, sizeof(kderive.f));
+		nla = NCR_INIT(kderive);
 		kderive.f.input_key = private2;
 		kderive.f.new_key = z2;
-		kderive.algo_head.nla_len = NLA_HDRLEN + sizeof(kderive.algo);
-		kderive.algo_head.nla_type = NCR_ATTR_DERIVATION_ALGORITHM;
-		strcpy(kderive.algo, NCR_DERIVE_DH);
-		kderive.flags_head.nla_len = NLA_HDRLEN + sizeof(kderive.flags);
-		kderive.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kderive.flags = NCR_KEY_FLAG_EXPORTABLE;
-		kderive.public_head.nla_len = NLA_HDRLEN + y1_size;
-		kderive.public_head.nla_type = NCR_ATTR_DH_PUBLIC;
-		memcpy(kderive.public, y1, y1_size);
-		nla = (struct nlattr *)((char *)&kderive.public_head
-					+
-					NLA_ALIGN(kderive.public_head.nla_len));
-		kderive.f.input_size = (char *)nla - (char *)&kderive;
+		ncr_put_string(&nla, NCR_ATTR_DERIVATION_ALGORITHM,
+			       NCR_DERIVE_DH);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, NCR_KEY_FLAG_EXPORTABLE);
+		ncr_put(&nla, NCR_ATTR_DH_PUBLIC, y1, y1_size);
+		NCR_FINISH(kderive, nla);
 		assert(kderive.f.input_size <= sizeof(kderive));
 
 		if (ioctl(cfd, NCRIO_KEY_DERIVE, &kderive)) {
@@ -649,39 +595,11 @@ static int test_ncr_wrap_key3(int cfd)
 	int ret, i;
 	ncr_key_t key;
 	size_t data_size;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_import f;
-		struct nlattr id_head ALIGN_NL;
-		uint8_t id[2] ALIGN_NL;
-		struct nlattr type_head ALIGN_NL;
-		uint32_t type ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kimport;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_wrap f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_WALG_AES_RFC5649)] ALIGN_NL;
-	}
-	kwrap;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_unwrap f;
-		struct nlattr wrap_algo_head ALIGN_NL;
-		char wrap_algo[sizeof(NCR_WALG_AES_RFC5649)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-	} kunwrap;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_generate_pair f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_RSA)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr bits_head ALIGN_NL;
-		uint32_t bits ALIGN_NL;
-	} kgen;
+	NCR_STRUCT(ncr_key_import) kimport;
+	NCR_STRUCT(ncr_key_wrap) kwrap;
+	NCR_STRUCT(ncr_key_unwrap) kunwrap;
+	NCR_STRUCT(ncr_key_generate_pair) kgen;
+	struct nlattr *nla;
 	ncr_key_t pubkey, privkey;
 	uint8_t data[DATA_SIZE];
 	/* only the first two should be allowed to be wrapped.
@@ -722,27 +640,18 @@ static int test_ncr_wrap_key3(int cfd)
 		return 1;
 	}
 
-	memset(&kimport.f, 0, sizeof(kimport.f));
-	kimport.f.input_size = sizeof(kimport);
+	nla = NCR_INIT(kimport);
 	kimport.f.key = key;
 	kimport.f.data =
 	    "\x00\x01\x02\x03\x04\x05\x06\x07\x08\x09\x0A\x0B\x0C\x0D\x0E\x0F";
 	kimport.f.data_size = 16;
-	kimport.id_head.nla_len = NLA_HDRLEN + sizeof(kimport.id);
-	kimport.id_head.nla_type = NCR_ATTR_KEY_ID;
-	kimport.id[0] = 'a';
-	kimport.id[1] = 'b';
-	kimport.type_head.nla_len = NLA_HDRLEN + sizeof(kimport.type);
-	kimport.type_head.nla_type = NCR_ATTR_KEY_TYPE;
-	kimport.type = NCR_KEY_TYPE_SECRET;
-	kimport.algo_head.nla_len = NLA_HDRLEN + sizeof(kimport.algo);
-	kimport.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kimport.algo, ALG_AES_CBC);
-	kimport.flags_head.nla_len = NLA_HDRLEN + sizeof(kimport.flags);
-	kimport.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kimport.flags =
-	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING |
-	    NCR_KEY_FLAG_UNWRAPPING;
+	ncr_put(&nla, NCR_ATTR_KEY_ID, "ab", 2);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_TYPE, NCR_KEY_TYPE_SECRET);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPING
+		    | NCR_KEY_FLAG_UNWRAPPING);
+	NCR_FINISH(kimport, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_IMPORT, &kimport)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -755,19 +664,14 @@ static int test_ncr_wrap_key3(int cfd)
 		fprintf(stdout, ".");
 		fflush(stdout);
 
-		memset(&kgen.f, 0, sizeof(kgen.f));
-		kgen.f.input_size = sizeof(kgen);
+		nla = NCR_INIT(kgen);
 		kgen.f.private_key = privkey;
 		kgen.f.public_key = pubkey;
-		kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-		kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		strcpy(kgen.algo, ALG_RSA);
-		kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-		kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-		kgen.flags = NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE;
-		kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
-		kgen.bits_head.nla_type = NCR_ATTR_RSA_MODULUS_BITS;
-		kgen.bits = sizes[i];
+		ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_RSA);
+		ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+			    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE);
+		ncr_put_u32(&nla, NCR_ATTR_RSA_MODULUS_BITS, sizes[i]);
+		NCR_FINISH(kgen, nla);
 
 		if (ioctl(cfd, NCRIO_KEY_GENERATE_PAIR, &kgen)) {
 			fprintf(stderr, "Error[%d-%d]: %s:%d\n", i, sizes[i],
@@ -777,15 +681,14 @@ static int test_ncr_wrap_key3(int cfd)
 		}
 
 		/* now try wrapping key2 using key */
-		memset(&kwrap.f, 0, sizeof(kwrap.f));
-		kwrap.f.input_size = sizeof(kwrap);
+		nla = NCR_INIT(kwrap);
 		kwrap.f.wrapping_key = key;
 		kwrap.f.source_key = pubkey;
 		kwrap.f.buffer = data;
 		kwrap.f.buffer_size = sizeof(data);
-		kwrap.algo_head.nla_len = NLA_HDRLEN + sizeof(kwrap.algo);
-		kwrap.algo_head.nla_type = NCR_ATTR_WRAPPING_ALGORITHM;
-		strcpy(kwrap.algo, NCR_WALG_AES_RFC5649);
+		ncr_put_string(&nla, NCR_ATTR_WRAPPING_ALGORITHM,
+			       NCR_WALG_AES_RFC5649);
+		NCR_FINISH(kwrap, nla);
 
 		ret = ioctl(cfd, NCRIO_KEY_WRAP, &kwrap);
 		if (ret < 0) {
@@ -796,15 +699,14 @@ static int test_ncr_wrap_key3(int cfd)
 		}
 
 		/* now try wrapping private using key */
-		memset(&kwrap.f, 0, sizeof(kwrap.f));
-		kwrap.f.input_size = sizeof(kwrap);
+		nla = NCR_INIT(kwrap);
 		kwrap.f.wrapping_key = key;
 		kwrap.f.source_key = privkey;
 		kwrap.f.buffer = data;
 		kwrap.f.buffer_size = sizeof(data);
-		kwrap.algo_head.nla_len = NLA_HDRLEN + sizeof(kwrap.algo);
-		kwrap.algo_head.nla_type = NCR_ATTR_WRAPPING_ALGORITHM;
-		strcpy(kwrap.algo, NCR_WALG_AES_RFC5649);
+		ncr_put_string(&nla, NCR_ATTR_WRAPPING_ALGORITHM,
+			       NCR_WALG_AES_RFC5649);
+		NCR_FINISH(kwrap, nla);
 
 		ret = ioctl(cfd, NCRIO_KEY_WRAP, &kwrap);
 		if (ret < 0 && i != 2) {
@@ -823,21 +725,15 @@ static int test_ncr_wrap_key3(int cfd)
 			data_size = ret;
 
 			/* try unwrapping */
-			memset(&kunwrap.f, 0, sizeof(kunwrap.f));
-			kunwrap.f.input_size = sizeof(kunwrap);
+			nla = NCR_INIT(kunwrap);
 			kunwrap.f.wrapping_key = key;
 			kunwrap.f.dest_key = privkey;
 			kunwrap.f.data = data;
 			kunwrap.f.data_size = data_size;
-			kunwrap.wrap_algo_head.nla_len
-			    = NLA_HDRLEN + sizeof(kunwrap.wrap_algo);
-			kunwrap.wrap_algo_head.nla_type
-			    = NCR_ATTR_WRAPPING_ALGORITHM;
-			strcpy(kunwrap.wrap_algo, NCR_WALG_AES_RFC5649);
-			kunwrap.flags_head.nla_len
-			    = NLA_HDRLEN + sizeof(kunwrap.flags);
-			kunwrap.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-			kunwrap.flags = 0;
+			ncr_put_string(&nla, NCR_ATTR_WRAPPING_ALGORITHM,
+				       NCR_WALG_AES_RFC5649);
+			ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS, 0);
+			NCR_FINISH(kunwrap, nla);
 
 			ret = ioctl(cfd, NCRIO_KEY_UNWRAP, &kunwrap);
 			if (ret) {
@@ -860,21 +756,8 @@ static int test_ncr_wrap_key3(int cfd)
 static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 			   int oaep)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_RSA)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr rsa_head ALIGN_NL;
-		uint32_t rsa ALIGN_NL;
-		struct nlattr oaep_hash_head ALIGN_NL;
-		char oaep_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-	} op;
+	NCR_STRUCT(ncr_session_once) op;
+	struct nlattr *nla;
 	uint8_t data[DATA_SIZE];
 	uint8_t vdata[RSA_ENCRYPT_SIZE];
 	size_t enc_size, dec_size;
@@ -887,34 +770,19 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 	memcpy(vdata, data, sizeof(vdata));
 
 	/* do encryption */
-	memset(&op.f, 0, sizeof(op.f));
-	op.f.input_size = sizeof(op);
+	nla = NCR_INIT(op);
 	op.f.op = NCR_OP_ENCRYPT;
-	op.algo_head.nla_len = NLA_HDRLEN + sizeof(op.algo);
-	op.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(op.algo, ALG_RSA);
-	op.key_head.nla_len = NLA_HDRLEN + sizeof(op.key);
-	op.key_head.nla_type = NCR_ATTR_KEY;
-	op.key = pubkey;
-	op.rsa_head.nla_len = NLA_HDRLEN + sizeof(op.rsa);
-	op.rsa_head.nla_type = NCR_ATTR_RSA_ENCODING_METHOD;
-	if (oaep) {
-		op.rsa = RSA_PKCS1_OAEP;
-	} else {
-		op.rsa = RSA_PKCS1_V1_5;
-	}
-	op.oaep_hash_head.nla_len = NLA_HDRLEN + sizeof(op.oaep_hash);
-	op.oaep_hash_head.nla_type = NCR_ATTR_RSA_OAEP_HASH_ALGORITHM;
-	strcpy(op.oaep_hash, SIGNATURE_HASH);	/* Ignored if not using OAEP */
-	op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
-	op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	op.input.data = data;
-	op.input.data_size = RSA_ENCRYPT_SIZE;
-	op.output_head.nla_len = NLA_HDRLEN + sizeof(op.output);
-	op.output_head.nla_type = NCR_ATTR_UPDATE_OUTPUT_BUFFER;
-	op.output.buffer = data;
-	op.output.buffer_size = sizeof(data);
-	op.output.result_size_ptr = &enc_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_RSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, pubkey);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_ENCODING_METHOD,
+		    oaep ? RSA_PKCS1_OAEP : RSA_PKCS1_V1_5);
+	ncr_put_string(&nla, NCR_ATTR_RSA_OAEP_HASH_ALGORITHM,
+		       SIGNATURE_HASH);	/* Ignored if not using OAEP */
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   RSA_ENCRYPT_SIZE);
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_UPDATE_OUTPUT_BUFFER, data,
+				      sizeof(data), &enc_size);
+	NCR_FINISH(op, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_ONCE, &op)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -923,34 +791,19 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 	}
 
 	/* decrypt data */
-	memset(&op.f, 0, sizeof(op.f));
-	op.f.input_size = sizeof(op);
+	nla = NCR_INIT(op);
 	op.f.op = NCR_OP_DECRYPT;
-	op.algo_head.nla_len = NLA_HDRLEN + sizeof(op.algo);
-	op.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(op.algo, ALG_RSA);
-	op.key_head.nla_len = NLA_HDRLEN + sizeof(op.key);
-	op.key_head.nla_type = NCR_ATTR_KEY;
-	op.key = privkey;
-	op.rsa_head.nla_len = NLA_HDRLEN + sizeof(op.rsa);
-	op.rsa_head.nla_type = NCR_ATTR_RSA_ENCODING_METHOD;
-	if (oaep) {
-		op.rsa = RSA_PKCS1_OAEP;
-	} else {
-		op.rsa = RSA_PKCS1_V1_5;
-	}
-	op.oaep_hash_head.nla_len = NLA_HDRLEN + sizeof(op.oaep_hash);
-	op.oaep_hash_head.nla_type = NCR_ATTR_RSA_OAEP_HASH_ALGORITHM;
-	strcpy(op.oaep_hash, SIGNATURE_HASH);	/* Ignored if not using OAEP */
-	op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
-	op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	op.input.data = data;
-	op.input.data_size = enc_size;
-	op.output_head.nla_len = NLA_HDRLEN + sizeof(op.output);
-	op.output_head.nla_type = NCR_ATTR_UPDATE_OUTPUT_BUFFER;
-	op.output.buffer = data;
-	op.output.buffer_size = sizeof(data);
-	op.output.result_size_ptr = &dec_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_RSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, privkey);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_ENCODING_METHOD,
+		    oaep ? RSA_PKCS1_OAEP :  RSA_PKCS1_V1_5);
+	ncr_put_string(&nla, NCR_ATTR_RSA_OAEP_HASH_ALGORITHM,
+		       SIGNATURE_HASH);	/* Ignored if not using OAEP */
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   enc_size);
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_UPDATE_OUTPUT_BUFFER, data,
+				      sizeof(data), &dec_size);
+	NCR_FINISH(op, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_ONCE, &op)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -976,36 +829,9 @@ static int rsa_key_encrypt(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 			       int pss)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_RSA)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr rsa_head ALIGN_NL;
-		uint32_t rsa ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_output_buffer signature ALIGN_NL;
-	} ksign;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_RSA)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr rsa_head ALIGN_NL;
-		uint32_t rsa ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_input_data signature ALIGN_NL;
-	} kverify;
+	NCR_STRUCT(ncr_session_once) ksign;
+	NCR_STRUCT(ncr_session_once) kverify;
+	struct nlattr *nla;
 	uint8_t data[DATA_SIZE];
 	uint8_t sig[DATA_SIZE];
 	size_t sig_size;
@@ -1018,30 +844,18 @@ static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 	memset(data, 0x3, sizeof(data));
 
 	/* sign data */
-	memset(&ksign.f, 0, sizeof(ksign.f));
-	ksign.f.input_size = sizeof(ksign);
+	nla = NCR_INIT(ksign);
 	ksign.f.op = NCR_OP_SIGN;
-	ksign.algo_head.nla_len = NLA_HDRLEN + sizeof(ksign.algo);
-	ksign.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(ksign.algo, ALG_RSA);
-	ksign.key_head.nla_len = NLA_HDRLEN + sizeof(ksign.key);
-	ksign.key_head.nla_type = NCR_ATTR_KEY;
-	ksign.key = privkey;
-	ksign.rsa_head.nla_len = NLA_HDRLEN + sizeof(ksign.rsa);
-	ksign.rsa_head.nla_type = NCR_ATTR_RSA_ENCODING_METHOD;
-	ksign.rsa = (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5;
-	ksign.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(ksign.sign_hash);
-	ksign.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(ksign.sign_hash, SIGNATURE_HASH);
-	ksign.input_head.nla_len = NLA_HDRLEN + sizeof(ksign.input);
-	ksign.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	ksign.input.data = data;
-	ksign.input.data_size = DATA_TO_SIGN;
-	ksign.signature_head.nla_len = NLA_HDRLEN + sizeof(ksign.signature);
-	ksign.signature_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-	ksign.signature.buffer = sig;
-	ksign.signature.buffer_size = sizeof(sig);
-	ksign.signature.result_size_ptr = &sig_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_RSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, privkey);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_ENCODING_METHOD,
+		    (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   DATA_TO_SIGN);
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_FINAL_OUTPUT_BUFFER, sig,
+				      sizeof(sig), &sig_size);
+	NCR_FINISH(ksign, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_ONCE, &ksign)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1052,29 +866,18 @@ static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 	/* verify signature */
 	memset(data, 0x3, sizeof(data));
 
-	memset(&kverify.f, 0, sizeof(kverify.f));
-	kverify.f.input_size = sizeof(kverify);
+	nla = NCR_INIT(kverify);
 	kverify.f.op = NCR_OP_VERIFY;
-	kverify.algo_head.nla_len = NLA_HDRLEN + sizeof(kverify.algo);
-	kverify.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kverify.algo, ALG_RSA);
-	kverify.key_head.nla_len = NLA_HDRLEN + sizeof(kverify.key);
-	kverify.key_head.nla_type = NCR_ATTR_KEY;
-	kverify.key = pubkey;
-	kverify.rsa_head.nla_len = NLA_HDRLEN + sizeof(kverify.rsa);
-	kverify.rsa_head.nla_type = NCR_ATTR_RSA_ENCODING_METHOD;
-	kverify.rsa = (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5;
-	kverify.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(kverify.sign_hash);
-	kverify.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(kverify.sign_hash, SIGNATURE_HASH);
-	kverify.input_head.nla_len = NLA_HDRLEN + sizeof(kverify.input);
-	kverify.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	kverify.input.data = data;
-	kverify.input.data_size = DATA_TO_SIGN;
-	kverify.signature_head.nla_len = NLA_HDRLEN + sizeof(kverify.signature);
-	kverify.signature_head.nla_type = NCR_ATTR_FINAL_INPUT_DATA;
-	kverify.signature.data = sig;
-	kverify.signature.data_size = sig_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_RSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, pubkey);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_ENCODING_METHOD,
+		    (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   DATA_TO_SIGN);
+	ncr_put_session_input_data(&nla, NCR_ATTR_FINAL_INPUT_DATA, sig,
+				   sig_size);
+	NCR_FINISH(kverify, nla);
 
 	ret = ioctl(cfd, NCRIO_SESSION_ONCE, &kverify);
 	if (ret < 0) {
@@ -1097,36 +900,9 @@ static int rsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey,
 static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 					   ncr_key_t pubkey, int pss)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_ALG_RSA_TRANSPARENT_HASH)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr rsa_head ALIGN_NL;
-		uint32_t rsa ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_output_buffer signature ALIGN_NL;
-	} ksign;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_ALG_RSA_TRANSPARENT_HASH)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr rsa_head ALIGN_NL;
-		uint32_t rsa ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_input_data signature ALIGN_NL;
-	} kverify;
+	NCR_STRUCT(ncr_session_once) ksign;
+	NCR_STRUCT(ncr_session_once) kverify;
+	struct nlattr *nla;
 	uint8_t data[SIGNATURE_HASH_SIZE];
 	uint8_t sig[DATA_SIZE];
 	size_t sig_size;
@@ -1139,30 +915,18 @@ static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 	memset(data, 0x3, sizeof(data));
 
 	/* sign data */
-	memset(&ksign.f, 0, sizeof(ksign.f));
-	ksign.f.input_size = sizeof(ksign);
+	nla = NCR_INIT(ksign);
 	ksign.f.op = NCR_OP_SIGN;
-	ksign.algo_head.nla_len = NLA_HDRLEN + sizeof(ksign.algo);
-	ksign.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(ksign.algo, NCR_ALG_RSA_TRANSPARENT_HASH);
-	ksign.key_head.nla_len = NLA_HDRLEN + sizeof(ksign.key);
-	ksign.key_head.nla_type = NCR_ATTR_KEY;
-	ksign.key = privkey;
-	ksign.rsa_head.nla_len = NLA_HDRLEN + sizeof(ksign.rsa);
-	ksign.rsa_head.nla_type = NCR_ATTR_RSA_ENCODING_METHOD;
-	ksign.rsa = (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5;
-	ksign.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(ksign.sign_hash);
-	ksign.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(ksign.sign_hash, SIGNATURE_HASH);
-	ksign.input_head.nla_len = NLA_HDRLEN + sizeof(ksign.input);
-	ksign.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	ksign.input.data = data;
-	ksign.input.data_size = SIGNATURE_HASH_SIZE;
-	ksign.signature_head.nla_len = NLA_HDRLEN + sizeof(ksign.signature);
-	ksign.signature_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-	ksign.signature.buffer = sig;
-	ksign.signature.buffer_size = sizeof(sig);
-	ksign.signature.result_size_ptr = &sig_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, NCR_ALG_RSA_TRANSPARENT_HASH);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, privkey);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_ENCODING_METHOD,
+		    (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   SIGNATURE_HASH_SIZE);
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_FINAL_OUTPUT_BUFFER, sig,
+				      sizeof(sig), &sig_size);
+	NCR_FINISH(ksign, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_ONCE, &ksign)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1173,29 +937,18 @@ static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 	/* verify signature */
 	memset(data, 0x3, sizeof(data));
 
-	memset(&kverify.f, 0, sizeof(kverify.f));
-	kverify.f.input_size = sizeof(kverify);
+	nla = NCR_INIT(kverify);
 	kverify.f.op = NCR_OP_VERIFY;
-	kverify.algo_head.nla_len = NLA_HDRLEN + sizeof(kverify.algo);
-	kverify.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kverify.algo, NCR_ALG_RSA_TRANSPARENT_HASH);
-	kverify.key_head.nla_len = NLA_HDRLEN + sizeof(kverify.key);
-	kverify.key_head.nla_type = NCR_ATTR_KEY;
-	kverify.key = pubkey;
-	kverify.rsa_head.nla_len = NLA_HDRLEN + sizeof(kverify.rsa);
-	kverify.rsa_head.nla_type = NCR_ATTR_RSA_ENCODING_METHOD;
-	kverify.rsa = (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5;
-	kverify.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(kverify.sign_hash);
-	kverify.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(kverify.sign_hash, SIGNATURE_HASH);
-	kverify.input_head.nla_len = NLA_HDRLEN + sizeof(kverify.input);
-	kverify.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	kverify.input.data = data;
-	kverify.input.data_size = SIGNATURE_HASH_SIZE;
-	kverify.signature_head.nla_len = NLA_HDRLEN + sizeof(kverify.signature);
-	kverify.signature_head.nla_type = NCR_ATTR_FINAL_INPUT_DATA;
-	kverify.signature.data = sig;
-	kverify.signature.data_size = sig_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, NCR_ALG_RSA_TRANSPARENT_HASH);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, pubkey);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_ENCODING_METHOD,
+		    (pss != 0) ? RSA_PKCS1_PSS : RSA_PKCS1_V1_5);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   SIGNATURE_HASH_SIZE);
+	ncr_put_session_input_data(&nla, NCR_ATTR_FINAL_INPUT_DATA, sig,
+				   sig_size);
+	NCR_FINISH(kverify, nla);
 
 	ret = ioctl(cfd, NCRIO_SESSION_ONCE, &kverify);
 	if (ret < 0) {
@@ -1216,32 +969,9 @@ static int rsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 
 static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_DSA)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_output_buffer signature ALIGN_NL;
-	} ksign;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_DSA)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_input_data signature ALIGN_NL;
-	} kverify;
+	NCR_STRUCT(ncr_session_once) ksign;
+	NCR_STRUCT(ncr_session_once) kverify;
+	struct nlattr *nla;
 	uint8_t data[DATA_SIZE];
 	uint8_t sig[DATA_SIZE];
 	size_t sig_size;
@@ -1253,27 +983,16 @@ static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 	memset(data, 0x3, sizeof(data));
 
 	/* sign data */
-	memset(&ksign.f, 0, sizeof(ksign.f));
-	ksign.f.input_size = sizeof(ksign);
+	nla = NCR_INIT(ksign);
 	ksign.f.op = NCR_OP_SIGN;
-	ksign.algo_head.nla_len = NLA_HDRLEN + sizeof(ksign.algo);
-	ksign.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(ksign.algo, ALG_DSA);
-	ksign.key_head.nla_len = NLA_HDRLEN + sizeof(ksign.key);
-	ksign.key_head.nla_type = NCR_ATTR_KEY;
-	ksign.key = privkey;
-	ksign.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(ksign.sign_hash);
-	ksign.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(ksign.sign_hash, SIGNATURE_HASH);
-	ksign.input_head.nla_len = NLA_HDRLEN + sizeof(ksign.input);
-	ksign.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	ksign.input.data = data;
-	ksign.input.data_size = DATA_TO_SIGN;
-	ksign.signature_head.nla_len = NLA_HDRLEN + sizeof(ksign.signature);
-	ksign.signature_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-	ksign.signature.buffer = sig;
-	ksign.signature.buffer_size = sizeof(sig);
-	ksign.signature.result_size_ptr = &sig_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_DSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, privkey);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   DATA_TO_SIGN);
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_FINAL_OUTPUT_BUFFER, sig,
+				      sizeof(sig), &sig_size);
+	NCR_FINISH(ksign, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_ONCE, &ksign)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1282,26 +1001,16 @@ static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 	}
 
 	/* verify signature */
-	memset(&kverify.f, 0, sizeof(kverify.f));
-	kverify.f.input_size = sizeof(kverify);
+	nla = NCR_INIT(kverify);
 	kverify.f.op = NCR_OP_VERIFY;
-	kverify.algo_head.nla_len = NLA_HDRLEN + sizeof(kverify.algo);
-	kverify.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kverify.algo, ALG_DSA);
-	kverify.key_head.nla_len = NLA_HDRLEN + sizeof(kverify.key);
-	kverify.key_head.nla_type = NCR_ATTR_KEY;
-	kverify.key = pubkey;
-	kverify.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(kverify.sign_hash);
-	kverify.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(kverify.sign_hash, SIGNATURE_HASH);
-	kverify.input_head.nla_len = NLA_HDRLEN + sizeof(kverify.input);
-	kverify.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	kverify.input.data = data;
-	kverify.input.data_size = DATA_TO_SIGN;
-	kverify.signature_head.nla_len = NLA_HDRLEN + sizeof(kverify.signature);
-	kverify.signature_head.nla_type = NCR_ATTR_FINAL_INPUT_DATA;
-	kverify.signature.data = sig;
-	kverify.signature.data_size = sizeof(sig);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_DSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, pubkey);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   DATA_TO_SIGN);
+	ncr_put_session_input_data(&nla, NCR_ATTR_FINAL_INPUT_DATA, sig,
+				   sizeof(sig));
+	NCR_FINISH(kverify, nla);
 
 	ret = ioctl(cfd, NCRIO_SESSION_ONCE, &kverify);
 	if (ret < 0) {
@@ -1324,32 +1033,9 @@ static int dsa_key_sign_verify(int cfd, ncr_key_t privkey, ncr_key_t pubkey)
 static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 					   ncr_key_t pubkey)
 {
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_ALG_DSA_TRANSPARENT_HASH)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_output_buffer signature ALIGN_NL;
-	} ksign;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(NCR_ALG_DSA_TRANSPARENT_HASH)] ALIGN_NL;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr sign_hash_head ALIGN_NL;
-		char sign_hash[sizeof(SIGNATURE_HASH)] ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr signature_head ALIGN_NL;
-		struct ncr_session_input_data signature ALIGN_NL;
-	} kverify;
+	NCR_STRUCT(ncr_session_once) ksign;
+	NCR_STRUCT(ncr_session_once) kverify;
+	struct nlattr *nla;
 	uint8_t data[SIGNATURE_HASH_SIZE];
 	uint8_t sig[DATA_SIZE];
 	size_t sig_size;
@@ -1361,27 +1047,16 @@ static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 	memset(data, 0x3, sizeof(data));
 
 	/* sign data */
-	memset(&ksign.f, 0, sizeof(ksign.f));
-	ksign.f.input_size = sizeof(ksign);
+	nla = NCR_INIT(ksign);
 	ksign.f.op = NCR_OP_SIGN;
-	ksign.algo_head.nla_len = NLA_HDRLEN + sizeof(ksign.algo);
-	ksign.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(ksign.algo, NCR_ALG_DSA_TRANSPARENT_HASH);
-	ksign.key_head.nla_len = NLA_HDRLEN + sizeof(ksign.key);
-	ksign.key_head.nla_type = NCR_ATTR_KEY;
-	ksign.key = privkey;
-	ksign.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(ksign.sign_hash);
-	ksign.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(ksign.sign_hash, SIGNATURE_HASH);
-	ksign.input_head.nla_len = NLA_HDRLEN + sizeof(ksign.input);
-	ksign.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	ksign.input.data = data;
-	ksign.input.data_size = SIGNATURE_HASH_SIZE;
-	ksign.signature_head.nla_len = NLA_HDRLEN + sizeof(ksign.signature);
-	ksign.signature_head.nla_type = NCR_ATTR_FINAL_OUTPUT_BUFFER;
-	ksign.signature.buffer = sig;
-	ksign.signature.buffer_size = sizeof(sig);
-	ksign.signature.result_size_ptr = &sig_size;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, NCR_ALG_DSA_TRANSPARENT_HASH);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, privkey);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   SIGNATURE_HASH_SIZE);
+	ncr_put_session_output_buffer(&nla, NCR_ATTR_FINAL_OUTPUT_BUFFER, sig,
+				      sizeof(sig), &sig_size);
+	NCR_FINISH(ksign, nla);
 
 	if (ioctl(cfd, NCRIO_SESSION_ONCE, &ksign)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1390,26 +1065,16 @@ static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 	}
 
 	/* verify signature */
-	memset(&kverify.f, 0, sizeof(kverify.f));
-	kverify.f.input_size = sizeof(kverify);
+	nla = NCR_INIT(kverify);
 	kverify.f.op = NCR_OP_VERIFY;
-	kverify.algo_head.nla_len = NLA_HDRLEN + sizeof(kverify.algo);
-	kverify.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kverify.algo, NCR_ALG_DSA_TRANSPARENT_HASH);
-	kverify.key_head.nla_len = NLA_HDRLEN + sizeof(kverify.key);
-	kverify.key_head.nla_type = NCR_ATTR_KEY;
-	kverify.key = pubkey;
-	kverify.sign_hash_head.nla_len = NLA_HDRLEN + sizeof(kverify.sign_hash);
-	kverify.sign_hash_head.nla_type = NCR_ATTR_SIGNATURE_HASH_ALGORITHM;
-	strcpy(kverify.sign_hash, SIGNATURE_HASH);
-	kverify.input_head.nla_len = NLA_HDRLEN + sizeof(kverify.input);
-	kverify.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-	kverify.input.data = data;
-	kverify.input.data_size = SIGNATURE_HASH_SIZE;
-	kverify.signature_head.nla_len = NLA_HDRLEN + sizeof(kverify.signature);
-	kverify.signature_head.nla_type = NCR_ATTR_FINAL_INPUT_DATA;
-	kverify.signature.data = sig;
-	kverify.signature.data_size = sizeof(sig);
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, NCR_ALG_DSA_TRANSPARENT_HASH);
+	ncr_put_u32(&nla, NCR_ATTR_KEY, pubkey);
+	ncr_put_string(&nla, NCR_ATTR_SIGNATURE_HASH_ALGORITHM, SIGNATURE_HASH);
+	ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA, data,
+				   SIGNATURE_HASH_SIZE);
+	ncr_put_session_input_data(&nla, NCR_ATTR_FINAL_INPUT_DATA, sig,
+				   sizeof(sig));
+	NCR_FINISH(kverify, nla);
 
 	ret = ioctl(cfd, NCRIO_SESSION_ONCE, &kverify);
 	if (ret < 0) {
@@ -1431,15 +1096,8 @@ static int dsa_key_sign_verify_transparent(int cfd, ncr_key_t privkey,
 static int test_ncr_rsa(int cfd)
 {
 	int ret;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_generate_pair f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_RSA)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr bits_head ALIGN_NL;
-		uint32_t bits ALIGN_NL;
-	} kgen;
+	NCR_STRUCT(ncr_key_generate_pair) kgen;
+	struct nlattr *nla;
 	ncr_key_t pubkey, privkey;
 	struct ncr_key_export kexport;
 	uint8_t data[DATA_SIZE];
@@ -1463,21 +1121,15 @@ static int test_ncr_rsa(int cfd)
 		return 1;
 	}
 
-	memset(&kgen, 0, sizeof(kgen));
-	kgen.f.input_size = sizeof(kgen);
+	nla = NCR_INIT(kgen);
 	kgen.f.private_key = privkey;
 	kgen.f.public_key = pubkey;
-	kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-	kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kgen.algo, ALG_RSA);
-	kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-	kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kgen.flags =
-	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE |
-	    NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH;
-	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
-	kgen.bits_head.nla_type = NCR_ATTR_RSA_MODULUS_BITS;
-	kgen.bits = 1024;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_RSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE
+		    | NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH);
+	ncr_put_u32(&nla, NCR_ATTR_RSA_MODULUS_BITS, 1024);
+	NCR_FINISH(kgen, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE_PAIR, &kgen)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -1571,17 +1223,8 @@ static int test_ncr_rsa(int cfd)
 static int test_ncr_dsa(int cfd)
 {
 	int ret;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_generate_pair f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_DSA)] ALIGN_NL;
-		struct nlattr flags_head ALIGN_NL;
-		uint32_t flags ALIGN_NL;
-		struct nlattr q_bits_head ALIGN_NL;
-		uint32_t q_bits ALIGN_NL;
-		struct nlattr p_bits_head ALIGN_NL;
-		uint32_t p_bits ALIGN_NL;
-	} kgen;
+	NCR_STRUCT(ncr_key_generate_pair) kgen;
+	struct nlattr *nla;
 	ncr_key_t pubkey, privkey;
 	struct ncr_key_export kexport;
 	uint8_t data[DATA_SIZE];
@@ -1605,24 +1248,16 @@ static int test_ncr_dsa(int cfd)
 		return 1;
 	}
 
-	memset(&kgen, 0, sizeof(kgen));
-	kgen.f.input_size = sizeof(kgen);
+	nla = NCR_INIT(kgen);
 	kgen.f.private_key = privkey;
 	kgen.f.public_key = pubkey;
-	kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-	kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kgen.algo, ALG_DSA);
-	kgen.flags_head.nla_len = NLA_HDRLEN + sizeof(kgen.flags);
-	kgen.flags_head.nla_type = NCR_ATTR_KEY_FLAGS;
-	kgen.flags =
-	    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE |
-	    NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH;
-	kgen.q_bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.q_bits);
-	kgen.q_bits_head.nla_type = NCR_ATTR_DSA_Q_BITS;
-	kgen.q_bits = 160;
-	kgen.p_bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.p_bits);
-	kgen.p_bits_head.nla_type = NCR_ATTR_DSA_P_BITS;
-	kgen.p_bits = 1024;
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_DSA);
+	ncr_put_u32(&nla, NCR_ATTR_KEY_FLAGS,
+		    NCR_KEY_FLAG_EXPORTABLE | NCR_KEY_FLAG_WRAPPABLE
+		    | NCR_KEY_FLAG_ALLOW_TRANSPARENT_HASH);
+	ncr_put_u32(&nla, NCR_ATTR_DSA_Q_BITS, 160);
+	ncr_put_u32(&nla, NCR_ATTR_DSA_P_BITS, 1024);
+	NCR_FINISH(kgen, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE_PAIR, &kgen)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
diff --git a/tests/speed.c b/tests/speed.c
index 8d3563a..406a88e 100644
--- a/tests/speed.c
+++ b/tests/speed.c
@@ -30,8 +30,8 @@
 #include <unistd.h>
 #include <linux/netlink.h>
 #include "../ncr.h"
+#include "utils.h"
 
-#define ALIGN_NL __attribute__((aligned(NLA_ALIGNTO)))
 #define ALG_AES_CBC "cbc(aes)"
 
 static double udifftimeval(struct timeval start, struct timeval end)
@@ -82,25 +82,9 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 	double secs, ddata, dspeed;
 	char metric[16];
 	ncr_key_t key;
-	struct __attribute__ ((packed)) {
-		struct ncr_key_generate f;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[sizeof(ALG_AES_CBC)] ALIGN_NL;
-		struct nlattr bits_head ALIGN_NL;
-		uint32_t bits ALIGN_NL;
-	} kgen;
-	struct __attribute__ ((packed)) {
-		struct ncr_session_once f;
-		struct nlattr key_head ALIGN_NL;
-		uint32_t key ALIGN_NL;
-		struct nlattr input_head ALIGN_NL;
-		struct ncr_session_input_data input ALIGN_NL;
-		struct nlattr output_head ALIGN_NL;
-		struct ncr_session_output_buffer output ALIGN_NL;
-		struct nlattr iv_head ALIGN_NL;
-		struct nlattr algo_head ALIGN_NL;
-		char algo[128] ALIGN_NL;
-	} op;
+	NCR_STRUCT(ncr_key_generate) kgen;
+	NCR_STRUCT(ncr_session_once) op;
+	struct nlattr *nla;
 	size_t algo_size;
 
 	algo_size = strlen(algo) + 1;
@@ -111,15 +95,11 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 		return 1;
 	}
 
-	memset(&kgen.f, 0, sizeof(kgen.f));
-	kgen.f.input_size = sizeof(kgen);
+	nla = NCR_INIT(kgen);
 	kgen.f.key = key;
-	kgen.algo_head.nla_len = NLA_HDRLEN + sizeof(kgen.algo);
-	kgen.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-	strcpy(kgen.algo, ALG_AES_CBC);
-	kgen.bits_head.nla_len = NLA_HDRLEN + sizeof(kgen.bits);
-	kgen.bits_head.nla_type = NCR_ATTR_SECRET_KEY_BITS;
-	kgen.bits = 128;	/* 16 bytes */
+	ncr_put_string(&nla, NCR_ATTR_ALGORITHM, ALG_AES_CBC);
+	ncr_put_u32(&nla, NCR_ATTR_SECRET_KEY_BITS, 128); /* 16 bytes */
+	NCR_FINISH(kgen, nla);
 
 	if (ioctl(cfd, NCRIO_KEY_GENERATE, &kgen)) {
 		fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
@@ -142,26 +122,17 @@ int encrypt_data_ncr_direct(int cfd, const char *algo, int chunksize)
 	do {
 		size_t output_size;
 
-		memset(&op.f, 0, sizeof(op.f));
+		nla = NCR_INIT(op);
 		op.f.op = NCR_OP_ENCRYPT;
-		op.key_head.nla_len = NLA_HDRLEN + sizeof(op.key);
-		op.key_head.nla_type = NCR_ATTR_KEY;
-		op.key = key;
-		op.input_head.nla_len = NLA_HDRLEN + sizeof(op.input);
-		op.input_head.nla_type = NCR_ATTR_UPDATE_INPUT_DATA;
-		op.input.data = buffer;
-		op.input.data_size = chunksize;
-		op.output_head.nla_len = NLA_HDRLEN + sizeof(op.output);
-		op.output_head.nla_type = NCR_ATTR_UPDATE_OUTPUT_BUFFER;
-		op.output.buffer = buffer;
-		op.output.buffer_size = chunksize;
-		op.output.result_size_ptr = &output_size;
-		op.iv_head.nla_len = NLA_HDRLEN + 0;
-		op.iv_head.nla_type = NCR_ATTR_IV;
-		op.algo_head.nla_len = NLA_HDRLEN + algo_size;
-		op.algo_head.nla_type = NCR_ATTR_ALGORITHM;
-		memcpy(op.algo, algo, algo_size);
-		op.f.input_size = op.algo + algo_size - (char *)&op;
+		ncr_put_u32(&nla, NCR_ATTR_KEY, key);
+		ncr_put_session_input_data(&nla, NCR_ATTR_UPDATE_INPUT_DATA,
+					   buffer, chunksize);
+		ncr_put_session_output_buffer(&nla,
+					      NCR_ATTR_UPDATE_OUTPUT_BUFFER,
+					      buffer, chunksize, &output_size);
+		ncr_put(&nla, NCR_ATTR_IV, NULL, 0);
+		ncr_put(&nla, NCR_ATTR_ALGORITHM, algo, algo_size);
+		NCR_FINISH(op, nla);
 
 		if (ioctl(cfd, NCRIO_SESSION_ONCE, &op)) {
 			fprintf(stderr, "Error: %s:%d\n", __func__, __LINE__);
diff --git a/tests/utils.h b/tests/utils.h
new file mode 100644
index 0000000..75a3dd5
--- /dev/null
+++ b/tests/utils.h
@@ -0,0 +1,90 @@
+#ifndef UTILS_H__
+#define UTILS_H__
+
+#include <string.h>
+#include <stdint.h>
+
+#include <linux/netlink.h>
+
+#define NCR_MAX_REQUEST 4096
+
+#define NCR_STRUCT(NAME) union {			\
+		struct NAME f;				\
+		unsigned char space[NCR_MAX_REQUEST];	\
+	}
+
+#define NCR_INIT(STRUCT)						\
+	({								\
+		memset(&(STRUCT).f, 0, sizeof((STRUCT).f));		\
+		(struct nlattr *)((STRUCT).space + sizeof((STRUCT).f)); \
+	})
+
+static inline void *
+ncr_reserve(struct nlattr **nla_p, uint16_t type, size_t size)
+{
+	struct nlattr *nla, x;
+	void *ptr;
+	size_t total_size;
+
+	total_size = NLA_HDRLEN + size;
+	x.nla_len = total_size;
+	x.nla_type = type;
+	nla = *nla_p;
+	memcpy(nla, &x, sizeof(x));
+	ptr = nla + 1;
+	*nla_p = (struct nlattr *)((char *)nla + NLA_ALIGN(total_size));
+	return ptr;
+}
+
+static inline void
+ncr_put(struct nlattr **nla_p, uint16_t type, const void *value, size_t size)
+{
+	void *ptr;
+
+	ptr = ncr_reserve(nla_p, type, size);
+	memcpy(ptr, value, size);
+}
+
+static inline void
+ncr_put_u32(struct nlattr **nla_p, uint16_t type, uint32_t value)
+{
+	return ncr_put(nla_p, type, &value, sizeof(value));
+}
+
+static inline void
+ncr_put_string(struct nlattr **nla_p, uint16_t type, const char *value)
+{
+	return ncr_put(nla_p, type, value, strlen(value) + 1);
+}
+
+static inline void
+ncr_put_session_input_data(struct nlattr **nla_p, uint16_t type,
+			   const void *data, size_t data_size)
+{
+	struct ncr_session_input_data *in, x;
+
+	in = ncr_reserve(nla_p, type, sizeof(*in));
+	x.data = data;
+	x.data_size = data_size;
+	memcpy(in, &x, sizeof(x));
+}
+
+static inline void
+ncr_put_session_output_buffer(struct nlattr **nla_p, uint16_t type,
+			      void *buffer, size_t buffer_size,
+			      size_t *result_size_ptr)
+{
+	struct ncr_session_output_buffer *out, x;
+
+	out = ncr_reserve(nla_p, type, sizeof(*out));
+	x.buffer = buffer;
+	x.buffer_size = buffer_size;
+	x.result_size_ptr = result_size_ptr;
+	memcpy(out, &x, sizeof(x));
+}
+
+#define NCR_FINISH(STRUCT, NLA) do {					\
+		(STRUCT).f.input_size = (char *)nla - (char *)&(STRUCT); \
+	} while (0)
+
+#endif