react-native-quick-crypto 0.7.3 → 1.0.0-beta.1

package/cpp/Utils/MGLUtils.h

@@ -1,358 +0,0 @@
-#ifndef MGLUtils_h
-#define MGLUtils_h
-
-#include <openssl/dsa.h>
-#include <openssl/ec.h>
-#include <openssl/err.h>
-#include <openssl/evp.h>
-#include <openssl/kdf.h>
-#include <openssl/rand.h>
-#include <openssl/rsa.h>
-#include <openssl/ssl.h>
-#ifndef OPENSSL_NO_ENGINE
-#include <openssl/engine.h>
-#endif  // !OPENSSL_NO_ENGINE
-
-#include <jsi/jsi.h>
-#include <memory>
-#include <optional>
-#include <string>
-#include <utility>
-#include <vector>
-#include <variant>
-
-#ifdef ANDROID
-#include "Utils/node.h"
-#else
-#include "node.h"
-#endif
-
-namespace margelo {
-
-namespace jsi = facebook::jsi;
-
-template <typename T, void (*function)(T*)>
-struct FunctionDeleter {
-    void operator()(T* pointer) const { function(pointer); }
-    typedef std::unique_ptr<T, FunctionDeleter> Pointer;
-};
-
-template <typename T, void (*function)(T*)>
-using DeleteFnPtr = typename FunctionDeleter<T, function>::Pointer;
-using X509Pointer = DeleteFnPtr<X509, X509_free>;
-using BIOPointer = DeleteFnPtr<BIO, BIO_free_all>;
-using PKCS8Pointer = DeleteFnPtr<PKCS8_PRIV_KEY_INFO, PKCS8_PRIV_KEY_INFO_free>;
-using EVPKeyCtxPointer = DeleteFnPtr<EVP_PKEY_CTX, EVP_PKEY_CTX_free>;
-using EVPKeyPointer = DeleteFnPtr<EVP_PKEY, EVP_PKEY_free>;
-using BignumPointer = DeleteFnPtr<BIGNUM, BN_free>;
-using RsaPointer = DeleteFnPtr<RSA, RSA_free>;
-using EVPMDPointer = DeleteFnPtr<EVP_MD_CTX, EVP_MD_CTX_free>;
-using ECDSASigPointer = DeleteFnPtr<ECDSA_SIG, ECDSA_SIG_free>;
-using ECKeyPointer = DeleteFnPtr<EC_KEY, EC_KEY_free>;
-using ECPointPointer = DeleteFnPtr<EC_POINT, EC_POINT_free>;
-using CipherCtxPointer = DeleteFnPtr<EVP_CIPHER_CTX, EVP_CIPHER_CTX_free>;
-
-
-#ifdef __GNUC__
-#define MUST_USE_RESULT __attribute__((warn_unused_result))
-#else
-#define MUST_USE_RESULT
-#endif
-
-struct CSPRNGResult {
-  const bool ok;
-  MUST_USE_RESULT bool is_ok() const { return ok; }
-  MUST_USE_RESULT bool is_err() const { return !ok; }
-};
-
-// Either succeeds with exactly |length| bytes of cryptographically
-// strong pseudo-random data, or fails. This function may block.
-// Don't assume anything about the contents of |buffer| on error.
-// As a special case, |length == 0| can be used to check if the CSPRNG
-// is properly seeded without consuming entropy.
-MUST_USE_RESULT CSPRNGResult CSPRNG(void* buffer, size_t length);
-
-template <typename T>
-class NonCopyableMaybe {
- public:
-    NonCopyableMaybe() : empty_(true) {}
-    explicit NonCopyableMaybe(T&& value)
-    : empty_(false), value_(std::move(value)) {}
-
-    bool IsEmpty() const { return empty_; }
-
-    const T* get() const { return empty_ ? nullptr : &value_; }
-
-    const T* operator->() const {
-        //    CHECK(!empty_);
-        return &value_;
-    }
-
-    T&& Release() {
-        //    CHECK_EQ(empty_, false);
-        empty_ = true;
-        return std::move(value_);
-    }
-
- private:
-    bool empty_;
-    T value_;
-};
-
-template <typename T>
-inline T MultiplyWithOverflowCheck(T a, T b) {
-    auto ret = a * b;
-    //  if (a != 0)
-    //    CHECK_EQ(b, ret / a);
-
-    return ret;
-}
-
-template <typename T>
-T* MallocOpenSSL(size_t count) {
-    void* mem = OPENSSL_malloc(MultiplyWithOverflowCheck(count, sizeof(T)));
-    //  CHECK_IMPLIES(mem == nullptr, count == 0);
-    return static_cast<T*>(mem);
-}
-
-// A helper class representing a read-only byte array. When deallocated, its
-// contents are zeroed.
-class ByteSource {
- public:
-    class Builder {
-     public:
-        // Allocates memory using OpenSSL's memory allocator.
-        explicit Builder(size_t size)
-        : data_(MallocOpenSSL<char>(size)), size_(size) {}
-
-        Builder(Builder&& other) = delete;
-        Builder& operator=(Builder&& other) = delete;
-        Builder(const Builder&) = delete;
-        Builder& operator=(const Builder&) = delete;
-
-        ~Builder() { OPENSSL_clear_free(data_, size_); }
-
-        // Returns the underlying non-const pointer.
-        template <typename T>
-        T* data() {
-            return reinterpret_cast<T*>(data_);
-        }
-
-        // Returns the (allocated) size in bytes.
-        size_t size() const { return size_; }
-
-        // Finalizes the Builder and returns a read-only view that is optionally
-        // truncated.
-        ByteSource release(std::optional<size_t> resize = std::nullopt) && {
-            if (resize) {
-                //        CHECK_LE(*resize, size_);
-                if (*resize == 0) {
-                    OPENSSL_clear_free(data_, size_);
-                    data_ = nullptr;
-                }
-                size_ = *resize;
-            }
-            ByteSource out = ByteSource::Allocated(data_, size_);
-            data_ = nullptr;
-            size_ = 0;
-            return out;
-        }
-
-     private:
-        void* data_;
-        size_t size_;
-    };
-
-    ByteSource() = default;
-    ByteSource(ByteSource&& other) noexcept;
-    ~ByteSource();
-
-    ByteSource& operator=(ByteSource&& other) noexcept;
-
-    ByteSource(const ByteSource&) = delete;
-    ByteSource& operator=(const ByteSource&) = delete;
-
-    template <typename T = void>
-    const T* data() const {
-        return reinterpret_cast<const T*>(data_);
-    }
-
-    size_t size() const { return size_; }
-
-    operator bool() const { return data_ != nullptr; }
-
-    inline BignumPointer ToBN() const {
-        return BignumPointer(BN_bin2bn(data<unsigned char>(), (int)size(), nullptr));
-    }
-
-    inline std::string ToString() const {
-        std::vector<uint8_t> buf(size_);
-        std::memcpy(&buf[0], data_, size_);
-        std::string ret(buf.begin(), buf.end());
-        return ret;
-    }
-
-    // Creates a v8::BackingStore that takes over responsibility for
-    // any allocated data. The ByteSource will be reset with size = 0
-    // after being called.
-    //  std::unique_ptr<v8::BackingStore> ReleaseToBackingStore();
-    //
-    //  v8::Local<v8::ArrayBuffer> ToArrayBuffer(Environment* env);
-    //
-    //  v8::MaybeLocal<v8::Uint8Array> ToBuffer(Environment* env);
-
-    static ByteSource Allocated(void* data, size_t size);
-    static ByteSource Foreign(const void* data, size_t size);
-
-     static ByteSource FromEncodedString(jsi::Runtime &rt,
-                                         std::string value,
-                                         enum encoding enc = BASE64);
-
-    static ByteSource FromStringOrBuffer(jsi::Runtime& runtime,
-                                         const jsi::Value& value);
-
-    static ByteSource FromString(std::string str, bool ntc = false);
-
-    static ByteSource FromBuffer(jsi::Runtime& runtime,
-                                 const jsi::ArrayBuffer& buffer,
-                                 bool ntc = false);
-
-    static ByteSource FromBIO(const BIOPointer& bio);
-
-    static ByteSource FromBN(const BIGNUM* bn, size_t size);
-
-    //  static ByteSource NullTerminatedCopy(Environment* env,
-    //                                       v8::Local<v8::Value> value);
-    //
-    //  static ByteSource FromSymmetricKeyObjectHandle(v8::Local<v8::Value>
-    //  handle);
-
-    //  static ByteSource FromSecretKeyBytes(
-    //                                       Environment* env,
-    //                                       v8::Local<v8::Value> value);
-
- private:
-    const void* data_ = nullptr;
-    void* allocated_data_ = nullptr;
-    size_t size_ = 0;
-
-    ByteSource(const void* data, void* allocated_data, size_t size)
-    : data_(data), allocated_data_(allocated_data), size_(size) {}
-};
-
-ByteSource ArrayBufferToByteSource(jsi::Runtime& runtime,
-                                   const jsi::ArrayBuffer& buffer);
-
-ByteSource ArrayBufferToNTCByteSource(jsi::Runtime& runtime,
-                                      const jsi::ArrayBuffer& buffer);
-
-// Originally part of the ArrayBufferContentOrView class
-inline ByteSource ToNullTerminatedByteSource(jsi::Runtime& runtime,
-                                             jsi::ArrayBuffer& buffer) {
-    if (buffer.size(runtime) == 0) return ByteSource();
-    char* buf = MallocOpenSSL<char>(buffer.size(runtime) + 1);
-    //    CHECK_NOT_NULL(buf);
-    buf[buffer.size(runtime)] = 0;
-    memcpy(buf, buffer.data(runtime), buffer.size(runtime));
-    return ByteSource::Allocated(buf, buffer.size(runtime));
-}
-
-inline int PasswordCallback(char* buf, int size, int rwflag, void* u) {
-    const ByteSource* passphrase = *static_cast<const ByteSource**>(u);
-    if (passphrase != nullptr) {
-        size_t buflen = static_cast<size_t>(size);
-        size_t len = passphrase->size();
-        if (buflen < len) return -1;
-        memcpy(buf, passphrase->data(), len);
-        return (int)len;
-    }
-
-    return -1;
-}
-
-inline void CheckEntropy() {
-    for (;;) {
-        int status = RAND_status();
-        //    CHECK_GE(status, 0);  // Cannot fail.
-        if (status != 0) break;
-
-        // Give up, RAND_poll() not supported.
-        if (RAND_poll() == 0) break;
-    }
-}
-
-std::string StringBytesWrite(jsi::Runtime &rt,
-                        const std::string val,
-                        enum encoding encoding);
-
-
-inline jsi::Value toJSI(jsi::Runtime& rt, std::string value) {
-  return jsi::String::createFromUtf8(rt, value);
-}
-
-inline jsi::Value toJSI(jsi::Runtime& rt, ByteSource value) {
-    jsi::Function array_buffer_ctor =
-        rt.global().getPropertyAsFunction(rt, "ArrayBuffer");
-    jsi::Object o = array_buffer_ctor.callAsConstructor(rt, (int)value.size())
-                        .getObject(rt);
-    jsi::ArrayBuffer buf = o.getArrayBuffer(rt);
-    // You cannot share raw memory between native and JS
-    // always copy the data
-    // see https://github.com/facebook/hermes/pull/419 and
-    // https://github.com/facebook/hermes/issues/564.
-    memcpy(buf.data(rt), value.data(), value.size());
-    return o;
-}
-
-ByteSource GetByteSourceFromJS(jsi::Runtime &rt,
-                               const jsi::Value &value,
-                               std::string name);
-
-std::string EncodeBignum(const BIGNUM* bn,
-                         size_t size,
-                         bool url = false);
-
-std::string EncodeBase64(const std::string data, bool url = false);
-std::string DecodeBase64(const std::string &in, bool remove_linebreaks = false);
-
-bool SetRsaOaepLabel(const EVPKeyCtxPointer& ctx, const ByteSource& label);
-
-// TODO: until shared, keep in sync with JS side (src/NativeQuickCrypto/Cipher.ts)
-enum KeyVariant {
-  kvRSA_SSA_PKCS1_v1_5,
-  kvRSA_PSS,
-  kvRSA_OAEP,
-  kvDSA,
-  kvEC,
-  kvNID,
-  kvDH,
-};
-
-enum FnMode {
-  kAsync,
-  kSync,
-};
-
-enum WebCryptoKeyFormat {
-  kWebCryptoKeyFormatRaw,
-  kWebCryptoKeyFormatPKCS8,
-  kWebCryptoKeyFormatSPKI,
-  kWebCryptoKeyFormatJWK
-};
-
-enum WebCryptoCipherMode {
-  kEncrypt,
-  kDecrypt,
-  // kWrapKey,
-  // kUnwrapKey,
-};
-
-enum class WebCryptoCipherStatus {
-  OK,
-  INVALID_KEY_TYPE,
-  FAILED
-};
-
-}  // namespace margelo
-
-#endif /* MGLUtils_h */

