base64: add known-length calls for base64_to_bytes/get_maximum_length

Author: jgriffiths

include/wally.hpp

@@ -463,6 +463,18 @@ inline int base64_get_maximum_length(const STR_IN& str_in, uint32_t flags, size_
     return detail::check_ret(__FUNCTION__, ret);
 }
 
+template <class STR_IN>
+inline int base64_n_get_maximum_length(const STR_IN& str_in, size_t str_len, uint32_t flags, size_t* written) {
+    int ret = ::wally_base64_n_get_maximum_length(detail::get_p(str_in), str_len, flags, written);
+    return detail::check_ret(__FUNCTION__, ret);
+}
+
+template <class STR_IN, class BYTES_OUT>
+inline int base64_n_to_bytes(const STR_IN& str_in, size_t str_len, uint32_t flags, BYTES_OUT& bytes_out, size_t* written) {
+    int ret = ::wally_base64_n_to_bytes(detail::get_p(str_in), str_len, flags, bytes_out.data(), bytes_out.size(), written);
+    return detail::check_ret(__FUNCTION__, ret);
+}
+
 template <class STR_IN, class BYTES_OUT>
 inline int base64_to_bytes(const STR_IN& str_in, uint32_t flags, BYTES_OUT& bytes_out, size_t* written) {
     int ret = ::wally_base64_to_bytes(detail::get_p(str_in), flags, bytes_out.data(), bytes_out.size(), written);

include/wally_core.h

@@ -350,6 +350,19 @@ WALLY_CORE_API int wally_base64_to_bytes(
     size_t len,
     size_t *written);
 
+/**
+ * Decode a known-length base64 encoded string back into into binary data.
+ *
+ * See `wally_base64_to_bytes`.
+ */
+WALLY_CORE_API int wally_base64_n_to_bytes(
+    const char *str_in,
+    size_t str_len,
+    uint32_t flags,
+    unsigned char *bytes_out,
+    size_t len,
+    size_t *written);
+
 /**
  * Return the maximum length of a base64 encoded string once decoded into bytes.
  *
@@ -369,6 +382,17 @@ WALLY_CORE_API int wally_base64_get_maximum_length(
     uint32_t flags,
     size_t *written);
 
+/**
+ * Return the maximum length of a known-length base64 encoded string once decoded into bytes.
+ *
+ * See `wally_base64_get_maximum_length`.
+ */
+WALLY_CORE_API int wally_base64_n_get_maximum_length(
+    const char *str_in,
+    size_t str_len,
+    uint32_t flags,
+    size_t *written);
+
 
 #ifndef SWIG
 /** The type of an overridable function to allocate memory */

include/wally_map.h

@@ -333,7 +333,7 @@ WALLY_CORE_API int wally_map_combine(
 /**
  * Replace a maps contents with another map.
  *
- * :param map_in: the destination to combine into.
+ * :param map_in: the destination to assign to.
  * :param source: the source to copy items from.
  *
  * .. note:: If this call fails, ``map_in`` is left untouched.

src/base_64.c

@@ -25,42 +25,55 @@ int wally_base64_from_bytes(const unsigned char *bytes, size_t bytes_len,
     return WALLY_OK;
 }
 
-int wally_base64_get_maximum_length(const char *str_in, uint32_t flags, size_t *written)
+int wally_base64_n_get_maximum_length(const char *str_in, size_t str_len, uint32_t flags, size_t *written)
 {
     if (written)
         *written = 0;
 
-    if (!str_in || !*str_in || flags || !written)
+    if (!str_in || !str_len || flags || !written)
         return WALLY_EINVAL;
 
-    *written = base64_decoded_length(strlen(str_in));
+    *written = base64_decoded_length(str_len);
     return WALLY_OK;
 }
 
-int wally_base64_to_bytes(const char *str_in, uint32_t flags,
-                          unsigned char *bytes_out, size_t len,
-                          size_t *written)
+int wally_base64_get_maximum_length(const char *str_in, uint32_t flags, size_t *written)
+{
+    size_t str_len = str_in ? strlen(str_in) : 0;
+    return wally_base64_n_get_maximum_length(str_in, str_len, flags, written);
+}
+
+int wally_base64_n_to_bytes(const char *str_in, size_t str_len, uint32_t flags,
+                            unsigned char *bytes_out, size_t len,
+                            size_t *written)
 {
-    size_t decode_len, str_in_len;
+    size_t decode_len;
     ssize_t actual_len;
 
     if (written)
         *written = 0;
 
-    if (!str_in || flags || !bytes_out || !len || !written)
+    if (!str_in || !str_len || flags || !bytes_out || !len || !written)
         return WALLY_EINVAL;
 
-    str_in_len = strlen(str_in);
-    decode_len = base64_decoded_length(str_in_len);
+    decode_len = base64_decoded_length(str_len);
     if (len < decode_len) {
         /* Not enough space; return the amount required */
         *written = decode_len;
         return WALLY_OK;
     }
 
-    actual_len = base64_decode((char *)bytes_out, decode_len, str_in, str_in_len);
+    actual_len = base64_decode((char *)bytes_out, decode_len, str_in, str_len);
     if (actual_len < 0)
         return WALLY_EINVAL; /* Invalid base64 data */
     *written = actual_len;
     return WALLY_OK;
 }
