From 4222316a1a802eb32b887caca2ce39303347f0ed Mon Sep 17 00:00:00 2001 From: John Jones Date: Sun, 13 Nov 2016 20:55:11 -0500 Subject: [PATCH] Added base16 encoding/decoding, as well as a wrapper around SHA256 --- Makefile | 2 +- crypto/encoding/Makefile | 4 +- crypto/encoding/base16.c | 76 +++++++++++++++++++++ crypto/encoding/base58.c | 31 ++++----- crypto/encoding/base64.c | 35 +++++++--- include/libp2p/crypto/encoding/base16.h | 35 ++++++++++ include/libp2p/crypto/encoding/base58.h | 14 ++-- include/libp2p/crypto/encoding/base64.h | 14 +++- include/libp2p/crypto/hashing/sha256.h | 18 +++++ test/Makefile | 2 +- test/crypto/test_base58.h | 26 +++++--- test/crypto/test_rsa.h | 4 +- test/test_mbedtls.h | 89 +++++++++++++++++++++++++ test/testit.c | 5 +- 14 files changed, 299 insertions(+), 56 deletions(-) create mode 100644 crypto/encoding/base16.c create mode 100644 include/libp2p/crypto/encoding/base16.h create mode 100644 include/libp2p/crypto/hashing/sha256.h create mode 100644 test/test_mbedtls.h diff --git a/Makefile b/Makefile index e5303bb..13bb959 100644 --- a/Makefile +++ b/Makefile @@ -3,7 +3,7 @@ DEBUG = true export DEBUG OBJS = crypto/rsa.o crypto/encoding/base58.o crypto/encoding/base64.o \ - crypto/encoding/x509.o thirdparty/mbedtls/*.o + crypto/encoding/x509.o thirdparty/mbedtls/*.o crypto/encoding/base16.o compile: diff --git a/crypto/encoding/Makefile b/crypto/encoding/Makefile index 0deb86c..3fae2a2 100644 --- a/crypto/encoding/Makefile +++ b/crypto/encoding/Makefile @@ -2,8 +2,8 @@ CC = gcc CFLAGS = -O0 -I../../include -g3 LFLAGS = DEPS = ../../include/libp2p/crypto/encoding/base58.h ../../include/libp2p/crypto/encoding/base64.h \ - ../../include/libp2p/crypto/encoding/x509.h -OBJS = base58.o base64.o x509.o + ../../include/libp2p/crypto/encoding/x509.h ../../include/libp2p/crypto/encoding/base16.h +OBJS = base58.o base64.o x509.o base16.o %.o: %.c $(DEPS) $(CC) -c -o $@ $< $(CFLAGS) diff --git a/crypto/encoding/base16.c b/crypto/encoding/base16.c new file mode 100644 index 0000000..bc9b8b4 --- /dev/null +++ b/crypto/encoding/base16.c @@ -0,0 +1,76 @@ +#include +#include + +#include "libp2p/crypto/encoding/base16.h" + +/** + * Encode in Base16 format + * @param incoming the incoming bytes + * @param incoming_length the length of the incoming bytes + * @param results where to put the results + * @param results_length the size of the buffer, and returns the actual length used + * @returns true(1) on success + */ +int libp2p_crypto_encoding_base16_encode(const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t* results_length) { + // the size will be 2x the size of incoming, so check that + if (*results_length < incoming_length * 2) + return 0; + + // clear out the results variable + memset(results, 0, *results_length); + + *results_length = 0; + for(int i = 0; i < incoming_length; i++) { + unsigned char buf[3]; + sprintf(buf, "%02x", incoming[i]); + results[i * 2] = buf[0]; + results[i * 2 + 1] = buf[1]; + *results_length += 2; + } + + return 1; +} + +/** + * Calculate the size of the buffer necessary to encode + * @param incoming_length the length of the incoming value + * @returns the size of the buffer necessary to hold the encoded bytes + */ +int libp2p_crypto_encoding_base16_encode_size(size_t incoming_length) { + return incoming_length * 2; +} + +/** + * Decode from Base16 format + * @param incoming the incoming base16 encoded string + * @param incoming_length the length of the incoming string (no need to include null) + * @param results where to put the results + * @param results_length the size of the buffer, and returns the actual length used + * @returns true(1) on success + */ +int libp2p_crypto_encoding_base16_decode(const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t* results_length) { + + // buffer too small + if (*results_length < incoming_length / 2) + return 0; + + memset(results, 0, *results_length); + + unsigned char* pos = (char*)incoming; + + for(int i = 0; i < incoming_length / 2; i++) { + sscanf(pos, "%2hhx", &results[i]); + pos += 2; + } + return 1; +} + +/** + * Calculate the size of the buffer necessary to decode + * @param incoming_length the length of the incoming value + * @returns the size of the buffer necessary to hold the decoded bytes + */ +int libp2p_crypto_encoding_base16_decode_size(size_t incoming_length) { + return incoming_length / 2; +} + diff --git a/crypto/encoding/base58.c b/crypto/encoding/base58.c index 1b17041..43ce920 100644 --- a/crypto/encoding/base58.c +++ b/crypto/encoding/base58.c @@ -170,32 +170,27 @@ int libp2p_crypto_encoding_base58_encode(const unsigned char* data, size_t binsz return 1; } -/*** - * calculate the size of the binary results based on an incoming base58 string - * @param base58_string the string - * @returns the size in bytes had the string been decoded +/** + * calculate the max length in bytes of an encoding of n source bytes + * @param encoded_size the size of the encoded string + * @returns the maximum size in bytes had the string been decoded */ -size_t libp2p_crypto_encoding_base58_decode_size(const unsigned char* base58_string) { - size_t string_length = strlen((char*)base58_string); - size_t decoded_length = 0; +size_t libp2p_crypto_encoding_base58_decode_size(size_t encoded_size) { size_t radix = strlen(b58digits_ordered); - double bits_per_digit = log2(radix); + double bits_per_digit = log2(radix); // each char represents about 6 bits - decoded_length = floor(string_length * bits_per_digit / 8); - return decoded_length; + return ceil(encoded_size * bits_per_digit / 8); } /** - * calculate the max length in bytes of an encoding of n source bits - * @param base58_string the string - * @returns the maximum size in bytes had the string been decoded + * calculate the max length in bytes of a decoding of n source bytes + * @param decoded_size the size of the incoming string to be encoded + * @returns the maximum size in bytes had the string been encoded */ -size_t libp2p_crypto_encoding_base58_decode_max_size(const unsigned char* base58_string) { - size_t string_length = strlen((char*)base58_string); - size_t decoded_length = 0; +size_t libp2p_crypto_encoding_base58_encode_size(size_t decoded_size) { size_t radix = strlen(b58digits_ordered); double bits_per_digit = log2(radix); + // each character - decoded_length = ceil(string_length * bits_per_digit / 8); - return decoded_length; + return ceil( 8 / bits_per_digit * decoded_size); } diff --git a/crypto/encoding/base64.c b/crypto/encoding/base64.c index 470c5d1..4fe034f 100644 --- a/crypto/encoding/base64.c +++ b/crypto/encoding/base64.c @@ -7,6 +7,8 @@ // #include +#include + #include "mbedtls/base64.h" /** @@ -23,12 +25,6 @@ int libp2p_crypto_encoding_base64_encode(const unsigned char* input_data, size_t return retVal == 0; } -size_t libp2p_crypto_encoding_base64_encode_length(const unsigned char* input_data, size_t input_length) { - size_t req_bytes; - mbedtls_base64_encode(NULL, 0, &req_bytes, input_data, input_length); - return req_bytes; -} - /** * decode something that was encoded as base64 * @param input_data the data to decode @@ -43,8 +39,27 @@ int libp2p_crypto_encoding_base64_decode(const unsigned char* input_data, size_t return retVal == 0; } -size_t libp2p_crypto_encoding_base64_decode_length(const unsigned char* input_data, size_t input_length) { - size_t req_bytes; - mbedtls_base64_decode(NULL, 0, &req_bytes, input_data, input_length); - return req_bytes; +/** + * calculate the max length in bytes of an encoding of n source bytes + * @param encoded_size the size of the encoded string + * @returns the maximum size in bytes had the string been decoded + */ +size_t libp2p_crypto_encoding_base64_decode_size(size_t encoded_size) { + size_t radix = 64; + double bits_per_digit = log2(radix); // each char represents about 6 bits + + return ceil(encoded_size * bits_per_digit / 8); } + +/** + * calculate the max length in bytes of a decoding of n source bytes + * @param decoded_size the size of the incoming string to be encoded + * @returns the maximum size in bytes had the string been encoded + */ +size_t libp2p_crypto_encoding_base64_encode_size(size_t decoded_size) { + size_t radix = 64; + double bits_per_digit = log2(radix); + + return ceil( 8 / bits_per_digit * decoded_size); +} + diff --git a/include/libp2p/crypto/encoding/base16.h b/include/libp2p/crypto/encoding/base16.h new file mode 100644 index 0000000..9047fe7 --- /dev/null +++ b/include/libp2p/crypto/encoding/base16.h @@ -0,0 +1,35 @@ +#include + +/** + * Encode in Base16 format + * @param incoming the incoming bytes + * @param incoming_length the length of the incoming bytes + * @param results where to put the results + * @param results_length the size of the buffer, and returns the actual length used + * @returns true(1) on success + */ +int libp2p_crypto_encoding_base16_encode(const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t* results_length); + +/** + * Calculate the size of the buffer necessary to encode + * @param incoming_length the length of the incoming value + * @returns the size of the buffer necessary to hold the encoded bytes + */ +int libp2p_crypto_encoding_base16_encode_size(size_t incoming_length); + +/** + * Decode from Base16 format + * @param incoming the incoming base16 encoded string + * @param incoming_length the length of the incoming string (no need to include null) + * @param results where to put the results + * @param results_length the size of the buffer, and returns the actual length used + * @returns true(1) on success + */ +int libp2p_crypto_encoding_base16_decode(const unsigned char* incoming, size_t incoming_length, unsigned char* results, size_t* results_length); + +/** + * Calculate the size of the buffer necessary to decode + * @param incoming_length the length of the incoming value + * @returns the size of the buffer necessary to hold the decoded bytes + */ +int libp2p_crypto_encoding_base16_decode_size(size_t incoming_length); diff --git a/include/libp2p/crypto/encoding/base58.h b/include/libp2p/crypto/encoding/base58.h index 0d238f2..827821b 100644 --- a/include/libp2p/crypto/encoding/base58.h +++ b/include/libp2p/crypto/encoding/base58.h @@ -30,18 +30,18 @@ int libp2p_crypto_encoding_base58_decode(const unsigned char* base58, size_t bas int libp2p_crypto_encoding_base58_encode(const unsigned char* binary_data, size_t binary_data_size, unsigned char** base58, size_t* base58_size); /*** - * calculate the size of the binary results based on an incoming base58 string with no initial padding - * @param base58_string the string - * @returns the size in bytes had the string been decoded + * calculate the size of the results based on an incoming string + * @param decoded_length the length of the string to be encoded + * @returns the size in bytes had the string been encoded */ -size_t libp2p_crypto_encoding_base58_decode_size(const unsigned char* base58_string); +size_t libp2p_crypto_encoding_base58_encode_size(size_t decoded_length); /** - * calculate the max length in bytes of an encoding of n source bits - * @param base58_string the string + * calculate the max length in bytes of an encoding of n source bytes + * @param encoded_length the length of the string to be decoded * @returns the maximum size in bytes had the string been decoded */ -size_t libp2p_crypto_encoding_base58_decode_max_size(const unsigned char* base58_string); +size_t libp2p_crypto_encoding_base58_decode_size(size_t encoded_length); #endif /* base58_h */ diff --git a/include/libp2p/crypto/encoding/base64.h b/include/libp2p/crypto/encoding/base64.h index a21646e..226fd0d 100644 --- a/include/libp2p/crypto/encoding/base64.h +++ b/include/libp2p/crypto/encoding/base64.h @@ -22,7 +22,12 @@ */ int libp2p_crypto_encoding_base64_encode(const unsigned char* input_data, size_t input_length, unsigned char* output_data, size_t max_output_length, size_t* bytes_written); -size_t base64_encode_length(const unsigned char* input_data, size_t input_length); +/** + * calculate the max length in bytes of an encoding of n source bytes + * @param encoded_size the size of the encoded string + * @returns the maximum size in bytes had the string been decoded + */ +size_t libp2p_crypto_encoding_base64_encode_size(size_t input_length); /** * decode something that was encoded as base64 @@ -35,6 +40,11 @@ size_t base64_encode_length(const unsigned char* input_data, size_t input_length */ int libp2p_crypto_encoding_base64_decode(const unsigned char* input_data, size_t input_length, unsigned char* output_data, size_t max_output_length, size_t* bytes_written); -size_t libp2p_crypto_encoding_base64_decode_length(const unsigned char* input_data, size_t input_length); +/** + * calculate the max length in bytes of a decoding of n source bytes + * @param decoded_size the size of the incoming string to be encoded + * @returns the maximum size in bytes had the string been encoded + */ +size_t libp2p_crypto_encoding_base64_decode_size(size_t input_length); #endif /* base64_h */ diff --git a/include/libp2p/crypto/hashing/sha256.h b/include/libp2p/crypto/hashing/sha256.h new file mode 100644 index 0000000..2e81596 --- /dev/null +++ b/include/libp2p/crypto/hashing/sha256.h @@ -0,0 +1,18 @@ +#ifndef __CRYPTO_HASHING_SHA256_H__ +#define __CRYPTO_HASHING_SHA256_H__ + +#include "mbedtls/sha256.h" + +/*** + * hash a string using SHA256 + * @param input the input string + * @param input_length the length of the input string + * @param output where to place the results + * @returns 1 + */ +int libp2p_crypto_hashing_sha256(const unsigned char* input, size_t input_length, unsigned char output[32]) { + mbedtls_sha256(input, input_length, output, 0); + return 1; +} + +#endif diff --git a/test/Makefile b/test/Makefile index 4af0420..6a8c196 100644 --- a/test/Makefile +++ b/test/Makefile @@ -6,7 +6,7 @@ CFLAGS += -g3 endif LFLAGS = -L../ -DEPS = crypto/test_base58.h crypto/test_rsa.h +DEPS = crypto/test_base58.h crypto/test_rsa.h test_mbedtls.h OBJS = testit.o %.o: %.c $(DEPS) diff --git a/test/crypto/test_base58.h b/test/crypto/test_base58.h index f564b22..aff1d04 100644 --- a/test/crypto/test_base58.h +++ b/test/crypto/test_base58.h @@ -43,30 +43,34 @@ int test_base58_encode_decode() { } int test_base58_size() { - unsigned char* unencoded = (unsigned char*)"Hello, World!"; + unsigned char* unencoded = (unsigned char*)"Hello, World!"; // 13 chars + 1 null size_t string_length = strlen((char*)unencoded) + 1; - size_t encoded_length = 100; - unsigned char encoded[encoded_length]; + size_t encoded_length = libp2p_crypto_encoding_base58_encode_size(string_length); + + if (encoded_length != 20) + return 0; + + size_t encoded_max_length = 100; + unsigned char encoded[encoded_max_length]; unsigned char* ptr = encoded; // now encode it - libp2p_crypto_encoding_base58_encode(unencoded, string_length, &ptr, &encoded_length); + libp2p_crypto_encoding_base58_encode(unencoded, string_length, &ptr, &encoded_max_length); - size_t size_enc = libp2p_crypto_encoding_base58_decode_size(ptr); - size_t max_size_enc = libp2p_crypto_encoding_base58_decode_max_size(ptr); + size_t decoded_length = libp2p_crypto_encoding_base58_decode_size(encoded_max_length); - if (size_enc <= string_length && max_size_enc >= string_length) - return 1; + if (decoded_length != string_length) + return 0; - return 0; + return 1; } int test_base58_max_size() { unsigned char hash[5] = {'S', 'D', 'Y', 'h', 'd' }; - size_t results = libp2p_crypto_encoding_base58_decode_max_size(hash); + size_t results = libp2p_crypto_encoding_base58_decode_size(5); if (results != 4) return 0; @@ -76,7 +80,7 @@ int test_base58_max_size() { int test_base58_peer_address() { char* x_data = "QmPZ9gcCEpqKTo6aq61g2nXGUhM4iCL3ewB6LDXZCtioEB"; size_t x_data_length = strlen(x_data); - size_t result_buffer_length = libp2p_crypto_encoding_base58_decode_max_size(x_data); + size_t result_buffer_length = libp2p_crypto_encoding_base58_decode_size(x_data_length); unsigned char result_buffer[result_buffer_length]; unsigned char* ptr_to_result = result_buffer; memset(result_buffer, 0, result_buffer_length); diff --git a/test/crypto/test_rsa.h b/test/crypto/test_rsa.h index 4d5592f..21c5cff 100644 --- a/test/crypto/test_rsa.h +++ b/test/crypto/test_rsa.h @@ -41,7 +41,7 @@ int test_crypto_rsa_private_key_der() { int test_crypto_x509_der_to_private2() { // this is an example private key. The type is not added. Therefore, it is not compatible with the go version char* der = "MIIEogIBAAKCAQEAmpDhRGecWN+MwfxW9UqsyEsZwnROHb2hCRBUATh7e0thgyi5Te6lT9x2++89x1sC7B9Egma1AJvY7BinIJYeFiOwzkKDe6/JxCle6TmLtCO1qmb8aGOIlu8NzO3L8EjcriYcgp0J5sZn5I3B4iU6q78u5jJQFpi2V7wsasanmfFwfF9ZUSxAnuwkcRkuhGnp5sBauHsQ4dn3IaiutiZDxPsAdxQyXX0SdrB4ew72UVAI2UsMAj5fRYy3plrsV/zZsGpeT6SDJI28weqOoSGvLzYaowf583MrH8O8dFoOWfXHq8hXy6qCDFOa7UYICCkb4QU9SLP7embmtfnB5/bVKwIDAQABAoIBADAwGwsIgmXyzB9uXG386gFH6LAHMpNzG1GIFaiLw3Oc/Lm3aI4zaLaNNUs2Ozx7011qIiHFg4i9DdQNm409QAQG/IhRlExrcawGeeCcYEG5IFoP4YFqBpuHy/Wn7XzsOmDQ4PKXow6frKREzb2Dfdcts6Fw7icdVTvlHrPrWzVS4azROsKy1spaCG7gYGd968f14Q2NBJmmlO75+dhjliI+cmMq5TaEvuCilXfSK4v6RWRGx+Mjl+ATSN1V7ksgzYsjNE15fdguxVWEIW5x5IsrpVviZdfGsDNWGsW9upoHoP118i2HKgrHRgbNcvTvWN/vCqJ/wDGz2FkYaa/3sYECgYEA9mBkSMW/Uc6m9/FNqlsEqCKLryI3ksxW9Ea6pHQ2p79gXYnlKuBLs7VdOA4XBIbV1vQdxjwJfojOdG7DmjklXYf+AYL/x26NSTszVV5feIIfR1jko67izBjeahPdizmpgQDFstgfdsc6vMKsbamvHzlZjpWeyanBz1t6OFPB8KUCgYEAoJpw2JB3o6ws4dASsSs4gthusY7e1Gcp0d7z8ZH0o8Rk2jxnQZuKHFUNnLY+qwxb6CP4zCpMMeGwuBVTapCE+7UkzUEk5GKmEgtO5G4Eu2yJFib1aGITlDnvxRkDOUGMSc/PVB5TnpdF9qXYbaJoLCziRzzgPJ9HWItnPuYudY8CgYB4mZZ9SM7t7IoutB+gVA1jgAWAJO+vG/c0e6rA9WILmtJA908GPeTQguaumbcKsDXckoJAlwLOvYjR1aZJx89SiU78znMF3EesoR3vm9J/2rIU6p6AwQqjfUjiA/deP0uJqicb9E7yhXNrEp/0ziq6zgfYk8S2UjJcnhqll9pHQQKBgGdoyfxHmSFD/Wowpbh6Edr+LNgbHBM7kcvWeNA0oIbKL/3tIrc1xUnU4fzjw5ozTQI+FzaujX0YysbcxGc7QsUnr9iRd4WulyvLKDMhO97KVcJzt1RMwjqQy3fnURIOyJvGOML6+/CDisLzqlV9WwIGrHQeGGwwSqoSqJnxcDy1AoGAMVmdK7mTMBtayUXRpthNCUmRAubaUKAjhKYm0j7ciPKWmo+mBHITbUshti07HqYeqxZE3LAIw/j0nowPsf4HIOxc69E+ZQqvETQwGyCwyHKJNYSFJi3tkHzCGEoP0/k9l6Fu8Qqcs1xhNQu8AcjQ1QL17rs/r9N44GKS2iXI+PY="; - size_t b64_length = libp2p_crypto_encoding_base64_decode_length((unsigned char*)der, strlen(der)); + size_t b64_length = libp2p_crypto_encoding_base64_decode_size(strlen(der)); unsigned char buffer[b64_length]; unsigned char* b = buffer; size_t ultimate_length; @@ -59,7 +59,7 @@ int test_crypto_x509_der_to_private2() { int test_crypto_x509_der_to_private() { // this is a base64 encoded string from the go version of ipfs char* der = "CAASpwkwggSjAgEAAoIBAQDTDJBWjDzS/HxDNOHazvzH2bu9CPMVHUrrvKRdBUM5ansL6/CC3MVZ6HVm4O6QHRapN6EF2CbrTgI4KBOXIL125Xo8MlROnyfXYk3O5q2tgwL/MbW8kXjtkyCfBak7MUoLOdLU7Svg0gkl3l+uDAiDcCLnwJVcFfq9ch6z4wMOhYJqE5dtx0uXxn6IuKWl1B69FTvBXCc0thw8Rw54b941FDcsBH5ttV9mRNCJym3poZ5qalNgXlxoIIB+PUx5QD+aq7KMJdpAX8HkapBntCOahP/QUceRmma0grlZLeYkH6/oi/hIrM6se3KUZ+F6tBuDFys8UAZy/X2BCUbKjbxtAgMBAAECggEANWfQfpYuLhXGPBt9q6kFPm1SnJtPJ+CpvM2XqhJS2IyhZnrl+bd0GTRBwS7aL42s1lVFYf04nAK5fQxnKK8YQqX/MIxr2RldM5ukpN6qxGWKtJkXrAgD2dqJPrRoBpqKahzPxSHfIJ0Fw5dqDtjsrpYJvyt0oEDPmnDuZAbmFx4sJqnesPNhKxtRMBx1+yxGVuRVJjHcqAgqPqwNiuoMEaYMY+G9yzT6vza8ovCpbX7BBIgM5fAT9PD8TBG//Vu9THvj/ZomiVG2qv6RL0qQyVb+DUzPZz1amBsSvahtXCl72jA3JwAZ943RxSR66P934S0ashkVwLUi46z/EAbJ4QKBgQDojGIO07BEVL2+7VxlGL9XGZQp4Y3qlhh2zDDQGwkCq/KQ+BdNYWitPwqRl9GqFLgpmeQIhyHTOa/IThx+AXGKVQ24ROH+skUs4IbO6R3qY7BKtb5lkZE/Yln09x70BBngUYAzh/rtnsXO3cl1x2XDDqUbCwlGcDAs8Jh/6UnvQwKBgQDoVSQs7Uq9MJCGIUM2bixX89tHzSxq5mn9wMD3/XRVfT5Ua8YkYBuzcmlcT39N7L5BwuyFqX3Vi7lv/Ya/qaQP6XkrZ8W1OAaTlYewfE5ZgknJqSpXcNWhABKeNmqndvqyQ/8HNCv/j8AdraGB2DGO57Xso5J0CQ43W/U9+QIyjwKBgHLL2hw3o+wXaRO3WMUPUmVM2zdRgR0suybp5a7Vqb0H5NZrohUw4NulIzJ8H6Q2VjMzJL6Q9sGu2HepF6ecTtBa7ErqtiVlG4Dr1aCOs5XhYEWBMlwxX+JKSt4Cn+UVoTB7Cy5lEhn7JurX0Xuy0ylXMWoIKKv89cs5eg6quzTBAoGAaq9eEztLjKCWXOE9SetBdYnG8aunb9cqaJlwgu/h0bfXPVDYBbAUSEyLURY4MQI7Q1tM3Pu9iqfEmUZj7/LoIV5mg6X9RX/alT6etk3+dF+9nlqN1OU9U9cCtZ/rTcb2y5EptJcidRH/eCFY/pTV/PcttOJPx/S4kHcroC+N8MUCgYEA6DA5QHxHfNN6Nxv+pEzy2DIxFe9RrBxS+KPBsra1C8jgdeMf4EmfU0Nox92V0q0bRrD5ztqQwSONI0hSRb1iiMWR6MuFnAFajUJfASjjIlZ6nIQjQslI7vjlvYyyHS/p/Codxap+yJlTLWwVEOXp2D9pWwiMq1xEyf0TH1BosvM="; - size_t b64_length = libp2p_crypto_encoding_base64_decode_length((unsigned char*)der, strlen(der)); + size_t b64_length = libp2p_crypto_encoding_base64_decode_size(strlen(der)); unsigned char buffer[b64_length]; unsigned char* b = buffer; size_t ultimate_length; diff --git a/test/test_mbedtls.h b/test/test_mbedtls.h new file mode 100644 index 0000000..7f57c03 --- /dev/null +++ b/test/test_mbedtls.h @@ -0,0 +1,89 @@ +/** + * A playground for testing mbedtls functions + */ + +#include "mbedtls/bignum.h" + +int convertToString(unsigned char* string, int len) { + // load up the mpi + mbedtls_mpi mpi; + mbedtls_mpi_init(&mpi); + int retVal = mbedtls_mpi_read_binary(&mpi, string, len); + if (retVal < 0) { + mbedtls_mpi_free(&mpi); + return 0; + } + + // put it in string form so we can see it + size_t buffer_len = 50; + size_t output_len = 0; + char buffer[buffer_len]; + retVal = mbedtls_mpi_write_string(&mpi, 10, buffer, buffer_len, &output_len); + if (retVal < 0) { + mbedtls_mpi_free(&mpi); + return 0; + } + for(int i = 0; i < output_len; i++) { + printf("%02x", buffer[i]); + } + printf("\n"); + mbedtls_mpi_free(&mpi); + return 1; +} + +int test_mbedtls_varint_128_binary() { + // the values I'm working with 0x08, 0x00, 0x18, 0xa7, 0x09 + unsigned char starting_val[5] = { 0x08, 0x00, 0x18, 0x87, 0x09 }; + size_t starting_len = 5; + + for(int i = 0; i < 5; i++) { + if (convertToString(&starting_val[i], 5 - i) != 1) + return 0; + } + + printf(" 3 and 4\n"); + if (convertToString(&starting_val[2], 2) != 1) { + return 0; + } + + printf("And now the other way...\n"); + + for(int i = 1; i <= 5; i--) { + if (convertToString(starting_val, i) != 1) + return 0; + } + + + return 1; +} + +int test_mbedtls_varint_128_string() { + // go from string to uint_128 and back again + char* bigint_string = "47942806932686753431"; + + mbedtls_mpi mpi; + + mbedtls_mpi_init(&mpi); + + int retVal = mbedtls_mpi_read_string( &mpi, 10, bigint_string ); + if (retVal < 0) { + mbedtls_mpi_free(&mpi); + return 0; + } + + // now go back again + size_t buffer_len = 50; + size_t output_len = 0; + char buffer[buffer_len]; + retVal = mbedtls_mpi_write_string(&mpi, 10, buffer, buffer_len, &output_len); + if (retVal < 0) { + mbedtls_mpi_free(&mpi); + return 0; + } + if (strcmp(buffer, bigint_string) != 0) { + mbedtls_mpi_free(&mpi); + return 0; + } + mbedtls_mpi_free(&mpi); + return 1; +} diff --git a/test/testit.c b/test/testit.c index ef3aaca..51c88bb 100644 --- a/test/testit.c +++ b/test/testit.c @@ -2,9 +2,8 @@ #include #include "crypto/test_rsa.h" -//#include "multihash/test_multihash.h" #include "crypto/test_base58.h" -//#include "crypto/test_mbedtls.h" +#include "test_mbedtls.h" int testit(const char* name, int (*func)(void)) { printf("Testing %s...\n", name); @@ -17,6 +16,8 @@ int testit(const char* name, int (*func)(void)) { } int main(int argc, char** argv) { + testit("test_mbedtls_varint_128_binary", test_mbedtls_varint_128_binary); + testit("test_mbedtls_varint_128_string", test_mbedtls_varint_128_string); testit("test_crypto_rsa_private_key_der", test_crypto_rsa_private_key_der); //testit("test_crypto_x509_private_to_der", test_crypto_x509_private_to_der); testit("test_crypto_x509_der_to_private2", test_crypto_x509_der_to_private2);