transcrypto 1.2.0__py3-none-any.whl → 1.4.0__py3-none-any.whl

transcrypto/profiler.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+#
+# Copyright 2025 Daniel Balparda (balparda@github.com) - Apache-2.0 license
+#
+"""Balparda's TransCrypto Profiler command line interface.
+
+See README.md for documentation on how to use.
+
+Notes on the layout (quick mental model):
+
+primes
+dsa
+doc md
+"""
+
+from __future__ import annotations
+
+import argparse
+import logging
+# import pdb
+import sys
+from typing import Callable
+
+from . import base, modmath, dsa
+
+__author__ = 'balparda@github.com'
+__version__: str = base.__version__  # version comes from base!
+__version_tuple__: tuple[int, ...] = base.__version_tuple__
+
+
+def _BuildParser() -> argparse.ArgumentParser:  # pylint: disable=too-many-statements,too-many-locals
+  """Construct the CLI argument parser (kept in sync with the docs)."""
+  # ========================= main parser ==========================================================
+  parser: argparse.ArgumentParser = argparse.ArgumentParser(
+      prog='poetry run profiler',
+      description=('profiler: CLI for TransCrypto Profiler, measure library performance.'),
+      epilog=(
+          'Examples:\n\n'
+          '  # --- Primes ---\n'
+          '  poetry run profiler -p -n 10 primes\n'
+          '  poetry run profiler -n 20 dsa\n'
+      ),
+      formatter_class=argparse.RawTextHelpFormatter)
+  sub = parser.add_subparsers(dest='command')
+
+  # ========================= global flags =========================================================
+  # -v/-vv/-vvv/-vvvv for ERROR/WARN/INFO/DEBUG
+  parser.add_argument(
+      '-v', '--verbose', action='count', default=0,
+      help='Increase verbosity (use -v/-vv/-vvv/-vvvv for ERROR/WARN/INFO/DEBUG)')
+
+  thread_grp = parser.add_mutually_exclusive_group()
+  thread_grp.add_argument(
+      '-s', '--serial', action='store_true',
+      help='If test can be serial, do it like that with no parallelization (default)')
+  thread_grp.add_argument(
+      '-p', '--parallel', action='store_true',
+      help='If test can be parallelized into processes, do it like that')
+
+  parser.add_argument(
+      '-n', '--number', type=int, default=15,
+      help='Number of experiments (repeats) for every measurement')
+  parser.add_argument(
+      '-c', '--confidence', type=int, default=98,
+      help=('Confidence level to evaluate measurements at as int percentage points [50,99], '
+            'inclusive, representing 50% to 99%'))
+
+  parser.add_argument(
+      '-b', '--bits', type=str, default='1000,9000,1000',
+      help=('Bit lengths to investigate as "int,int,int"; behaves like arguments for range(), '
+            'i.e., "start,stop,step", eg. "1000,3000,500" will investigate 1000,1500,2000,2500'))
+
+  # ========================= Prime Generation =====================================================
+
+  # Regular prime generation
+  sub.add_parser(
+      'primes',
+      help='Measure regular prime generation.',
+      epilog=('-n 30 -b 9000,11000,1000 primes\nStarting SERIAL regular primes test\n'
+              '9000 → 38.88 s ± 14.74 s [24.14 s … 53.63 s]98%CI@30\n'
+              '10000 → 41.26 s ± 22.82 s [18.44 s … 1.07 min]98%CI@30\nFinished in 40.07 min'))
+
+  # DSA primes generation
+  sub.add_parser(
+      'dsa',
+      help='Measure DSA prime generation.',
+      epilog=('-p -n 2 -b 1000,1500,100 -c 80 dsa\nStarting PARALLEL DSA primes test\n'
+              '1000 → 236.344 ms ± 273.236 ms [*0.00 s … 509.580 ms]80%CI@2\n'
+              '1100 → 319.308 ms ± 639.775 ms [*0.00 s … 959.083 ms]80%CI@2\n'
+              '1200 → 523.885 ms ± 879.981 ms [*0.00 s … 1.40 s]80%CI@2\n'
+              '1300 → 506.285 ms ± 687.153 ms [*0.00 s … 1.19 s]80%CI@2\n'
+              '1400 → 552.840 ms ± 47.012 ms [505.828 ms … 599.852 ms]80%CI@2\nFinished in 4.12 s'))
+
+  # ========================= Markdown Generation ==================================================
+
+  # Documentation generation
+  doc: argparse.ArgumentParser = sub.add_parser(
+      'doc', help='Documentation utilities. (Not for regular use: these are developer utils.)')
+  doc_sub = doc.add_subparsers(dest='doc_command')
+  doc_sub.add_parser(
+      'md',
+      help='Emit Markdown docs for the CLI (see README.md section "Creating a New Version").',
+      epilog='doc md > profiler.md\n<<saves file>>')
+
+  return parser
+
+
+def _PrimeProfiler(
+    prime_callable: Callable[[int], int],
+    repeats: int, n_bits_range: tuple[int, int, int], confidence: float, /) -> None:
+  primes: dict[int, list[float]] = {}
+  for n_bits in range(*n_bits_range):
+    # investigate for size n_bits
+    primes[n_bits] = []
+    for _ in range(repeats):
+      with base.Timer(emit_log=False) as tmr:
+        pr: int = prime_callable(n_bits)
+      assert pr and pr.bit_length() == n_bits
+      primes[n_bits].append(tmr.elapsed)
+    # finished collecting n_bits-sized primes
+    measurements: str = base.HumanizedMeasurements(
+        primes[n_bits], parser=base.HumanizedSeconds, confidence=confidence)
+    print(f'{n_bits} → {measurements}')
+
+
+def main(argv: list[str] | None = None, /) -> int:  # pylint: disable=invalid-name,too-many-locals,too-many-branches,too-many-statements
+  """Main entry point."""
+  # build the parser and parse args
+  parser: argparse.ArgumentParser = _BuildParser()
+  args: argparse.Namespace = parser.parse_args(argv)
+  # take care of global options
+  levels: list[int] = [logging.ERROR, logging.WARNING, logging.INFO, logging.DEBUG]
+  logging.basicConfig(
+      level=levels[min(args.verbose, len(levels) - 1)],  # type: ignore
+      format=getattr(base, 'LOG_FORMAT', '%(levelname)s:%(message)s'))
+  logging.captureWarnings(True)
+
+  try:
+    # get the command, do basic checks and switch
+    command: str = args.command.lower().strip() if args.command else ''
+    repeats: int = 1 if args.number < 1 else args.number
+    confidence: int = 55 if args.confidence < 55 else args.confidence
+    confidence = 99 if confidence > 99 else confidence
+    args.serial = True if (not args.serial and not args.parallel) else args.serial  # make default
+    bits: tuple[int, ...] = tuple(int(x, 10) for x in args.bits.strip().split(','))
+    if len(bits) != 3:
+      raise base.InputError('-b/--bits should be 3 ints, like: start,stop,step; eg.: 1000,3000,500')
+    with base.Timer(emit_log=False) as tmr:
+      match command:
+        # -------- Primes ----------
+        case 'primes':
+          print(f'Starting {"SERIAL" if args.serial else "PARALLEL"} regular primes test')
+          _PrimeProfiler(
+              lambda n: modmath.NBitRandomPrimes(n, serial=args.serial, n_primes=1).pop(),
+              repeats, bits, confidence / 100.0)
+
+        case 'dsa':
+          print(f'Starting {"SERIAL" if args.serial else "PARALLEL"} DSA primes test')
+          _PrimeProfiler(
+              lambda n: dsa.NBitRandomDSAPrimes(n, n // 2, serial=args.serial)[0],
+              repeats, bits, confidence / 100.0)
+
+        # -------- Documentation ----------
+        case 'doc':
+          doc_command: str = (
+              args.doc_command.lower().strip() if getattr(args, 'doc_command', '') else '')
+          match doc_command:
+            case 'md':
+              print(base.GenerateCLIMarkdown(
+                  'profiler', _BuildParser(), description=(
+                      '`profiler` is a command-line utility that provides stats on TransCrypto '
+                      'performance.')))
+            case _:
+              raise NotImplementedError()
+
+        case _:
+          parser.print_help()
+
+    if command not in ('doc',):
+      print(f'Finished in {tmr}')
+
+  except NotImplementedError as err:
+    print(f'Invalid command: {err}')
+  except (base.Error, ValueError) as err:
+    print(str(err))
+
+  return 0
+
+
+if __name__ == '__main__':
+  sys.exit(main())

transcrypto/rsa.py

@@ -14,6 +14,8 @@ import logging
 # import pdb
 from typing import Self
 
+import gmpy2  # type:ignore
+
 from . import base, modmath, aes
 
 __author__ = 'balparda@github.com'
@@ -100,7 +102,7 @@ class RSAPublicKey(base.CryptoKey, base.Encryptor, base.Verifier):
     if not 0 < message < self.public_modulus:
       raise base.InputError(f'invalid message: {message=}')
     # encrypt
-    return modmath.ModExp(message, self.encrypt_exp, self.public_modulus)
+    return int(gmpy2.powmod(message, self.encrypt_exp, self.public_modulus))  # type:ignore  # pylint:disable=no-member
 
   def Encrypt(self, plaintext: bytes, /, *, associated_data: bytes | None = None) -> bytes:
     """Encrypt `plaintext` and return `ciphertext`.
@@ -290,8 +292,8 @@ class RSAObfuscationPair(RSAPublicKey):
     if not 0 < message < self.public_modulus:
       raise base.InputError(f'invalid message: {message=}')
     # encrypt
-    return (message * modmath.ModExp(
-        self.random_key, self.encrypt_exp, self.public_modulus)) % self.public_modulus
+    return (message * int(gmpy2.powmod(  # type:ignore  # pylint:disable=no-member
+        self.random_key, self.encrypt_exp, self.public_modulus))) % self.public_modulus
 
   def RevealOriginalSignature(self, message: int, signature: int, /) -> int:
     """Recover original signature for `message` from obfuscated `signature`.
@@ -451,9 +453,9 @@ class RSAPrivateKey(RSAPublicKey, base.Decryptor, base.Signer):  # pylint: disab
     if not 0 <= ciphertext < self.public_modulus:
       raise base.InputError(f'invalid message: {ciphertext=}')
     # decrypt using CRT (Chinese Remainder Theorem); 4x speedup; all the below is equivalent
-    # of doing: return modmath.ModExp(ciphertext, self.decrypt_exp, self.public_modulus)
-    m_p: int = modmath.ModExp(ciphertext % self.modulus_p, self.remainder_p, self.modulus_p)
-    m_q: int = modmath.ModExp(ciphertext % self.modulus_q, self.remainder_q, self.modulus_q)
+    # of doing: return pow(ciphertext, self.decrypt_exp, self.public_modulus)
+    m_p: int = int(gmpy2.powmod(ciphertext % self.modulus_p, self.remainder_p, self.modulus_p))  # type:ignore  # pylint:disable=no-member
+    m_q: int = int(gmpy2.powmod(ciphertext % self.modulus_q, self.remainder_q, self.modulus_q))  # type:ignore  # pylint:disable=no-member
     h: int = (self.q_inverse_p * (m_p - m_q)) % self.modulus_p
     return (m_q + h * self.modulus_q) % self.public_modulus
 
@@ -568,21 +570,19 @@ class RSAPrivateKey(RSAPublicKey, base.Decryptor, base.Signer):  # pylint: disab
     failures: int = 0
     while True:
       try:
-        primes: list[int] = [modmath.NBitRandomPrime(bit_length // 2),
-                             modmath.NBitRandomPrime(bit_length // 2)]
-        modulus: int = primes[0] * primes[1]
-        while modulus.bit_length() != bit_length or primes[0] == primes[1]:
-          primes.remove(min(primes))
-          primes.append(modmath.NBitRandomPrime(
-              bit_length // 2 + (bit_length % 2 if modulus.bit_length() < bit_length else 0)))
-          modulus = primes[0] * primes[1]
+        primes: set[int] = set()
+        modulus: int = 0
+        p: int = 0
+        q: int = 0
+        while modulus.bit_length() != bit_length:
+          primes = modmath.NBitRandomPrimes((bit_length + 1) // 2, n_primes=2)
+          p, q = min(primes), max(primes)  # "p" is always the smaller, "q" the larger
+          modulus = p * q
         # build object
-        phi: int = (primes[0] - 1) * (primes[1] - 1)
+        phi: int = (p - 1) * (q - 1)
         prime_exp: int = (_SMALL_ENCRYPTION_EXPONENT if phi <= _BIG_ENCRYPTION_EXPONENT else
                           _BIG_ENCRYPTION_EXPONENT)
         decrypt_exp: int = modmath.ModInv(prime_exp, phi)
-        p: int = min(primes)  # "p" is always the smaller
-        q: int = max(primes)  # "q" is always the larger
         return cls(
             modulus_p=p,
             modulus_q=q,