+
+int wally_base64_to_bytes(const char *str_in, uint32_t flags,
+                          unsigned char *bytes_out, size_t len,
+                          size_t *written)
+{
+    size_t str_len = str_in ? strlen(str_in) : 0;
+    return wally_base64_n_to_bytes(str_in, str_len, flags, bytes_out, len, written);
+}

src/swig_java/swig.i

@@ -551,7 +551,9 @@ static jobjectArray create_jstringArray(JNIEnv *jenv, char **p, size_t len) {
 %returns_size_t(wally_base58_n_to_bytes);
 %returns_string(wally_base64_from_bytes);
 %returns_size_t(wally_base64_to_bytes);
+%returns_size_t(wally_base64_n_to_bytes);
 %returns_size_t(wally_base64_get_maximum_length);
+%returns_size_t(wally_base64_n_get_maximum_length);
 %returns_string(wally_bip32_key_to_address);
 %returns_string(wally_bip32_key_to_addr_segwit);
 %returns_array_(wally_bip340_tagged_hash, 4, 5, SHA256_LEN);

src/swig_python/python_extra.py_in

@@ -119,6 +119,7 @@ aes_cbc = _wrap_bin(aes_cbc, aes_cbc_get_maximum_length, resize=True)
 aes_cbc_with_ecdh_key = _wrap_bin(aes_cbc_with_ecdh_key, aes_cbc_with_ecdh_key_get_maximum_length, resize=True)
 base58_n_to_bytes = _wrap_bin(base58_n_to_bytes, base58_n_to_bytes_len, resize=True)
 base58_to_bytes = _wrap_bin(base58_to_bytes, base58_to_bytes_len, resize=True)
+base64_n_to_bytes = _wrap_bin(base64_n_to_bytes, base64_n_get_maximum_length, resize=True)
 base64_to_bytes = _wrap_bin(base64_to_bytes, base64_get_maximum_length, resize=True)
 bip32_key_from_base58 = bip32_key_from_base58_alloc
 bip32_key_from_base58_n = bip32_key_from_base58_n_alloc

src/test/test_base64.py

@@ -35,12 +35,19 @@ def test_vectors(self):
             self.assertEqual(ret, WALLY_OK)
             self.assertTrue(max_len >= len(str_in))
 
+            ret, max_len_n = wally_base64_n_get_maximum_length(b64_in, len(b64_in), 0)
+            self.assertEqual(ret, WALLY_OK)
+            self.assertEqual(max_len, max_len_n)
+
             ret, b64_out = wally_base64_from_bytes(utf8(str_in), len(str_in), 0)
             self.assertEqual((ret, b64_out), (WALLY_OK, b64_in))
 
             ret, written = wally_base64_to_bytes(utf8(b64_in), 0, buf, max_len)
             self.assertEqual((ret, buf[:written]), (WALLY_OK, utf8(str_in)))
 
+            ret, written = wally_base64_n_to_bytes(utf8(b64_in), len(b64_in), 0, buf, max_len)
+            self.assertEqual((ret, buf[:written]), (WALLY_OK, utf8(str_in)))
+
     def test_get_maximum_length(self):
         # Invalid args
         valid_b64 = utf8(ROUND_TRIP_CASES[0][1])
@@ -69,6 +76,7 @@ def test_base64_to_bytes(self):
         # Invalid args
         buf, buf_len = make_cbuffer('00' * 1024)
         valid_b64 = utf8(ROUND_TRIP_CASES[0][1])
+        valid_len = len(valid_b64)
         _, max_len = wally_base64_get_maximum_length(valid_b64, 0)
 
         for args in [
@@ -80,6 +88,13 @@ def test_base64_to_bytes(self):
             ret, written = wally_base64_to_bytes(*args)
             self.assertEqual((ret, written), (WALLY_EINVAL, 0))
 
+        for args in [
+            (None,      valid_len, 0, buf,  max_len),  # NULL base64 string, non-0 length
+            (valid_b64, 0,         0, buf,  max_len),  # Non-NULL base64 string, 0 length
+            ]:
+            ret, written = wally_base64_n_to_bytes(*args)
+            self.assertEqual((ret, written), (WALLY_EINVAL, 0))
+
         # Too short output length returns the number of bytes needed
         ret, written = wally_base64_to_bytes(valid_b64, 0, buf,  max_len-1)
         self.assertEqual((ret, written), (WALLY_OK, max_len))

src/test/util.py

@@ -300,6 +300,8 @@ class wally_psbt(Structure):
     ('wally_base58_to_bytes', c_int, [c_char_p, c_uint32, c_void_p, c_size_t, c_size_t_p]),
     ('wally_base64_from_bytes', c_int, [c_void_p, c_size_t, c_uint32, c_char_p_p]),
     ('wally_base64_get_maximum_length', c_int, [c_char_p, c_uint32, c_size_t_p]),
+    ('wally_base64_n_get_maximum_length', c_int, [c_char_p, c_size_t, c_uint32, c_size_t_p]),
+    ('wally_base64_n_to_bytes', c_int, [c_char_p, c_size_t, c_uint32, c_void_p, c_size_t, c_size_t_p]),
     ('wally_base64_to_bytes', c_int, [c_char_p, c_uint32, c_void_p, c_size_t, c_size_t_p]),
     ('wally_bip32_key_to_addr_segwit', c_int, [POINTER(ext_key), c_char_p, c_uint32, c_char_p_p]),
     ('wally_bip32_key_to_address', c_int, [POINTER(ext_key), c_uint32, c_uint32, c_char_p_p]),

src/wasm_package/src/functions.js

@@ -56,6 +56,7 @@ export function base58_get_length(str_in: string): number;
 export function base58_n_get_length(str_in: string, str_len: number): number;
 export function base64_from_bytes(bytes: Buffer|Uint8Array, flags: number): string;
 export function base64_get_maximum_length(str_in: string, flags: number): number;
+export function base64_n_get_maximum_length(str_in: string, str_len: number, flags: number): number;
 export function bip32_key_free(hdkey: Ref_ext_key): void;
 export function bip32_key_from_base58(base58: string): Ref_ext_key;
 export function bip32_key_from_base58_n(base58: string, base58_len: number): Ref_ext_key;
@@ -741,6 +742,7 @@ export function asset_pak_whitelistproof(online_keys: Buffer|Uint8Array, offline
 export function asset_surjectionproof(output_asset: Buffer|Uint8Array, output_abf: Buffer|Uint8Array, output_generator: Buffer|Uint8Array, bytes: Buffer|Uint8Array, asset: Buffer|Uint8Array, abf: Buffer|Uint8Array, generator: Buffer|Uint8Array): Buffer;
 export function base58_n_to_bytes(str_in: string, str_len: number, flags: number): Buffer;
 export function base58_to_bytes(str_in: string, flags: number): Buffer;
+export function base64_n_to_bytes(str_in: string, str_len: number, flags: number): Buffer;
 export function base64_to_bytes(str_in: string, flags: number): Buffer;
 export function descriptor_get_key_child_path_str(descriptor: Ref_wally_descriptor, index: number): string;
 export function descriptor_get_key_origin_path_str(descriptor: Ref_wally_descriptor, index: number): string;