franre 0.1.0__tar.gz

franre-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 zyrokun
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

franre-0.1.0/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: franre
+Version: 0.1.0
+Summary: Franklin-Reiter RSA related-message solver
+Author: zyrokun
+License-Expression: MIT
+Project-URL: repository, https://github.com/zyrokun/franre
+Project-URL: issues, https://github.com/zyrokun/franre/issues
+Keywords: rsa,cryptography,franklin-reiter,cryptanalysis
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# franre - python library to speedrun tasks that are related to Franklin-Reiter RSA
+
+## how to download
+
+1. download the archive
+2. uhh, yeah
+3. unarchive the archive
+4. go to the folder where you've successfully unarchived the archive
+5. run this:
+
+```bash
+python3 -m pip install . --break-system-packages
+```
+6. you're done.
+
+## example of usage
+
+```python
+import franre
+# or 'from franre import solve'
+n = big numba
+e = 67
+m = another big numba
+a = 1
+b = 1234
+c1 = ciphertext from your task
+c2 = another ciphertext from your task
+
+franre.solve(c1, c2, n, e, a=a, b=b) # or if you've used another option of importing: solve(c1, c2, n, e, a=a, b=b)
+
+#if you've got the m, just import 'from Crypto.Util.number import long_to_bytes' and run print(long_to_bytes(m)) where m is the number that you've extracted from the output. glhf :3
+
+```

franre-0.1.0/README.md

@@ -0,0 +1,33 @@
+# franre - python library to speedrun tasks that are related to Franklin-Reiter RSA
+
+## how to download
+
+1. download the archive
+2. uhh, yeah
+3. unarchive the archive
+4. go to the folder where you've successfully unarchived the archive
+5. run this:
+
+```bash
+python3 -m pip install . --break-system-packages
+```
+6. you're done.
+
+## example of usage
+
+```python
+import franre
+# or 'from franre import solve'
+n = big numba
+e = 67
+m = another big numba
+a = 1
+b = 1234
+c1 = ciphertext from your task
+c2 = another ciphertext from your task
+
+franre.solve(c1, c2, n, e, a=a, b=b) # or if you've used another option of importing: solve(c1, c2, n, e, a=a, b=b)
+
+#if you've got the m, just import 'from Crypto.Util.number import long_to_bytes' and run print(long_to_bytes(m)) where m is the number that you've extracted from the output. glhf :3
+
+```

