cleaning up

Signed-off-by: Wojciech Ozga <woz@zurich.ibm.com>
IBM · Oct 7, 2024 · d7e1f5d · d7e1f5d
1 parent e5d61f8
commit d7e1f5d
Show file tree

Hide file tree

Showing 25 changed files with 283 additions and 231 deletions.
diff --git a/.gitignore b/.gitignore
@@ -4,7 +4,7 @@
 build/*
 target/*
 
-tools/local_attestation/target
+tools/cove_tap_tool/target
 security-monitor/target
 
 configurations/overlay/root/harness/baremetal

diff --git a/Makefile b/Makefile
@@ -51,11 +51,11 @@ hypervisor: setup devtools
 
 confidential_vms: setup devtools hypervisor tools
 	BIN_DIR="$(OVERLAY_ROOT_DIR)/" RELEASE="" $(MAKE) -C $(CONFIDENTIAL_VMS_SOURCE_DIR)/baremetal/ ;\
-	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) $(MAKE) -C $(CONFIDENTIAL_VMS_SOURCE_DIR)/linux_vm/ buildroot ;\
-	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) $(MAKE) -C $(CONFIDENTIAL_VMS_SOURCE_DIR)/linux_vm/ overlay ;\
+	# PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) $(MAKE) -C $(CONFIDENTIAL_VMS_SOURCE_DIR)/linux_vm/ buildroot ;\
+	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) $(MAKE) -C $(CONFIDENTIAL_VMS_SOURCE_DIR)/linux_vm/ rootfs ;\
 	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) $(MAKE) -C hypervisor rootfs;
 
-hypervisor_dev: 
+hypervisor_dev:
 	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) $(MAKE) -C hypervisor dev
 
 dev: tools
@@ -79,7 +79,7 @@ emulator: setup devtools
 
 tools: setup
 	mkdir -p $(TOOLS_WORK_DIR)
-	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) CROSS_COMPILE=$(CROSS_COMPILE) $(MAKE) -C tools/local_attestation build
+	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" ACE_DIR=$(ACE_DIR) CROSS_COMPILE=$(CROSS_COMPILE) $(MAKE) -C tools/cove_tap_tool build
 	cp -rf $(TOOLS_SOURCE_DIR)/*.sh $(TOOLS_WORK_DIR)/
 	cp -rf $(TOOLS_SOURCE_DIR)/ace $(TOOLS_WORK_DIR)/
 

diff --git a/confidential-vms/linux_vm/Makefile b/confidential-vms/linux_vm/Makefile
@@ -23,12 +23,11 @@ LINUX_VM_KERNEL_CONFIG				?= $(CONFIDENTIAL_VMS_LINUX_SOURCE_DIR)/configurations
 LINUX_VM_BUILDROOT_CONFIG			?= $(CONFIDENTIAL_VMS_LINUX_SOURCE_DIR)/configurations/qemu_riscv64_virt_defconfig
 LINUX_VM_BUILDROOT_OVERRIDE_DIR		?= $(CONFIDENTIAL_VMS_LINUX_SOURCE_DIR)/configurations/package_override.dev
 LINUX_VM_PATCHES_DIR				?= $(CONFIDENTIAL_VMS_LINUX_SOURCE_DIR)/patches/linux/6.3-rc4
+LINUX_DIR							?= $(LINUX_VM_BUILDROOT_WORK_DIR)/build/linux-6.3-rc4/
 # overlays
 HYPERVISOR_OVERLAY_DIR				?= $(ACE_DIR)/hypervisor/overlay/
 HYPERVISOR_OVERLAY_ROOT_DIR			?= $(HYPERVISOR_OVERLAY_DIR)/root/
 HYPERVISOR_OVERLAY_LINUX_VM_DIR		?= $(HYPERVISOR_OVERLAY_ROOT_DIR)/linux_vm/
-#
-LOCAL_ATTESTATION_UTILS_DIR			?= $(CONFIDENTIAL_VMS_LINUX_SOURCE_DIR)/../../tools/local_attestation
 
 RISCV_GNU_TOOLCHAIN_WORK_DIR		?= $(ACE_DIR)/riscv-gnu-toolchain/
 export PATH 						:= $(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)
@@ -60,25 +59,30 @@ buildroot: setup
 
 dev:
 	echo "Rebuilding buildroot"; \
+	sed "s@^BR2_ROOTFS_OVERLAY=.*@BR2_ROOTFS_OVERLAY=\"$(LINUX_VM_OVERLAY_WORK_DIR)\"@g" -i $(LINUX_VM_BUILDROOT_WORK_DIR)/.config; \
 	sed "s@^BR2_PACKAGE_OVERRIDE_FILE=.*@BR2_PACKAGE_OVERRIDE_FILE=\"$(LINUX_VM_BUILDROOT_OVERRIDE_DIR)\"@g" -i $(LINUX_VM_BUILDROOT_WORK_DIR)/.config ;\
 	sed "s@^BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE=.*@BR2_LINUX_KERNEL_CUSTOM_CONFIG_FILE=\"$(LINUX_VM_KERNEL_CONFIG)\"@g" -i $(LINUX_VM_BUILDROOT_WORK_DIR)/.config; \
 	sed "s@^BR2_TARGET_ROOTFS_EXT2_SIZE=.*@BR2_TARGET_ROOTFS_EXT2_SIZE=\"$(LINUX_VM_BUILDROOT_ROOTFS_SIZE)\"@g" -i $(LINUX_VM_BUILDROOT_WORK_DIR)/.config; \
 	$(MAKE) -s -C $(LINUX_VM_BUILDROOT_SOURCE_DIR) RISCV=$(RISCV_GNU_TOOLCHAIN_WORK_DIR) PATH=$(PATH) O=$(LINUX_VM_BUILDROOT_WORK_DIR) CROSS_COMPILE=$(CROSS_COMPILE) BR2_JLEVEL=0 linux-rebuild all
 
 overlay: setup
 	mkdir -p $(LINUX_VM_OVERLAY_WORK_DIR) ;\
+	mkdir -p $(LINUX_VM_OVERLAY_WORK_ROOT_DIR); \
 	cp -r $(LINUX_VM_OVERLAY_SOURCE_DIR)/* $(LINUX_VM_OVERLAY_WORK_DIR)/ ;\
+	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" $(MAKE) -s -C $(LINUX_VM_OVERLAY_WORK_ROOT_DIR)/ace_module/ RISCV=$(RISCV_GNU_TOOLCHAIN_WORK_DIR) PATH=$(PATH) ARCH=riscv KDIR=$(LINUX_DIR) CROSS_COMPILE=$(CROSS_COMPILE) CC="riscv64-unknown-linux-gnu-gcc" O=$(LINUX_DIR) ;\
 	mkdir -p $(HYPERVISOR_OVERLAY_ROOT_DIR) ;\
 	cp $(LINUX_VM_ROOTFS_SOURCE_DIR)/*.sh $(HYPERVISOR_OVERLAY_ROOT_DIR)/ ;\
-	rm -rf $(HYPERVISOR_OVERLAY_LINUX_VM_DIR) ;\
-	mkdir -p $(HYPERVISOR_OVERLAY_LINUX_VM_DIR) ;\
+	rm -rf $(HYPERVISOR_OVERLAY_LINUX_VM_DIR) && mkdir -p $(HYPERVISOR_OVERLAY_LINUX_VM_DIR) ;\
 	cp -r $(LINUX_VM_IMAGE) $(HYPERVISOR_OVERLAY_LINUX_VM_DIR)/ ;\
 	cp -r $(LINUX_VM_BUILDROOT_ROOTFS) $(HYPERVISOR_OVERLAY_LINUX_VM_DIR) ;\
 	cp -r $(LINUX_VM_BUILDROOT_WORK_DIR)/images/rootfs.cpio $(HYPERVISOR_OVERLAY_LINUX_VM_DIR) ;\
-	mkdir -p $(LINUX_VM_OVERLAY_WORK_ROOT_DIR); \
-	cp $(ACE_DIR)/tools/ace-tap $(LINUX_VM_OVERLAY_WORK_ROOT_DIR)/
+
+rootfs: overlay
+	PATH="$(RISCV_GNU_TOOLCHAIN_WORK_DIR)/bin:$(PATH)" $(MAKE) -s -C $(LINUX_VM_BUILDROOT_SOURCE_DIR) RISCV=$(RISCV_GNU_TOOLCHAIN_WORK_DIR) PATH=$(PATH) ARCH=riscv64 KDIR=$(LINUX_DIR) CROSS_COMPILE=$(CROSS_COMPILE) O=$(LINUX_VM_BUILDROOT_WORK_DIR) rootfs-ext2; \
+	cp -r $(LINUX_VM_BUILDROOT_WORK_DIR)/images/rootfs.cpio $(HYPERVISOR_OVERLAY_LINUX_VM_DIR);
+
 
 clean:
 	rm -rf $(ACE_DIR)
 
-.PHONY: all buildroot linux clean overlay rootfs
+.PHONY: all buildroot linux clean overlay
diff --git a/confidential-vms/linux_vm/hypervisor_rootfs/run_linux_vm.sh b/confidential-vms/linux_vm/hypervisor_rootfs/run_linux_vm.sh
@@ -32,7 +32,7 @@ for i in "$@"; do
     -m=*|--memory=*)
       MEMORY="${i#*=}"
       shift
-      ;;      
+      ;;
     --daemonize*)
       INTERACTIVE="-daemonize"
       shift
@@ -55,11 +55,10 @@ ${QEMU_CMD} ${DEBUG_OPTIONS} \
     -machine virt -cpu rv64,f=true -smp ${SMP} -m ${MEMORY} \
     -kernel ${KERNEL} \
     -seed 0 \
-    -initrd ${INITRAMFS} \
     -global virtio-mmio.force-legacy=false \
     -append "console=ttyS0 ro swiotlb=mmnn,force promote_to_cove_guest" \
     -device virtio-blk-pci,drive=hd0,iommu_platform=on,disable-legacy=on,disable-modern=off \
     -drive if=none,format=raw,file=${DRIVE},id=hd0 \
     -device virtio-net-pci,netdev=net0,iommu_platform=on,disable-legacy=on,disable-modern=off \
     -netdev user,id=net0,net=192.168.100.1/24,dhcpstart=192.168.100.128,hostfwd=tcp::${HOST_PORT}-:22 \
-    -nographic 
+    -nographic
diff --git a/confidential-vms/linux_vm/overlay/root/ace_module/Makefile b/confidential-vms/linux_vm/overlay/root/ace_module/Makefile
@@ -0,0 +1,27 @@
+CONFIG_MODULE_SIG=n
+
+startstop-objs := start.o stop.o
+obj-m += ace.o
+
+ifeq ($(CONFIG_STATUS_CHECK_GCC),y)
+	CC=$(STATUS_CHECK_GCC)
+	ccflags-y += -fanalyzer
+endif
+
+KDIR ?= /lib/modules/$(shell uname -r)/build
+PWD := $(CURDIR)
+
+default:
+	$(MAKE) -C $(KDIR) CC="$(CC)" M="$(PWD)" modules
+	rm -f .Module* .modules* .ace* *.symvers *.order ace.mod.* *.o *.mod
+
+load:
+	@insmod ace.ko
+
+clean:
+	$(MAKE) -C /lib/modules/$(shell uname -r)/build CC="$(CC)" M="$(PWD)" clean
+	$(RM) other/cat_noblock *.plist
+
+indent:
+	clang-format -i *[.ch]
+	clang-format -i other/*[.ch]
diff --git a/confidential-vms/linux_vm/overlay/root/ace_module/ace.c b/confidential-vms/linux_vm/overlay/root/ace_module/ace.c
@@ -0,0 +1,39 @@
+#include<linux/init.h>
+#include<linux/module.h>
+#include <asm/sbi.h>
+#include <linux/io.h>
+#include <linux/kernel.h>
+#include <linux/debugfs.h>
+#include <linux/delay.h> /* usleep_range */
+#include <linux/kthread.h>
+#include <linux/seq_file.h> /* single_open, single_release */
+#include <linux/slab.h> /* kmalloc, kfree */
+
+MODULE_LICENSE("GPL");
+MODULE_AUTHOR("Wojciech Ozga <woz@zurich.ibm.com>");
+
+static int ace_init(void){
+    volatile u8 *secret;
+    struct sbiret ret;
+    int i;
+
+    printk(KERN_ALERT "Requesting secret from the security monitor\n");    
+    secret = kmalloc(1024*sizeof(u8), GFP_KERNEL);
+    ret = sbi_ecall(0x434F5647, 9, virt_to_phys((void *) secret), 1024, 0, 0, 0, 0);
+    if (!ret.error) {
+        printk(KERN_ALERT "Secret=0x");
+        for (i=0; i<ret.value; i++) {
+            printk(KERN_CONT "%02x", secret[i]);
+        }
+        printk(KERN_CONT "\n");
+    } else {
+        printk(KERN_ALERT "Error: %lx %lx", ret.error, ret.value);
+    }
+	return 0;
+}
+
+static void ace_exit(void){
+}
+
+module_init(ace_init);
+module_exit(ace_exit);
diff --git a/confidential-vms/linux_vm/overlay/root/this_is_confidential_vm_filesystem b/confidential-vms/linux_vm/overlay/root/this_is_confidential_vm_filesystem
@@ -0,0 +1 @@
+hello from confidential VM's filesystem
diff --git a/confidential-vms/linux_vm/overlay/this_is_confidential_vm_filesystem b/confidential-vms/linux_vm/overlay/this_is_confidential_vm_filesystem
@@ -0,0 +1 @@
+hello from confidential VM's filesystem
diff --git a/security-monitor/rust-crates/cove_tap/src/error.rs b/security-monitor/rust-crates/cove_tap/src/error.rs
@@ -6,13 +6,13 @@ use thiserror_no_std::Error;
 #[derive(Error, Debug)]
 pub enum TapError {
     #[error("Unsupported TAP Lockbox algorithm {0}")]
-    UnsupportedTapLockboxAlgorithm(u16),
+    UnsupportedLockboxAlgorithm(u16),
     #[error("Unsupported TAP digest entry type {0}")]
-    UnsupportedTapDigestEntryType(u16),
+    UnsupportedDigestEntryType(u16),
     #[error("Unsupported TAP digest algorithm {0}")]
-    UnsupportedTapDigestAlgorithm(u16),
+    UnsupportedDigestAlgorithm(u16),
     #[error("Unsupported TAP payload encryption algorithm {0}")]
-    UnsupportedTapPayloadEncryptionAlgorithm(u16),
+    UnsupportedPayloadEncryptionAlgorithm(u16),
     #[error("Invalid magic in the beginning of TAP")]
     InvalidMagicStart(),
     #[error("Invalid size of the TAP")]

diff --git a/security-monitor/rust-crates/cove_tap/src/lib.rs b/security-monitor/rust-crates/cove_tap/src/lib.rs
@@ -12,10 +12,10 @@ mod parser;
 mod serializer;
 
 #[cfg(feature = "parser")]
-pub use parser::TeeAttestationPayloadParser;
+pub use parser::AttestationPayloadParser;
 
 #[cfg(feature = "serializer")]
-pub use serializer::TeeAttestationPayloadSerializer;
+pub use serializer::AttestationPayloadSerializer;
 
 pub use spec::*;
 pub use error::*;

diff --git a/security-monitor/rust-crates/cove_tap/src/parser.rs b/security-monitor/rust-crates/cove_tap/src/parser.rs
@@ -7,20 +7,20 @@ use alloc::vec::Vec;
 use alloc::vec;
 use crate::spec::*;
 
-pub struct TeeAttestationPayloadParser {
+pub struct AttestationPayloadParser {
     pub pointer: *const u8,
     pub size: usize,
 }
 
-impl TeeAttestationPayloadParser {
+impl AttestationPayloadParser {
     pub fn from_raw_pointer(pointer: *const u8, size: usize) -> Result<Self, TapError> {
         Ok(Self {
             pointer, size
         })
     }
 
-    pub fn parse_and_verify(&mut self) -> Result<TeeAttestationPayload, TapError> {
-        if self.read_u16()? != ACE_MAGIC_TAP_START {
+    pub fn parse_and_verify(&mut self) -> Result<AttestationPayload, TapError> {
+        if self.read_u32()? != ACE_MAGIC_TAP_START {
             return Err(TapError::InvalidMagicStart());
         }
         self.read_u16()?;
@@ -32,7 +32,7 @@ impl TeeAttestationPayloadParser {
         for _ in 0..number_of_lockboxes {
             let size = self.read_u16()? as usize;
             let name = self.read_u64()?;
-            let algorithm = TapLockboxAlgorithm::from_u16(self.read_u16()?)?;
+            let algorithm = LockboxAlgorithm::from_u16(self.read_u16()?)?;
             let value = self.read_exact(size-10)?;
             lockboxes.push(Lockbox {
                 name,
@@ -43,20 +43,20 @@ impl TeeAttestationPayloadParser {
         // TODO: recover symmetric key
         let symmetric_key = [0u8; 32];
 
-        let payload_encryption_algorithm = TapPayloadEncryptionAlgorithm::from_u16(self.read_u16()?)?;
+        let payload_encryption_algorithm = PayloadEncryptionAlgorithm::from_u16(self.read_u16()?)?;
         match payload_encryption_algorithm {
-            TapPayloadEncryptionAlgorithm::Debug => {},
-            TapPayloadEncryptionAlgorithm::AesGcm256 => self.decrypt_aes_gcm_256(symmetric_key)?,
+            PayloadEncryptionAlgorithm::Debug => {},
+            PayloadEncryptionAlgorithm::AesGcm256 => self.decrypt_aes_gcm_256(symmetric_key)?,
         }
 
         let number_of_digests = self.read_u16()?;
         let mut digests = vec![];
         for _ in 0..number_of_digests {
             let size = self.read_u16()? as usize;
             let pcr_id = self.read_u16()?;
-            let algorithm = TapDigestAlgorithm::from_u16(self.read_u16()?)?;
+            let algorithm = DigestAlgorithm::from_u16(self.read_u16()?)?;
             let value = self.read_exact(size-4)?;
-            digests.push(TapDigest {
+            digests.push(Digest {
                 pcr_id,
                 algorithm,
                 value
@@ -69,10 +69,10 @@ impl TeeAttestationPayloadParser {
             let size = self.read_u16()? as usize;
             let name = self.read_u64()? as u64;
             let value = self.read_exact(size-10)?;
-            secrets.push(TapSecret { name, value });
+            secrets.push(Secret { name, value });
         }
 
-        Ok(TeeAttestationPayload {
+        Ok(AttestationPayload {
             lockboxes,
             digests,
             secrets,
@@ -91,7 +91,7 @@ impl TeeAttestationPayloadParser {
         let key: Key<Aes256Gcm> = symmetric_key.into();
         let cipher = Aes256Gcm::new(&key);
         let nonce = Nonce::from_slice(&nonce);
-        let tag = Tag::from_slice(&tag); 
+        let tag = Tag::from_slice(&tag);
         let mut data_slice = unsafe{ core::slice::from_raw_parts_mut(self.pointer as *mut u8, payload_size) };
         cipher.decrypt_in_place_detached(nonce, b"", &mut data_slice, &tag)?;
         Ok(())
@@ -103,6 +103,12 @@ impl TeeAttestationPayloadParser {
         Ok(value)
     }
 
+    fn read_u32(&mut self) -> Result<u32, TapError> {
+        let value = unsafe { (self.pointer as *const u32).read_volatile() };
+        self.pointer = self.pointer.wrapping_add(4);
+        Ok(value)
+    }
+
     fn read_u64(&mut self) -> Result<u64, TapError> {
         let value = unsafe { (self.pointer as *const u64).read_volatile() };
         self.pointer = self.pointer.wrapping_add(8);

diff --git a/security-monitor/rust-crates/cove_tap/src/serializer.rs b/security-monitor/rust-crates/cove_tap/src/serializer.rs
@@ -6,35 +6,35 @@ use alloc::vec;
 use crate::spec::*;
 use alloc::vec::Vec;
 
-pub struct TeeAttestationPayloadSerializer {
+pub struct AttestationPayloadSerializer {
 
 }
 
-impl TeeAttestationPayloadSerializer {
+impl AttestationPayloadSerializer {
     pub fn new() -> Self {
         Self {}
     }
 
-    pub fn serialize(&self, mut payload: TeeAttestationPayload) -> Result<Vec<u8>, TapError> {
+    pub fn serialize(&self, mut payload: AttestationPayload) -> Result<Vec<u8>, TapError> {
         let digests = self.serialize_digests(&mut payload)?;
         let secrets = self.serialize_secrets(&mut payload)?;
         let mut encrypted_part = self.encrypt_aes_gcm_256(digests, secrets)?;
         let mut lockboxes = self.serialize_lockboxes(&mut payload)?;
 
-        let total_size = lockboxes.len() + encrypted_part.len() + ACE_FOOTER_SIZE; // 4 bytes for footer
+        let total_size = lockboxes.len() + encrypted_part.len();
 
         let mut result = vec![];
         result.append(&mut ACE_MAGIC_TAP_START.to_le_bytes().to_vec());
         result.append(&mut (total_size as u16).to_le_bytes().to_vec());
         result.append(&mut lockboxes);
         result.append(&mut encrypted_part);
-        result.append(&mut ACE_MAGIC_TAP_END.to_le_bytes().to_vec());
-        result.append(&mut ((total_size + ACE_HEADER_SIZE) as u16).to_le_bytes().to_vec());
+        // result.append(&mut ACE_MAGIC_TAP_END.to_le_bytes().to_vec());
+        // result.append(&mut ((total_size + ACE_HEADER_SIZE) as u16).to_le_bytes().to_vec());
 
         Ok(result)
     }
 
-    fn serialize_lockboxes(&self, payload: &mut TeeAttestationPayload) -> Result<Vec<u8>, TapError> {
+    fn serialize_lockboxes(&self, payload: &mut AttestationPayload) -> Result<Vec<u8>, TapError> {
         // TODO: sanity check: lockboxes < 1024
         let mut result = vec![];
         result.append(&mut (payload.lockboxes.len() as u16).to_le_bytes().to_vec());
@@ -48,7 +48,7 @@ impl TeeAttestationPayloadSerializer {
         Ok(result)
     }
 
-    fn serialize_digests(&self, payload: &mut TeeAttestationPayload) -> Result<Vec<u8>, TapError> {
+    fn serialize_digests(&self, payload: &mut AttestationPayload) -> Result<Vec<u8>, TapError> {
         // TODO: sanity check: digests < 1024
         let mut result = vec![];
         result.append(&mut (payload.digests.len() as u16).to_le_bytes().to_vec());
@@ -62,7 +62,7 @@ impl TeeAttestationPayloadSerializer {
         Ok(result)
     }
 
-    fn serialize_secrets(&self, payload: &mut TeeAttestationPayload) -> Result<Vec<u8>, TapError> {
+    fn serialize_secrets(&self, payload: &mut AttestationPayload) -> Result<Vec<u8>, TapError> {
         // TODO: sanity check: secrets < 1024
         let mut result = vec![];
         result.append(&mut (payload.secrets.len() as u16).to_le_bytes().to_vec());
@@ -96,7 +96,7 @@ impl TeeAttestationPayloadSerializer {
             .unwrap();
 
         let mut result = vec![];
-        result.append(&mut (TapPayloadEncryptionAlgorithm::AesGcm256 as u16).to_le_bytes().to_vec());
+        result.append(&mut (PayloadEncryptionAlgorithm::AesGcm256 as u16).to_le_bytes().to_vec());
         result.append(&mut (nonce.as_slice().len() as u16).to_le_bytes().to_vec());
         result.append(&mut nonce.as_slice().to_vec());
         result.append(&mut (tag.as_slice().len() as u16).to_le_bytes().to_vec());