crypto: Implement BigNum/ExpMod

libraries/libvapours/source/crypto/impl/crypto_bignum.cpp

@@ -0,0 +1,148 @@
+/*
+ * Copyright (c) 2018-2020 Atmosphère-NX
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms and conditions of the GNU General Public License,
+ * version 2, as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope 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 <vapours.hpp>
+
+namespace ams::crypto::impl {
+
+    void BigNum::ImportImpl(Word *out, size_t out_size, const u8 *src, size_t src_size) {
+        size_t octet_ofs = src_size;
+        size_t word_ofs  = 0;
+
+        /* Parse octets into words. */
+        while (word_ofs < out_size && octet_ofs > 0) {
+            Word w = 0;
+            for (size_t shift = 0; octet_ofs > 0 && shift < BITSIZEOF(Word); shift += BITSIZEOF(u8)) {
+                w |= static_cast<Word>(src[--octet_ofs]) << shift;
+            }
+            out[word_ofs++] = w;
+        }
+
+        /* Zero-fill upper words. */
+        while (word_ofs < out_size) {
+            out[word_ofs++] = 0;
+        }
+    }
+
+    void BigNum::ExportImpl(u8 *out, size_t out_size, const Word *src, size_t src_size) {
+        size_t octet_ofs = out_size;
+
+        /* Parse words into octets. */
+        for (size_t word_ofs = 0; word_ofs < src_size && octet_ofs > 0; word_ofs++) {
+            const Word w = src[word_ofs];
+            for (size_t shift = 0; octet_ofs > 0 && shift < BITSIZEOF(Word); shift += BITSIZEOF(u8)) {
+                out[--octet_ofs] = static_cast<u8>(w >> shift);
+            }
+        }
+
+        /* Zero-clear remaining octets. */
+        while (octet_ofs > 0) {
+            out[--octet_ofs] = 0;
+        }
+    }
+
+    size_t BigNum::GetSize() const {
+        if (this->num_words == 0) {
+            return 0;
+        }
+        static_assert(sizeof(Word) == 4);
+
+        size_t size = this->num_words * sizeof(Word);
+        const Word last = this->words[this->num_words - 1];
+        AMS_ASSERT(last != 0);
+        if (last >= 0x01000000u) {
+            return size - 0;
+        } else if (last >= 0x00010000u) {
+            return size - 1;
+        } else if (last >= 0x00000100u) {
+            return size - 2;
+        } else {
+            return size - 3;
+        }
+    }
+
+    bool BigNum::Import(const void *src, size_t src_size) {
+        AMS_ASSERT((src != nullptr) || (src_size != 0));
+
+        /* Ignore leading zeroes. */
+        const u8 *data = static_cast<const u8 *>(src);
+        while (src_size > 0 && *data == 0) {
+            ++data;
+            --src_size;
+        }
+
+        /* Ensure we have space for the number. */
+        AMS_ASSERT(src_size <= this->max_words * sizeof(Word));
+        if (AMS_UNLIKELY(!(src_size <= this->max_words * sizeof(Word)))) {
+            return false;
+        }
+
+        /* Import. */
+        this->num_words = util::AlignUp(src_size, sizeof(Word)) / sizeof(Word);
+
+        ImportImpl(this->words, this->max_words, data, src_size);
+        return true;
+    }
+
+    void BigNum::Export(void *dst, size_t dst_size) {
+        AMS_ASSERT(dst_size >= this->GetSize());
+        ExportImpl(static_cast<u8 *>(dst), dst_size, this->words, this->num_words);
+    }
+
+    bool BigNum::ExpMod(void *dst, const void *src, size_t size, const BigNum &exp, u32 *work_buf, size_t work_buf_size) const {
+        /* Can't exponentiate with or about zero. */
+        if (this->IsZero() || exp.IsZero()) {
+            return false;
+        }
+        AMS_ASSERT(size == this->GetSize());
+
+        /* Create an allocator. */
+        WordAllocator allocator(work_buf, work_buf_size / sizeof(Word));
+        ON_SCOPE_EXIT { ClearMemory(work_buf, allocator.GetMaxUsedSize()); };
+
+        /* Create a BigNum for the signature. */
+        BigNum signature;
+        auto signature_words = allocator.Allocate(size / sizeof(Word));
+        if (!signature_words.IsValid()) {
+            return false;
+        }
+
+        /* Import data for the signature. */
+        signature.ReserveStatic(signature_words.GetBuffer(), signature_words.GetCount());
+        if (!signature.Import(src, size)) {
+            return false;
+        }
+
+        /* Perform the exponentiation. */
+        if (!ExpMod(signature.words, signature.words, exp.words, exp.num_words, this->words, this->num_words, std::addressof(allocator))) {
+            return false;
+        }
+
+        /* We succeeded, so export. */
+        signature.UpdateCount();
+        signature.Export(dst, size);
+
+        return true;
+    }
+
+    void BigNum::ClearToZero() {
+        std::memset(this->words, 0, this->num_words * sizeof(Word));
+    }
+
+    void BigNum::UpdateCount() {
+        this->num_words = CountWords(this->words, this->max_words);
+    }
+
+}