franre-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "franre"
+version = "0.1.0"
+description = "Franklin-Reiter RSA related-message solver"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [{ name = "zyrokun" }]
+keywords = ["rsa", "cryptography", "franklin-reiter", "cryptanalysis"]
+classifiers = [
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3 :: Only",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[project.urls]
+repository = "https://github.com/zyrokun/franre"
+issues = "https://github.com/zyrokun/franre/issues"
+
+[tool.setuptools]
+package-dir = { "" = "src" }
+
+[tool.setuptools.packages.find]
+where = ["src"]

franre-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

franre-0.1.0/src/franre/__init__.py

@@ -0,0 +1,5 @@
+from .core import solve
+
+__all__ = ["solve"]
+
+__version__ = "0.1.0"

franre-0.1.0/src/franre/core.py

@@ -0,0 +1,204 @@
+from __future__ import annotations
+
+from math import comb, gcd
+
+
+class FranklinReiterError(Exception):
+    pass
+
+
+class NoSolutionError(FranklinReiterError):
+    pass
+
+
+class AmbiguousSolutionError(FranklinReiterError):
+    def __init__(self, degree: int):
+        self.degree = degree
+        super().__init__(f"the polynomial gcd has degree {degree}, not 1")
+
+
+class NonInvertibleCoefficientError(FranklinReiterError):
+    def __init__(self, coefficient: int, modulus: int, factor: int):
+        self.coefficient = coefficient
+        self.modulus = modulus
+        self.factor = factor
+        super().__init__(
+            f"coefficient {coefficient} is not invertible modulo {modulus}; "
+            f"gcd(coefficient, modulus) = {factor}"
+        )
+
+
+Polynomial = list[int]
+
+
+def _trim(poly: Polynomial, modulus: int) -> Polynomial:
+    result = [coefficient % modulus for coefficient in poly]
+    while result and result[-1] == 0:
+        result.pop()
+    return result
+
+
+def _inverse(value: int, modulus: int) -> int:
+    value %= modulus
+    factor = gcd(value, modulus)
+    if factor != 1:
+        raise NonInvertibleCoefficientError(value, modulus, factor)
+    return pow(value, -1, modulus)
+
+
+def _poly_divmod(
+    dividend: Polynomial, divisor: Polynomial, modulus: int
+) -> tuple[Polynomial, Polynomial]:
+    dividend = _trim(dividend, modulus)
+    divisor = _trim(divisor, modulus)
+    if not divisor:
+        raise ZeroDivisionError("polynomial division by zero")
+    if not dividend or len(dividend) < len(divisor):
+        return [], dividend
+
+    quotient = [0] * max(0, len(dividend) - len(divisor) + 1)
+    remainder = dividend[:]
+    inverse_lead = _inverse(divisor[-1], modulus)
+
+    while remainder and len(remainder) >= len(divisor):
+        shift = len(remainder) - len(divisor)
+        factor = remainder[-1] * inverse_lead % modulus
+        quotient[shift] = factor
+        for index, coefficient in enumerate(divisor):
+            remainder[index + shift] = (
+                remainder[index + shift] - factor * coefficient
+            ) % modulus
+        remainder = _trim(remainder, modulus)
+
+    return _trim(quotient, modulus), remainder
+
+
+def _poly_gcd(first: Polynomial, second: Polynomial, modulus: int) -> Polynomial:
+    first = _trim(first, modulus)
+    second = _trim(second, modulus)
+    while second:
+        _, remainder = _poly_divmod(first, second, modulus)
+        first, second = second, remainder
+
+    if not first:
+        return []
+    inverse_lead = _inverse(first[-1], modulus)
+    return _trim([coefficient * inverse_lead for coefficient in first], modulus)
+
+
+def _make_polynomials(
+    c1: int, c2: int, modulus: int, exponent: int, a: int, b: int
+) -> tuple[Polynomial, Polynomial]:
+    first = [(-c1) % modulus] + [0] * (exponent - 1) + [1]
+
+    second = [
+        (comb(exponent, degree)
+         * pow(a, degree, modulus)
+         * pow(b, exponent - degree, modulus))
+        % modulus
+        for degree in range(exponent + 1)
+    ]
+    second[0] = (second[0] - c2) % modulus
+    return _trim(first, modulus), _trim(second, modulus)
+
+
+def _check_candidate(
+    candidate: int,
+    c1: int,
+    c2: int,
+    modulus: int,
+    exponent: int,
+    a: int,
+    b: int,
+) -> int:
+    candidate %= modulus
+    if pow(candidate, exponent, modulus) != c1 % modulus:
+        raise NoSolutionError("candidate does not reproduce the first ciphertext")
+    related = (a * candidate + b) % modulus
+    if pow(related, exponent, modulus) != c2 % modulus:
+        raise NoSolutionError("candidate does not reproduce the second ciphertext")
+    return candidate
+
+
+def _crt_pair(first: int, first_modulus: int, second: int, second_modulus: int) -> int:
+    if gcd(first_modulus, second_modulus) != 1:
+        raise NoSolutionError("cannot combine non-coprime modulus factors")
+    step = (
+        (second - first)
+        * pow(first_modulus, -1, second_modulus)
+    ) % second_modulus
+    return (first + first_modulus * step) % (first_modulus * second_modulus)
+
+
+def _attack_modulus(
+    c1: int, c2: int, modulus: int, exponent: int, a: int, b: int
+) -> int:
+    first_poly, second_poly = _make_polynomials(
+        c1, c2, modulus, exponent, a, b
+    )
+
+    try:
+        common = _poly_gcd(first_poly, second_poly, modulus)
+    except NonInvertibleCoefficientError as error:
+        factor = error.factor
+        other_factor = modulus // factor
+        if factor in (1, modulus) or gcd(factor, other_factor) != 1:
+            raise
+
+        first_residue = _attack_modulus(
+            c1, c2, factor, exponent, a, b
+        )
+        second_residue = _attack_modulus(
+            c1, c2, other_factor, exponent, a, b
+        )
+        candidate = _crt_pair(
+            first_residue, factor, second_residue, other_factor
+        )
+        return _check_candidate(candidate, c1, c2, modulus, exponent, a, b)
+
+    if len(common) == 1:
+        raise NoSolutionError("the ciphertext polynomials have no common root")
+    degree = len(common) - 1
+    if degree != 1:
+        raise AmbiguousSolutionError(degree)
+
+    candidate = -common[0] * _inverse(common[1], modulus) % modulus
+    return _check_candidate(candidate, c1, c2, modulus, exponent, a, b)
+
+
+def _execute(
+    c1: int,
+    c2: int,
+    n: int,
+    e: int,
+    *,
+    a: int,
+    b: int,
+) -> int:
+    if not isinstance(n, int) or isinstance(n, bool) or n <= 1:
+        raise ValueError("n must be an integer greater than 1")
+    if not isinstance(e, int) or isinstance(e, bool) or e < 2:
+        raise ValueError("e must be an integer greater than or equal to 2")
+    if not all(isinstance(value, int) and not isinstance(value, bool)
+               for value in (c1, c2, a, b)):
+        raise TypeError("c1, c2, a, and b must be integers")
+
+    return _attack_modulus(c1, c2, n, e, a % n, b % n)
+
+
+def solve(
+    c1: int,
+    c2: int,
+    n: int,
+    e: int,
+    *,
+    a: int,
+    b: int,
+) -> None:
+    try:
+        message = _execute(c1, c2, n, e, a=a, b=b)
+    except (FranklinReiterError, TypeError, ValueError):
+        print("no solutions lol")
+        return
+
+    print(f"woah, its m : {message}")

franre-0.1.0/src/franre.egg-info/PKG-INFO

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: franre
+Version: 0.1.0
+Summary: Franklin-Reiter RSA related-message solver
+Author: zyrokun
+License-Expression: MIT
+Project-URL: repository, https://github.com/zyrokun/franre
+Project-URL: issues, https://github.com/zyrokun/franre/issues
+Keywords: rsa,cryptography,franklin-reiter,cryptanalysis
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# franre - python library to speedrun tasks that are related to Franklin-Reiter RSA
+
+## how to download
+
+1. download the archive
+2. uhh, yeah
+3. unarchive the archive
+4. go to the folder where you've successfully unarchived the archive
+5. run this:
+
+```bash
+python3 -m pip install . --break-system-packages
+```
+6. you're done.
+
+## example of usage
+
+```python
+import franre
+# or 'from franre import solve'
+n = big numba
+e = 67
+m = another big numba
+a = 1
+b = 1234
+c1 = ciphertext from your task
+c2 = another ciphertext from your task
+
+franre.solve(c1, c2, n, e, a=a, b=b) # or if you've used another option of importing: solve(c1, c2, n, e, a=a, b=b)
+
+#if you've got the m, just import 'from Crypto.Util.number import long_to_bytes' and run print(long_to_bytes(m)) where m is the number that you've extracted from the output. glhf :3
+
+```

franre-0.1.0/src/franre.egg-info/SOURCES.txt

@@ -0,0 +1,9 @@
+LICENSE
+README.md
+pyproject.toml
+src/franre/__init__.py
+src/franre/core.py
+src/franre.egg-info/PKG-INFO
+src/franre.egg-info/SOURCES.txt
+src/franre.egg-info/dependency_links.txt
+src/franre.egg-info/top_level.txt

franre-0.1.0/src/franre.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

franre-0.1.0/src/franre.egg-info/top_level.txt

@@ -0,0 +1 @@
+franre