LargeBlob trait supports buffering choice

[kaczmarczyck]

Also makes LargeBlob a proper stateful command that loses state when interleaved.

To make sure the API does indeed support buffering in both memory and flash, see the following diff for reference:

diff --git a/libraries/opensk/src/api/persist.rs b/libraries/opensk/src/api/persist.rs
index 6caaec9..b9e3543 100644
--- a/libraries/opensk/src/api/persist.rs
+++ b/libraries/opensk/src/api/persist.rs
@@ -236,7 +236,11 @@ pub trait Persist {
     ///
     /// Returns a buffer that is returned to other API calls for potential usage.
     fn init_large_blob(&mut self, expected_length: usize) -> CtapResult<Vec<u8>> {
-        Ok(Vec::with_capacity(expected_length))
+        debug_assert!(expected_length <= keys::LARGE_BLOB_SHARDS.len() * VALUE_LENGTH);
+        for key in keys::LARGE_BLOB_SHARDS {
+            self.remove(key)?;
+        }
+        Ok(Vec::new())
     }
 
     /// Writes a large blob chunk to the buffer.
@@ -246,13 +250,22 @@ pub trait Persist {
         &mut self,
         offset: usize,
         chunk: &mut Vec<u8>,
-        buffer: &mut Vec<u8>,
+        _buffer: &mut Vec<u8>,
     ) -> CtapResult<()> {
-        if buffer.len() != offset {
-            // This should be caught on CTAP level.
-            return Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR);
+        for (i, key) in keys::LARGE_BLOB_SHARDS.enumerate() {
+            let start = cmp::max(i * VALUE_LENGTH, offset);
+            let end = cmp::min((i + 1) * VALUE_LENGTH, offset.saturating_add(chunk.len()));
+            if start >= end {
+                continue;
+            }
+            let mut stored = self.find(key)?.unwrap_or_default();
+            let shard_offset = start - i * VALUE_LENGTH;
+            if stored.len() != shard_offset {
+                return Err(Ctap2StatusCode::CTAP2_ERR_VENDOR_INTERNAL_ERROR);
+            }
+            stored.extend_from_slice(&chunk[start - offset..][..end - start]);
+            self.insert(key, &stored)?;
         }
-        buffer.append(chunk);
         Ok(())
     }
 
@@ -266,14 +279,8 @@ pub trait Persist {
         &self,
         mut offset: usize,
         byte_count: usize,
-        buffer: Option<&Vec<u8>>,
+        _buffer: Option<&Vec<u8>>,
     ) -> CtapResult<Option<Vec<u8>>> {
-        if let Some(buffer) = buffer {
-            let start = cmp::min(offset, buffer.len());
-            let end = offset.saturating_add(byte_count);
-            let end = cmp::min(end, buffer.len());
-            return Ok(Some(buffer[start..end].to_vec()));
-        }
         let mut result = Vec::with_capacity(byte_count);
         for key in keys::LARGE_BLOB_SHARDS {
             if offset >= VALUE_LENGTH {
@@ -297,19 +304,8 @@ pub trait Persist {
     }
 
     /// Sets a byte vector as the serialized large blobs array.
-    fn commit_large_blob_array(&mut self, buffer: &Vec<u8>) -> CtapResult<()> {
-        debug_assert!(buffer.len() <= keys::LARGE_BLOB_SHARDS.len() * VALUE_LENGTH);
-        let mut offset = 0;
-        for key in keys::LARGE_BLOB_SHARDS {
-            let cur_len = cmp::min(buffer.len().saturating_sub(offset), VALUE_LENGTH);
-            let slice = &buffer[offset..][..cur_len];
-            if slice.is_empty() {
-                self.remove(key)?;
-            } else {
-                self.insert(key, slice)?;
-            }
-            offset += cur_len;
-        }
+    #[allow(clippy::ptr_arg)]
+    fn commit_large_blob_array(&mut self, _buffer: &Vec<u8>) -> CtapResult<()> {
         Ok(())
     }

[coveralls]

coverage: 97.14% (+0.1%) from 97.026%
when pulling 85a06db on kaczmarczyck:stateful-large-blob
into 3faea59 on google:develop.