Cryptonote tools WIP

src/base/tools/cryptonote/WalletAddress.cpp

@@ -0,0 +1,116 @@
+/* XMRig
+ * Copyright 2014-2021 The Monero Project
+ * Copyright 2018-2021 SChernykh   <https://github.com/SChernykh>
+ * Copyright 2016-2021 XMRig       <https://github.com/xmrig>, <support@xmrig.com>
+ *
+ *   This program is free software: you can redistribute it and/or modify
+ *   it under the terms of the GNU General Public License as published by
+ *   the Free Software Foundation, either version 3 of the License, or
+ *   (at your option) any later version.
+ *
+ *   This program is distributed in the hope that it will be useful,
+ *   but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ *   GNU General Public License for more details.
+ *
+ *   You should have received a copy of the GNU General Public License
+ *   along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+
+#include "base/crypto/keccak.h"
+#include "base/tools/cryptonote/BlobReader.h"
+#include "base/tools/cryptonote/WalletAddress.h"
+#include "base/tools/Buffer.h"
+#include "crypto/cn/umul128.h"
+#include <array>
+
+
+#pragma optimize("", off)
+
+
+namespace xmrig {
+
+
+bool WalletAddress::Decode(const String& address)
+{
+    static constexpr std::array<int, 9> block_sizes{ 0, 2, 3, 5, 6, 7, 9, 10, 11 };
+    static constexpr char alphabet[] = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
+    constexpr size_t alphabet_size = sizeof(alphabet) - 1;
+
+    int8_t reverse_alphabet[256];
+    memset(reverse_alphabet, -1, sizeof(reverse_alphabet));
+
+    for (int i = 0; i < alphabet_size; ++i) {
+        reverse_alphabet[alphabet[i]] = i;
+    }
+
+    const int len = static_cast<int>(address.size());
+    const int num_full_blocks = len / block_sizes.back();
+    const int last_block_size = len % block_sizes.back();
+
+    int last_block_size_index = -1;
+
+    for (int i = 0; i < block_sizes.size(); ++i) {
+        if (block_sizes[i] == last_block_size) {
+            last_block_size_index = i;
+            break;
+        }
+    }
+
+    if (last_block_size_index < 0) {
+        return false;
+    }
+
+    Buffer data;
+    data.reserve(static_cast<size_t>(num_full_blocks) * sizeof(uint64_t) + last_block_size_index);
+
+    const char* address_data = address.data();
+
+    for (int i = 0; i <= num_full_blocks; ++i) {
+        uint64_t num = 0;
+        uint64_t order = 1;
+
+        for (int j = ((i < num_full_blocks) ? block_sizes.back() : last_block_size) - 1; j >= 0; --j) {
+            const int digit = reverse_alphabet[address_data[j]];
+            if (digit < 0) {
+                return false;
+            }
+
+            uint64_t hi;
+            const uint64_t tmp = num + __umul128(order, static_cast<uint64_t>(digit), &hi);
+            if ((tmp < num) || hi) {
+                return false;
+            }
+
+            num = tmp;
+            order *= alphabet_size;
+        }
+
+        address_data += block_sizes.back();
+
+        uint8_t* p = reinterpret_cast<uint8_t*>(&num);
+        for (int j = ((i < num_full_blocks) ? sizeof(num) : last_block_size_index) - 1; j >= 0; --j) {
+            data.emplace_back(p[j]);
+        }
+    }
+
+    CBlobReader ar(data.data(), data.size());
+
+    ar(tag);
+    ar(public_spend_key);
+    ar(public_view_key);
+    ar(checksum);
+
+    uint8_t md[200];
+    keccak(data.data(), data.size() - sizeof(checksum), md);
+
+    if (memcmp(checksum, md, sizeof(checksum)) != 0) {
+        return false;
+    }
+
+    return true;
+}
+
+
+} /* namespace xmrig */