mtproto 0.0.29 → 0.0.30

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 0a50a3572643e17c2435e3b310979e9a9ddbbf498bf8febb5819d96a73443899
-  data.tar.gz: 622d75782346d1cf190e3daa6097305afc3520b5fe5834b727a79bf4c0e86b36
+  metadata.gz: 573ffb4ecced33cf4a62f7d2faab6ad88d9903246732dc521f3193c8bba3a0dd
+  data.tar.gz: 68f6fb65b7121568e5a1ca7c46daf287430214de1204a7de718d4046d596d4de
 SHA512:
-  metadata.gz: 7ec7ee0beac3ee1143720d8e4972dba6a6f7db379069b0cc2a3274b5c81becb8e1353f448654b4c6c9d0385472d4985725292da56c040a50476ec94d2f980a93
-  data.tar.gz: c0951ce0991d6c960f6963647849156333bf5bebe4d59b0857af6703707430249c54bc4805be7b8e2527df84141f68dce9c43e6668ca5200eb4f4b7f3d146d4c
+  metadata.gz: a9e3cd7660f5d50be09e4ec3e68f5d1d84c96e8cfb8a056036b1d41eb1dd4e23fdcc6fb7399d7ea922987f6a18de2be8496c8cabc94bfcd1f1ff020daa5578da
+  data.tar.gz: e1fb03e7f7b214788fbc12fdfa859873b809f1483e5e2e008bc07d68e4d751c78b7b4c8a441489f178a809d109efc9ba8273b231ce4450eed2fde6daac85a531

data/ext/factorization/factorization.c

@@ -1,11 +1,46 @@
 #include <ruby.h>
 #include <stdint.h>
-#include <math.h>
 
 static VALUE mMTProto;
 static VALUE mCrypto;
 static VALUE mFactorization;
 
+static uint64_t
+mulmod(uint64_t a, uint64_t b, uint64_t m)
+{
+    return (uint64_t)(((__uint128_t)a * b) % m);
+}
+
+static uint64_t
+gcd64(uint64_t a, uint64_t b)
+{
+    while (b) {
+        uint64_t t = a % b;
+        a = b;
+        b = t;
+    }
+    return a;
+}
+
+/* Pollard's rho with f(x) = x^2 + c (mod n). Returns a non-trivial factor, or n
+ * on failure (cycle with no factor) so the caller can retry with another c. The
+ * MTProto pq is a product of two ~31-bit primes, so this finds a factor in a
+ * few thousand steps rather than the ~2^31 of trial division. */
+static uint64_t
+pollard_rho(uint64_t n, uint64_t c)
+{
+    uint64_t x = 2, y = 2, d = 1;
+    while (d == 1) {
+        x = (mulmod(x, x, n) + c) % n;
+        y = (mulmod(y, y, n) + c) % n;
+        y = (mulmod(y, y, n) + c) % n;
+        uint64_t diff = x > y ? x - y : y - x;
+        if (diff == 0) return n;
+        d = gcd64(diff, n);
+    }
+    return d;
+}
+
 static VALUE
 factorize_pq(VALUE self, VALUE pq_bytes)
 {
@@ -23,33 +58,32 @@ factorize_pq(VALUE self, VALUE pq_bytes)
         rb_raise(rb_eArgError, "Number must be > 3");
     }
 
+    uint64_t p;
     if (n % 2 == 0) {
-        VALUE result = rb_ary_new2(2);
-        rb_ary_push(result, ULL2NUM(2));
-        rb_ary_push(result, ULL2NUM(n / 2));
-        return result;
+        p = 2;
+    } else {
+        uint64_t d = n;
+        for (uint64_t c = 1; c < 256; c++) {
+            d = pollard_rho(n, c);
+            if (d != n && d > 1) break;
+        }
+        if (d == n || d <= 1) {
+            rb_raise(rb_eRuntimeError, "No non-trivial factors found (n might be prime)");
+        }
+        p = d;
     }
 
-    uint64_t limit = (uint64_t)sqrt((double)n) + 1;
-    for (uint64_t i = 3; i < limit; i += 2) {
-        if (n % i == 0) {
-            uint64_t p = i;
-            uint64_t q = n / i;
-
-            if (p > q) {
-                uint64_t tmp = p;
-                p = q;
-                q = tmp;
-            }
-
-            VALUE result = rb_ary_new2(2);
-            rb_ary_push(result, ULL2NUM(p));
-            rb_ary_push(result, ULL2NUM(q));
-            return result;
-        }
+    uint64_t q = n / p;
+    if (p > q) {
+        uint64_t tmp = p;
+        p = q;
+        q = tmp;
     }
 
-    rb_raise(rb_eRuntimeError, "No non-trivial factors found (n might be prime)");
+    VALUE result = rb_ary_new2(2);
+    rb_ary_push(result, ULL2NUM(p));
+    rb_ary_push(result, ULL2NUM(q));
+    return result;
 }
 
 void Init_factorization(void)

data/lib/mtproto/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module MTProto
-  VERSION = '0.0.29'
+  VERSION = '0.0.30'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: mtproto
 version: !ruby/object:Gem::Version
-  version: 0.0.29
+  version: 0.0.30
 platform: ruby
 authors:
 - Artem Levenkov