diff --git a/CMakeLists.txt b/CMakeLists.txt
index f37482e..21ac5c5 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -9,7 +9,8 @@ INCLUDE( VersionMacros )
 INCLUDE( SetupTargetMacros )
 INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR} )
 INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/include )
-INCLUDE_DIRECTORIES( ${CMAKE_SOURCE_DIR}/vendor/boost_1_51/include )
+INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/vendor/cyoencode-1.0.2/src )
+INCLUDE_DIRECTORIES( ${CMAKE_CURRENT_SOURCE_DIR}/vendor/boost_1.51/include )
 
 SET( DEFAULT_HEADER_INSTALL_DIR include/\${target} )
 SET( DEFAULT_LIBRARY_INSTALL_DIR lib/ )
@@ -57,7 +58,6 @@ option( UNITY_BUILD OFF )
 
 FIND_PACKAGE( OpenSSL )
 
-include_directories( vendor/boost_1.51/include )
 include_directories( ${Boost_INCLUDE_DIR} )
 include_directories( ${OPENSSL_INCLUDE_DIR} )
 
@@ -106,6 +106,7 @@ set( fc_sources
      src/crypto/sha512.cpp
      src/crypto/dh.cpp
      src/crypto/blowfish.cpp
+     src/crypto/elliptic.cpp
      src/network/tcp_socket.cpp
      src/network/udp_socket.cpp
      src/network/http/http_connection.cpp
@@ -113,6 +114,8 @@ set( fc_sources
      src/network/ip.cpp
      src/network/resolve.cpp
      src/network/url.cpp
+     vendor/cyoencode-1.0.2/src/CyoDecode.c
+     vendor/cyoencode-1.0.2/src/CyoEncode.c
 #     src/ssh/client.cpp
 #     src/ssh/process.cpp
      )
diff --git a/include/fc/array.hpp b/include/fc/array.hpp
index 9f2b4b7..1533182 100644
--- a/include/fc/array.hpp
+++ b/include/fc/array.hpp
@@ -20,12 +20,12 @@ namespace fc {
   template<typename T, size_t N>
   void to_variant( const array<T,N>& bi, variant& v )
   {
-     v = fc::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
+     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
   }
   template<typename T, size_t N>
   void from_variant( const variant& v, array<T,N>& bi )
   {
-    fc::vector<char> ve = v.as< vector<char> >();
+    std::vector<char> ve = v.as< std::vector<char> >();
     if( ve.size() )
     {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
diff --git a/include/fc/crypto/elliptic.hpp b/include/fc/crypto/elliptic.hpp
index 167d663..7aac348 100644
--- a/include/fc/crypto/elliptic.hpp
+++ b/include/fc/crypto/elliptic.hpp
@@ -4,28 +4,38 @@
 #include <fc/crypto/sha512.hpp>
 #include <fc/fwd.hpp>
 #include <fc/array.hpp>
+#include <fc/io/raw_fwd.hpp>
 
-namespace fc { namespace ecc {
-    
+namespace fc { 
+
+  namespace ecc {
     namespace detail 
     { 
       class public_key_impl; 
       class private_key_impl; 
     }
 
-    typedef fc::array<char,72> signature;
+    typedef fc::array<char,33>          public_key_data;
+    typedef fc::array<char,72>          signature;
     typedef fc::array<unsigned char,65> compact_signature;
 
     class public_key
     {
         public:
            public_key();
+           public_key(const public_key& k);
            ~public_key();
            bool verify( const fc::sha256& digest, const signature& sig );
-
-           std::vector<char> serialize();
-           public_key( const std::vector<char>& v );
+           public_key_data serialize()const;
+           public_key( const public_key_data& v );
            public_key( const compact_signature& c, const fc::sha256& digest );
+
+           bool valid()const;
+           public_key mult( const fc::sha256& digest );
+
+           public_key( public_key&& pk );
+           public_key& operator=( public_key&& pk );
+           public_key& operator=( const public_key& pk );
         private:
           friend class private_key;
           fc::fwd<detail::public_key_impl,8> my;
@@ -37,8 +47,13 @@ namespace fc { namespace ecc {
         public:
            private_key();
            private_key( std::vector<char> k );
+           private_key( private_key&& pk );
+           private_key( const private_key& pk );
            ~private_key();
 
+           private_key& operator=( private_key&& pk );
+           private_key& operator=( const private_key& pk );
+
            static private_key generate();
            static private_key regenerate( const fc::sha256& secret );
 
@@ -51,11 +66,48 @@ namespace fc { namespace ecc {
            fc::sha512 get_shared_secret( const public_key& pub );
 
            signature         sign( const fc::sha256& digest );
-           compact_signature sign_compact( const fc::sha256& digest );
-           bool      verify( const fc::sha256& digest, const signature& sig );
+           compact_signature sign_compact( const fc::sha256& digest )const;
+           bool              verify( const fc::sha256& digest, const signature& sig );
 
            public_key get_public_key()const;
         private:
            fc::fwd<detail::private_key_impl,8> my;
     };
-} } // fc::ecc
+  } // namespace ecc
+  void to_variant( const ecc::private_key& var,  variant& vo );
+  void from_variant( const variant& var,  ecc::private_key& vo );
+  void to_variant( const ecc::public_key& var,  variant& vo );
+  void from_variant( const variant& var,  ecc::public_key& vo );
+
+  namespace raw
+  {
+      template<typename Stream>
+      void unpack( Stream& s, fc::ecc::public_key& pk)
+      {
+          ecc::public_key_data ser;
+          fc::raw::unpack(s,ser);
+          pk = fc::ecc::public_key( ser );
+      }
+
+      template<typename Stream>
+      void pack( Stream& s, const fc::ecc::public_key& pk)
+      {
+          fc::raw::pack( s, pk.serialize() );
+      }
+
+      template<typename Stream>
+      void unpack( Stream& s, fc::ecc::private_key& pk)
+      {
+          fc::sha256 sec;
+          unpack( s, sec );
+          pk = ecc::private_key::regenerate(sec);
+      }
+
+      template<typename Stream>
+      void pack( Stream& s, const fc::ecc::private_key& pk)
+      {
+          fc::raw::pack( s, pk.get_secret() );
+      }
+  } // namespace raw
+
+} // namespace fc 
diff --git a/include/fc/crypto/sha1.hpp b/include/fc/crypto/sha1.hpp
index e91503e..991ae57 100644
--- a/include/fc/crypto/sha1.hpp
+++ b/include/fc/crypto/sha1.hpp
@@ -64,4 +64,22 @@ class sha1
     uint32_t _hash[5]; 
 };
 
+  class variant;
+  void to_variant( const sha1& bi, variant& v );
+  void from_variant( const variant& v, sha1& bi );
+
 } // namespace fc
+
+namespace std
+{
+    template<typename T> struct hash;
+
+    template<>
+    struct hash<fc::sha1>
+    {
+       size_t operator()( const fc::sha1& s )const
+       {
+           return  *((size_t*)&s);
+       }
+    };
+}
diff --git a/include/fc/crypto/sha224.hpp b/include/fc/crypto/sha224.hpp
new file mode 100644
index 0000000..4097e1d
--- /dev/null
+++ b/include/fc/crypto/sha224.hpp
@@ -0,0 +1,86 @@
+#pragma once
+#include <fc/fwd.hpp>
+#include <fc/string.hpp>
+
+namespace fc
+{
+
+class sha224 
+{
+  public:
+    sha224();
+    explicit sha224( const string& hex_str );
+
+    string str()const;
+    operator string()const;
+
+    char*    data()const;
+
+    static sha224 hash( const char* d, uint32_t dlen );
+    static sha224 hash( const string& );
+
+    template<typename T>
+    static sha224 hash( const T& t ) 
+    { 
+      sha224::encoder e; 
+      e << t; 
+      return e.result(); 
+    } 
+
+    class encoder 
+    {
+      public:
+        encoder();
+        ~encoder();
+
+        void write( const char* d, uint32_t dlen );
+        void put( char c ) { write( &c, 1 ); }
+        void reset();
+        sha224 result();
+
+      private:
+        struct      impl;
+        fc::fwd<impl,112> my;
+    };
+
+    template<typename T>
+    inline friend T& operator<<( T& ds, const sha224& ep ) {
+      ds.write( ep.data(), sizeof(ep) );
+      return ds;
+    }
+
+    template<typename T>
+    inline friend T& operator>>( T& ds, sha224& ep ) {
+      ds.read( ep.data(), sizeof(ep) );
+      return ds;
+    }
+    friend sha224 operator << ( const sha224& h1, uint32_t i       );
+    friend bool   operator == ( const sha224& h1, const sha224& h2 );
+    friend bool   operator != ( const sha224& h1, const sha224& h2 );
+    friend sha224 operator ^  ( const sha224& h1, const sha224& h2 );
+    friend bool   operator >= ( const sha224& h1, const sha224& h2 );
+    friend bool   operator >  ( const sha224& h1, const sha224& h2 ); 
+    friend bool   operator <  ( const sha224& h1, const sha224& h2 ); 
+                             
+    uint64_t _hash[3]; 
+    uint32_t _hash4; 
+};
+
+  class variant;
+  void to_variant( const sha224& bi, variant& v );
+  void from_variant( const variant& v, sha224& bi );
+
+} // fc
+namespace std
+{
+    template<typename T> struct hash;
+
+    template<>
+    struct hash<fc::sha224>
+    {
+       size_t operator()( const fc::sha224& s )const
+       {
+           return  *((size_t*)&s);
+       }
+    };
+}
diff --git a/include/fc/io/raw.hpp b/include/fc/io/raw.hpp
index 52321bc..5d4b81f 100644
--- a/include/fc/io/raw.hpp
+++ b/include/fc/io/raw.hpp
@@ -106,13 +106,13 @@ namespace fc {
       if( b ) { v = T(); unpack( s, *v ); }
     }
 
-    // fc::vector
-    template<typename Stream> inline void pack( Stream& s, const fc::vector<char>& value ) { 
+    // std::vector
+    template<typename Stream> inline void pack( Stream& s, const std::vector<char>& value ) { 
       pack( s, unsigned_int(value.size()) );
       if( value.size() )
         s.write( &value.front(), value.size() );
     }
-    template<typename Stream> inline void unpack( Stream& s, fc::vector<char>& value ) { 
+    template<typename Stream> inline void unpack( Stream& s, std::vector<char>& value ) { 
       unsigned_int size; unpack( s, size );
       value.resize(size.value);
       if( value.size() )
@@ -126,8 +126,10 @@ namespace fc {
     }
 
     template<typename Stream> inline void unpack( Stream& s, fc::string& v )  {
-      fc::vector<char> tmp; unpack(s,tmp);
-      v = fc::string(tmp.begin(),tmp.end());
+      std::vector<char> tmp; unpack(s,tmp);
+      if( tmp.size() )
+         v = fc::string(tmp.data(),tmp.data()+tmp.size());
+      else v = fc::string();
     }
 
     // bool
@@ -211,7 +213,7 @@ namespace fc {
 
 
     template<typename Stream, typename T>
-    inline void pack( Stream& s, const fc::vector<T>& value ) {
+    inline void pack( Stream& s, const std::vector<T>& value ) {
       pack( s, unsigned_int(value.size()) );
       auto itr = value.begin();
       auto end = value.end();
@@ -222,7 +224,7 @@ namespace fc {
     }
 
     template<typename Stream, typename T>
-    inline void unpack( Stream& s, fc::vector<T>& value ) {
+    inline void unpack( Stream& s, std::vector<T>& value ) {
       unsigned_int size; unpack( s, size );
       value.resize(size.value);
       auto itr = value.begin();
@@ -383,10 +385,10 @@ namespace fc {
     }
 
     template<typename T>
-    inline fc::vector<char> pack(  const T& v ) {
+    inline std::vector<char> pack(  const T& v ) {
       datastream<size_t> ps; 
       raw::pack(ps,v );
-      fc::vector<char> vec(ps.tellp());
+      std::vector<char> vec(ps.tellp());
 
       if( vec.size() ) {
         datastream<char*>  ds( vec.data(), size_t(vec.size()) ); 
@@ -396,7 +398,7 @@ namespace fc {
     }
 
     template<typename T>
-    inline T unpack( const fc::vector<char>& s ) {
+    inline T unpack( const std::vector<char>& s ) {
       T tmp;
       if( s.size() ) {
         datastream<const char*>  ds( s.data(), size_t(s.size()) ); 
diff --git a/include/fc/io/raw_fwd.hpp b/include/fc/io/raw_fwd.hpp
index 24e1c1a..ce3159a 100644
--- a/include/fc/io/raw_fwd.hpp
+++ b/include/fc/io/raw_fwd.hpp
@@ -1,19 +1,29 @@
 #pragma once
 #include <fc/io/varint.hpp>
 #include <fc/array.hpp>
+#include <vector>
+#include <string>
 
-namespace fc { namespace raw {
+namespace fc { 
+   namespace ecc { class public_key; class private_key; }
+   namespace raw {
     template<typename Stream, typename T> void unpack( Stream& s, fc::optional<T>& v ); 
     template<typename Stream, typename T> void pack( Stream& s, const fc::optional<T>& v );
 
     template<typename Stream> void unpack( Stream& s, fc::string& ); 
     template<typename Stream> void pack( Stream& s, const fc::string& );
+    template<typename Stream> void unpack( Stream& s, std::string& ); 
+    template<typename Stream> void pack( Stream& s, const std::string& );
+    template<typename Stream> void unpack( Stream& s, fc::ecc::public_key& ); 
+    template<typename Stream> void pack( Stream& s, const fc::ecc::public_key& );
+    template<typename Stream> void unpack( Stream& s, fc::ecc::private_key& ); 
+    template<typename Stream> void pack( Stream& s, const fc::ecc::private_key& );
 
     template<typename Stream, typename T> inline void pack( Stream& s, const T& v ); 
     template<typename Stream, typename T> inline void unpack( Stream& s, T& v );
 
-    template<typename Stream, typename T> inline void pack( Stream& s, const fc::vector<T>& v );
-    template<typename Stream, typename T> inline void unpack( Stream& s, fc::vector<T>& v );
+    template<typename Stream, typename T> inline void pack( Stream& s, const std::vector<T>& v );
+    template<typename Stream, typename T> inline void unpack( Stream& s, std::vector<T>& v );
 
     template<typename Stream> inline void pack( Stream& s, const signed_int& v );
     template<typename Stream> inline void unpack( Stream& s, signed_int& vi );
@@ -22,8 +32,8 @@ namespace fc { namespace raw {
     template<typename Stream> inline void unpack( Stream& s, unsigned_int& vi );
 
     template<typename Stream> inline void pack( Stream& s, const char* v );
-    template<typename Stream> inline void pack( Stream& s, const fc::vector<char>& value );
-    template<typename Stream> inline void unpack( Stream& s, fc::vector<char>& value );
+    template<typename Stream> inline void pack( Stream& s, const std::vector<char>& value );
+    template<typename Stream> inline void unpack( Stream& s, std::vector<char>& value );
 
     template<typename Stream, typename T, size_t N> inline void pack( Stream& s, const fc::array<T,N>& v);
     template<typename Stream, typename T, size_t N> inline void unpack( Stream& s, fc::array<T,N>& v);
@@ -31,8 +41,8 @@ namespace fc { namespace raw {
     template<typename Stream> inline void pack( Stream& s, const bool& v );
     template<typename Stream> inline void unpack( Stream& s, bool& v );
 
-    template<typename T> inline fc::vector<char> pack( const T& v );
-    template<typename T> inline T unpack( const fc::vector<char>& s );
+    template<typename T> inline std::vector<char> pack( const T& v );
+    template<typename T> inline T unpack( const std::vector<char>& s );
     template<typename T> inline T unpack( const char* d, uint32_t s );
     template<typename T> inline void unpack( const char* d, uint32_t s, T& v );
 } }
diff --git a/include/fc/log/console_appender.hpp b/include/fc/log/console_appender.hpp
index 0ff9de0..ddc54f2 100644
--- a/include/fc/log/console_appender.hpp
+++ b/include/fc/log/console_appender.hpp
@@ -1,6 +1,7 @@
 #pragma once
 #include <fc/log/appender.hpp>
 #include <fc/log/logger.hpp>
+#include <vector>
 
 namespace fc 
 {
@@ -41,7 +42,7 @@ namespace fc
 
                fc::string                         format;
                console_appender::stream::type     stream;
-               std::vector<level_color>            level_colors;
+               std::vector<level_color>           level_colors;
                bool                               flush;
             };
 
diff --git a/include/fc/reflect/reflect.hpp b/include/fc/reflect/reflect.hpp
index 57bf64a..502e5f4 100644
--- a/include/fc/reflect/reflect.hpp
+++ b/include/fc/reflect/reflect.hpp
@@ -13,6 +13,7 @@
 #include <boost/preprocessor/seq/seq.hpp>
 #include <boost/preprocessor/stringize.hpp>
 #include <stdint.h>
+#include <string.h>
 
 #include <fc/reflect/typename.hpp>
 
diff --git a/include/fc/variant.hpp b/include/fc/variant.hpp
index c74d291..c248682 100644
--- a/include/fc/variant.hpp
+++ b/include/fc/variant.hpp
@@ -1,9 +1,10 @@
 #pragma once 
+#include <vector>
 #include <fc/optional.hpp>
 #include <fc/string.hpp>
 #include <memory>
-#include <vector>
-#include <string.h>
+#include <string.h> // memset
+#include <unordered_set>
 
 namespace fc
 {
@@ -38,6 +39,12 @@ namespace fc
    void from_variant( const variant& var,  mutable_variant_object& vo );
    void to_variant( const std::vector<char>& var,  variant& vo );
    void from_variant( const variant& var,  std::vector<char>& vo );
+
+   template<typename T>
+   void to_variant( const std::unordered_set<T>& var,  variant& vo );
+   template<typename T>
+   void from_variant( const variant& var,  std::unordered_set<T>& vo );
+
    void to_variant( const time_point& var,  variant& vo );
    void from_variant( const variant& var,  time_point& vo );
    #ifdef __APPLE__
@@ -244,6 +251,24 @@ namespace fc
           from_variant( var, *vo );
       }
    }
+   template<typename T>
+   void to_variant( const std::unordered_set<T>& var,  variant& vo )
+   {
+       std::vector<variant> vars(var.size());
+       size_t i = 0;
+       for( auto itr = var.begin(); itr != var.end(); ++itr )
+          vars[i] = variant(*itr);
+       vo = vars;
+   }
+   template<typename T>
+   void from_variant( const variant& var,  std::unordered_set<T>& vo )
+   {
+      const variants& vars = var.get_array();
+      vo.clear();
+      vo.reserve( vars.size() );
+      for( auto itr = vars.begin(); itr != vars.end(); ++itr )
+         vo.insert( itr->as<T>() );
+   }
 
    /** @ingroup Serializable */
    template<typename T>
diff --git a/include/fc/vector.hpp b/include/fc/vector.hpp
index d45f384..29b3388 100644
--- a/include/fc/vector.hpp
+++ b/include/fc/vector.hpp
@@ -1,3 +1,2 @@
 #pragma once
 #include <vector>
-
diff --git a/src/crypto/base32.cpp b/src/crypto/base32.cpp
index a41e300..789a926 100644
--- a/src/crypto/base32.cpp
+++ b/src/crypto/base32.cpp
@@ -3,25 +3,25 @@
 #include <CyoEncode.h>
 namespace fc
 {
-    fc::vector<char> from_base32( const fc::string& b32 )
+    std::vector<char> from_base32( const std::string& b32 )
     {
        auto len = cyoBase32DecodeGetLength( b32.size() );
-       fc::vector<char> v(len);
+       std::vector<char> v(len);
        cyoBase32Decode( v.data(), b32.c_str(), b32.size() );
        return v;
     }
 
-    fc::string to_base32( const char* data, size_t len )
+    std::string to_base32( const char* data, size_t len )
     { 
        auto s = cyoBase16EncodeGetLength(len);
-       fc::string b32;
+       std::vector<char> b32;
        b32.resize(s);
        cyoBase16Encode( b32.data(), data, len );
        b32.resize( b32.size()-1); // strip the nullterm
-       return b32;
+       return std::string(b32.begin(),b32.end());
     }
 
-    fc::string to_base32( const fc::vector<char>& vec )
+    std::string to_base32( const std::vector<char>& vec )
     {
        return to_base32( vec.data(), vec.size() );
     }
diff --git a/src/crypto/elliptic.cpp b/src/crypto/elliptic.cpp
index 2c15abb..6443674 100644
--- a/src/crypto/elliptic.cpp
+++ b/src/crypto/elliptic.cpp
@@ -11,6 +11,50 @@
 #include <assert.h>
 
 namespace fc { namespace ecc {
+
+template <typename ssl_type>
+struct ssl_wrapper
+{
+    ssl_wrapper(ssl_type* obj)
+      : obj(obj) {}
+    virtual ~ssl_wrapper()
+    {
+    }
+    operator ssl_type*()
+    {
+        return obj;
+    }
+
+    ssl_type* obj;
+};
+
+struct ssl_bignum
+  : public ssl_wrapper<BIGNUM>
+{
+    ssl_bignum()
+      : ssl_wrapper(BN_new()) {}
+    ~ssl_bignum()
+    {
+        BN_free(obj);
+    }
+};
+
+    #define SSL_TYPE(name, ssl_type, free_func) \
+        struct name \
+          : public ssl_wrapper<ssl_type> \
+        { \
+            name(ssl_type* obj) \
+              : ssl_wrapper(obj) {} \
+            ~name() \
+            { \
+                free_func(obj); \
+            } \
+        };
+
+    SSL_TYPE(ec_group, EC_GROUP, EC_GROUP_free)
+    SSL_TYPE(ec_point, EC_POINT, EC_POINT_free)
+    SSL_TYPE(bn_ctx, BN_CTX, BN_CTX_free)
+
     namespace detail 
     { 
       class public_key_impl
@@ -188,6 +232,30 @@ namespace fc { namespace ecc {
     }
     */
 
+    public_key public_key::mult( const fc::sha256& digest )
+    {
+        // get point from this public key
+        const EC_POINT* master_pub   = EC_KEY_get0_public_key( my->_key );
+        ec_group group(EC_GROUP_new_by_curve_name(NID_secp256k1));
+
+        ssl_bignum z;
+        BN_bin2bn((unsigned char*)&digest, sizeof(digest), z);
+
+        // multiply by digest
+        ssl_bignum one;
+        bn_ctx ctx(BN_CTX_new());
+        BN_one(one);
+
+        ec_point result(EC_POINT_new(group));
+        EC_POINT_mul(group, result, z, master_pub, one, ctx);
+
+        public_key rtn;
+        rtn.my->_key = EC_KEY_new_by_curve_name( NID_secp256k1 );
+        EC_KEY_set_public_key(rtn.my->_key,result);
+
+        return rtn;
+    }
+
     private_key::private_key()
     {}
 
@@ -272,14 +340,14 @@ namespace fc { namespace ecc {
       return 1 == ECDSA_verify( 0, (unsigned char*)&digest, sizeof(digest), (unsigned char*)&sig, sizeof(sig), my->_key ); 
     }
 
-    std::vector<char> public_key::serialize()
+    public_key_data public_key::serialize()const
     {
       EC_KEY_set_conv_form( my->_key, POINT_CONVERSION_COMPRESSED );
-      size_t nbytes = i2o_ECPublicKey( my->_key, nullptr );
-      std::vector<char> dat(nbytes);
-      char* front = &dat[0];
+      /*size_t nbytes = */i2o_ECPublicKey( my->_key, nullptr );
+      /*assert( nbytes == 33 )*/
+      public_key_data dat;
+      char* front = &dat.data[0];
       i2o_ECPublicKey( my->_key, (unsigned char**)&front  );
-      fprintf( stderr, "public key size: %lu\n", nbytes );
       return dat;
       /*
        EC_POINT* pub   = EC_KEY_get0_public_key( my->_key );
@@ -293,11 +361,11 @@ namespace fc { namespace ecc {
     public_key::~public_key()
     {
     }
-    public_key::public_key( const std::vector<char>& v )
+    public_key::public_key( const public_key_data& dat )
     {
-      const char* front = &v[0];
+      const char* front = &dat.data[0];
       my->_key = EC_KEY_new_by_curve_name( NID_secp256k1 );
-      my->_key = o2i_ECPublicKey( &my->_key, (const unsigned char**)&front, v.size() );
+      my->_key = o2i_ECPublicKey( &my->_key, (const unsigned char**)&front, sizeof(public_key_data) );
       if( !my->_key ) 
       {
         fprintf( stderr, "decode error occurred??" );
@@ -384,7 +452,7 @@ namespace fc { namespace ecc {
         FC_THROW_EXCEPTION( exception, "unable to reconstruct public key from signature" );
     }
 
-    compact_signature private_key::sign_compact( const fc::sha256& digest )
+    compact_signature private_key::sign_compact( const fc::sha256& digest )const
     {
         ECDSA_SIG *sig = ECDSA_do_sign((unsigned char*)&digest, sizeof(digest), my->_key);
 
@@ -426,4 +494,84 @@ namespace fc { namespace ecc {
         return csig;
     }
 
-} }
+   private_key& private_key::operator=( private_key&& pk )
+   {
+     if( my->_key )
+     {
+       EC_KEY_free(my->_key);
+     }
+     my->_key = pk.my->_key;
+     pk.my->_key = nullptr;
+     return *this;
+   }
+   public_key::public_key( const public_key& pk )
+   :my(pk.my)
+   {
+   }
+   public_key::public_key( public_key&& pk )
+   :my( fc::move( pk.my) )
+   {
+   }
+   private_key::private_key( const private_key& pk )
+   :my(pk.my)
+   {
+   }
+   private_key::private_key( private_key&& pk )
+   :my( fc::move( pk.my) )
+   {
+   }
+
+   public_key& public_key::operator=( public_key&& pk )
+   {
+     if( my->_key )
+     {
+       EC_KEY_free(my->_key);
+     }
+     my->_key = pk.my->_key;
+     pk.my->_key = nullptr;
+     return *this;
+   }
+   public_key& public_key::operator=( const public_key& pk )
+   {
+     if( my->_key )
+     {
+       EC_KEY_free(my->_key);
+     }
+     my->_key = EC_KEY_dup(pk.my->_key);
+     return *this;
+   }
+   private_key& private_key::operator=( const private_key& pk )
+   {
+     if( my->_key )
+     {
+       EC_KEY_free(my->_key);
+     }
+     my->_key = EC_KEY_dup(pk.my->_key);
+     return *this;
+   }
+
+}
+  void to_variant( const ecc::private_key& var,  variant& vo )
+  {
+    vo = var.get_secret();
+  }
+  void from_variant( const variant& var,  ecc::private_key& vo )
+  {
+    fc::sha256 sec;
+    from_variant( var, sec );
+    vo = ecc::private_key::regenerate(sec);
+  }
+
+  void to_variant( const ecc::public_key& var,  variant& vo )
+  {
+    vo = var.serialize();
+  }
+  void from_variant( const variant& var,  ecc::public_key& vo )
+  {
+    ecc::public_key_data dat; 
+    from_variant( var, dat );
+    vo = ecc::public_key(dat);
+  }
+
+
+}
diff --git a/src/crypto/sha1.cpp b/src/crypto/sha1.cpp
index 2617d97..479d1ed 100644
--- a/src/crypto/sha1.cpp
+++ b/src/crypto/sha1.cpp
@@ -3,6 +3,8 @@
 #include <openssl/sha.h>
 #include <string.h>
 #include <fc/crypto/sha1.hpp>
+#include <fc/variant.hpp>
+#include <vector>
 
 namespace fc 
 {
@@ -84,4 +86,19 @@ bool operator == ( const sha1& h1, const sha1& h2 ) {
   return memcmp( h1._hash, h2._hash, sizeof(h1._hash) ) == 0;
 }
   
+  void to_variant( const sha1& bi, variant& v )
+  {
+     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
+  }
+  void from_variant( const variant& v, sha1& bi )
+  {
+    std::vector<char> ve = v.as< std::vector<char> >();
+    if( ve.size() )
+    {
+        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
+    }
+    else
+        memset( &bi, char(0), sizeof(bi) );
+  }
+  
 } // fc
diff --git a/src/crypto/sha224.cpp b/src/crypto/sha224.cpp
new file mode 100644
index 0000000..cc8056e
--- /dev/null
+++ b/src/crypto/sha224.cpp
@@ -0,0 +1,100 @@
+#include <fc/crypto/hex.hpp>
+#include <fc/fwd_impl.hpp>
+#include <openssl/sha.h>
+#include <string.h>
+#include <fc/crypto/sha224.hpp>
+#include <fc/variant.hpp>
+  
+namespace fc {
+
+    sha224::sha224() { memset( _hash, 0, sizeof(_hash) ); }
+    sha224::sha224( const string& hex_str ) {
+      fc::from_hex( hex_str, (char*)_hash, sizeof(_hash) );  
+    }
+
+    string sha224::str()const {
+      return fc::to_hex( (char*)_hash, sizeof(_hash) );
+    }
+    sha224::operator string()const { return  str(); }
+
+    char* sha224::data()const { return (char*)&_hash[0]; }
+
+
+    struct sha224::encoder::impl {
+       SHA256_CTX ctx;
+    };
+
+    sha224::encoder::~encoder() {}
+    sha224::encoder::encoder() {
+      reset();
+    }
+
+    sha224 sha224::hash( const char* d, uint32_t dlen ) {
+      encoder e;
+      e.write(d,dlen);
+      return e.result();
+    }
+    sha224 sha224::hash( const string& s ) {
+      return hash( s.c_str(), s.size() );
+    }
+
+    void sha224::encoder::write( const char* d, uint32_t dlen ) {
+      SHA224_Update( &my->ctx, d, dlen); 
+    }
+    sha224 sha224::encoder::result() {
+      sha224 h;
+      SHA224_Final((uint8_t*)h.data(), &my->ctx );
+      return h;
+    }
+    void sha224::encoder::reset() {
+      SHA224_Init( &my->ctx);  
+    }
+
+    sha224 operator << ( const sha224& h1, uint32_t i ) {
+      sha224 result;
+      uint8_t* r = (uint8_t*)&result;//result._hash;
+      uint8_t* s = (uint8_t*)&h1;//h1._hash;
+      for( uint32_t p = 0; p < sizeof(sha224)-1; ++p )
+          r[p] = s[p] << i | (s[p+1]>>(8-i));
+      r[sizeof(sha224)-1] = s[sizeof(sha224)-1] << i;
+      return result;
+    }
+    sha224 operator ^ ( const sha224& h1, const sha224& h2 ) {
+      sha224 result;
+      result._hash[0] = h1._hash[0] ^ h2._hash[0];
+      result._hash[1] = h1._hash[1] ^ h2._hash[1];
+      result._hash[2] = h1._hash[2] ^ h2._hash[2];
+      result._hash4 = h1._hash4 ^ h2._hash4;
+      return result;
+    }
+    bool operator >= ( const sha224& h1, const sha224& h2 ) {
+      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) >= 0;
+    }
+    bool operator > ( const sha224& h1, const sha224& h2 ) {
+      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) > 0;
+    }
+    bool operator < ( const sha224& h1, const sha224& h2 ) {
+      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) < 0;
+    }
+    bool operator != ( const sha224& h1, const sha224& h2 ) {
+      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) != 0;
+    }
+    bool operator == ( const sha224& h1, const sha224& h2 ) {
+      return memcmp( h1._hash, h2._hash, sizeof(sha224) ) == 0;
+    }
+  
+  void to_variant( const sha224& bi, variant& v )
+  {
+     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
+  }
+  void from_variant( const variant& v, sha224& bi )
+  {
+    std::vector<char> ve = v.as< std::vector<char> >();
+    if( ve.size() )
+    {
+        memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
+    }
+    else
+        memset( &bi, char(0), sizeof(bi) );
+  }
+}
diff --git a/src/crypto/sha512.cpp b/src/crypto/sha512.cpp
index 0c598c5..d177fe3 100644
--- a/src/crypto/sha512.cpp
+++ b/src/crypto/sha512.cpp
@@ -89,11 +89,11 @@ namespace fc {
   
   void to_variant( const sha512& bi, variant& v )
   {
-     v = fc::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
+     v = std::vector<char>( (const char*)&bi, ((const char*)&bi) + sizeof(bi) );
   }
   void from_variant( const variant& v, sha512& bi )
   {
-    fc::vector<char> ve = v.as< vector<char> >();
+    std::vector<char> ve = v.as< std::vector<char> >();
     if( ve.size() )
     {
         memcpy(&bi, ve.data(), fc::min<size_t>(ve.size(),sizeof(bi)) );
diff --git a/src/io/json.cpp b/src/io/json.cpp
index c2fa1a8..f280447 100644
--- a/src/io/json.cpp
+++ b/src/io/json.cpp
@@ -443,9 +443,94 @@ namespace fc
       return ss.str();
    }
 
+
+    fc::string pretty_print( const fc::string& v, uint8_t indent ) {
+      int level = 0;
+      fc::stringstream ss;
+      bool first = false;
+      bool quote = false;
+      bool escape = false;
+      for( uint32_t i = 0; i < v.size(); ++i ) {
+         switch( v[i] ) {
+            case '\\':
+              if( !escape ) {
+                if( quote ) 
+                  escape = true;
+              } else { escape = false; }
+              ss<<v[i];
+              break;
+            case ':':
+              if( !quote ) {
+                ss<<": ";
+              } else {
+                ss<<':';
+              }
+              break;
+            case '"':
+              if( first ) {
+                 ss<<'\n';
+                 for( int i = 0; i < level*indent; ++i ) ss<<' ';
+                 first = false;
+              }
+              if( !escape ) {
+                quote = !quote;
+              } 
+              escape = false;
+              ss<<'"';
+              break;
+            case '{':
+            case '[':
+              ss<<v[i];
+              if( !quote ) {
+                ++level;
+                first = true;
+              }else {
+                escape = false;
+              }
+              break;
+            case '}':
+            case ']':
+              if( !quote ) {
+                if( v[i-1] != '[' && v[i-1] != '{' ) {
+                  ss<<'\n';
+                }
+                --level;
+                if( !first ) {
+                  for( int i = 0; i < level*indent; ++i ) ss<<' ';
+                }
+                ss<<v[i];
+                break;
+              } else {
+                escape = false;
+                ss<<v[i];
+              }
+              break;
+            case ',':
+              if( !quote ) {
+                ss<<',';
+                first = true;
+              } else {
+                escape = false;
+                ss<<',';
+              }
+              break;
+            default:
+              if( first ) {
+                 ss<<'\n';
+                 for( int i = 0; i < level*indent; ++i ) ss<<' ';
+                 first = false;
+              }
+              ss << v[i];
+         }
+      }
+      return ss.str();
+    }
+
+
+
    fc::string   json::to_pretty_string( const variant& v )
    {
-	   return to_string(v);
+	   return pretty_print(to_string(v), 2);
    }
 
    void          json::save_to_file( const variant& v, const string& fi, bool pretty )
diff --git a/vendor/cyoencode-1.0.2/README.TXT b/vendor/cyoencode-1.0.2/README.TXT
new file mode 100644
index 0000000..30df17d
--- /dev/null
+++ b/vendor/cyoencode-1.0.2/README.TXT
@@ -0,0 +1,50 @@
+===============================================================================
+CyoEncode
+http://cyoencode.sourceforge.net/
+
+Copyright (c) 2009-2012, Graham Bull. All rights reserved.
+===============================================================================
+
+Version 1.0.2
+Release Date 5th January 2012
+
+-------------------------------------------------------------------------------
+1. License
+-------------------------------------------------------------------------------
+
+CyoEncode is made available under the terms of the Berkeley Software
+Distribution (BSD) licence, as detailed in LICENSE.TXT. This allows you
+complete freedom to use and distribute the code in source and/or binary form,
+as long as you respect the original copyright.
+
+-------------------------------------------------------------------------------
+2. Instructions
+-------------------------------------------------------------------------------
+
+Simply copy the required source files (CyoEncode.h/cpp and CyoDecode.h/cpp)
+into your C/C++ project.
+
+Examples of usage can be found in the test.c file.
+
+For Unix/Linux developers, there's a shell script that will build the test
+using GCC.
+
+For Windows developers, Visual Studio projects are included.
+
+-------------------------------------------------------------------------------
+3. Release Notes
+-------------------------------------------------------------------------------
+
+1.0.2 - 5th January 2012
+- A little refactoring, added some shared functions.
+- Added VS42010 project file.
+- Added x64 build configurations.
+
+1.0.1 - 25th September 2009
+- Added the cyoBase??Validate() functions.
+- Added detection of invalid encodings in the cyoBase??Decode() functions,
+  rather than relying on assertions.
+
+1.0.0 - 19th August 2009
+- First release.
+
diff --git a/vendor/cyoencode-1.0.2/src/CyoDecode.c b/vendor/cyoencode-1.0.2/src/CyoDecode.c
new file mode 100644
index 0000000..d40e3a8
--- /dev/null
+++ b/vendor/cyoencode-1.0.2/src/CyoDecode.c
@@ -0,0 +1,398 @@
+/*
+ * CyoDecode.c - part of the CyoEncode library
+ *
+ * Copyright (c) 2009-2012, Graham Bull.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "CyoDecode.h"
+
+#include <assert.h>
+
+#include <stdio.h> //TEMP
+
+/********************************** Shared ***********************************/
+
+static int cyoBaseXXValidate( const char* src, size_t size, size_t inputBytes, size_t maxPadding,
+                              unsigned char maxValue, const unsigned char table[] )
+{
+    /*
+     * returns 0 if the source is a valid baseXX encoding
+     */
+
+    if (!src)
+        return -1; /*ERROR - NULL pointer*/
+
+    if (size % inputBytes != 0)
+        return -1; /*ERROR - extra characters*/
+
+    /* check the bytes */
+    for (; size >= 1; --size, ++src)
+    {
+        unsigned char ch = *src;
+        if ((ch >= 0x80) || (table[ ch ] > maxValue))
+            break;
+    }
+
+    /* check any padding */
+    for (; 1 <= size && size <= maxPadding; --size, ++src)
+    {
+        unsigned char ch = *src;
+        if ((ch >= 0x80) || (table[ ch ] != maxValue + 1))
+            break;
+    }
+
+    /* if size isn't zero then the encoded string isn't valid */
+    if (size != 0)
+        return -2; /*ERROR - invalid baseXX character*/
+
+    /* OK */
+    return 0;
+}
+
+static size_t cyoBaseXXDecodeGetLength( size_t size, size_t inputBytes, size_t outputBytes )
+{
+    if (size % inputBytes != 0)
+        return 0; /*ERROR - extra characters*/
+
+    /* OK */
+    return (((size + inputBytes - 1) / inputBytes) * outputBytes) + 1; /*plus terminator*/
+}
+
+/****************************** Base16 Decoding ******************************/
+
+static const size_t BASE16_INPUT = 2;
+static const size_t BASE16_OUTPUT = 1;
+static const size_t BASE16_MAX_PADDING = 0;
+static const unsigned char BASE16_MAX_VALUE = 15;
+static const unsigned char BASE16_TABLE[ 0x80 ] = {
+    /*00-07*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*08-0f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*10-17*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*18-1f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*20-27*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*28-2f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*30-37*/ 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /*8 = '0'-'7'*/
+    /*38-3f*/ 0x08, 0x09, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /*2 = '8'-'9'*/
+    /*40-47*/ 0xFF, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xFF, /*6 = 'A'-'F'*/
+    /*48-4f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*50-57*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*58-5f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*60-67*/ 0xFF, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f, 0xFF, /*6 = 'a'-'f' (same as 'A'-'F')*/
+    /*68-6f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*70-77*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*78-7f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF
+};
+
+int cyoBase16Validate( const char* src, size_t size )
+{
+    return cyoBaseXXValidate( src, size, BASE16_INPUT, BASE16_MAX_PADDING, BASE16_MAX_VALUE, BASE16_TABLE );
+}
+
+size_t cyoBase16DecodeGetLength( size_t size )
+{
+    return cyoBaseXXDecodeGetLength( size, BASE16_INPUT, BASE16_OUTPUT );
+}
+
+size_t cyoBase16Decode( void* dest, const char* src, size_t size )
+{
+    /*
+     * output 1 byte for every 2 input:
+     *
+     *               outputs: 1
+     * inputs: 1 = ----1111 = 1111----
+     *         2 = ----2222 = ----2222
+     */
+
+    if (dest && src && (size % BASE16_INPUT == 0))
+    {
+        unsigned char* pDest = (unsigned char*)dest;
+        size_t dwSrcSize = size;
+        size_t dwDestSize = 0;
+        unsigned char in1, in2;
+
+        while (dwSrcSize >= 1)
+        {
+            /* 2 inputs */
+            in1 = *src++;
+            in2 = *src++;
+            dwSrcSize -= BASE16_INPUT;
+
+            /* Validate ascii */
+            if (in1 >= 0x80 || in2 >= 0x80)
+                return 0; /*ERROR - invalid base16 character*/
+
+            /* Convert ascii to base16 */
+            in1 = BASE16_TABLE[ in1 ];
+            in2 = BASE16_TABLE[ in2 ];
+
+            /* Validate base16 */
+            if (in1 > BASE16_MAX_VALUE || in2 > BASE16_MAX_VALUE)
+                return 0; /*ERROR - invalid base16 character*/
+
+            /* 1 output */
+            *pDest++ = ((in1 << 4) | in2);
+            dwDestSize += BASE16_OUTPUT;
+        }
+        *pDest++ = '\x0'; /*append terminator*/
+
+        return dwDestSize;
+    }
+    else
+        return 0; /*ERROR - null pointer, or size isn't a multiple of 2*/
+}
+
+/****************************** Base32 Decoding ******************************/
+
+static const size_t BASE32_INPUT = 8;
+static const size_t BASE32_OUTPUT = 5;
+static const size_t BASE32_MAX_PADDING = 6;
+static const unsigned char BASE32_MAX_VALUE = 31;
+static const unsigned char BASE32_TABLE[ 0x80 ] = {
+    /*00-07*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*08-0f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*10-17*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*18-1f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*20-27*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*28-2f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*30-37*/ 0xFF, 0xFF, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, /*6 = '2'-'7'*/
+    /*38-3f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0x20, 0xFF, 0xFF, /*1 = '='*/
+    /*40-47*/ 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /*7 = 'A'-'G'*/
+    /*48-4f*/ 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, /*8 = 'H'-'O'*/
+    /*50-57*/ 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, /*8 = 'P'-'W'*/
+    /*58-5f*/ 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /*3 = 'X'-'Z'*/
+    /*60-67*/ 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /*7 = 'a'-'g' (same as 'A'-'G')*/
+    /*68-6f*/ 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, /*8 = 'h'-'o' (same as 'H'-'O')*/
+    /*70-77*/ 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, /*8 = 'p'-'w' (same as 'P'-'W')*/
+    /*78-7f*/ 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF  /*3 = 'x'-'z' (same as 'X'-'Z')*/
+};
+
+int cyoBase32Validate( const char* src, size_t size )
+{
+    return cyoBaseXXValidate( src, size, BASE32_INPUT, BASE32_MAX_PADDING, BASE32_MAX_VALUE, BASE32_TABLE );
+}
+
+size_t cyoBase32DecodeGetLength( size_t size )
+{
+    return cyoBaseXXDecodeGetLength( size, BASE32_INPUT, BASE32_OUTPUT );
+}
+
+size_t cyoBase32Decode( void* dest, const char* src, size_t size )
+{
+    /*
+     * output 5 bytes for every 8 input:
+     *
+     *               outputs: 1        2        3        4        5
+     * inputs: 1 = ---11111 = 11111---
+     *         2 = ---222XX = -----222 XX------
+     *         3 = ---33333 =          --33333-
+     *         4 = ---4XXXX =          -------4 XXXX----
+     *         5 = ---5555X =                   ----5555 X-------
+     *         6 = ---66666 =                            -66666--
+     *         7 = ---77XXX =                            ------77 XXX-----
+     *         8 = ---88888 =                                     ---88888
+     */
+
+    if (dest && src && (size % BASE32_INPUT == 0))
+    {
+        unsigned char* pDest = (unsigned char*)dest;
+        size_t dwSrcSize = size;
+        size_t dwDestSize = 0;
+        unsigned char in1, in2, in3, in4, in5, in6, in7, in8;
+
+        while (dwSrcSize >= 1)
+        {
+            /* 8 inputs */
+            in1 = *src++;
+            in2 = *src++;
+            in3 = *src++;
+            in4 = *src++;
+            in5 = *src++;
+            in6 = *src++;
+            in7 = *src++;
+            in8 = *src++;
+            dwSrcSize -= BASE32_INPUT;
+
+            /* Validate ascii */
+            if (   in1 >= 0x80 || in2 >= 0x80 || in3 >= 0x80 || in4 >= 0x80
+                || in5 >= 0x80 || in6 >= 0x80 || in7 >= 0x80 || in8 >= 0x80)
+                return 0; /*ERROR - invalid base32 character*/
+
+            /* Convert ascii to base16 */
+            in1 = BASE32_TABLE[ in1 ];
+            in2 = BASE32_TABLE[ in2 ];
+            in3 = BASE32_TABLE[ in3 ];
+            in4 = BASE32_TABLE[ in4 ];
+            in5 = BASE32_TABLE[ in5 ];
+            in6 = BASE32_TABLE[ in6 ];
+            in7 = BASE32_TABLE[ in7 ];
+            in8 = BASE32_TABLE[ in8 ];
+
+            /* Validate base32 */
+            if (in1 > BASE32_MAX_VALUE || in2 > BASE32_MAX_VALUE)
+                return 0; /*ERROR - invalid base32 character*/
+            /*the following can be padding*/
+            if (   in3 > BASE32_MAX_VALUE + 1 || in4 > BASE32_MAX_VALUE + 1 || in5 > BASE32_MAX_VALUE + 1
+                || in6 > BASE32_MAX_VALUE + 1 || in7 > BASE32_MAX_VALUE + 1 || in8 > BASE32_MAX_VALUE + 1)
+                return 0; /*ERROR - invalid base32 character*/
+
+            /* 5 outputs */
+            *pDest++ = ((in1 & 0x1f) << 3) | ((in2 & 0x1c) >> 2);
+            *pDest++ = ((in2 & 0x03) << 6) | ((in3 & 0x1f) << 1) | ((in4 & 0x10) >> 4);
+            *pDest++ = ((in4 & 0x0f) << 4) | ((in5 & 0x1e) >> 1);
+            *pDest++ = ((in5 & 0x01) << 7) | ((in6 & 0x1f) << 2) | ((in7 & 0x18) >> 3);
+            *pDest++ = ((in7 & 0x07) << 5) | (in8 & 0x1f);
+            dwDestSize += BASE32_OUTPUT;
+
+            /* Padding */
+            if (in8 == BASE32_MAX_VALUE + 1)
+            {
+                --dwDestSize;
+                assert( (in7 == BASE32_MAX_VALUE + 1 && in6 == BASE32_MAX_VALUE + 1) || (in7 != BASE32_MAX_VALUE + 1) );
+                if (in6 == BASE32_MAX_VALUE + 1)
+                {
+                    --dwDestSize;
+                    if (in5 == BASE32_MAX_VALUE + 1)
+                    {
+                        --dwDestSize;
+                        assert( (in4 == BASE32_MAX_VALUE + 1 && in3 == BASE32_MAX_VALUE + 1) || (in4 != BASE32_MAX_VALUE + 1) );
+                        if (in3 == BASE32_MAX_VALUE + 1)
+                        {
+                            --dwDestSize;
+                        }
+                    }
+                }
+            }
+        }
+        *pDest++ = '\x0'; /*append terminator*/
+
+        return dwDestSize;
+    }
+    else
+        return 0; /*ERROR - null pointer, or size isn't a multiple of 8*/
+}
+
+/****************************** Base64 Decoding ******************************/
+
+static const size_t BASE64_INPUT = 4;
+static const size_t BASE64_OUTPUT = 3;
+static const size_t BASE64_MAX_PADDING = 2;
+static const unsigned char BASE64_MAX_VALUE = 63;
+static const unsigned char BASE64_TABLE[ 0x80 ] = {
+    /*00-07*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*08-0f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*10-17*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*18-1f*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*20-27*/ 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF,
+    /*28-2f*/ 0xFF, 0xFF, 0xFF, 0x3e, 0xFF, 0xFF, 0xFF, 0x3f, /*2 = '+' and '/'*/
+    /*30-37*/ 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a, 0x3b, /*8 = '0'-'7'*/
+    /*38-3f*/ 0x3c, 0x3d, 0xFF, 0xFF, 0xFF, 0x40, 0xFF, 0xFF, /*2 = '8'-'9' and '='*/
+    /*40-47*/ 0xFF, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, /*7 = 'A'-'G'*/
+    /*48-4f*/ 0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, /*8 = 'H'-'O'*/
+    /*50-57*/ 0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, /*8 = 'P'-'W'*/
+    /*58-5f*/ 0x17, 0x18, 0x19, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, /*3 = 'X'-'Z'*/
+    /*60-67*/ 0xFF, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e, 0x1f, 0x20, /*7 = 'a'-'g'*/
+    /*68-6f*/ 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, /*8 = 'h'-'o'*/
+    /*70-77*/ 0x29, 0x2a, 0x2b, 0x2c, 0x2d, 0x2e, 0x2f, 0x30, /*8 = 'p'-'w'*/
+    /*78-7f*/ 0x31, 0x32, 0x33, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF  /*3 = 'x'-'z'*/
+};
+
+int cyoBase64Validate( const char* src, size_t size )
+{
+    return cyoBaseXXValidate( src, size, BASE64_INPUT, BASE64_MAX_PADDING, BASE64_MAX_VALUE, BASE64_TABLE );
+}
+
+size_t cyoBase64DecodeGetLength( size_t size )
+{
+    return cyoBaseXXDecodeGetLength( size, BASE64_INPUT, BASE64_OUTPUT );
+}
+
+size_t cyoBase64Decode( void* dest, const char* src, size_t size )
+{
+    /*
+     * output 3 bytes for every 4 input:
+     *
+     *               outputs: 1        2        3
+     * inputs: 1 = --111111 = 111111--
+     *         2 = --22XXXX = ------22 XXXX----
+     *         3 = --3333XX =          ----3333 XX------
+     *         4 = --444444 =                   --444444
+     */
+
+    if (dest && src && (size % BASE64_INPUT == 0))
+    {
+        unsigned char* pDest = (unsigned char*)dest;
+        size_t dwSrcSize = size;
+        size_t dwDestSize = 0;
+        unsigned char in1, in2, in3, in4;
+
+        while (dwSrcSize >= 1)
+        {
+            /* 4 inputs */
+            in1 = *src++;
+            in2 = *src++;
+            in3 = *src++;
+            in4 = *src++;
+            dwSrcSize -= BASE64_INPUT;
+
+            /* Validate ascii */
+            if (in1 >= 0x80 || in2 >= 0x80 || in3 >= 0x80 || in4 >= 0x80)
+                return 0; /*ERROR - invalid base64 character*/
+
+            /* Convert ascii to base64 */
+            in1 = BASE64_TABLE[ in1 ];
+            in2 = BASE64_TABLE[ in2 ];
+            in3 = BASE64_TABLE[ in3 ];
+            in4 = BASE64_TABLE[ in4 ];
+
+            /* Validate base64 */
+            if (in1 > BASE64_MAX_VALUE || in2 > BASE64_MAX_VALUE)
+                return 0; /*ERROR - invalid base64 character*/
+            /*the following can be padding*/
+            if (in3 > BASE64_MAX_VALUE + 1 || in4 > BASE64_MAX_VALUE + 1)
+                return 0; /*ERROR - invalid base64 character*/
+
+            /* 3 outputs */
+            *pDest++ = ((in1 & 0x3f) << 2) | ((in2 & 0x30) >> 4);
+            *pDest++ = ((in2 & 0x0f) << 4) | ((in3 & 0x3c) >> 2);
+            *pDest++ = ((in3 & 0x03) << 6) | (in4 & 0x3f);
+            dwDestSize += BASE64_OUTPUT;
+
+            /* Padding */
+            if (in4 == BASE64_MAX_VALUE + 1)
+            {
+                --dwDestSize;
+                if (in3 == BASE64_MAX_VALUE + 1)
+                {
+                    --dwDestSize;
+                }
+            }
+        }
+        *pDest++ = '\x0'; /*append terminator*/
+
+        return dwDestSize;
+    }
+    else
+        return 0; /*ERROR - null pointer, or size isn't a multiple of 4*/
+}
diff --git a/vendor/cyoencode-1.0.2/src/CyoDecode.h b/vendor/cyoencode-1.0.2/src/CyoDecode.h
new file mode 100644
index 0000000..873ed20
--- /dev/null
+++ b/vendor/cyoencode-1.0.2/src/CyoDecode.h
@@ -0,0 +1,58 @@
+/*
+ * CyoDecode.h - part of the CyoEncode library
+ *
+ * Copyright (c) 2009-2012, Graham Bull.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __CYODECODE_H
+#define __CYODECODE_H
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Base16 Decoding */
+int    cyoBase16Validate( const char* src, size_t size );
+size_t cyoBase16DecodeGetLength( size_t size );
+size_t cyoBase16Decode( void* dest, const char* src, size_t size );
+
+/* Base32 Decoding */
+int    cyoBase32Validate( const char* src, size_t size );
+size_t cyoBase32DecodeGetLength( size_t size );
+size_t cyoBase32Decode( void* dest, const char* src, size_t size );
+
+/* Base64 Decoding */
+int    cyoBase64Validate( const char* src, size_t size );
+size_t cyoBase64DecodeGetLength( size_t size );
+size_t cyoBase64Decode( void* dest, const char* src, size_t size );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*__CYODECODE_H*/
+
diff --git a/vendor/cyoencode-1.0.2/src/CyoEncode.c b/vendor/cyoencode-1.0.2/src/CyoEncode.c
new file mode 100644
index 0000000..3e9191f
--- /dev/null
+++ b/vendor/cyoencode-1.0.2/src/CyoEncode.c
@@ -0,0 +1,283 @@
+/*
+ * CyoEncode.c - part of the CyoEncode library
+ *
+ * Copyright (c) 2009-2012, Graham Bull.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#include "CyoEncode.h"
+
+#include <assert.h>
+
+/********************************** Shared ***********************************/
+
+static size_t cyoBaseXXEncodeGetLength( size_t size, size_t inputBytes, size_t outputBytes )
+{
+    return (((size + inputBytes - 1) / inputBytes) * outputBytes) + 1; /*plus terminator*/
+}
+
+/****************************** Base16 Encoding ******************************/
+
+static const size_t BASE16_INPUT = 1;
+static const size_t BASE16_OUTPUT = 2;
+static const char* const BASE16_TABLE = "0123456789ABCDEF";
+
+size_t cyoBase16EncodeGetLength( size_t size )
+{
+    return cyoBaseXXEncodeGetLength( size, BASE16_INPUT, BASE16_OUTPUT );
+}
+
+size_t cyoBase16Encode( char* dest, const void* src, size_t size )
+{
+    /*
+     * output 2 bytes for every 1 input:
+     *
+     *                 inputs: 1
+     * outputs: 1 = ----1111 = 1111----
+     *          2 = ----2222 = ----2222
+     */
+
+    if (dest && src)
+    {
+        unsigned char* pSrc = (unsigned char*)src;
+        size_t dwSrcSize = size;
+        size_t dwDestSize = 0;
+        unsigned char ch;
+
+        while (dwSrcSize >= 1)
+        {
+            /* 1 input */
+            ch = *pSrc++;
+            dwSrcSize -= BASE16_INPUT;
+
+            /* 2 outputs */
+            *dest++ = BASE16_TABLE[ (ch & 0xf0) >> 4 ];
+            *dest++ = BASE16_TABLE[ (ch & 0x0f)      ];
+            dwDestSize += BASE16_OUTPUT;
+        }
+        *dest++ = '\x0'; /*append terminator*/
+
+        return dwDestSize;
+    }
+    else
+        return 0; /*ERROR - null pointer*/
+}
+
+/****************************** Base32 Encoding ******************************/
+
+static const size_t BASE32_INPUT = 5;
+static const size_t BASE32_OUTPUT = 8;
+static const char* const BASE32_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZ234567=";
+
+size_t cyoBase32EncodeGetLength( size_t size )
+{
+    return cyoBaseXXEncodeGetLength( size, BASE32_INPUT, BASE32_OUTPUT );
+}
+
+size_t cyoBase32Encode( char* dest, const void* src, size_t size )
+{
+    /*
+     * output 8 bytes for every 5 input:
+     *
+     *                 inputs: 1        2        3        4        5
+     * outputs: 1 = ---11111 = 11111---
+     *          2 = ---222XX = -----222 XX------
+     *          3 = ---33333 =          --33333-
+     *          4 = ---4XXXX =          -------4 XXXX----
+     *          5 = ---5555X =                   ----5555 X-------
+     *          6 = ---66666 =                            -66666--
+     *          7 = ---77XXX =                            ------77 XXX-----
+     *          8 = ---88888 =                                     ---88888
+     */
+
+    if (dest && src)
+    {
+        unsigned char* pSrc = (unsigned char*)src;
+        size_t dwSrcSize = size;
+        size_t dwDestSize = 0;
+        size_t dwBlockSize;
+        unsigned char n1, n2, n3, n4, n5, n6, n7, n8;
+
+        while (dwSrcSize >= 1)
+        {
+            /* Encode inputs */
+            dwBlockSize = (dwSrcSize < BASE32_INPUT ? dwSrcSize : BASE32_INPUT);
+            n1 = n2 = n3 = n4 = n5 = n6 = n7 = n8 = 0;
+            switch (dwBlockSize)
+            {
+            case 5:
+                n8  =  (pSrc[ 4 ] & 0x1f);
+                n7  = ((pSrc[ 4 ] & 0xe0) >> 5);
+            case 4:
+                n7 |= ((pSrc[ 3 ] & 0x03) << 3);
+                n6  = ((pSrc[ 3 ] & 0x7c) >> 2);
+                n5  = ((pSrc[ 3 ] & 0x80) >> 7);
+            case 3:
+                n5 |= ((pSrc[ 2 ] & 0x0f) << 1);
+                n4  = ((pSrc[ 2 ] & 0xf0) >> 4);
+            case 2:
+                n4 |= ((pSrc[ 1 ] & 0x01) << 4);
+                n3  = ((pSrc[ 1 ] & 0x3e) >> 1);
+                n2  = ((pSrc[ 1 ] & 0xc0) >> 6);
+            case 1:
+                n2 |= ((pSrc[ 0 ] & 0x07) << 2);
+                n1  = ((pSrc[ 0 ] & 0xf8) >> 3);
+                break;
+
+            default:
+                assert( 0 );
+            }
+            pSrc += dwBlockSize;
+            dwSrcSize -= dwBlockSize;
+
+            /* Validate */
+            assert( n1 <= 31 );
+            assert( n2 <= 31 );
+            assert( n3 <= 31 );
+            assert( n4 <= 31 );
+            assert( n5 <= 31 );
+            assert( n6 <= 31 );
+            assert( n7 <= 31 );
+            assert( n8 <= 31 );
+
+            /* Padding */
+            switch (dwBlockSize)
+            {
+            case 1: n3 = n4 = 32;
+            case 2: n5 = 32;
+            case 3: n6 = n7 = 32;
+            case 4: n8 = 32;
+            case 5:
+                break;
+
+            default:
+                assert( 0 );
+            }
+
+            /* 8 outputs */
+            *dest++ = BASE32_TABLE[ n1 ];
+            *dest++ = BASE32_TABLE[ n2 ];
+            *dest++ = BASE32_TABLE[ n3 ];
+            *dest++ = BASE32_TABLE[ n4 ];
+            *dest++ = BASE32_TABLE[ n5 ];
+            *dest++ = BASE32_TABLE[ n6 ];
+            *dest++ = BASE32_TABLE[ n7 ];
+            *dest++ = BASE32_TABLE[ n8 ];
+            dwDestSize += BASE32_OUTPUT;
+        }
+        *dest++ = '\x0'; /*append terminator*/
+
+        return dwDestSize;
+    }
+    else
+        return 0; /*ERROR - null pointer*/
+}
+
+/****************************** Base64 Encoding ******************************/
+
+static const size_t BASE64_INPUT = 3;
+static const size_t BASE64_OUTPUT = 4;
+static const char* const BASE64_TABLE = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
+
+size_t cyoBase64EncodeGetLength( size_t size )
+{
+    return cyoBaseXXEncodeGetLength( size, BASE64_INPUT, BASE64_OUTPUT );
+}
+
+size_t cyoBase64Encode( char* dest, const void* src, size_t size )
+{
+    /*
+     * output 4 bytes for every 3 input:
+     *
+     *                 inputs: 1        2        3
+     * outputs: 1 = --111111 = 111111--
+     *          2 = --22XXXX = ------22 XXXX----
+     *          3 = --3333XX =          ----3333 XX------
+     *          4 = --444444 =                   --444444
+     */
+
+    if (dest && src)
+    {
+        unsigned char* pSrc = (unsigned char*)src;
+        size_t dwSrcSize = size;
+        size_t dwDestSize = 0;
+        size_t dwBlockSize = 0;
+        unsigned char n1, n2, n3, n4;
+
+        while (dwSrcSize >= 1)
+        {
+            /* Encode inputs */
+            dwBlockSize = (dwSrcSize < BASE64_INPUT ? dwSrcSize : BASE64_INPUT);
+            n1 = n2 = n3 = n4 = 0;
+            switch (dwBlockSize)
+            {
+            case 3:
+                n4  =  (pSrc[ 2 ] & 0x3f);
+                n3  = ((pSrc[ 2 ] & 0xc0) >> 6);
+            case 2:
+                n3 |= ((pSrc[ 1 ] & 0x0f) << 2);
+                n2  = ((pSrc[ 1 ] & 0xf0) >> 4);
+            case 1:
+                n2 |= ((pSrc[ 0 ] & 0x03) << 4);
+                n1  = ((pSrc[ 0 ] & 0xfc) >> 2);
+                break;
+
+            default:
+                assert( 0 );
+            }
+            pSrc += dwBlockSize;
+            dwSrcSize -= dwBlockSize;
+
+            /* Validate */
+            assert( n1 <= 63 );
+            assert( n2 <= 63 );
+            assert( n3 <= 63 );
+            assert( n4 <= 63 );
+
+            /* Padding */
+            switch (dwBlockSize)
+            {
+            case 1: n3 = 64;
+            case 2: n4 = 64;
+            case 3:
+                break;
+
+            default:
+                assert( 0 );
+            }
+
+            /* 4 outputs */
+            *dest++ = BASE64_TABLE[ n1 ];
+            *dest++ = BASE64_TABLE[ n2 ];
+            *dest++ = BASE64_TABLE[ n3 ];
+            *dest++ = BASE64_TABLE[ n4 ];
+            dwDestSize += BASE64_OUTPUT;
+        }
+        *dest++ = '\x0'; /*append terminator*/
+
+        return dwDestSize;
+    }
+    else
+        return 0; /*ERROR - null pointer*/
+}
diff --git a/vendor/cyoencode-1.0.2/src/CyoEncode.h b/vendor/cyoencode-1.0.2/src/CyoEncode.h
new file mode 100644
index 0000000..183a66e
--- /dev/null
+++ b/vendor/cyoencode-1.0.2/src/CyoEncode.h
@@ -0,0 +1,55 @@
+/*
+ * CyoEncode.h - part of the CyoEncode library
+ *
+ * Copyright (c) 2009-2012, Graham Bull.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+#ifndef __CYOENCODE_H
+#define __CYOENCODE_H
+
+#include <stdlib.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* Base16 Encoding */
+size_t cyoBase16EncodeGetLength( size_t size );
+size_t cyoBase16Encode( char* dest, const void* src, size_t size );
+
+/* Base32 Encoding */
+size_t cyoBase32EncodeGetLength( size_t size );
+size_t cyoBase32Encode( char* dest, const void* src, size_t size );
+
+/* Base64 Encoding */
+size_t cyoBase64EncodeGetLength( size_t size );
+size_t cyoBase64Encode( char* dest, const void* src, size_t size );
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /*__CYOENCODE_H*/
+
diff --git a/vendor/cyoencode-1.0.2/src/test.c b/vendor/cyoencode-1.0.2/src/test.c
new file mode 100644
index 0000000..9274105
--- /dev/null
+++ b/vendor/cyoencode-1.0.2/src/test.c
@@ -0,0 +1,191 @@
+/*
+ * test.c - part of the CyoEncode library
+ * 
+ * Copyright (c) 2009-2012, Graham Bull.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  * Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ *
+ *  * Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+ * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+ * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+ * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+ * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+ 
+#include "CyoEncode.h"
+#include "CyoDecode.h"
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+
+#define TEST_BASExx(base,str,expected) \
+    printf( "TEST_BASE%s('%s')='%s'", #base, str, expected ); \
+    required = cyoBase##base##EncodeGetLength( strlen( str )); \
+    encoded = (char*)malloc( required ); \
+    if (encoded == NULL) { \
+        printf( "\n*** ERROR: Unable to allocate buffer for encoding ***\n" ); \
+        goto exit; \
+    } \
+    cyoBase##base##Encode( encoded, str, strlen( str )); \
+    if (strcmp( encoded, expected ) != 0) { \
+        printf( "\n*** ERROR: Encoding failure ***\n" ); \
+        goto exit; \
+    } \
+    valid = cyoBase##base##Validate( encoded, strlen( encoded )); \
+    if (valid < 0) \
+    { \
+        printf( "\n*** ERROR: Unable to validate encoding (error %d) ***\n", valid ); \
+        goto exit; \
+    } \
+    printf( " [passed]\n" ); \
+    free( encoded ); encoded = NULL;
+
+#define TEST_BASE64(str,expected) TEST_BASExx(64,str,expected)
+#define TEST_BASE32(str,expected) TEST_BASExx(32,str,expected)
+#define TEST_BASE16(str,expected) TEST_BASExx(16,str,expected)
+
+#define CHECK_INVALID_BASExx(base,str,res) \
+    printf( "CHECK_INVALID_BASE%s('%s')=%d", #base, str, res ); \
+    valid = cyoBase##base##Validate( str, strlen( str )); \
+    if (valid == 0) \
+    { \
+        printf( "\n*** ERROR: This is a valid encoding! ***\n" ); \
+        goto exit; \
+    } \
+    if (valid != res) \
+    { \
+        printf( "\n*** ERROR: Expected a different return code! (%d) ***\n", valid ); \
+        goto exit; \
+    } \
+    printf( " [passed]\n", #base, str ); \
+
+#define CHECK_INVALID_BASE16(enc,res) CHECK_INVALID_BASExx(16,enc,res)
+#define CHECK_INVALID_BASE32(enc,res) CHECK_INVALID_BASExx(32,enc,res)
+#define CHECK_INVALID_BASE64(enc,res) CHECK_INVALID_BASExx(64,enc,res)
+
+int main( void )
+{
+    const char* const original = "A wise man speaks when he has something to say";
+    size_t required = 0;
+    char* encoded = NULL;
+    char* decoded = NULL;
+    int valid = 0;
+    int retcode = 1;
+
+    printf( "Running CyoEncode tests...\n" );
+
+    /* Encode using Base64 */
+
+    printf( "Original = '%s'\n", original );
+    required = cyoBase64EncodeGetLength( strlen( original ));
+    encoded = (char*)malloc( required );
+    if (encoded == NULL)
+    {
+        printf( "*** ERROR: Unable to allocate buffer for encoding ***\n" );
+        goto exit;
+    }
+    cyoBase64Encode( encoded, original, strlen( original ));
+    printf( "Encoded = '%s'\n", encoded );
+    
+    /* Validate encoding */
+    
+    valid = cyoBase64Validate( encoded, strlen( encoded ));
+    if (valid < 0)
+    {
+        printf( "*** ERROR: Encoding failure (error %d) ***\n", valid );
+        goto exit;
+    }
+
+    /* Decode using Base64 */
+
+    required = cyoBase64DecodeGetLength( strlen( encoded ));
+    decoded = (char*)malloc( required );
+    if (decoded == NULL)
+    {
+        printf( "*** ERROR: Unable to allocate buffer for decoding ***\n" );
+        goto exit;
+    }
+    cyoBase64Decode( decoded, encoded, strlen( encoded ));
+    printf( "Decoded = '%s'\n", decoded );
+
+    /* Validate */
+
+    if (strcmp( original, decoded ) != 0)
+    {
+        printf( "*** ERROR: Encoding/decoding failure ***\n" );
+        goto exit;
+    }
+
+    free( encoded );
+    encoded = NULL;
+    free( decoded );
+    decoded = NULL;
+
+    /* Test vectors from RFC 4648 */
+
+    TEST_BASE16( "", "" );
+    TEST_BASE16( "f", "66" );
+    TEST_BASE16( "fo", "666F" );
+    TEST_BASE16( "foo", "666F6F" );
+    TEST_BASE16( "foob", "666F6F62" );
+    TEST_BASE16( "fooba", "666F6F6261" );
+    TEST_BASE16( "foobar", "666F6F626172" );
+    
+    TEST_BASE32( "", "" );
+    TEST_BASE32( "f", "MY======" );
+    TEST_BASE32( "fo", "MZXQ====" );
+    TEST_BASE32( "foo", "MZXW6===" );
+    TEST_BASE32( "foob", "MZXW6YQ=" );
+    TEST_BASE32( "fooba", "MZXW6YTB" );
+    TEST_BASE32( "foobar", "MZXW6YTBOI======" );
+
+    TEST_BASE64( "", "" );
+    TEST_BASE64( "f", "Zg==" );
+    TEST_BASE64( "fo", "Zm8=" );
+    TEST_BASE64( "foo", "Zm9v" );
+    TEST_BASE64( "foob", "Zm9vYg==" );
+    TEST_BASE64( "fooba", "Zm9vYmE=" );
+    TEST_BASE64( "foobar", "Zm9vYmFy" );
+
+    /* Other tests */
+
+    CHECK_INVALID_BASE16( "1", -1 );
+    CHECK_INVALID_BASE16( "123", -1 );
+    CHECK_INVALID_BASE16( "1G", -2 );
+
+    CHECK_INVALID_BASE32( "A", -1 );
+    CHECK_INVALID_BASE32( "ABCDEFG", -1 );
+    CHECK_INVALID_BASE32( "ABCDEFG1", -2 );
+    CHECK_INVALID_BASE32( "A=======", -2 );
+
+    CHECK_INVALID_BASE64( "A", -1 );
+    CHECK_INVALID_BASE64( "ABCDE", -1 );
+    CHECK_INVALID_BASE64( "A&B=", -2 );
+    CHECK_INVALID_BASE64( "A===", -2 );
+
+    printf( "*** All tests passed ***\n" );
+    retcode = 0;
+
+exit:
+    if (encoded != NULL)
+        free( encoded );
+    if (decoded != NULL)
+        free( decoded );
+
+    return retcode;
+}