LibCrypto: Split BigInteger operations into an Algorithms class

Since the operations are already complicated and will become even more so soon, let's split them into their own files. We can also integrate the NumberTheory operations that would better fit there into this class as well. This commit doesn't change behaviors, but moves the allocation of some variables into caller classes.
2025-05-31 07:38:10 +00:00 · 2021-05-10 20:55:25 +02:00 · 2021-05-10 20:55:25 +02:00 · 5963f6f9ff
commit 5963f6f9ff
parent 0853d98420
13 changed files with 736 additions and 582 deletions
--- a/Userland/Libraries/LibCrypto/BigInt/Algorithms/ModularInverse.cpp
+++ b/Userland/Libraries/LibCrypto/BigInt/Algorithms/ModularInverse.cpp
@ -0,0 +1,99 @@
+/*
+ * Copyright (c) 2020, Ali Mohammad Pur <mpfard@serenityos.org>
+ * Copyright (c) 2020-2021, Dex♪ <dexes.ttp@gmail.com>
+ *
+ * SPDX-License-Identifier: BSD-2-Clause
+ */
+
+#include "UnsignedBigIntegerAlgorithms.h"
+
+namespace Crypto {
+
+void UnsignedBigIntegerAlgorithms::modular_inverse_without_allocation(
+    UnsignedBigInteger const& a,
+    UnsignedBigInteger const& b,
+    UnsignedBigInteger& temp_1,
+    UnsignedBigInteger& temp_2,
+    UnsignedBigInteger& temp_3,
+    UnsignedBigInteger& temp_4,
+    UnsignedBigInteger& temp_plus,
+    UnsignedBigInteger& temp_minus,
+    UnsignedBigInteger& temp_quotient,
+    UnsignedBigInteger& temp_d,
+    UnsignedBigInteger& temp_u,
+    UnsignedBigInteger& temp_v,
+    UnsignedBigInteger& temp_x,
+    UnsignedBigInteger& result)
+{
+    UnsignedBigInteger one { 1 };
+
+    temp_u.set_to(a);
+    if (a.words()[0] % 2 == 0) {
+        // u += b
+        add_without_allocation(temp_u, b, temp_plus);
+        temp_u.set_to(temp_plus);
+    }
+
+    temp_v.set_to(b);
+    temp_x.set_to(0);
+
+    // d = b - 1
+    subtract_without_allocation(b, one, temp_d);
+
+    while (!(temp_v == 1)) {
+        while (temp_v < temp_u) {
+            // u -= v
+            subtract_without_allocation(temp_u, temp_v, temp_minus);
+            temp_u.set_to(temp_minus);
+
+            // d += x
+            add_without_allocation(temp_d, temp_x, temp_plus);
+            temp_d.set_to(temp_plus);
+
+            while (temp_u.words()[0] % 2 == 0) {
+                if (temp_d.words()[0] % 2 == 1) {
+                    // d += b
+                    add_without_allocation(temp_d, b, temp_plus);
+                    temp_d.set_to(temp_plus);
+                }
+
+                // u /= 2
+                divide_u16_without_allocation(temp_u, 2, temp_quotient, temp_1);
+                temp_u.set_to(temp_quotient);
+
+                // d /= 2
+                divide_u16_without_allocation(temp_d, 2, temp_quotient, temp_1);
+                temp_d.set_to(temp_quotient);
+            }
+        }
+
+        // v -= u
+        subtract_without_allocation(temp_v, temp_u, temp_minus);
+        temp_v.set_to(temp_minus);
+
+        // x += d
+        add_without_allocation(temp_x, temp_d, temp_plus);
+        temp_x.set_to(temp_plus);
+
+        while (temp_v.words()[0] % 2 == 0) {
+            if (temp_x.words()[0] % 2 == 1) {
+                // x += b
+                add_without_allocation(temp_x, b, temp_plus);
+                temp_x.set_to(temp_plus);
+            }
+
+            // v /= 2
+            divide_u16_without_allocation(temp_v, 2, temp_quotient, temp_1);
+            temp_v.set_to(temp_quotient);
+
+            // x /= 2
+            divide_u16_without_allocation(temp_x, 2, temp_quotient, temp_1);
+            temp_x.set_to(temp_quotient);
+        }
+    }
+
+    // return x % b
+    divide_without_allocation(temp_x, b, temp_1, temp_2, temp_3, temp_4, temp_quotient, result);
+}
+
+}