package/cpp/Utils/base64.h

@@ -1,320 +0,0 @@
-/*
-   base64.h
-
-   base64 encoding and decoding with C++.
-   More information at
-     https://renenyffenegger.ch/notes/development/Base64/Encoding-and-decoding-base-64-with-cpp
-
-   Version: 2.rc.09 (release candidate)
-
-   Copyright (C) 2004-2017, 2020-2022 René Nyffenegger
-
-   This source code is provided 'as-is', without any express or implied
-   warranty. In no event will the author be held liable for any damages
-   arising from the use of this software.
-
-   Permission is granted to anyone to use this software for any purpose,
-   including commercial applications, and to alter it and redistribute it
-   freely, subject to the following restrictions:
-
-   1. The origin of this source code must not be misrepresented; you must not
-      claim that you wrote the original source code. If you use this source code
-      in a product, an acknowledgment in the product documentation would be
-      appreciated but is not required.
-
-   2. Altered source versions must be plainly marked as such, and must not be
-      misrepresented as being the original source code.
-
-   3. This notice may not be removed or altered from any source distribution.
-
-   René Nyffenegger rene.nyffenegger@adp-gmbh.ch
-*/
-/**
- * Copyright (C) 2023 Kevin Heifner
- *
- * Modified to be header only.
- * Templated for std::string, std::string_view, std::vector<char> and other char containers.
- */
-
-#pragma once
-
-#include <algorithm>
-#include <string>
-#include <string_view>
-#include <stdexcept>
-
-// Interface:
-// Defaults allow for use:
-//   std::string s = "foobar";
-//   std::string encoded = base64_encode(s);
-//   std::string_view sv = "foobar";
-//   std::string encoded = base64_encode(sv);
-//   std::vector<char> vc = {'f', 'o', 'o'};
-//   std::string encoded = base64_encode(vc);
-//
-// Also allows for user provided char containers and specified return types:
-//   std::string s = "foobar";
-//   std::vector<char> encoded = base64_encode<std::vector<char>>(s);
-
-template <typename RetString = std::string, typename String = std::string>
-RetString base64_encode(const String& s, bool url = false);
-
-template <typename RetString = std::string, typename String = std::string>
-RetString base64_encode_pem(const String& s);
-
-template <typename RetString = std::string, typename String = std::string>
-RetString base64_encode_mime(const String& s);
-
-template <typename RetString = std::string, typename String = std::string>
-RetString base64_decode(const String& s, bool remove_linebreaks = false);
-
-template <typename RetString = std::string>
-RetString base64_encode(const unsigned char* s, size_t len, bool url = false);
-
-namespace detail {
- //
- // Depending on the url parameter in base64_chars, one of
- // two sets of base64 characters needs to be chosen.
- // They differ in their last two characters.
- //
-constexpr const char* to_base64_chars[2] = {
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789"
-             "+/",
-
-             "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
-             "abcdefghijklmnopqrstuvwxyz"
-             "0123456789"
-             "-_"};
-
-constexpr unsigned char from_base64_chars[256] = {
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 62, 64, 62, 64, 63,
-    52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 64, 64, 64, 64, 64, 64,
-    64,  0,  1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14,
-    15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 64, 64, 64, 64, 63,
-    64, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
-    41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,
-    64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64
-};
-
-inline unsigned int pos_of_char(const unsigned char chr) {
-   //
-   // Return the position of chr within base64_encode()
-   //
-
-   if (from_base64_chars[chr] != 64) return from_base64_chars[chr];
-
-   //
-   // 2020-10-23: Throw std::exception rather than const char*
-   //(Pablo Martin-Gomez, https://github.com/Bouska)
-   //
-   throw std::runtime_error("Input is not valid base64-encoded data.");
-}
-
-template <typename RetString, typename String>
-inline RetString insert_linebreaks(const String& str, size_t distance) {
-   //
-   // Provided by https://github.com/JomaCorpFX, adapted by Rene & Kevin
-   //
-   if (!str.size()) {
-      return RetString{};
-   }
-
-   if (distance < str.size()) {
-      size_t pos = distance;
-      String s{str};
-      while (pos < s.size()) {
-         s.insert(pos, "\n");
-         pos += distance + 1;
-      }
-      return s;
-   } else {
-      return str;
-   }
-}
-
-template <typename RetString, typename String, unsigned int line_length>
-inline RetString encode_with_line_breaks(String s) {
-   return insert_linebreaks<RetString, String>(base64_encode(s, false), line_length);
-}
-
-template <typename RetString, typename String>
-inline RetString encode_pem(String s) {
-   return encode_with_line_breaks<RetString, String, 64>(s);
-}
-
-template <typename RetString, typename String>
-inline RetString encode_mime(String s) {
-   return encode_with_line_breaks<RetString, String, 76>(s);
-}
-
-template <typename RetString, typename String>
-inline RetString encode(String s, bool url) {
-   return base64_encode<RetString>(reinterpret_cast<const unsigned char*>(s.data()), s.size(), url);
-}
-
-} // namespace detail
-
-template <typename RetString>
-inline RetString base64_encode(const unsigned char* bytes_to_encode, size_t in_len, bool url) {
-   size_t len_encoded = (in_len + 2) / 3 * 4;
-
-   unsigned char trailing_char = url ? '.' : '=';
-
-   //
-   // Choose set of base64 characters. They differ
-   // for the last two positions, depending on the url
-   // parameter.
-   // A bool (as is the parameter url) is guaranteed
-   // to evaluate to either 0 or 1 in C++ therefore,
-   // the correct character set is chosen by subscripting
-   // base64_chars with url.
-   //
-   const char *base64_chars_ = detail::to_base64_chars[url];
-
-   RetString ret;
-   ret.reserve(len_encoded);
-
-   unsigned int pos = 0;
-
-   while (pos < in_len) {
-      ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0xfc) >> 2]);
-
-      if (pos + 1 < in_len) {
-         ret.push_back(base64_chars_[((bytes_to_encode[pos + 0] & 0x03) << 4) +
-                                     ((bytes_to_encode[pos + 1] & 0xf0) >> 4)]);
-
-         if (pos + 2 < in_len) {
-            ret.push_back(base64_chars_[((bytes_to_encode[pos + 1] & 0x0f) << 2) +
-                                        ((bytes_to_encode[pos + 2] & 0xc0) >> 6)]);
-            ret.push_back(base64_chars_[bytes_to_encode[pos + 2] & 0x3f]);
-         } else {
-            ret.push_back(base64_chars_[(bytes_to_encode[pos + 1] & 0x0f) << 2]);
-            ret.push_back(trailing_char);
-         }
-      } else {
-         ret.push_back(base64_chars_[(bytes_to_encode[pos + 0] & 0x03) << 4]);
-         ret.push_back(trailing_char);
-         ret.push_back(trailing_char);
-      }
-
-      pos += 3;
-   }
-
-   return ret;
-}
-
-namespace detail {
-
-template <typename RetString, typename String>
-inline RetString decode(const String& encoded_string, bool remove_linebreaks) {
-    static_assert(!std::is_same<RetString, std::string_view>::value,
-                  "RetString should not be std::string_view");
-
-   //
-   // decode(…) is templated so that it can be used with String = const std::string&
-   // or std::string_view (requires at least C++17)
-   //
-
-   if (encoded_string.empty())
-      return RetString{};
-
-   if (remove_linebreaks) {
-      String copy{encoded_string};
-
-      copy.erase(std::remove(copy.begin(), copy.end(), '\n'), copy.end());
-
-      return base64_decode<RetString, String>(copy, false);
-   }
-
-   size_t length_of_string = encoded_string.size();
-   size_t pos = 0;
-
-   //
-   // The approximate length (bytes) of the decoded string might be one or
-   // two bytes smaller, depending on the amount of trailing equal signs
-   // in the encoded string. This approximation is needed to reserve
-   // enough space in the string to be returned.
-   //
-   size_t approx_length_of_decoded_string = length_of_string / 4 * 3;
-   RetString ret;
-   ret.reserve(approx_length_of_decoded_string);
-
-   while (pos < length_of_string) {
-      //
-      // Iterate over encoded input string in chunks. The size of all
-      // chunks except the last one is 4 bytes.
-      //
-      // The last chunk might be padded with equal signs or dots
-      // in order to make it 4 bytes in size as well, but this
-      // is not required as per RFC 2045.
-      //
-      // All chunks except the last one produce three output bytes.
-      //
-      // The last chunk produces at least one and up to three bytes.
-      //
-
-      size_t pos_of_char_1 = pos_of_char(encoded_string.at(pos + 1));
-
-      //
-      // Emit the first output byte that is produced in each chunk:
-      //
-      ret.push_back(static_cast<typename RetString::value_type>(((pos_of_char(encoded_string.at(pos + 0))) << 2) + ((pos_of_char_1 & 0x30) >> 4)));
-
-      if ((pos + 2 < length_of_string) &&
-          // Check for data that is not padded with equal signs (which is allowed by RFC 2045)
-          encoded_string.at(pos + 2) != '=' &&
-          encoded_string.at(pos + 2) != '.' ) {     // accept URL-safe base 64 strings, too, so check for '.' also.
-         //
-         // Emit a chunk's second byte (which might not be produced in the last chunk).
-         //
-         unsigned int pos_of_char_2 = pos_of_char(encoded_string.at(pos + 2));
-         ret.push_back(static_cast<typename RetString::value_type>(((pos_of_char_1 & 0x0f) << 4) + ((pos_of_char_2 & 0x3c) >> 2)));
-
-         if ((pos + 3 < length_of_string) &&
-             encoded_string.at(pos + 3) != '=' &&
-             encoded_string.at(pos + 3) != '.' ) {
-            //
-            // Emit a chunk's third byte (which might not be produced in the last chunk).
-            //
-            ret.push_back(static_cast<typename RetString::value_type>(((pos_of_char_2 & 0x03) << 6) + pos_of_char(encoded_string.at(pos + 3))));
-         }
-      }
-
-      pos += 4;
-   }
-
-   return ret;
-}
-
-} // namespace detail
-
-template <typename RetString, typename String>
-inline RetString base64_decode(const String& s, bool remove_linebreaks) {
-   return detail::decode<RetString, String>(s, remove_linebreaks);
-}
-
-template <typename RetString, typename String>
-inline RetString base64_encode(const String& s, bool url) {
-   return detail::encode<RetString, String>(s, url);
-}
-
-template <typename RetString, typename String>
-inline RetString base64_encode_pem (const String& s) {
-   return detail::encode_pem<RetString, String>(s);
-}
-
-template <typename RetString, typename String>
-inline RetString base64_encode_mime(const String& s) {
-   return detail::encode_mime<RetString, String>(s);
-}