aboutsummaryrefslogtreecommitdiff
diff options
context:
space:
mode:
Diffstat
-rw-r--r--src/crypto/slow-hash.c4
-rw-r--r--src/mnemonics/electrum-words.cpp82
-rw-r--r--src/mnemonics/electrum-words.h3
-rw-r--r--src/mnemonics/english.h1
-rw-r--r--src/mnemonics/japanese.h1
-rw-r--r--src/mnemonics/language_base.h8
-rw-r--r--src/mnemonics/old_english.h1
-rw-r--r--src/mnemonics/portuguese.h1
-rw-r--r--src/mnemonics/spanish.h1
-rw-r--r--src/rpc/core_rpc_server.cpp22
-rw-r--r--tests/CMakeLists.txt2
-rw-r--r--tests/unit_tests/mnemonics.cpp167
-rw-r--r--tests/unit_tests/slow_memmem.cpp126
13 files changed, 356 insertions, 63 deletions
diff --git a/src/crypto/slow-hash.c b/src/crypto/slow-hash.c
index ce8e90bb7..787545830 100644
--- a/src/crypto/slow-hash.c
+++ b/src/crypto/slow-hash.c
@@ -105,7 +105,7 @@
_a = _mm_load_si128(R128(a)); \
/*
- * An SSE-optimized implementation of the second half of CryptoNote step 3.
+ * An SSE-optimized implementation of the second half of CryptoNight step 3.
* After using AES to mix a scratchpad value into _c (done by the caller),
* this macro xors it with _b and stores the result back to the same index (j) that it
* loaded the scratchpad value from. It then performs a second random memory
@@ -522,7 +522,7 @@ void cn_slow_hash(const void *data, size_t length, char *hash)
hash_process(&state.hs, data, length);
memcpy(text, state.init, INIT_SIZE_BYTE);
- /* CryptoNight Step 2: Iteratively encrypt the results from keccak to fill
+ /* CryptoNight Step 2: Iteratively encrypt the results from Keccak to fill
* the 2MB large random access buffer.
*/
diff --git a/src/mnemonics/electrum-words.cpp b/src/mnemonics/electrum-words.cpp
index b204e81cf..ffa82b21e 100644
--- a/src/mnemonics/electrum-words.cpp
+++ b/src/mnemonics/electrum-words.cpp
@@ -61,7 +61,6 @@
namespace
{
- const int seed_length = 24;
/*!
* \brief Finds the word list that contains the seed words and puts the indices
@@ -69,11 +68,11 @@ namespace
* \param seed List of words to match.
* \param has_checksum If word list passed checksum test, we need to only do a prefix check.
* \param matched_indices The indices where the seed words were found are added to this.
+ * \param language Language instance pointer to write to after it is found.
* \return true if all the words were present in some language false if not.
*/
bool find_seed_language(const std::vector<std::string> &seed,
- bool has_checksum, std::vector<uint32_t> &matched_indices, uint32_t &word_list_length,
- std::string &language_name)
+ bool has_checksum, std::vector<uint32_t> &matched_indices, Language::Base **language)
{
// If there's a new language added, add an instance of it here.
std::vector<Language::Base*> language_instances({
@@ -83,18 +82,6 @@ namespace
Language::Singleton<Language::Japanese>::instance(),
Language::Singleton<Language::OldEnglish>::instance()
});
- // To hold trimmed seed words in case of a checksum being present.
- std::vector<std::string> trimmed_seed;
- if (has_checksum)
- {
- // If it had a checksum, we'll just compare the unique prefix
- // So we create a list of trimmed seed words
- for (std::vector<std::string>::const_iterator it = seed.begin(); it != seed.end(); it++)
- {
- trimmed_seed.push_back(it->length() > Language::unique_prefix_length ?
- it->substr(0, Language::unique_prefix_length) : *it);
- }
- }
// Iterate through all the languages and find a match
for (std::vector<Language::Base*>::iterator it1 = language_instances.begin();
@@ -104,23 +91,22 @@ namespace
const std::unordered_map<std::string, uint32_t> &trimmed_word_map = (*it1)->get_trimmed_word_map();
// To iterate through seed words
std::vector<std::string>::const_iterator it2;
- // To iterate through trimmed seed words
- std::vector<std::string>::iterator it3;
bool full_match = true;
+ std::string trimmed_word;
// Iterate through all the words and see if they're all present
- for (it2 = seed.begin(), it3 = trimmed_seed.begin();
- it2 != seed.end(); it2++, it3++)
+ for (it2 = seed.begin(); it2 != seed.end(); it2++)
{
if (has_checksum)
{
+ trimmed_word = it2->substr(0, (*it1)->get_unique_prefix_length());
// Use the trimmed words and map
- if (trimmed_word_map.count(*it3) == 0)
+ if (trimmed_word_map.count(trimmed_word) == 0)
{
full_match = false;
break;
}
- matched_indices.push_back(trimmed_word_map.at(*it3));
+ matched_indices.push_back(trimmed_word_map.at(trimmed_word));
}
else
{
@@ -134,8 +120,7 @@ namespace
}
if (full_match)
{
- word_list_length = (*it1)->get_word_list().size();
- language_name = (*it1)->get_language_name();
+ *language = *it1;
return true;
}
// Some didn't match. Clear the index array.
@@ -146,18 +131,20 @@ namespace
/*!
* \brief Creates a checksum index in the word list array on the list of words.
- * \param word_list Vector of words
- * \return Checksum index
+ * \param word_list Vector of words
+ * \param unique_prefix_length the prefix length of each word to use for checksum
+ * \return Checksum index
*/
- uint32_t create_checksum_index(const std::vector<std::string> &word_list)
+ uint32_t create_checksum_index(const std::vector<std::string> &word_list,
+ uint32_t unique_prefix_length)
{
std::string trimmed_words = "";
for (std::vector<std::string>::const_iterator it = word_list.begin(); it != word_list.end(); it++)
{
- if (it->length() > 4)
+ if (it->length() > unique_prefix_length)
{
- trimmed_words += it->substr(0, Language::unique_prefix_length);
+ trimmed_words += it->substr(0, unique_prefix_length);
}
else
{
@@ -166,25 +153,26 @@ namespace
}
boost::crc_32_type result;
result.process_bytes(trimmed_words.data(), trimmed_words.length());
- return result.checksum() % seed_length;
+ return result.checksum() % crypto::ElectrumWords::seed_length;
}
/*!
* \brief Does the checksum test on the seed passed.
- * \param seed Vector of seed words
- * \return True if the test passed false if not.
+ * \param seed Vector of seed words
+ * \param unique_prefix_length the prefix length of each word to use for checksum
+ * \return True if the test passed false if not.
*/
- bool checksum_test(std::vector<std::string> seed)
+ bool checksum_test(std::vector<std::string> seed, uint32_t unique_prefix_length)
{
// The last word is the checksum.
std::string last_word = seed.back();
seed.pop_back();
- std::string checksum = seed[create_checksum_index(seed)];
+ std::string checksum = seed[create_checksum_index(seed, unique_prefix_length)];
- std::string trimmed_checksum = checksum.length() > 4 ? checksum.substr(0, Language::unique_prefix_length) :
+ std::string trimmed_checksum = checksum.length() > unique_prefix_length ? checksum.substr(0, unique_prefix_length) :
checksum;
- std::string trimmed_last_word = checksum.length() > 4 ? last_word.substr(0, Language::unique_prefix_length) :
+ std::string trimmed_last_word = last_word.length() > unique_prefix_length ? last_word.substr(0, unique_prefix_length) :
last_word;
return trimmed_checksum == trimmed_last_word;
}
@@ -211,11 +199,12 @@ namespace crypto
* \param language_name Language of the seed as found gets written here.
* \return false if not a multiple of 3 words, or if word is not in the words list
*/
- bool words_to_bytes(const std::string& words, crypto::secret_key& dst,
+ bool words_to_bytes(std::string words, crypto::secret_key& dst,
std::string &language_name)
{
std::vector<std::string> seed;
+ boost::algorithm::trim(words);
boost::split(seed, words, boost::is_any_of(" "));
// error on non-compliant word list
@@ -227,22 +216,25 @@ namespace crypto
// If it is seed with a checksum.
bool has_checksum = seed.size() == (seed_length + 1);
+
+ std::vector<uint32_t> matched_indices;
+ Language::Base *language;
+ if (!find_seed_language(seed, has_checksum, matched_indices, &language))
+ {
+ return false;
+ }
+ language_name = language->get_language_name();
+ uint32_t word_list_length = language->get_word_list().size();
+
if (has_checksum)
{
- if (!checksum_test(seed))
+ if (!checksum_test(seed, language->get_unique_prefix_length()))
{
// Checksum fail
return false;
}
seed.pop_back();
}
-
- std::vector<uint32_t> matched_indices;
- uint32_t word_list_length = 0;
- if (!find_seed_language(seed, has_checksum, matched_indices, word_list_length, language_name))
- {
- return false;
- }
for (unsigned int i=0; i < seed.size() / 3; i++)
{
@@ -335,7 +327,7 @@ namespace crypto
}
words.pop_back();
- words += (' ' + words_store[create_checksum_index(words_store)]);
+ words += (' ' + words_store[create_checksum_index(words_store, language->get_unique_prefix_length())]);
return false;
}
diff --git a/src/mnemonics/electrum-words.h b/src/mnemonics/electrum-words.h
index b822e7740..b75de30e9 100644
--- a/src/mnemonics/electrum-words.h
+++ b/src/mnemonics/electrum-words.h
@@ -59,6 +59,7 @@ namespace crypto
namespace ElectrumWords
{
+ const int seed_length = 24;
const std::string old_language_name = "OldEnglish";
/*!
* \brief Converts seed words to bytes (secret key).
@@ -67,7 +68,7 @@ namespace crypto
* \param language_name Language of the seed as found gets written here.
* \return false if not a multiple of 3 words, or if word is not in the words list
*/
- bool words_to_bytes(const std::string& words, crypto::secret_key& dst,
+ bool words_to_bytes(std::string words, crypto::secret_key& dst,
std::string &language_name);
/*!
diff --git a/src/mnemonics/english.h b/src/mnemonics/english.h
index ae39d44fd..8ca0a3fe3 100644
--- a/src/mnemonics/english.h
+++ b/src/mnemonics/english.h
@@ -1681,6 +1681,7 @@ namespace Language
"zones",
"zoom"
});
+ unique_prefix_length = 3;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "English";
diff --git a/src/mnemonics/japanese.h b/src/mnemonics/japanese.h
index 22c7a53ba..fc3d1ee74 100644
--- a/src/mnemonics/japanese.h
+++ b/src/mnemonics/japanese.h
@@ -1681,6 +1681,7 @@ namespace Language
"びじゅつかん",
"ひしょ"
});
+ unique_prefix_length = 4;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "Japanese";
diff --git a/src/mnemonics/language_base.h b/src/mnemonics/language_base.h
index 0f1062b09..06815e39d 100644
--- a/src/mnemonics/language_base.h
+++ b/src/mnemonics/language_base.h
@@ -45,7 +45,6 @@
*/
namespace Language
{
- const int unique_prefix_length = 4; /*!< Length of the prefix of all words guaranteed to be unique */
/*!
* \class Base
* \brief A base language class which all languages have to inherit from for
@@ -58,7 +57,7 @@ namespace Language
std::unordered_map<std::string, uint32_t> *word_map; /*!< hash table to find word's index */
std::unordered_map<std::string, uint32_t> *trimmed_word_map; /*!< hash table to find word's trimmed index */
std::string language_name; /*!< Name of language */
- int trim_length; /*!< Number of unique starting characters to trim the wordlist to when matching */
+ uint32_t unique_prefix_length; /*!< Number of unique starting characters to trim the wordlist to when matching */
/*!
* \brief Populates the word maps after the list is ready.
*/
@@ -85,6 +84,7 @@ namespace Language
word_list = new std::vector<std::string>;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
+ unique_prefix_length = 4;
}
/*!
* \brief Returns a pointer to the word list.
@@ -122,9 +122,9 @@ namespace Language
* \brief Returns the number of unique starting characters to be used for matching.
* \return Number of unique starting characters.
*/
- int get_trim_length() const
+ uint32_t get_unique_prefix_length() const
{
- return trim_length;
+ return unique_prefix_length;
}
};
}
diff --git a/src/mnemonics/old_english.h b/src/mnemonics/old_english.h
index 09ac37e66..b91a593b6 100644
--- a/src/mnemonics/old_english.h
+++ b/src/mnemonics/old_english.h
@@ -1681,6 +1681,7 @@ namespace Language
"weapon",
"weary"
});
+ unique_prefix_length = 4;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "OldEnglish";
diff --git a/src/mnemonics/portuguese.h b/src/mnemonics/portuguese.h
index c040a0415..6a90659e0 100644
--- a/src/mnemonics/portuguese.h
+++ b/src/mnemonics/portuguese.h
@@ -1679,6 +1679,7 @@ namespace Language
"zenite",
"zumbi"
});
+ unique_prefix_length = 4;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "Portuguese";
diff --git a/src/mnemonics/spanish.h b/src/mnemonics/spanish.h
index 8d695a4b1..f71627086 100644
--- a/src/mnemonics/spanish.h
+++ b/src/mnemonics/spanish.h
@@ -1681,6 +1681,7 @@ namespace Language
"ritmo",
"rito"
});
+ unique_prefix_length = 4;
word_map = new std::unordered_map<std::string, uint32_t>;
trimmed_word_map = new std::unordered_map<std::string, uint32_t>;
language_name = "Spanish";
diff --git a/src/rpc/core_rpc_server.cpp b/src/rpc/core_rpc_server.cpp
index e80451cda..036cb64ff 100644
--- a/src/rpc/core_rpc_server.cpp
+++ b/src/rpc/core_rpc_server.cpp
@@ -111,7 +111,7 @@ namespace cryptonote
}
return true;
}
-#define CHECK_CORE_BUSY() if(!check_core_busy()){res.status = CORE_RPC_STATUS_BUSY;return true;}
+#define CHECK_CORE_BUSY() do { if(!check_core_busy()){res.status = CORE_RPC_STATUS_BUSY;return true;} } while(0)
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::check_core_ready()
{
@@ -121,7 +121,7 @@ namespace cryptonote
}
return check_core_busy();
}
-#define CHECK_CORE_READY() if(!check_core_ready()){res.status = CORE_RPC_STATUS_BUSY;return true;}
+#define CHECK_CORE_READY() do { if(!check_core_ready()){res.status = CORE_RPC_STATUS_BUSY;return true;} } while(0)
//------------------------------------------------------------------------------------------------------------------------------
bool core_rpc_server::on_get_height(const COMMAND_RPC_GET_HEIGHT::request& req, COMMAND_RPC_GET_HEIGHT::response& res, connection_context& cntx)
@@ -398,17 +398,19 @@ namespace cryptonote
return true;
}
//------------------------------------------------------------------------------------------------------------------------------
- uint64_t slow_memmem(void* start_buff, size_t buflen,void* pat,size_t patlen)
+ // equivalent of strstr, but with arbitrary bytes (ie, NULs)
+ // This does not differentiate between "not found" and "found at offset 0"
+ uint64_t slow_memmem(const void* start_buff, size_t buflen,const void* pat,size_t patlen)
{
- void* buf = start_buff;
- void* end=(char*)buf+buflen-patlen;
- while((buf=memchr(buf,((char*)pat)[0],buflen)))
+ const void* buf = start_buff;
+ const void* end=(const char*)buf+buflen;
+ if (patlen > buflen || patlen == 0) return 0;
+ while(buflen>0 && (buf=memchr(buf,((const char*)pat)[0],buflen-patlen+1)))
{
- if(buf>end)
- return 0;
if(memcmp(buf,pat,patlen)==0)
- return (char*)buf - (char*)start_buff;
- buf=(char*)buf+1;
+ return (const char*)buf - (const char*)start_buff;
+ buf=(const char*)buf+1;
+ buflen = (const char*)end - (const char*)buf;
}
return 0;
}
diff --git a/tests/CMakeLists.txt b/tests/CMakeLists.txt
index 44582463d..d663df0d9 100644
--- a/tests/CMakeLists.txt
+++ b/tests/CMakeLists.txt
@@ -68,7 +68,7 @@ target_link_libraries(functional_tests cryptonote_core wallet common crypto ${UN
target_link_libraries(hash-tests crypto)
target_link_libraries(hash-target-tests crypto cryptonote_core)
target_link_libraries(performance_tests cryptonote_core common crypto ${UNBOUND_LIBRARY} ${Boost_LIBRARIES} ${EXTRA_LIBRARIES})
-target_link_libraries(unit_tests gtest_main cryptonote_core wallet crypto common ${UNBOUND_LIBRARY} ${Boost_LIBRARIES} ${EXTRA_LIBRARIES})
+target_link_libraries(unit_tests gtest_main rpc cryptonote_core wallet crypto common ${UNBOUND_LIBRARY} ${Boost_LIBRARIES} ${EXTRA_LIBRARIES})
target_link_libraries(net_load_tests_clt cryptonote_core common crypto gtest_main ${UNBOUND_LIBRARY} ${Boost_LIBRARIES} ${EXTRA_LIBRARIES})
target_link_libraries(net_load_tests_srv cryptonote_core common crypto gtest_main ${UNBOUND_LIBRARY} ${Boost_LIBRARIES} ${EXTRA_LIBRARIES})
diff --git a/tests/unit_tests/mnemonics.cpp b/tests/unit_tests/mnemonics.cpp
new file mode 100644
index 000000000..70e8a413f
--- /dev/null
+++ b/tests/unit_tests/mnemonics.cpp
@@ -0,0 +1,167 @@
+// Copyright (c) 2014, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. 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.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// 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 "gtest/gtest.h"
+#include "mnemonics/electrum-words.h"
+#include "crypto/crypto.h"
+#include <stdlib.h>
+#include <vector>
+#include <time.h>
+#include <iostream>
+#include <boost/algorithm/string.hpp>
+#include "mnemonics/english.h"
+#include "mnemonics/spanish.h"
+#include "mnemonics/portuguese.h"
+#include "mnemonics/japanese.h"
+#include "mnemonics/old_english.h"
+#include "mnemonics/language_base.h"
+#include "mnemonics/singleton.h"
+
+namespace
+{
+ /*!
+ * \brief Returns random index from 0 to max-1
+ * \param max Range maximum
+ * \return required random index
+ */
+ uint32_t get_random_index(int max)
+ {
+ return rand() % max;
+ }
+
+ /*!
+ * \brief Print a seed
+ * \param seed word list
+ */
+ void print_seed(const std::vector<std::string> &seed)
+ {
+ for (std::vector<std::string>::const_iterator it = seed.begin(); it != seed.end(); it++)
+ {
+ std::cout << *it << " ";
+ }
+ std::cout << std::endl;
+ }
+
+ /*!
+ * \brief Compares vectors for equality
+ * \param expected expected vector
+ * \param present current vector
+ */
+ void compare_vectors(const std::vector<std::string> &expected, const std::vector<std::string> &present)
+ {
+ std::vector<std::string>::const_iterator it1, it2;
+ for (it1 = expected.begin(), it2 = present.begin(); it1 != expected.end() && it2 != present.end();
+ it1++, it2++)
+ {
+ ASSERT_STREQ(it1->c_str(), it2->c_str());
+ }
+ }
+
+ /*!
+ * \brief Tests the given language mnemonics.
+ * \param language A Language instance to test
+ */
+ void test_language(const Language::Base &language)
+ {
+ const std::vector<std::string> &word_list = language.get_word_list();
+ std::string seed = "", return_seed = "";
+ // Generate a random seed without checksum
+ for (int ii = 0; ii < crypto::ElectrumWords::seed_length; ii++)
+ {
+ seed += (word_list[get_random_index(word_list.size())] + ' ');
+ }
+ seed.pop_back();
+ std::cout << "Test seed without checksum:\n";
+ std::cout << seed << std::endl;
+
+ crypto::secret_key key;
+ std::string language_name;
+ bool res;
+ std::vector<std::string> seed_vector, return_seed_vector;
+ std::string checksum_word;
+
+ // Convert it to secret key
+ res = crypto::ElectrumWords::words_to_bytes(seed, key, language_name);
+ ASSERT_EQ(true, res);
+ std::cout << "Detected language: " << language_name << std::endl;
+ ASSERT_STREQ(language.get_language_name().c_str(), language_name.c_str());
+
+ // Convert the secret key back to seed
+ crypto::ElectrumWords::bytes_to_words(key, return_seed, language.get_language_name());
+ ASSERT_EQ(true, res);
+ std::cout << "Returned seed:\n";
+ std::cout << return_seed << std::endl;
+ boost::split(seed_vector, seed, boost::is_any_of(" "));
+ boost::split(return_seed_vector, return_seed, boost::is_any_of(" "));
+
+ // Extract the checksum word
+ checksum_word = return_seed_vector.back();
+ return_seed_vector.pop_back();
+ ASSERT_EQ(seed_vector.size(), return_seed_vector.size());
+ // Ensure that the rest of it is same
+ compare_vectors(seed_vector, return_seed_vector);
+
+ // Append the checksum word to repeat the entire process with a seed with checksum
+ seed += (" " + checksum_word);
+ std::cout << "Test seed with checksum:\n";
+ std::cout << seed << std::endl;
+ res = crypto::ElectrumWords::words_to_bytes(seed, key, language_name);
+ ASSERT_EQ(true, res);
+ std::cout << "Detected language: " << language_name << std::endl;
+ ASSERT_STREQ(language.get_language_name().c_str(), language_name.c_str());
+
+ return_seed = "";
+ crypto::ElectrumWords::bytes_to_words(key, return_seed, language.get_language_name());
+ ASSERT_EQ(true, res);
+ std::cout << "Returned seed:\n";
+ std::cout << return_seed << std::endl;
+
+ seed_vector.clear();
+ return_seed_vector.clear();
+ boost::split(seed_vector, seed, boost::is_any_of(" "));
+ boost::split(return_seed_vector, return_seed, boost::is_any_of(" "));
+ ASSERT_EQ(seed_vector.size(), return_seed_vector.size());
+ compare_vectors(seed_vector, return_seed_vector);
+ }
+}
+
+TEST(mnemonics, all_languages)
+{
+ srand(time(NULL));
+ std::vector<Language::Base*> languages({
+ Language::Singleton<Language::English>::instance(),
+ Language::Singleton<Language::Spanish>::instance(),
+ Language::Singleton<Language::Portuguese>::instance(),
+ Language::Singleton<Language::Japanese>::instance(),
+ });
+
+ for (std::vector<Language::Base*>::iterator it = languages.begin(); it != languages.end(); it++)
+ {
+ test_language(*(*it));
+ }
+}
diff --git a/tests/unit_tests/slow_memmem.cpp b/tests/unit_tests/slow_memmem.cpp
new file mode 100644
index 000000000..b1a7622b2
--- /dev/null
+++ b/tests/unit_tests/slow_memmem.cpp
@@ -0,0 +1,126 @@
+// Copyright (c) 2014, The Monero Project
+//
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without modification, are
+// permitted provided that the following conditions are met:
+//
+// 1. Redistributions of source code must retain the above copyright notice, this list of
+// conditions and the following disclaimer.
+//
+// 2. 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.
+//
+// 3. Neither the name of the copyright holder nor the names of its contributors may be
+// used to endorse or promote products derived from this software without specific
+// prior written permission.
+//
+// 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.
+//
+// Parts of this file are originally copyright (c) 2012-2013 The Cryptonote developers
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <string.h>
+#include <stdint.h>
+#include <malloc.h>
+#include "gtest/gtest.h"
+
+//#define TEST_ORIGINAL
+//#define VERBOSE
+
+#ifdef TEST_ORIGINAL
+uint64_t slow_memmem_original(void* start_buff, size_t buflen,void* pat,size_t patlen)
+{
+ void* buf = start_buff;
+ void* end=(char*)buf+buflen-patlen;
+ while((buf=memchr(buf,((char*)pat)[0],buflen)))
+ {
+ if(buf>end)
+ return 0;
+ if(memcmp(buf,pat,patlen)==0)
+ return (char*)buf - (char*)start_buff;
+ buf=(char*)buf+1;
+ }
+ return 0;
+}
+
+#define slow_memmem slow_memmem_original
+#else
+namespace cryptonote {
+ uint64_t slow_memmem(const void* start_buff, size_t buflen,const void* pat,size_t patlen);
+}
+using namespace cryptonote;
+#endif
+
+static const struct {
+ size_t buflen;
+ const char *buf;
+ size_t patlen;
+ const char *pat;
+ uint64_t res;
+} T[]={
+ {0,"",0,"",0},
+ {1,"",0,"",0},
+ {0,"",1,"",0},
+ {1,"x",1,"x",0},
+ {2,"x",1,"",1},
+ {1,"x",1,"",0},
+ {1,"x",2,"",0},
+ {1,"x",2,"x",0},
+ {2,"ax",2,"x",0},
+ {1,"xx",2,"xx",0},
+ {4,"abcd",3,"abc",0},
+ {4,"abcd",3,"bcd",1},
+ {4,"abcd",4,"abcd",0},
+ {4,"abcd",1,"d",3},
+ {4,"abcd",1,"c",2},
+ {4,"abcd",1,"bc",1},
+ {4,"abcd",1,"",0},
+ {3,"abcd",1,"d",0},
+ {5,"aaaab",2,"ab",3},
+ {7,"aaaabab",2,"ab",3},
+ {7,"aaaabab",3,"abc",0},
+ {4,"abcd",2,"cd",2},
+ {3,"abcd",2,"cd",0},
+ {3,"a\0b",1,"",1},
+ {3,"a\0b",2,"\0b",1},
+ {8,"xxxxxxab",3,"xyz",0},
+ {8,"xxxxxxab",6,"abcdef",0},
+ {9,"\0xxxxxab",3,"ab",6},
+ {4,"\0\0a",3,"\0a",1},
+};
+
+TEST(slowmem,Success)
+{
+ size_t n;
+ for (n=0;n<sizeof(T)/sizeof(T[0]);++n) {
+#ifdef VERBOSE
+ printf("%3zu: ",n);
+ fflush(stdout);
+#endif
+ void *buf=malloc(T[n].buflen);
+ memcpy(buf,T[n].buf,T[n].buflen);
+ void *pat=malloc(T[n].patlen);
+ memcpy(pat,T[n].pat,T[n].patlen);
+ uint64_t res=slow_memmem(buf,T[n].buflen,pat,T[n].patlen);
+ free(pat);
+ free(buf);
+ ASSERT_EQ(res,T[n].res);
+ASSERT_EQ(1,1);
+#ifdef VERBOSE
+ if (res!=T[n].res) printf("failed (got %zu, expected %zu)",res,T[n].res); else printf("ok");
+ printf("\n");
+#endif
+ }
+}
generated by cgit v1.2.3 (git 2.25.1) at 2025-01-21 13:08:55 +0000