diff --git a/.gitignore b/.gitignore index 8d0f132..c18dd8d 100644 --- a/.gitignore +++ b/.gitignore @@ -1,3 +1 @@ __pycache__/ -nimble.develop -nimble.paths diff --git a/README b/README index 1303d8b..f616f3f 100644 --- a/README +++ b/README @@ -1,28 +1 @@ The "imbaud python library" (imp lib), or just imp for short! - -TODO: -- define a getPrime function like PyCryptodome's -- rewrite nim-lang/bigints to implement features like Karatsuba multiplication, or even Toom-3 multiplication - - -PyCryptodome defines getPrime as follows: -```py -def getPrime(N, randfunc=None): - """Return a random N-bit prime number. - - N must be an integer larger than 1. - If randfunc is omitted, then :meth:`Random.get_random_bytes` is used. - """ - if randfunc is None: - randfunc = Random.get_random_bytes - - if N < 2: - raise ValueError("N must be larger than 1") - - while True: - number = getRandomNBitInteger(N, randfunc) | 1 - if isPrime(number, randfunc=randfunc): - break - return number -``` -in essence infinite random generation until a prime is found diff --git a/README-primefac b/README-primefac deleted file mode 100644 index 8be9abc..0000000 --- a/README-primefac +++ /dev/null @@ -1,6 +0,0 @@ -`primefac-nim` is a translation of Lucas A. Brown's [primefac project](https://github.com/lucasaugustus/primefac) -into Nim. Why? 1. I like his work and wanted it in Nim, 2. I'm trying to learn number theory. - -Some functions are not verbatim translation, and will be marked as such. -This allows me to implement my own optimisations, such as using -the Sieve of Atkins for prime generation rather than the Sieve of Eratosthenes. diff --git a/celeste.nimble b/celeste.nimble deleted file mode 100644 index a3d4f31..0000000 --- a/celeste.nimble +++ /dev/null @@ -1,10 +0,0 @@ -# Package -version = "0.1.0" -author = "Emile Clark-Boman" -description = "Self contained framework for computational mathematics" -license = "MIT" -srcDir = "src" - - -# Dependencies -requires "nim >= 2.2.0" diff --git a/celeste/attacks/paddingoracle.py b/celeste/attacks/paddingoracle.py deleted file mode 100644 index 5529624..0000000 --- a/celeste/attacks/paddingoracle.py +++ /dev/null @@ -1,106 +0,0 @@ -from math import inf, ceil -from typing import Callable - -from celeste.math.util import clamp_max - -SPACER = b'\xff' # arbitrary spacing character - -class DecryptFailed(Exception): - pass - -def round_to_blocks(n: int, block_size: int) -> int: - return ceil(n / block_size) - -def crack_secret_len(cipher: Callable[[str], str], - max_iters: int = inf) -> int | None: - # calculate length for i = 1 - init_len = len(cipher(SPACER)) - secret_len = None - i = 2 - while True: - if i - 2 > max_iters: - break - elif len(cipher(SPACER*i)) != init_len: - secret_len = init_len - i - break - i += 1 - return secret_len - -''' - -NOTE: pad_if_perfect exists for PKCS#7 which will add a full block -NOTE: of padding if the input is perfectly alligned to the blocks already. -''' -def crack(cipher: Callable[[str], str], - padfn: Callable[[bytes, int], bytes], - charset: list, - block_size: int, - max_secret_iters: int = inf, - batch_size: int = 1, - pad_if_perfect: bool = True, - debug: bool = False) -> str | None: - if len(charset) % batch_size: - raise ValueError(f'batch_size={batch_size} does not divide len(charset)={len(charset)}') - # calculate the secret length - secret_len = crack_secret_len(cipher, max_iters=max_secret_iters) - if debug: - print(f'[+] Found secret length: {secret_len}') - - # calculate how many blocks the secret stretches over - # NOTE: secret_block_len - secret_len represents the number of - # NOTE: bytes required to make the secret fill the blocks with no padding - secret_block_len = round_to_blocks(secret_len, block_size) * block_size - default_push = (secret_block_len - secret_len) - known = b'' - while True: - # the "full tail" is all characters we know + the 1 we're cracking (target) - # the "current tail" is the characters in the same block as the target - full_tail_bytes = len(known) + 1 - tail_bytes = clamp_max(full_tail_bytes, block_size - 1) - # generate ALL possible tails (avoid padding if no padding required) - tails = [c + known[:tail_bytes] for c in charset] - if len(tails[0]) != block_size: - tails = [padfn(tail, 16) for tail in tails] - # calculate the "push" applied to the secret - push_size = (default_push + full_tail_bytes) % block_size - - matched = False - NUM_BATCHES = len(tails) // batch_size - for i in range(NUM_BATCHES): - if debug: - print(f'{int(i/NUM_BATCHES*100)}%', end='\r') - batch = tails[i*batch_size : (i+1)*batch_size] - batch = b''.join(batch) + (SPACER * push_size) # apply spacing - - # encrypt batch and split the ciphertext into blocks - ciphertext = cipher(batch) - num_blocks = len(ciphertext)//block_size - blocks = [ciphertext[i*block_size : (i+1)*block_size] for i in range(num_blocks)] - - oracle_pos = round_to_blocks(full_tail_bytes, block_size) - if pad_if_perfect and (push_size + secret_len) % block_size == 0: - oracle_pos += 1 - - for j, cipher_block in enumerate(blocks[:batch_size]): - if cipher_block == blocks[-oracle_pos]: - char = charset[i*batch_size + j] - known = char + known - if debug: - print(f'[*] Found Tail: {known}') - matched = True - break - if matched: - break - if not matched: - break - elif len(known) == secret_len: - if debug: - print('[+] SUCCESS') - return known - # if we reached the end (no return) - # then the attack failed - err_msg = 'Padding oracle attack failed' - if not debug: - raise DecryptFailed(err_msg) - print(f'\n[!] {err_msg}') - diff --git a/celeste/crypto/hash.py b/celeste/crypto/hash.py deleted file mode 100644 index e7811ec..0000000 --- a/celeste/crypto/hash.py +++ /dev/null @@ -1,7 +0,0 @@ -import hashlib - -def sha256(data: bytes, as_bytes: bool = False) -> bytes: - hasher = hashlib.sha256() - hasher.update(data) - hash = hasher.digest() - return hash if as_bytes else int.from_bytes(hash) diff --git a/celeste/crypto/rsa.py b/celeste/crypto/rsa.py deleted file mode 100644 index 09cd94d..0000000 --- a/celeste/crypto/rsa.py +++ /dev/null @@ -1,18 +0,0 @@ -''' -Simplification of Euler's Totient function knowing -the prime factorisation for the public key N value. -''' -def _totient(p: int, q: int) -> int: - return (p - 1) * (q - 1) - -''' -Implements RSA encryption as modular exponentiation. -''' -def encrypt(plaintext: int, e: int, N: int) -> int: - return pow(plaintext, e, N) -def decrypt(ciphertext: int, d: int, N: int) -> int: - return pow(ciphertext, d, N) - -def gen_private_key(e: int, p: int, q: int) -> int: - return pow(e, -1, _totient(p, q)) - diff --git a/celeste/math/__init__.py b/celeste/math/__init__.py deleted file mode 100644 index e69de29..0000000 diff --git a/celeste/math/crt.py b/celeste/math/crt.py deleted file mode 100644 index a50679c..0000000 --- a/celeste/math/crt.py +++ /dev/null @@ -1,124 +0,0 @@ -def crt(eqs: list[tuple[int, int]]) -> tuple[int, int]: - ''' - Solves simultaneous linear diophantine equations - using the Chinese-Remainder Theorem. - Example: - >>> crt([2, 3), (3, 5), (2, 7)]) - (23, 105) - # aka x is congruent to 23 modulo 105 - ''' - # calculate the quotient and remainder form of the unknown - q = 1 - r = 0 - # store remainders and moduli for each linear equation - R = [eq[0] for eq in eqs] - M = [eq[1] for eq in eqs] - N = len(eqs) - for i in range(N): - (R_i, M_i) = (R[i], M[i]) - # adjust quotient and remainder - r += R_i * q - q *= M_i - # apply current eq to future eqs - for j in range(i+1, N): - R[j] -= R_i - R[j] *= pow(M_i, -1, M[j]) - R[j] %= M[j] - return r # NOTE: forall integers k: qk+r is also a solution - - -from math import isqrt, prod - -def bsgs(g: int, h: int, n: int) -> int: - ''' - The Baby-Step Giant-Step algorithm computes the - discrete logarithm (or order) of an element in a - finite abelian group. - - Specifically, for a generator g of a finite abelian - group G order n, and an element h in G, the BSGS - algorithm returns the integer x such that g^x = h. - For example, if G = Z_n the cyclic group order n then: - bsgs solves g^x = h (mod n) for x. - ''' - # ensure g and h are reduced modulo n - g %= n - h %= n - # ignore trivial case - # NOTE: for the Pohlig-Hellman algorithm to work properly - # NOTE: BSGS must return 1 NOT 0 for bsgs(1, 1, n) - if g == h: return 1 - m = isqrt(n) + 1 # ceil(sqrt(n)) - # store g^j values in a hash table - H = {j: pow(g, j, n) for j in range(m)} - I = pow(g, -m, n) - y = h - for i in range(m): - for j in range(m): - if H[j] == y: - return i*m + j - y = (y * I) % n - return None # No Solutions - -def factors_prod(pf: list[tuple[int, int]]) -> int: - return prod(p**e for (p, e) in pf) - -def sph(g: int, h: int, pf: list[tuple[int, int]]) -> int: - ''' - The Silver-Pohlig-Hellman algorithm for computing - discrete logarithms in finite abelian groups whose - order is a smooth integer. - - NOTE: this works in the special case, - NOTE: but I can't get the general case to work :( - ''' - # ignore the trivial case - if g == h: - return 1 - R = len(pf) # number of prime factors - N = factors_prod(pf) # pf is the prime factorisation of N - print('N', N) - # Special Case: groups of prime-power order: - if R == 1: - (p, e) = pf[0] - x = 0 - y = pow(g, p**(e-1), N) - for k in range(e): - # temporary variables for defining h_k - w = pow(g, -x, N) - # NOTE: by construction the order of h_k must divide p - h_k = pow(w*h, p**(e-1-k), N) - # apply BSGS to find d such that y^d = h_k - d = bsgs(y, h_k, N) - if d is None: - return None # No Solutions - x = x + (p**k)*d - return x - - # General Case: - eqs = [] - for i in range(R): - (p_i, e_i) = pf[i] - # phi = (p_i - 1)*(p_i**(e_i - 1)) # Euler totient - # pe = p_i**e_i - # P = (N//(p_i**e_i)) % phi # reduce mod phi by Euler's theorem - g_i = pow(g, N//(p_i**e_i), N) - h_i = pow(h, N//(p_i**e_i), N) - print("g and h", g_i, h_i) - print("p^e", p_i, e_i) - x_i = sph(g_i, h_i, [(p_i,e_i)]) - print("x_i", x_i) - if x_i is None: - return None # No Solutions - eqs.append((x_i, p_i**e_i)) - print() - # ignore the quotient, solve CRT for 0 <= x <= n-1 - x = crt(eqs) # NOTE: forall integers k: Nk+x is also a solution - print('solution:', x) - print(eqs) - return x - - -if __name__ == '__main__': - result = sph(3, 11, [(2, 1),(7,1)]) - diff --git a/celeste/math/factor/__init__.py b/celeste/math/factor/__init__.py deleted file mode 100644 index e4a5de0..0000000 --- a/celeste/math/factor/__init__.py +++ /dev/null @@ -1,2 +0,0 @@ -from .pftrialdivision import trial_division -from .factordb import DBResult, FType, FCertainty diff --git a/celeste/math/factor/factordb.py b/celeste/math/factor/factordb.py deleted file mode 100644 index b24382e..0000000 --- a/celeste/math/factor/factordb.py +++ /dev/null @@ -1,161 +0,0 @@ -''' -Simple interface for https://factordb.com inspired by -https://github.com/ihebski/factordb - -TODO: -1. Implement primality certificate generation, read this: -https://reference.wolfram.com/language/PrimalityProving/ref/ProvablePrimeQ.html -''' - -import requests -from enum import Enum, StrEnum - -_FDB_URI = 'https://factordb.com' -# Generated by https://www.asciiart.eu/text-to-ascii-art -# using "ANSI Shadow" font and "Box drawings double" border with 1 H. Padding -_BANNER = ''' -╔═══════════════════════════════════════════════════╗ -║ ███████╗ ██████╗████████╗██████╗ ██████╗ ██████╗ ║ -║ ██╔════╝██╔════╝╚══██╔══╝██╔══██╗██╔══██╗██╔══██╗ ║ -║ █████╗ ██║ ██║ ██████╔╝██║ ██║██████╔╝ ║ -║ ██╔══╝ ██║ ██║ ██╔══██╗██║ ██║██╔══██╗ ║ -║ ██║ ╚██████╗ ██║ ██║ ██║██████╔╝██████╔╝ ║ -║ ╚═╝ ╚═════╝ ╚═╝ ╚═╝ ╚═╝╚═════╝ ╚═════╝ ║ -╚═══════════════════════════════════════════════════╝ -╚═══ cli by imbored ═══╝ -'''.strip() - -# Enumeration of number types based on their factorisation -class FType(Enum): - Unit = 1 - Composite = 2 - Prime = 3 - Unknown = 4 - -class FCertainty(Enum): - Certain = 1 - Partial = 2 - Unknown = 3 - -# FactorDB result status codes -class DBStatus(StrEnum): - C = 'C' - CF = 'CF' - FF = 'FF' - P = 'P' - PRP = 'PRP' - U = 'U' - Unit = 'Unit' # just for 1 - N = 'N' - Add = '*' - - def is_unknown(self) -> bool: - return (self in [DBStatus.U, DBStatus.N, DBStatus.Add]) - - def classify(self) -> tuple[FType, FCertainty]: - return _STATUS_MAP[self] - - def msg_verbose(self) -> str: - return _STATUS_MSG_VERBOSE[self] - -# Map of DB Status codes to their factorisation type and certainty -_STATUS_MAP = { - DBStatus.Unit: (FType.Unit, FCertainty.Certain), - DBStatus.C: (FType.Composite, FCertainty.Unknown), - DBStatus.CF: (FType.Composite, FCertainty.Partial), - DBStatus.FF: (FType.Composite, FCertainty.Certain), - DBStatus.P: (FType.Prime, FCertainty.Certain), - DBStatus.PRP: (FType.Prime, FCertainty.Partial), - DBStatus.U: (FType.Unknown, FCertainty.Unknown), - DBStatus.N: (FType.Unknown, FCertainty.Unknown), - DBStatus.Add: (FType.Unknown, FCertainty.Unknown), -} - -# Reference: https://factordb.com/status.html -# NOTE: my factor messages differ slightly from the reference -_STATUS_MSG_VERBOSE = { - DBStatus.Unit: 'Unit, trivial factorisation', - DBStatus.C: 'Composite, no factors known', - DBStatus.CF: 'Composite, *partially* factors', - DBStatus.FF: 'Composite, fully factored', - DBStatus.P: 'Prime', - DBStatus.PRP: 'Probable prime', - DBStatus.U: 'Unknown (*but in database)', - DBStatus.N: 'Not in database (-not added due to your settings)', - DBStatus.Add: 'Not in database (+added during request)', -} - -# Struct for storing database results with named properties -class DBResult: - def __init__(self, - status: DBStatus, - factors: tuple[tuple[int, int]]) -> None: - self.status = status - self.factors = factors - self.ftype, self.certainty = self.status.classify() - -def _make_cookie(fdbuser: str | None) -> dict[str, str]: - return {} if fdbuser is None else {'fdbuser': fdbuser} - -def _get_key(by_id: bool): - return 'id' if by_id else 'query' - -def _api_query(n: int, - fdbuser: str | None, - by_id: bool = False) -> requests.models.Response: - key = _get_key(by_id) - uri = f'{_FDB_URI}/api?{key}={n}' - return requests.get(uri, cookies=_make_cookie(fdbuser)) - -def _report_factor(n: int, - factor: int, - fdbuser: str | None, - by_id: bool = False) -> requests.models.Response: - key = _get_key(by_id) - uri = f'{_FDB_URI}/reportfactor.php?{key}={n}&factor={factor}' - return requests.get(uri, cookies=_make_cookie(fdbuser)) - -''' -Attempts a query to FactorDB, returns a DBResult object -on success, or None if the request failed due to the -get request raising a RequestException. -''' -def query(n: int, - token: str | None = None, - by_id: bool = False, - cli: bool = False) -> DBResult | None: - if cli: - print(_BANNER) - try: - resp = _api_query(n, token, by_id=by_id) - except requests.exceptions.RequestException: - return None - content = resp.json() - result = DBResult( - DBStatus(content['status']), - tuple((int(F[0]), F[1]) for F in content['factors']) - ) - if cli: - print(f'Status: {result.status.msg_verbose()}') - print(result.factors) - - # ensure the unit has the trivial factorisation (for consistency) - if result.status == DBStatus.Unit: - result.factors = ((1, 1),) - return result - -''' -Reports a known factor to FactorDB, also tests it is -actually a factor to avoid wasting FactorDBs resources. -''' -def report(n: int, - factor: int, - by_id: int, - token: str | None = None) -> None: - try: - resp = _report_factor(n, factor, token) - except requests.exceptions.RequestException: - return None - content = resp.json() - print(content) - diff --git a/celeste/math/factor/pftrialdivision.py b/celeste/math/factor/pftrialdivision.py deleted file mode 100644 index 8e1b3d0..0000000 --- a/celeste/math/factor/pftrialdivision.py +++ /dev/null @@ -1,46 +0,0 @@ -''' -The trial division algorithm is essentially the idea that -all factors of an integer n are less than or equal to isqrt(n), -where isqrt is floor(sqrt(n)). - -Moreover, if p divides n, then all other factors of n must -be factors of n//p. Hence they must be <= isqrt(n//p). -''' -from math import isqrt # integer square root - -# Returns the "multiplicity" of a prime factor -def pf_multiplicity(n: int, p: int) -> int: - mult = 0 - while n % p == 0: - n //= p - mult += 1 - return n, mult - -''' -Trial division prime factorisation algorithm. -Returns a list of tuples (p, m) where p is -a prime factor and m is its multiplicity. -''' -def trial_division(n: int) -> list[tuple[int, int]]: - factors = [] - - # determine multiplicity of the only even prime (2) - n, mult_2 = pf_multiplicity(n, 2) - if mult_2: factors.append((2, mult_2)) - # determine odd factors and their multiplicities - p = 3 - mult = 0 - limit = isqrt(n) - while p <= limit: - n, mult = pf_multiplicity(n, p) - if mult: - factors.append((p, mult)) - limit = isqrt(n) # recalculate limit - mult = 0 # reset - else: - p += 2 - # if n is still greater than 1, then n is a prime factor - if n > 1: - factors.append((n, 1)) - return factors - diff --git a/celeste/math/numbertheory.py b/celeste/math/numbertheory.py deleted file mode 100644 index 66b6256..0000000 --- a/celeste/math/numbertheory.py +++ /dev/null @@ -1,21 +0,0 @@ -def euclidean_algo(a: int, b: int) -> int: - while b: a, b = b, a % b - return a - -''' -Calculates coefficients x and y of Bezout's identity: ax + by = gcd(a,b) -NOTE: Based on the Extended Euclidean Algorithm's Wikipedia page -''' -def extended_euclid_algo(a: int, b: int) -> tuple[int, int]: - (old_r, r) = (a, b) - (old_s, s) = (1, 0) - (old_t, t) = (0, 1) - while r != 0: - q = old_r // r - (old_r, r) = (r, old_r - q*r) - (old_s, s) = (s, old_s - q*s) - (old_t, t) = (t, old_t - q*t) - # Bezout cofficients: (old_s, old_t) - # Greatest Common Divisor: old_r - # Quotients by the gcd: (t, s) - return (t, s) diff --git a/celeste/math/primes/__init__.py b/celeste/math/primes/__init__.py deleted file mode 100644 index ed6d3ca..0000000 --- a/celeste/math/primes/__init__.py +++ /dev/null @@ -1,48 +0,0 @@ -from math import inf, isqrt # integer square root -from itertools import takewhile, compress - -SMALL_PRIMES = (2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59) - -''' -Euler's Totient (Phi) Function -Implemented in O(nloglog(n)) using the Sieve of Eratosthenes. -''' -def eulertotient(n: int) -> int: - phi = int(n > 1 and n) - for p in range(2, isqrt(n) + 1): - if not n % p: - phi -= phi // p - while not n % p: - n //= p - #if n is > 1 it means it is prime - if n > 1: phi -= phi // n - return phi - -''' -Tests the primality of an integer using its totient. -NOTE: If totient(n) has already been calculated - then pass it as the optional phi parameter. -''' -def is_prime(n: int, phi: int = None) -> bool: - return n - 1 == (phi if phi is not None else eulertotient(n)) - -# Taken from Lucas A. Brown's primefac.py (some variables renamed) -def primegen(limit=inf) -> int: - ltlim = lambda x: x < limit - yield from takewhile(ltlim, SMALL_PRIMES) - pl, prime = [3,5,7], primegen() - for p in pl: next(prime) - n = next(prime); nn = n*n - while True: - n = next(prime); ll, nn = nn, n*n - delta = nn - ll - sieve = bytearray([True]) * delta - for p in pl: - k = (-ll) % p - sieve[k::p] = bytearray([False]) * ((delta-k)//p + 1) - if nn > limit: break - yield from compress(range(ll,ll+delta,2), sieve[::2]) - pl.append(n) - yield from takewhile(ltlim, compress(range(ll,ll+delta,2), sieve[::2])) - - diff --git a/celeste/math/util.py b/celeste/math/util.py deleted file mode 100644 index d0d058b..0000000 --- a/celeste/math/util.py +++ /dev/null @@ -1,29 +0,0 @@ -from collections.abc import Iterable -from itertools import chain, combinations - -def clamp(n: int, min: int, max: int) -> int: - if n < min: - return min - elif n > max: - return max - return n - -def clamp_max(n: int, max: int) -> int: - return max if n > max else n - -def clamp_min(n: int, max: int) -> int: - return min if n < min else n - -def digits(n: int) -> int: - return len(str(n)) - -# NOTE: assumes A and B are equal length -def xor_bytes(A: bytes, B: bytes) -> bytes: - return b''.join([(a ^ b).to_bytes() for (a, b) in zip(A, B)]) -def xor_str(A: str, B: str) -> str: - return ''.join([chr(ord(a) ^ ord(b)) for (a, b) in zip(A, B)]) - - -def powerset(iterable: Iterable) -> Iterable: - s = list(iterable) - return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) diff --git a/config.nims b/config.nims deleted file mode 100644 index 8ee48d2..0000000 --- a/config.nims +++ /dev/null @@ -1,4 +0,0 @@ -# begin Nimble config (version 2) -when withDir(thisDir(), system.fileExists("nimble.paths")): - include "nimble.paths" -# end Nimble config diff --git a/ctf-solutions/bean_counter.py b/ctf-solutions/bean_counter.py deleted file mode 100644 index f0b5634..0000000 --- a/ctf-solutions/bean_counter.py +++ /dev/null @@ -1,92 +0,0 @@ -''' -Solution for https://cryptohack.org/courses/symmetric/bean_counter/ -''' - -import os -import requests -from math import ceil - -from Crypto.Cipher import AES - -from celeste.math.util import xor_bytes - -class StepUpCounter(object): - def __init__(self, step_up=False): - self.value = os.urandom(16).hex() - self.step = 1 - self.stup = step_up - - def increment(self): - if self.stup: - self.newIV = hex(int(self.value, 16) + self.step) - else: - self.newIV = hex(int(self.value, 16) - self.stup) - self.value = self.newIV[2:len(self.newIV)] - return bytes.fromhex(self.value.zfill(32)) - - def __repr__(self): - self.increment() - return self.value - -''' -NOTE: Since step_up is used ONLY as false, we can simplify: -class StepUpCounter(object): - def __init__(self): - self.value = os.urandom(16).hex() - - # SAME AS DOING NOTHING - def increment(self): - return self.value() - - def __repr__(self): - return self.value -''' - -URL = 'https://aes.cryptohack.org/bean_counter' - -def get_encrypted() -> bytes: - resp = requests.get(f'{URL}/encrypt/') - encrypted = bytes.fromhex(resp.json()['encrypted']) - return encrypted - -PNG_HEADER = [ - '89', '50', '4e', '47', - '0d', '0a', '1a', '0a', - '00', '00', '00', '0d', - '49', '48', '44', '52' -] - -def main() -> None: - # NOTE: the counter is constant! - ctr = StepUpCounter() - # init = ctr.increment() - # init_val = ctr.value - # for i in range(2560000): - # if ctr.increment() != init: - # print('Counter Changed') - # print(i) - # break - # elif ctr.value != init_val: - # print('valued changed') - # print(i) - # break - - # PNGs *should* have a constant header, we will use the first 16 bytes - # to determine what the counter value must be set to - encrypted = get_encrypted() - png_header = bytes.fromhex(''.join(PNG_HEADER)) - ctr_value = xor_bytes(encrypted[:16], png_header) - # apply the counter value to the entire encrypted image (in blocks of 16 bytes) - BLOCK_SIZE = 16 - with open('bean_flag.png', 'wb') as f: - for i in range(ceil(len(encrypted) / BLOCK_SIZE)): - block = encrypted[i*BLOCK_SIZE : (i+1)*BLOCK_SIZE] - # NOTE: the block we get is not guaranteed to be block size (ie if at end) - plaintext_block = xor_bytes(block, ctr_value[:len(block)]) - f.write(plaintext_block) - -if __name__ == '__main__': - try: - main() - except (KeyboardInterrupt, EOFError): - print('\n[!] Interrupt') diff --git a/ctf-solutions/flipping_cookie.py b/ctf-solutions/flipping_cookie.py deleted file mode 100644 index 4e6e8e2..0000000 --- a/ctf-solutions/flipping_cookie.py +++ /dev/null @@ -1,55 +0,0 @@ -''' -Solution to https://cryptohack.org/courses/symmetric/flipping_cookie/ -''' - -import requests -from datetime import datetime, timedelta - -URL = 'https://aes.cryptohack.org/flipping_cookie' - -# NOTE: assumes A and B are equal length -def xor_bytes(A: bytes, B: bytes) -> bytes: - return b''.join([(a ^ b).to_bytes() for (a, b) in zip(A, B)]) -def xor_str(A: str, B: str) -> str: - return ''.join([chr(ord(a) ^ ord(b)) for (a, b) in zip(A, B)]) - -def gen_expiry() -> str: - return (datetime.today() + timedelta(days=1)).strftime("%s") - -def get_cookie() -> tuple[bytes, bytes]: - resp = requests.get(f'{URL}/get_cookie/') - cookie = resp.json()['cookie'] - iv = bytes.fromhex(cookie[:32]) - ciphertext = bytes.fromhex(cookie[32:]) - return iv, ciphertext - - -def main() -> None: - # cookie flipping preprocessing step - admin_len = len('admin=') - expiry_len = len(';expiry=') + len(gen_expiry()) - admin_mask = '\x00' * admin_len - expiry_mask = '\x00' * expiry_len - # we aim to replace "admin=False;" with "admin=True;;" - # NOTE: double semicolon ("True;;") is intentional - # NOTE: and the server won't ever realise it happened! - deletion = admin_mask + 'False' + expiry_mask - insertion = admin_mask + 'True;' + expiry_mask - # determine the value that replaces deletion with insertion - cookie_flip = xor_str(deletion, insertion) - - # get our new cookie and apply the cookie flip! - iv, ciphertext = get_cookie() - flipped_iv = xor_bytes(cookie_flip.encode(), iv) - - print('Flipped Cookie:') - print('IV:', flipped_iv.hex()) - print('Body:', ciphertext.hex()) - - - - - - -if __name__ == '__main__': - main() diff --git a/ctf-solutions/symmetry.py b/ctf-solutions/symmetry.py deleted file mode 100644 index 47d103e..0000000 --- a/ctf-solutions/symmetry.py +++ /dev/null @@ -1,39 +0,0 @@ -''' -Solution to https://cryptohack.org/courses/symmetric/symmetry/ -''' - -import os -import requests - -from celeste.math.util import xor_bytes, xor_str - -URL = 'https://aes.cryptohack.org/symmetry' - -def get_encrypted_flag() -> tuple[bytes, bytes]: - resp = requests.get(f'{URL}/encrypt_flag/') - ciphertext = resp.json()['ciphertext'] - iv = bytes.fromhex(ciphertext[:32]) - flag = bytes.fromhex(ciphertext[32:]) - return iv, flag - -def encrypt(plaintext: bytes, iv: bytes) -> bytes: - plaintext, iv = plaintext.hex(), iv.hex() - resp = requests.get(f'{URL}/encrypt/{plaintext}/{iv}') - return bytes.fromhex(resp.json()['ciphertext']) - -def main() -> None: - iv, flag = get_encrypted_flag() - # generate a random plaintext of equal length to the flag - random_plaintext = os.urandom(len(flag)) - random_ciphertext = encrypt(random_plaintext, iv) - # XOR random plaintext with corresponding ciphertext to - # get the set generated by IV under the keyed AES permutation - aes_orbit = xor_bytes(random_plaintext, random_ciphertext) - # XOR this orbit with the flag to get the hexed flag plaintext - flag_plaintext = xor_bytes(flag, aes_orbit) - print('Flag:', flag_plaintext.decode()) - - print('IV:', iv.hex()) - -if __name__ == '__main__': - main() diff --git a/default.nix b/default.nix deleted file mode 100644 index d637d64..0000000 --- a/default.nix +++ /dev/null @@ -1,10 +0,0 @@ -let - sources = import ./nix/sources.nix; - pkgs = import sources.nixpkgs {}; - # Let all API attributes like "poetry2nix.mkPoetryApplication" - # use the packages and versions (python3, poetry etc.) from our pinned nixpkgs above - # under the hood: - poetry2nix = import sources.poetry2nix {inherit pkgs;}; - myPythonApp = poetry2nix.mkPoetryApplication {projectDir = ./.;}; -in - myPythonApp diff --git a/examples/cryptohack-ecboracle.py b/examples/cryptohack-ecboracle.py deleted file mode 100644 index 86c69c3..0000000 --- a/examples/cryptohack-ecboracle.py +++ /dev/null @@ -1,46 +0,0 @@ -import requests - -from celeste.constants import PRINTABLE -from celeste.attacks import paddingoracle - -from Crypto.Util.Padding import pad - -import string - -NIBBLESET = [n.to_bytes() for n in range(256)] - -HOST = 'https://aes.cryptohack.org' -ENDPOINT = '/ecb_oracle/encrypt/{0}/' -URI = HOST + ENDPOINT - -CHARSET = [c.encode() for c in string.printable] -# CHARSET = NIBBLESET # OVERRIDE - -FLAG_LEN = 26 # flag length, calculated by hand -SPACER = b'\x0f' # arbitrary spacing character - -BLOCK_BYTES = 16 -BLOCK_NIBBLES = 32 # measured in nibbles - - -def mkreq(hextext: str) -> dict[str, str]: - resp = requests.get(URI.format(hextext)) - if resp.status_code != 200: - raise Exception(f'[!] resp failed! {resp} : {resp.text}') - return resp.json() - -def encrypt(b: bytes) -> bytes: - resp = mkreq(b.hex()) - return bytes.fromhex(resp['ciphertext']) - -def main() -> None: - paddingoracle.crack(encrypt, pad, CHARSET, 16, batch_size=20, debug=True) - - - -if __name__ == '__main__': - try: - main() - except (KeyboardInterrupt, EOFError): - print('\n[!] Interrupt') - diff --git a/examples/local-ecboracle.py b/examples/local-ecboracle.py deleted file mode 100644 index d3aeda7..0000000 --- a/examples/local-ecboracle.py +++ /dev/null @@ -1,28 +0,0 @@ -import string - -from celeste.attacks import paddingoracle - -from Crypto.Cipher import AES -from Crypto.Util.Padding import pad - -CHARSET = [c.encode() for c in string.printable] - -KEY = b'you wont get me!' -FLAG = b'imbaud{omg_you_catched_me}' -CIPHER = AES.new(KEY, AES.MODE_ECB) - -def encrypt(b: bytes, debug=False) -> bytes: - padded = pad(b + FLAG, 16) - if debug: - print(padded) - # print(padded) - return CIPHER.encrypt(padded) - -def main() -> None: - paddingoracle.crack(encrypt, pad, CHARSET, 16, batch_size=50, debug=True) - -if __name__ == '__main__': - try: - main() - except (KeyboardInterrupt, EOFError): - print('\n[!] Interrupt') diff --git a/celeste/__init__.py b/imp/__init__.py similarity index 100% rename from celeste/__init__.py rename to imp/__init__.py diff --git a/celeste/constants.py b/imp/constants.py similarity index 94% rename from celeste/constants.py rename to imp/constants.py index 729ebfb..73d70aa 100644 --- a/celeste/constants.py +++ b/imp/constants.py @@ -9,7 +9,6 @@ ALPHA_UPPER = 'ABCDEFGHIJKLMNOPQRSTUVWXYZ' ALPHA = ALPHA_LOWER + ALPHA_UPPER ALPHANUM = ALPHA + DIGITS SYMBOLS = '!\"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~' -PRINTABLE = ALPHANUM + SYMBOLS # Other DIGITS_BIN = '01' DIGITS_OCT = '01234567' diff --git a/celeste/attacks/__init__.py b/imp/crypto/__init__.py similarity index 100% rename from celeste/attacks/__init__.py rename to imp/crypto/__init__.py diff --git a/celeste/crypto/cyphers.py b/imp/crypto/cyphers.py similarity index 98% rename from celeste/crypto/cyphers.py rename to imp/crypto/cyphers.py index 2d0b504..b6896eb 100644 --- a/celeste/crypto/cyphers.py +++ b/imp/crypto/cyphers.py @@ -12,7 +12,7 @@ Terminology: substitutions to the entire message (ie vigenere) ''' -from celeste.constants import ALPHA_LOWER, ALPHA_UPPER +from imp.constants import ALPHA_LOWER, ALPHA_UPPER ''' Constant Declarations diff --git a/celeste/crypto/__init__.py b/imp/extern/__init__.py similarity index 100% rename from celeste/crypto/__init__.py rename to imp/extern/__init__.py diff --git a/celeste/extern/primefac.py b/imp/extern/primefac.py similarity index 100% rename from celeste/extern/primefac.py rename to imp/extern/primefac.py diff --git a/celeste/extern/__init__.py b/imp/math/__init__.py similarity index 100% rename from celeste/extern/__init__.py rename to imp/math/__init__.py diff --git a/celeste/math/groups.py b/imp/math/groups.py similarity index 100% rename from celeste/math/groups.py rename to imp/math/groups.py diff --git a/celeste/math/numbers/__init__.py b/imp/math/numbers/__init__.py similarity index 98% rename from celeste/math/numbers/__init__.py rename to imp/math/numbers/__init__.py index 83a0705..22a0d21 100644 --- a/celeste/math/numbers/__init__.py +++ b/imp/math/numbers/__init__.py @@ -6,7 +6,7 @@ Terminology: the "prime proper divisors of n". ''' -from celeste.extern.primefac import primefac +from imp.extern.primefac import primefac def factors(n: int) -> int: pfactors: list[tuple[int, int]] = [] diff --git a/celeste/math/numbers/functions.py b/imp/math/numbers/functions.py similarity index 100% rename from celeste/math/numbers/functions.py rename to imp/math/numbers/functions.py diff --git a/celeste/math/numbers/kinds.py b/imp/math/numbers/kinds.py similarity index 100% rename from celeste/math/numbers/kinds.py rename to imp/math/numbers/kinds.py diff --git a/celeste/math/primes.py b/imp/math/primes.py similarity index 93% rename from celeste/math/primes.py rename to imp/math/primes.py index d657367..b130a0c 100644 --- a/celeste/math/primes.py +++ b/imp/math/primes.py @@ -1,7 +1,7 @@ from math import gcd, inf -from celeste.math.numbers import bigomega, factors -from celeste.extern.primefac import ( +from imp.math.numbers import bigomega, factors +from imp.extern.primefac import ( isprime, primegen as Primes, ) diff --git a/imp/math/util.py b/imp/math/util.py new file mode 100644 index 0000000..4dacda2 --- /dev/null +++ b/imp/math/util.py @@ -0,0 +1,9 @@ +from collections.abc import Iterable +from itertools import chain, combinations + +def digits(n: int) -> int: + return len(str(n)) + +def powerset(iterable: Iterable) -> Iterable: + s = list(iterable) + return chain.from_iterable(combinations(s, r) for r in range(len(s)+1)) diff --git a/celeste/structs/__init__.py b/imp/structs/__init__.py similarity index 100% rename from celeste/structs/__init__.py rename to imp/structs/__init__.py diff --git a/celeste/structs/__result.py b/imp/structs/__result.py similarity index 100% rename from celeste/structs/__result.py rename to imp/structs/__result.py diff --git a/poetry.lock b/poetry.lock deleted file mode 100644 index 6588134..0000000 --- a/poetry.lock +++ /dev/null @@ -1,220 +0,0 @@ -# This file is automatically @generated by Poetry 1.8.4 and should not be changed by hand. - -[[package]] -name = "certifi" -version = "2025.6.15" -description = "Python package for providing Mozilla's CA Bundle." -optional = false -python-versions = ">=3.7" -files = [ - {file = "certifi-2025.6.15-py3-none-any.whl", hash = "sha256:2e0c7ce7cb5d8f8634ca55d2ba7e6ec2689a2fd6537d8dec1296a477a4910057"}, - {file = "certifi-2025.6.15.tar.gz", hash = "sha256:d747aa5a8b9bbbb1bb8c22bb13e22bd1f18e9796defa16bab421f7f7a317323b"}, -] - -[[package]] -name = "charset-normalizer" -version = "3.4.2" -description = "The Real First Universal Charset Detector. Open, modern and actively maintained alternative to Chardet." -optional = false -python-versions = ">=3.7" -files = [ - {file = "charset_normalizer-3.4.2-cp310-cp310-macosx_10_9_universal2.whl", hash = "sha256:7c48ed483eb946e6c04ccbe02c6b4d1d48e51944b6db70f697e089c193404941"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:b2d318c11350e10662026ad0eb71bb51c7812fc8590825304ae0bdd4ac283acd"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:9cbfacf36cb0ec2897ce0ebc5d08ca44213af24265bd56eca54bee7923c48fd6"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:18dd2e350387c87dabe711b86f83c9c78af772c748904d372ade190b5c7c9d4d"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8075c35cd58273fee266c58c0c9b670947c19df5fb98e7b66710e04ad4e9ff86"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:5bf4545e3b962767e5c06fe1738f951f77d27967cb2caa64c28be7c4563e162c"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:7a6ab32f7210554a96cd9e33abe3ddd86732beeafc7a28e9955cdf22ffadbab0"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:b33de11b92e9f75a2b545d6e9b6f37e398d86c3e9e9653c4864eb7e89c5773ef"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_ppc64le.whl", hash = "sha256:8755483f3c00d6c9a77f490c17e6ab0c8729e39e6390328e42521ef175380ae6"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_s390x.whl", hash = "sha256:68a328e5f55ec37c57f19ebb1fdc56a248db2e3e9ad769919a58672958e8f366"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:21b2899062867b0e1fde9b724f8aecb1af14f2778d69aacd1a5a1853a597a5db"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-win32.whl", hash = "sha256:e8082b26888e2f8b36a042a58307d5b917ef2b1cacab921ad3323ef91901c71a"}, - {file = "charset_normalizer-3.4.2-cp310-cp310-win_amd64.whl", hash = "sha256:f69a27e45c43520f5487f27627059b64aaf160415589230992cec34c5e18a509"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-macosx_10_9_universal2.whl", hash = "sha256:be1e352acbe3c78727a16a455126d9ff83ea2dfdcbc83148d2982305a04714c2"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:aa88ca0b1932e93f2d961bf3addbb2db902198dca337d88c89e1559e066e7645"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d524ba3f1581b35c03cb42beebab4a13e6cdad7b36246bd22541fa585a56cccd"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:28a1005facc94196e1fb3e82a3d442a9d9110b8434fc1ded7a24a2983c9888d8"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fdb20a30fe1175ecabed17cbf7812f7b804b8a315a25f24678bcdf120a90077f"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0f5d9ed7f254402c9e7d35d2f5972c9bbea9040e99cd2861bd77dc68263277c7"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:efd387a49825780ff861998cd959767800d54f8308936b21025326de4b5a42b9"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:f0aa37f3c979cf2546b73e8222bbfa3dc07a641585340179d768068e3455e544"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_ppc64le.whl", hash = "sha256:e70e990b2137b29dc5564715de1e12701815dacc1d056308e2b17e9095372a82"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_s390x.whl", hash = "sha256:0c8c57f84ccfc871a48a47321cfa49ae1df56cd1d965a09abe84066f6853b9c0"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:6b66f92b17849b85cad91259efc341dce9c1af48e2173bf38a85c6329f1033e5"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-win32.whl", hash = "sha256:daac4765328a919a805fa5e2720f3e94767abd632ae410a9062dff5412bae65a"}, - {file = "charset_normalizer-3.4.2-cp311-cp311-win_amd64.whl", hash = "sha256:e53efc7c7cee4c1e70661e2e112ca46a575f90ed9ae3fef200f2a25e954f4b28"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-macosx_10_13_universal2.whl", hash = "sha256:0c29de6a1a95f24b9a1aa7aefd27d2487263f00dfd55a77719b530788f75cff7"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:cddf7bd982eaa998934a91f69d182aec997c6c468898efe6679af88283b498d3"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:fcbe676a55d7445b22c10967bceaaf0ee69407fbe0ece4d032b6eb8d4565982a"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:d41c4d287cfc69060fa91cae9683eacffad989f1a10811995fa309df656ec214"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:4e594135de17ab3866138f496755f302b72157d115086d100c3f19370839dd3a"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:cf713fe9a71ef6fd5adf7a79670135081cd4431c2943864757f0fa3a65b1fafd"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:a370b3e078e418187da8c3674eddb9d983ec09445c99a3a263c2011993522981"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:a955b438e62efdf7e0b7b52a64dc5c3396e2634baa62471768a64bc2adb73d5c"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_ppc64le.whl", hash = "sha256:7222ffd5e4de8e57e03ce2cef95a4c43c98fcb72ad86909abdfc2c17d227fc1b"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_s390x.whl", hash = "sha256:bee093bf902e1d8fc0ac143c88902c3dfc8941f7ea1d6a8dd2bcb786d33db03d"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:dedb8adb91d11846ee08bec4c8236c8549ac721c245678282dcb06b221aab59f"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-win32.whl", hash = "sha256:db4c7bf0e07fc3b7d89ac2a5880a6a8062056801b83ff56d8464b70f65482b6c"}, - {file = "charset_normalizer-3.4.2-cp312-cp312-win_amd64.whl", hash = "sha256:5a9979887252a82fefd3d3ed2a8e3b937a7a809f65dcb1e068b090e165bbe99e"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-macosx_10_13_universal2.whl", hash = "sha256:926ca93accd5d36ccdabd803392ddc3e03e6d4cd1cf17deff3b989ab8e9dbcf0"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:eba9904b0f38a143592d9fc0e19e2df0fa2e41c3c3745554761c5f6447eedabf"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3fddb7e2c84ac87ac3a947cb4e66d143ca5863ef48e4a5ecb83bd48619e4634e"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98f862da73774290f251b9df8d11161b6cf25b599a66baf087c1ffe340e9bfd1"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6c9379d65defcab82d07b2a9dfbfc2e95bc8fe0ebb1b176a3190230a3ef0e07c"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e635b87f01ebc977342e2697d05b56632f5f879a4f15955dfe8cef2448b51691"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:1c95a1e2902a8b722868587c0e1184ad5c55631de5afc0eb96bc4b0d738092c0"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:ef8de666d6179b009dce7bcb2ad4c4a779f113f12caf8dc77f0162c29d20490b"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_ppc64le.whl", hash = "sha256:32fc0341d72e0f73f80acb0a2c94216bd704f4f0bce10aedea38f30502b271ff"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_s390x.whl", hash = "sha256:289200a18fa698949d2b39c671c2cc7a24d44096784e76614899a7ccf2574b7b"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:4a476b06fbcf359ad25d34a057b7219281286ae2477cc5ff5e3f70a246971148"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-win32.whl", hash = "sha256:aaeeb6a479c7667fbe1099af9617c83aaca22182d6cf8c53966491a0f1b7ffb7"}, - {file = "charset_normalizer-3.4.2-cp313-cp313-win_amd64.whl", hash = "sha256:aa6af9e7d59f9c12b33ae4e9450619cf2488e2bbe9b44030905877f0b2324980"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1cad5f45b3146325bb38d6855642f6fd609c3f7cad4dbaf75549bf3b904d3184"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:b2680962a4848b3c4f155dc2ee64505a9c57186d0d56b43123b17ca3de18f0fa"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:36b31da18b8890a76ec181c3cf44326bf2c48e36d393ca1b72b3f484113ea344"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f4074c5a429281bf056ddd4c5d3b740ebca4d43ffffe2ef4bf4d2d05114299da"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c9e36a97bee9b86ef9a1cf7bb96747eb7a15c2f22bdb5b516434b00f2a599f02"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_aarch64.whl", hash = "sha256:1b1bde144d98e446b056ef98e59c256e9294f6b74d7af6846bf5ffdafd687a7d"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_i686.whl", hash = "sha256:915f3849a011c1f593ab99092f3cecfcb4d65d8feb4a64cf1bf2d22074dc0ec4"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_ppc64le.whl", hash = "sha256:fb707f3e15060adf5b7ada797624a6c6e0138e2a26baa089df64c68ee98e040f"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_s390x.whl", hash = "sha256:25a23ea5c7edc53e0f29bae2c44fcb5a1aa10591aae107f2a2b2583a9c5cbc64"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-musllinux_1_2_x86_64.whl", hash = "sha256:770cab594ecf99ae64c236bc9ee3439c3f46be49796e265ce0cc8bc17b10294f"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-win32.whl", hash = "sha256:6a0289e4589e8bdfef02a80478f1dfcb14f0ab696b5a00e1f4b8a14a307a3c58"}, - {file = "charset_normalizer-3.4.2-cp37-cp37m-win_amd64.whl", hash = "sha256:6fc1f5b51fa4cecaa18f2bd7a003f3dd039dd615cd69a2afd6d3b19aed6775f2"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-macosx_10_9_universal2.whl", hash = "sha256:76af085e67e56c8816c3ccf256ebd136def2ed9654525348cfa744b6802b69eb"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e45ba65510e2647721e35323d6ef54c7974959f6081b58d4ef5d87c60c84919a"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:046595208aae0120559a67693ecc65dd75d46f7bf687f159127046628178dc45"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:75d10d37a47afee94919c4fab4c22b9bc2a8bf7d4f46f87363bcf0573f3ff4f5"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6333b3aa5a12c26b2a4d4e7335a28f1475e0e5e17d69d55141ee3cab736f66d1"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e8323a9b031aa0393768b87f04b4164a40037fb2a3c11ac06a03ffecd3618027"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:24498ba8ed6c2e0b56d4acbf83f2d989720a93b41d712ebd4f4979660db4417b"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:844da2b5728b5ce0e32d863af26f32b5ce61bc4273a9c720a9f3aa9df73b1455"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_ppc64le.whl", hash = "sha256:65c981bdbd3f57670af8b59777cbfae75364b483fa8a9f420f08094531d54a01"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_s390x.whl", hash = "sha256:3c21d4fca343c805a52c0c78edc01e3477f6dd1ad7c47653241cf2a206d4fc58"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:dc7039885fa1baf9be153a0626e337aa7ec8bf96b0128605fb0d77788ddc1681"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-win32.whl", hash = "sha256:8272b73e1c5603666618805fe821edba66892e2870058c94c53147602eab29c7"}, - {file = "charset_normalizer-3.4.2-cp38-cp38-win_amd64.whl", hash = "sha256:70f7172939fdf8790425ba31915bfbe8335030f05b9913d7ae00a87d4395620a"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-macosx_10_9_universal2.whl", hash = "sha256:005fa3432484527f9732ebd315da8da8001593e2cf46a3d817669f062c3d9ed4"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e92fca20c46e9f5e1bb485887d074918b13543b1c2a1185e69bb8d17ab6236a7"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:50bf98d5e563b83cc29471fa114366e6806bc06bc7a25fd59641e41445327836"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:721c76e84fe669be19c5791da68232ca2e05ba5185575086e384352e2c309597"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:82d8fd25b7f4675d0c47cf95b594d4e7b158aca33b76aa63d07186e13c0e0ab7"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b3daeac64d5b371dea99714f08ffc2c208522ec6b06fbc7866a450dd446f5c0f"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:dccab8d5fa1ef9bfba0590ecf4d46df048d18ffe3eec01eeb73a42e0d9e7a8ba"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:aaf27faa992bfee0264dc1f03f4c75e9fcdda66a519db6b957a3f826e285cf12"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_ppc64le.whl", hash = "sha256:eb30abc20df9ab0814b5a2524f23d75dcf83cde762c161917a2b4b7b55b1e518"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_s390x.whl", hash = "sha256:c72fbbe68c6f32f251bdc08b8611c7b3060612236e960ef848e0a517ddbe76c5"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:982bb1e8b4ffda883b3d0a521e23abcd6fd17418f6d2c4118d257a10199c0ce3"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-win32.whl", hash = "sha256:43e0933a0eff183ee85833f341ec567c0980dae57c464d8a508e1b2ceb336471"}, - {file = "charset_normalizer-3.4.2-cp39-cp39-win_amd64.whl", hash = "sha256:d11b54acf878eef558599658b0ffca78138c8c3655cf4f3a4a673c437e67732e"}, - {file = "charset_normalizer-3.4.2-py3-none-any.whl", hash = "sha256:7f56930ab0abd1c45cd15be65cc741c28b1c9a34876ce8c17a2fa107810c0af0"}, - {file = "charset_normalizer-3.4.2.tar.gz", hash = "sha256:5baececa9ecba31eff645232d59845c07aa030f0c81ee70184a90d35099a0e63"}, -] - -[[package]] -name = "idna" -version = "3.10" -description = "Internationalized Domain Names in Applications (IDNA)" -optional = false -python-versions = ">=3.6" -files = [ - {file = "idna-3.10-py3-none-any.whl", hash = "sha256:946d195a0d259cbba61165e88e65941f16e9b36ea6ddb97f00452bae8b1287d3"}, - {file = "idna-3.10.tar.gz", hash = "sha256:12f65c9b470abda6dc35cf8e63cc574b1c52b11df2c86030af0ac09b01b13ea9"}, -] - -[package.extras] -all = ["flake8 (>=7.1.1)", "mypy (>=1.11.2)", "pytest (>=8.3.2)", "ruff (>=0.6.2)"] - -[[package]] -name = "pycryptodome" -version = "3.23.0" -description = "Cryptographic library for Python" -optional = false -python-versions = "!=3.0.*,!=3.1.*,!=3.2.*,!=3.3.*,!=3.4.*,!=3.5.*,!=3.6.*,>=2.7" -files = [ - {file = "pycryptodome-3.23.0-cp27-cp27m-macosx_10_9_x86_64.whl", hash = "sha256:a176b79c49af27d7f6c12e4b178b0824626f40a7b9fed08f712291b6d54bf566"}, - {file = "pycryptodome-3.23.0-cp27-cp27m-manylinux2010_i686.whl", hash = "sha256:573a0b3017e06f2cffd27d92ef22e46aa3be87a2d317a5abf7cc0e84e321bd75"}, - {file = "pycryptodome-3.23.0-cp27-cp27m-manylinux2010_x86_64.whl", hash = "sha256:63dad881b99ca653302b2c7191998dd677226222a3f2ea79999aa51ce695f720"}, - {file = "pycryptodome-3.23.0-cp27-cp27m-win32.whl", hash = "sha256:b34e8e11d97889df57166eda1e1ddd7676da5fcd4d71a0062a760e75060514b4"}, - {file = "pycryptodome-3.23.0-cp27-cp27mu-manylinux2010_i686.whl", hash = "sha256:7ac1080a8da569bde76c0a104589c4f414b8ba296c0b3738cf39a466a9fb1818"}, - {file = "pycryptodome-3.23.0-cp27-cp27mu-manylinux2010_x86_64.whl", hash = "sha256:6fe8258e2039eceb74dfec66b3672552b6b7d2c235b2dfecc05d16b8921649a8"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_universal2.whl", hash = "sha256:0011f7f00cdb74879142011f95133274741778abba114ceca229adbf8e62c3e4"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:90460fc9e088ce095f9ee8356722d4f10f86e5be06e2354230a9880b9c549aae"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4764e64b269fc83b00f682c47443c2e6e85b18273712b98aa43bcb77f8570477"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:eb8f24adb74984aa0e5d07a2368ad95276cf38051fe2dc6605cbcf482e04f2a7"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d97618c9c6684a97ef7637ba43bdf6663a2e2e77efe0f863cce97a76af396446"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:9a53a4fe5cb075075d515797d6ce2f56772ea7e6a1e5e4b96cf78a14bac3d265"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:763d1d74f56f031788e5d307029caef067febf890cd1f8bf61183ae142f1a77b"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:954af0e2bd7cea83ce72243b14e4fb518b18f0c1649b576d114973e2073b273d"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-win32.whl", hash = "sha256:257bb3572c63ad8ba40b89f6fc9d63a2a628e9f9708d31ee26560925ebe0210a"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-win_amd64.whl", hash = "sha256:6501790c5b62a29fcb227bd6b62012181d886a767ce9ed03b303d1f22eb5c625"}, - {file = "pycryptodome-3.23.0-cp313-cp313t-win_arm64.whl", hash = "sha256:9a77627a330ab23ca43b48b130e202582e91cc69619947840ea4d2d1be21eb39"}, - {file = "pycryptodome-3.23.0-cp37-abi3-macosx_10_9_universal2.whl", hash = "sha256:187058ab80b3281b1de11c2e6842a357a1f71b42cb1e15bce373f3d238135c27"}, - {file = "pycryptodome-3.23.0-cp37-abi3-macosx_10_9_x86_64.whl", hash = "sha256:cfb5cd445280c5b0a4e6187a7ce8de5a07b5f3f897f235caa11f1f435f182843"}, - {file = "pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:67bd81fcbe34f43ad9422ee8fd4843c8e7198dd88dd3d40e6de42ee65fbe1490"}, - {file = "pycryptodome-3.23.0-cp37-abi3-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c8987bd3307a39bc03df5c8e0e3d8be0c4c3518b7f044b0f4c15d1aa78f52575"}, - {file = "pycryptodome-3.23.0-cp37-abi3-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:aa0698f65e5b570426fc31b8162ed4603b0c2841cbb9088e2b01641e3065915b"}, - {file = "pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_aarch64.whl", hash = "sha256:53ecbafc2b55353edcebd64bf5da94a2a2cdf5090a6915bcca6eca6cc452585a"}, - {file = "pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_i686.whl", hash = "sha256:156df9667ad9f2ad26255926524e1c136d6664b741547deb0a86a9acf5ea631f"}, - {file = "pycryptodome-3.23.0-cp37-abi3-musllinux_1_2_x86_64.whl", hash = "sha256:dea827b4d55ee390dc89b2afe5927d4308a8b538ae91d9c6f7a5090f397af1aa"}, - {file = "pycryptodome-3.23.0-cp37-abi3-win32.whl", hash = "sha256:507dbead45474b62b2bbe318eb1c4c8ee641077532067fec9c1aa82c31f84886"}, - {file = "pycryptodome-3.23.0-cp37-abi3-win_amd64.whl", hash = "sha256:c75b52aacc6c0c260f204cbdd834f76edc9fb0d8e0da9fbf8352ef58202564e2"}, - {file = "pycryptodome-3.23.0-cp37-abi3-win_arm64.whl", hash = "sha256:11eeeb6917903876f134b56ba11abe95c0b0fd5e3330def218083c7d98bbcb3c"}, - {file = "pycryptodome-3.23.0-pp27-pypy_73-manylinux2010_x86_64.whl", hash = "sha256:350ebc1eba1da729b35ab7627a833a1a355ee4e852d8ba0447fafe7b14504d56"}, - {file = "pycryptodome-3.23.0-pp27-pypy_73-win32.whl", hash = "sha256:93837e379a3e5fd2bb00302a47aee9fdf7940d83595be3915752c74033d17ca7"}, - {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:ddb95b49df036ddd264a0ad246d1be5b672000f12d6961ea2c267083a5e19379"}, - {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d8e95564beb8782abfd9e431c974e14563a794a4944c29d6d3b7b5ea042110b4"}, - {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:14e15c081e912c4b0d75632acd8382dfce45b258667aa3c67caf7a4d4c13f630"}, - {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a7fc76bf273353dc7e5207d172b83f569540fc9a28d63171061c42e361d22353"}, - {file = "pycryptodome-3.23.0-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:45c69ad715ca1a94f778215a11e66b7ff989d792a4d63b68dc586a1da1392ff5"}, - {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-macosx_10_15_x86_64.whl", hash = "sha256:865d83c906b0fc6a59b510deceee656b6bc1c4fa0d82176e2b77e97a420a996a"}, - {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:89d4d56153efc4d81defe8b65fd0821ef8b2d5ddf8ed19df31ba2f00872b8002"}, - {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e3f2d0aaf8080bda0587d58fc9fe4766e012441e2eed4269a77de6aea981c8be"}, - {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:64093fc334c1eccfd3933c134c4457c34eaca235eeae49d69449dc4728079339"}, - {file = "pycryptodome-3.23.0-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:ce64e84a962b63a47a592690bdc16a7eaf709d2c2697ababf24a0def566899a6"}, - {file = "pycryptodome-3.23.0.tar.gz", hash = "sha256:447700a657182d60338bab09fdb27518f8856aecd80ae4c6bdddb67ff5da44ef"}, -] - -[[package]] -name = "requests" -version = "2.32.4" -description = "Python HTTP for Humans." -optional = false -python-versions = ">=3.8" -files = [ - {file = "requests-2.32.4-py3-none-any.whl", hash = "sha256:27babd3cda2a6d50b30443204ee89830707d396671944c998b5975b031ac2b2c"}, - {file = "requests-2.32.4.tar.gz", hash = "sha256:27d0316682c8a29834d3264820024b62a36942083d52caf2f14c0591336d3422"}, -] - -[package.dependencies] -certifi = ">=2017.4.17" -charset_normalizer = ">=2,<4" -idna = ">=2.5,<4" -urllib3 = ">=1.21.1,<3" - -[package.extras] -socks = ["PySocks (>=1.5.6,!=1.5.7)"] -use-chardet-on-py3 = ["chardet (>=3.0.2,<6)"] - -[[package]] -name = "urllib3" -version = "2.5.0" -description = "HTTP library with thread-safe connection pooling, file post, and more." -optional = false -python-versions = ">=3.9" -files = [ - {file = "urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc"}, - {file = "urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760"}, -] - -[package.extras] -brotli = ["brotli (>=1.0.9)", "brotlicffi (>=0.8.0)"] -h2 = ["h2 (>=4,<5)"] -socks = ["pysocks (>=1.5.6,!=1.5.7,<2.0)"] -zstd = ["zstandard (>=0.18.0)"] - -[metadata] -lock-version = "2.0" -python-versions = "^3.12" -content-hash = "859d413e44bf90cb7b04f63effef25027c68025a706462c668c1ef0d3cb3cb1f" diff --git a/primegen.nim b/primegen.nim deleted file mode 100644 index 748f1a4..0000000 --- a/primegen.nim +++ /dev/null @@ -1,10 +0,0 @@ -iterator primegen(limit: int = high(BiggestInt)): int: - """ - Generates primes < limit almost lazily by a segmented sieve of Eratosthenes. - Examples: - >>> primegen().take(20) - [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71] - >>> primegen(73).toSeq() - [2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71] - """ - diff --git a/pyproject.toml b/pyproject.toml deleted file mode 100644 index fac77e1..0000000 --- a/pyproject.toml +++ /dev/null @@ -1,15 +0,0 @@ -[tool.poetry] -name = "Celeste" -version = "0.1.0" -description = "" -authors = ["Emile Clark-Boman "] -readme = "README.md" - -[tool.poetry.dependencies] -python = "^3.12" -requests = "^2.32.4" - - -[build-system] -requires = ["poetry-core"] -build-backend = "poetry.core.masonry.api" diff --git a/research/aparith/README b/research/aparith/README deleted file mode 100644 index eca4c93..0000000 --- a/research/aparith/README +++ /dev/null @@ -1,12 +0,0 @@ -Comparing the speeds of various Nim libraries for -arbitrary precision integers. - -Test Targets: -https://github.com/status-im/nim-stint -https://github.com/nim-lang/bigints -https://github.com/michaeljclark/bignum -https://github.com/FedeOmoto/bignum -https://github.com/fsh/integers - -Test algorithms: -https://en.wikipedia.org/wiki/Pollard%27s_rho_algorithm#Algorithm diff --git a/research/aparith/aparith b/research/aparith/aparith deleted file mode 100755 index c74e32c..0000000 Binary files a/research/aparith/aparith and /dev/null differ diff --git a/research/aparith/aparith.nimble b/research/aparith/aparith.nimble deleted file mode 100644 index 8581321..0000000 --- a/research/aparith/aparith.nimble +++ /dev/null @@ -1,14 +0,0 @@ -# Package - -version = "1.0.0" -author = "Emile Clark-Boman" -description = "Arbitrary Precision Integer Test - BigInts" -license = "MIT" -srcDir = "src" -bin = @["aparith", "speedtest_bigint"] - - -# Dependencies - -requires "nim >= 2.2.0" -requires "bigints >= 1.0.0" diff --git a/research/aparith/src/aparith.nim b/research/aparith/src/aparith.nim deleted file mode 100644 index 862d40c..0000000 --- a/research/aparith/src/aparith.nim +++ /dev/null @@ -1,5 +0,0 @@ -# This is just an example to get you started. A typical binary package -# uses this file as the main entry point of the application. - -when isMainModule: - echo("Hello, World!") diff --git a/research/aparith/src/bigints.git.nim b/research/aparith/src/bigints.git.nim deleted file mode 100644 index b00d466..0000000 --- a/research/aparith/src/bigints.git.nim +++ /dev/null @@ -1,1311 +0,0 @@ -## Arbitrary precision integers. -## -## The bitwise operations behave as if negative numbers were represented in 2's complement. - -import std/[algorithm, bitops, math, options] - -type - BigInt* = object - ## An arbitrary precision integer. - # Invariants for `a: BigInt`: - # * if `a` is non-zero: `a.limbs[a.limbs.high] != 0` - # * if `a` is zero: `a.limbs.len <= 1` - limbs: seq[uint32] - isNegative: bool - - -# forward declarations -func succ*(a: BigInt, b: int = 1): BigInt -func inc*(a: var BigInt, b: int = 1) -func dec*(a: var BigInt, b: int = 1) - - -func normalize(a: var BigInt) = - for i in countdown(a.limbs.high, 0): - if a.limbs[i] > 0'u32: - a.limbs.setLen(i+1) - return - a.limbs.setLen(1) - -func initBigInt*(vals: sink seq[uint32], isNegative = false): BigInt = - ## Initializes a `BigInt` from a sequence of `uint32` values. - runnableExamples: - let a = @[10'u32, 2'u32].initBigInt - let b = 10 + 2 shl 32 - assert $a == $b - result.limbs = vals - result.isNegative = isNegative - normalize(result) - -func initBigInt*[T: int8|int16|int32](val: T): BigInt = - if val < 0: - result.limbs = @[(not val).uint32 + 1] # manual 2's complement (to avoid overflow) - result.isNegative = true - else: - result.limbs = @[val.uint32] - result.isNegative = false - -func initBigInt*[T: uint8|uint16|uint32](val: T): BigInt = - result.limbs = @[val.uint32] - -func initBigInt*(val: int64): BigInt = - var a = val.uint64 - if val < 0: - a = not a + 1 # 2's complement - result.isNegative = true - if a > uint32.high: - result.limbs = @[(a and uint32.high).uint32, (a shr 32).uint32] - else: - result.limbs = @[a.uint32] - -func initBigInt*(val: uint64): BigInt = - if val > uint32.high: - result.limbs = @[(val and uint32.high).uint32, (val shr 32).uint32] - else: - result.limbs = @[val.uint32] - -when sizeof(int) == 4: - template initBigInt*(val: int): BigInt = initBigInt(val.int32) - template initBigInt*(val: uint): BigInt = initBigInt(val.uint32) -else: - template initBigInt*(val: int): BigInt = initBigInt(val.int64) - template initBigInt*(val: uint): BigInt = initBigInt(val.uint64) - -func initBigInt*(val: BigInt): BigInt = - result = val - -const - zero = initBigInt(0) - one = initBigInt(1) - -func isZero(a: BigInt): bool {.inline.} = - a.limbs.len == 0 or (a.limbs.len == 1 and a.limbs[0] == 0) - -func abs*(a: BigInt): BigInt = - # Returns the absolute value of `a`. - runnableExamples: - assert abs(42.initBigInt) == 42.initBigInt - assert abs(-12.initBigInt) == 12.initBigInt - result = a - result.isNegative = false - -func unsignedCmp(a: BigInt, b: uint32): int64 = - # ignores the sign of `a` - # `a` and `b` are assumed to not be zero - result = int64(a.limbs.len) - 1 - if result != 0: return - result = int64(a.limbs[0]) - int64(b) - -func unsignedCmp(a: uint32, b: BigInt): int64 = -unsignedCmp(b, a) - -func unsignedCmp(a, b: BigInt): int64 = - # ignores the signs of `a` and `b` - # `a` and `b` are assumed to not be zero - result = int64(a.limbs.len) - int64(b.limbs.len) - if result != 0: return - for i in countdown(a.limbs.high, 0): - result = int64(a.limbs[i]) - int64(b.limbs[i]) - if result != 0: - return - -func cmp(a, b: BigInt): int64 = - ## Returns: - ## * a value less than zero, if `a < b` - ## * a value greater than zero, if `a > b` - ## * zero, if `a == b` - if a.isZero: - if b.isZero: - return 0 - elif b.isNegative: - return 1 - else: - return -1 - elif a.isNegative: - if b.isZero or not b.isNegative: - return -1 - else: - return unsignedCmp(b, a) - else: # a > 0 - if b.isZero or b.isNegative: - return 1 - else: - return unsignedCmp(a, b) - -func cmp(a: BigInt, b: int32): int64 = - ## Returns: - ## * a value less than zero, if `a < b` - ## * a value greater than zero, if `a > b` - ## * zero, if `a == b` - if a.isZero: - return -b.int64 - elif a.isNegative: - if b < 0: - return unsignedCmp((not b).uint32 + 1, a) - else: - return -1 - else: # a > 0 - if b <= 0: - return 1 - else: - return unsignedCmp(a, b.uint32) - -func cmp(a: int32, b: BigInt): int64 = -cmp(b, a) - -func `==`*(a, b: BigInt): bool = - ## Compares if two `BigInt` numbers are equal. - runnableExamples: - let - a = 5.initBigInt - b = 3.initBigInt - c = 2.initBigInt - assert a == b + c - assert b != c - cmp(a, b) == 0 - -func `<`*(a, b: BigInt): bool = - runnableExamples: - let - a = 5.initBigInt - b = 3.initBigInt - c = 2.initBigInt - assert b < a - assert b > c - cmp(a, b) < 0 - -func `<=`*(a, b: BigInt): bool = - runnableExamples: - let - a = 5.initBigInt - b = 3.initBigInt - c = 2.initBigInt - assert a <= b + c - assert c <= b - cmp(a, b) <= 0 - -func `==`(a: BigInt, b: int32): bool = cmp(a, b) == 0 -func `<`(a: BigInt, b: int32): bool = cmp(a, b) < 0 -func `<`(a: int32, b: BigInt): bool = cmp(a, b) < 0 - -template addParts(toAdd) = - tmp += toAdd - a.limbs[i] = uint32(tmp and uint32.high) - tmp = tmp shr 32 - -func unsignedAdditionInt(a: var BigInt, b: BigInt, c: uint32) = - let bl = b.limbs.len - a.limbs.setLen(bl) - - var tmp: uint64 = uint64(c) - for i in 0 ..< bl: - addParts(uint64(b.limbs[i])) - if tmp > 0'u64: - a.limbs.add(uint32(tmp)) - a.isNegative = false - -func unsignedAddition(a: var BigInt, b, c: BigInt) = - let - bl = b.limbs.len - cl = c.limbs.len - var m = min(bl, cl) - a.limbs.setLen(max(bl, cl)) - - var tmp = 0'u64 - for i in 0 ..< m: - addParts(uint64(b.limbs[i]) + uint64(c.limbs[i])) - if bl < cl: - for i in m ..< cl: - addParts(uint64(c.limbs[i])) - else: - for i in m ..< bl: - addParts(uint64(b.limbs[i])) - if tmp > 0'u64: - a.limbs.add(uint32(tmp)) - a.isNegative = false - -func negate(a: var BigInt) = - a.isNegative = not a.isNegative - -func `-`*(a: BigInt): BigInt = - ## Unary minus for `BigInt`. - runnableExamples: - let - a = 5.initBigInt - b = -10.initBigInt - assert (-a) == -5.initBigInt - assert (-b) == 10.initBigInt - result = a - negate(result) - -template realUnsignedSubtractionInt(a: var BigInt, b: BigInt, c: uint32) = - # b > c - let bl = b.limbs.len - a.limbs.setLen(bl) - - var tmp = int64(c) - for i in 0 ..< bl: - tmp = int64(uint32.high) + 1 + int64(b.limbs[i]) - tmp - a.limbs[i] = uint32(tmp and int64(uint32.high)) - tmp = 1 - (tmp shr 32) - a.isNegative = false - - normalize(a) - assert tmp == 0 - -template realUnsignedSubtraction(a: var BigInt, b, c: BigInt) = - # b > c - let - bl = b.limbs.len - cl = c.limbs.len - var m = min(bl, cl) - a.limbs.setLen(max(bl, cl)) - - var tmp = 0'i64 - for i in 0 ..< m: - tmp = int64(uint32.high) + 1 + int64(b.limbs[i]) - int64(c.limbs[i]) - tmp - a.limbs[i] = uint32(tmp and int64(uint32.high)) - tmp = 1 - (tmp shr 32) - if bl < cl: - for i in m ..< cl: - tmp = int64(uint32.high) + 1 - int64(c.limbs[i]) - tmp - a.limbs[i] = uint32(tmp and int64(uint32.high)) - tmp = 1 - (tmp shr 32) - a.isNegative = true - else: - for i in m ..< bl: - tmp = int64(uint32.high) + 1 + int64(b.limbs[i]) - tmp - a.limbs[i] = uint32(tmp and int64(uint32.high)) - tmp = 1 - (tmp shr 32) - a.isNegative = false - - normalize(a) - assert tmp == 0 - -func unsignedSubtractionInt(a: var BigInt, b: BigInt, c: uint32) = - # `b` is not zero - let cmpRes = unsignedCmp(b, c) - if cmpRes > 0: - realUnsignedSubtractionInt(a, b, c) - elif cmpRes < 0: - # `b` is only a single limb - a.limbs = @[c - b.limbs[0]] - a.isNegative = true - else: # b == c - a = zero - -func unsignedSubtraction(a: var BigInt, b, c: BigInt) = - let cmpRes = unsignedCmp(b, c) - if cmpRes > 0: - realUnsignedSubtraction(a, b, c) - elif cmpRes < 0: - realUnsignedSubtraction(a, c, b) - a.negate() - else: # b == c - a = zero - -func additionInt(a: var BigInt, b: BigInt, c: int32) = - # a = b + c - if b.isZero: - a = c.initBigInt - elif b.isNegative: - if c < 0: - unsignedAdditionInt(a, b, (not c).uint32 + 1) - else: - unsignedSubtractionInt(a, b, c.uint32) - a.negate() - else: - if c < 0: - unsignedSubtractionInt(a, b, (not c).uint32 + 1) - else: - unsignedAdditionInt(a, b, c.uint32) - -func addition(a: var BigInt, b, c: BigInt) = - # a = b + c - if b.isNegative: - if c.isNegative: - unsignedAddition(a, b, c) - a.isNegative = true - else: - unsignedSubtraction(a, c, b) - else: - if c.isNegative: - unsignedSubtraction(a, b, c) - else: - unsignedAddition(a, b, c) - -func `+`*(a, b: BigInt): BigInt = - ## Addition for `BigInt`s. - runnableExamples: - let - a = 5.initBigInt - b = 10.initBigInt - assert a + b == 15.initBigInt - assert (-a) + b == 5.initBigInt - assert a + (-b) == -5.initBigInt - addition(result, a, b) - -template `+=`*(a: var BigInt, b: BigInt) = - runnableExamples: - var a = 5.initBigInt - a += 2.initBigInt - assert a == 7.initBigInt - a = a + b - -func subtractionInt(a: var BigInt, b: BigInt, c: int32) = - # a = b - c - if b.isZero: - a = -c.initBigInt - elif b.isNegative: - if c < 0: - unsignedSubtractionInt(a, b, (not c).uint32 + 1) - else: - unsignedAdditionInt(a, b, c.uint32) - a.negate() - else: - if c < 0: - unsignedAdditionInt(a, b, (not c).uint32 + 1) - else: - unsignedSubtractionInt(a, b, c.uint32) - -func subtraction(a: var BigInt, b, c: BigInt) = - # a = b - c - if b.isNegative: - if c.isNegative: - unsignedSubtraction(a, c, b) - else: - unsignedAddition(a, b, c) - a.isNegative = true - else: - if c.isNegative: - unsignedAddition(a, b, c) - else: - unsignedSubtraction(a, b, c) - -func `-`*(a, b: BigInt): BigInt = - ## Subtraction for `BigInt`s. - runnableExamples: - let - a = 15.initBigInt - b = 10.initBigInt - assert a - b == 5.initBigInt - assert (-a) - b == -25.initBigInt - assert a - (-b) == 25.initBigInt - subtraction(result, a, b) - -template `-=`*(a: var BigInt, b: BigInt) = - runnableExamples: - var a = 5.initBigInt - a -= 2.initBigInt - assert a == 3.initBigInt - a = a - b - - -func unsignedMultiplication(a: var BigInt, b, c: BigInt) {.inline.} = - # always called with bl >= cl - let - bl = b.limbs.len - cl = c.limbs.len - a.limbs.setLen(bl + cl) - var tmp = 0'u64 - - for i in 0 ..< bl: - tmp += uint64(b.limbs[i]) * uint64(c.limbs[0]) - a.limbs[i] = uint32(tmp and uint32.high) - tmp = tmp shr 32 - - a.limbs[bl] = uint32(tmp) - - for j in 1 ..< cl: - tmp = 0'u64 - for i in 0 ..< bl: - tmp += uint64(a.limbs[j + i]) + uint64(b.limbs[i]) * uint64(c.limbs[j]) - a.limbs[j + i] = uint32(tmp and uint32.high) - tmp = tmp shr 32 - var pos = j + bl - while tmp > 0'u64: - tmp += uint64(a.limbs[pos]) - a.limbs[pos] = uint32(tmp and uint32.high) - tmp = tmp shr 32 - inc pos - normalize(a) - -func multiplication(a: var BigInt, b, c: BigInt) = - # a = b * c - if b.isZero or c.isZero: - a = zero - return - let - bl = b.limbs.len - cl = c.limbs.len - - if cl > bl: - unsignedMultiplication(a, c, b) - else: - unsignedMultiplication(a, b, c) - a.isNegative = b.isNegative xor c.isNegative - -func `*`*(a, b: BigInt): BigInt = - ## Multiplication for `BigInt`s. - runnableExamples: - let - a = 421.initBigInt - b = 200.initBigInt - assert a * b == 84200.initBigInt - multiplication(result, a, b) - -template `*=`*(a: var BigInt, b: BigInt) = - runnableExamples: - var a = 15.initBigInt - a *= 10.initBigInt - assert a == 150.initBigInt - a = a * b - -func pow*(x: BigInt, y: Natural): BigInt = - ## Computes `x` to the power of `y`. - var base = x - var exp = y - result = one - - # binary exponentiation - while exp > 0: - if (exp and 1) > 0: - result *= base - exp = exp shr 1 - base *= base - -func `shl`*(x: BigInt, y: Natural): BigInt = - ## Shifts a `BigInt` to the left. - runnableExamples: - let a = 24.initBigInt - assert a shl 1 == 48.initBigInt - assert a shl 2 == 96.initBigInt - - if x.isZero: - return x - - var carry = 0'u64 - let a = y div 32 - let b = uint32(y mod 32) - let mask = ((1'u64 shl b) - 1) shl (64 - b) - result.limbs.setLen(x.limbs.len + a) - result.isNegative = x.isNegative - - for i in countup(0, x.limbs.high): - let acc = (uint64(x.limbs[i]) shl 32) or carry - carry = (acc and mask) shr 32 - result.limbs[i + a] = uint32((acc shl b) shr 32) - - if carry > 0: - result.limbs.add(uint32(carry shr (32 - b))) - -func `shr`*(x: BigInt, y: Natural): BigInt = - ## Shifts a `BigInt` to the right (arithmetically). - runnableExamples: - let a = 24.initBigInt - assert a shr 1 == 12.initBigInt - assert a shr 2 == 6.initBigInt - - var carry = 0'u64 - let a = y div 32 - if a >= x.limbs.len: - return zero - let b = uint32(y mod 32) - let mask = (1'u32 shl b) - 1 - result.limbs.setLen(x.limbs.len - a) - result.isNegative = x.isNegative - - for i in countdown(x.limbs.high, a): - let acc = (carry shl 32) or x.limbs[i] - carry = acc and mask - result.limbs[i - a] = uint32(acc shr b) - - if result.isNegative: - var underflow = false - if carry > 0: - underflow = true - else: - for i in 0 .. a - 1: - if x.limbs[i] > 0: - underflow = true - break - - if underflow: - dec result - - if result.limbs.len > 1 and result.limbs[result.limbs.high] == 0: - # normalize - result.limbs.setLen(result.limbs.high) - - -# bitwise operations - -func invertIn(a: BigInt): BigInt {.inline.} = - result = a - result.isNegative = false - dec(result) - -func invertOut(a: var BigInt) {.inline.} = - inc(a) - a.isNegative = true - -func `not`*(a: BigInt): BigInt = - ## Bitwise `not` for `BigInt`s. - # 2's complement: -x = not x + 1 <=> not x = -x - 1 = -(x + 1) - result = succ(a) - negate(result) - -func `and`*(a, b: BigInt): BigInt = - ## Bitwise `and` for `BigInt`s. - if a.isNegative and not a.isZero: - if b.isNegative and not b.isZero: - # - and - - let a = invertIn(a) - let b = invertIn(b) - result.limbs.setLen(max(a.limbs.len, b.limbs.len)) - let m = min(a.limbs.len, b.limbs.len) - for i in 0 ..< m: - result.limbs[i] = a.limbs[i] or b.limbs[i] - for i in m ..< a.limbs.len: - result.limbs[i] = a.limbs[i] - for i in m ..< b.limbs.len: - result.limbs[i] = b.limbs[i] - invertOut(result) - else: - # - and + - let a = invertIn(a) - result = b - for i in 0 ..< min(a.limbs.len, b.limbs.len): - result.limbs[i] = (not a.limbs[i]) and b.limbs[i] - else: - if b.isNegative and not b.isZero: - # + and - - let b = invertIn(b) - result = a - for i in 0 ..< min(a.limbs.len, b.limbs.len): - result.limbs[i] = a.limbs[i] and (not b.limbs[i]) - else: - # + and + - result.limbs.setLen(min(a.limbs.len, b.limbs.len)) - for i in 0 ..< result.limbs.len: - result.limbs[i] = a.limbs[i] and b.limbs[i] - normalize(result) - -func `or`*(a, b: BigInt): BigInt = - ## Bitwise `or` for `BigInt`s. - if a.isNegative and not a.isZero: - if b.isNegative and not b.isZero: - # - or - - let a = invertIn(a) - let b = invertIn(b) - result.limbs.setLen(min(a.limbs.len, b.limbs.len)) - for i in 0 ..< result.limbs.len: - result.limbs[i] = a.limbs[i] and b.limbs[i] - invertOut(result) - else: - # - or + - let a = invertIn(a) - result = a - for i in 0 ..< min(a.limbs.len, b.limbs.len): - result.limbs[i] = a.limbs[i] and (not b.limbs[i]) - invertOut(result) - else: - if b.isNegative and not b.isZero: - # + or - - let b = invertIn(b) - result = b - for i in 0 ..< min(a.limbs.len, b.limbs.len): - result.limbs[i] = (not a.limbs[i]) and b.limbs[i] - invertOut(result) - else: - # + or + - result.limbs.setLen(max(a.limbs.len, b.limbs.len)) - let m = min(a.limbs.len, b.limbs.len) - for i in 0 ..< m: - result.limbs[i] = a.limbs[i] or b.limbs[i] - for i in m ..< a.limbs.len: - result.limbs[i] = a.limbs[i] - for i in m ..< b.limbs.len: - result.limbs[i] = b.limbs[i] - normalize(result) - -func `xor`*(a, b: BigInt): BigInt = - ## Bitwise `xor` for `BigInt`s. - if a.isNegative and not a.isZero: - if b.isNegative and not b.isZero: - # - xor - - let a = invertIn(a) - let b = invertIn(b) - result.limbs.setLen(max(a.limbs.len, b.limbs.len)) - let m = min(a.limbs.len, b.limbs.len) - for i in 0 ..< m: - result.limbs[i] = a.limbs[i] xor b.limbs[i] - for i in m ..< a.limbs.len: - result.limbs[i] = a.limbs[i] - for i in m ..< b.limbs.len: - result.limbs[i] = b.limbs[i] - else: - # - xor + - let a = invertIn(a) - result.limbs.setLen(max(a.limbs.len, b.limbs.len)) - let m = min(a.limbs.len, b.limbs.len) - for i in 0 ..< m: - result.limbs[i] = a.limbs[i] xor b.limbs[i] - for i in m ..< a.limbs.len: - result.limbs[i] = a.limbs[i] - for i in m ..< b.limbs.len: - result.limbs[i] = b.limbs[i] - invertOut(result) - else: - if b.isNegative and not b.isZero: - # + xor - - let b = invertIn(b) - result.limbs.setLen(max(a.limbs.len, b.limbs.len)) - let m = min(a.limbs.len, b.limbs.len) - for i in 0 ..< m: - result.limbs[i] = a.limbs[i] xor b.limbs[i] - for i in m ..< a.limbs.len: - result.limbs[i] = a.limbs[i] - for i in m ..< b.limbs.len: - result.limbs[i] = b.limbs[i] - invertOut(result) - else: - # + xor + - result.limbs.setLen(max(a.limbs.len, b.limbs.len)) - let m = min(a.limbs.len, b.limbs.len) - for i in 0 ..< m: - result.limbs[i] = a.limbs[i] xor b.limbs[i] - for i in m ..< a.limbs.len: - result.limbs[i] = a.limbs[i] - for i in m ..< b.limbs.len: - result.limbs[i] = b.limbs[i] - normalize(result) - - -func reset(a: var BigInt) = - ## Resets a `BigInt` back to the zero value. - a.limbs.setLen(1) - a.limbs[0] = 0 - a.isNegative = false - -func unsignedDivRem(q: var BigInt, r: var uint32, n: BigInt, d: uint32) = - q.limbs.setLen(n.limbs.len) - r = 0 - for i in countdown(n.limbs.high, 0): - let tmp = uint64(n.limbs[i]) + uint64(r) shl 32 - q.limbs[i] = uint32(tmp div d) - r = uint32(tmp mod d) - normalize(q) - -func bits(d: uint32): int = - const bitLengths = [0, 1, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 4, 4, - 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5] - var d = d - while d >= 32'u32: - result += 6 - d = d shr 6 - result += bitLengths[int(d)] - -# From Knuth and Python -func unsignedDivRem(q, r: var BigInt, n, d: BigInt) = - var - nn = n.limbs.len - dn = d.limbs.len - - if n.isZero: - q = zero - r = zero - elif nn < dn: - # n < d - q = zero - r = n - elif dn == 1: - var x: uint32 - unsignedDivRem(q, x, n, d.limbs[0]) - r.limbs = @[x] - r.isNegative = false - else: - assert nn >= dn and dn >= 2 - - # normalize - let ls = 32 - bits(d.limbs[d.limbs.high]) - r = d shl ls - q = n shl ls - if q.limbs.len > n.limbs.len or q.limbs[q.limbs.high] >= r.limbs[r.limbs.high]: - q.limbs.add(0'u32) - inc(nn) - - let k = nn - dn - assert k >= 0 - var a: BigInt - a.limbs.setLen(k) - let wm1 = r.limbs[r.limbs.high] - let wm2 = r.limbs[r.limbs.high-1] - var ak = k - - var zhi = zero - var z = zero - var qib = zero - var q1b = zero - - for v in countdown(k-1, 0): - # estimate quotient digit, may rarely overestimate by 1 - let vtop = q.limbs[v + dn] - assert vtop <= wm1 - let vv = (uint64(vtop) shl 32) or q.limbs[v+dn-1] - var q1 = vv div wm1 - var r1 = vv mod wm1 - - while (wm2 * q1) > ((r1 shl 32) or q.limbs[v+dn-2]): - dec q1 - r1 += wm1 - if r1 > uint32.high: - break - - assert q1 <= uint32.high - - q1b.limbs[0] = uint32(q1) - - # subtract - zhi.reset() - for i in 0 ..< dn: - z.reset() - z.limbs[0] = r.limbs[i] - z *= q1b - z.isNegative = true - z += zhi - var z1 = z - qib.limbs[0] = q.limbs[v+i] - z += qib - - if z < 0: - q.limbs[v+i] = not z.limbs[0] + 1 - else: - q.limbs[v+i] = z.limbs[0] - - if z.limbs.len > 1: - zhi.limbs[0] = z1.limbs[1] - if z1.limbs[0] > qib.limbs[0]: - zhi.limbs[0] += 1 - zhi.isNegative = true - elif z < 0: - zhi.limbs[0] = 1 - zhi.isNegative = true - else: - zhi.reset() - - # add back if was too large (rare branch) - if vtop.initBigInt + zhi < 0: - var carry = 0'u64 - for i in 0 ..< dn: - carry += q.limbs[v+i] - carry += r.limbs[i] - q.limbs[v+i] = uint32(carry and uint32.high) - carry = carry shr 32 - dec(q1) - - # store quotient digit - assert q1 <= uint32.high - dec(ak) - a.limbs[ak] = uint32(q1) - - # unshift remainder, we reuse w1 to store the result - q.limbs.setLen(dn) - r = q shr ls - - normalize(r) - q = a - normalize(q) - -func division(q, r: var BigInt, n, d: BigInt) = - # q = n div d - # r = n mod d - if d.isZero: - raise newException(DivByZeroDefect, "division by zero") - - unsignedDivRem(q, r, n, d) - - q.isNegative = n < 0 xor d < 0 - r.isNegative = n < 0 and r != 0 - - # divrem -> divmod - if (r < 0 and d > 0) or (r > 0 and d < 0): - r += d - q -= one - -func `div`*(a, b: BigInt): BigInt = - ## Computes the integer division of two `BigInt` numbers. - ## Raises a `DivByZeroDefect` if `b` is zero. - ## - ## If you also need the modulo (remainder), use the `divmod func <#divmod,BigInt,BigInt>`_. - runnableExamples: - let - a = 17.initBigInt - b = 5.initBigInt - assert a div b == 3.initBigInt - assert (-a) div b == -4.initBigInt - assert a div (-b) == -4.initBigInt - assert (-a) div (-b) == 3.initBigInt - var tmp: BigInt - division(result, tmp, a, b) - -func `mod`*(a, b: BigInt): BigInt = - ## Computes the integer modulo (remainder) of two `BigInt` numbers. - ## Raises a `DivByZeroDefect` if `b` is zero. - ## - ## If you also need an integer division, use the `divmod func <#divmod,BigInt,BigInt>`_. - runnableExamples: - let - a = 17.initBigInt - b = 5.initBigInt - assert a mod b == 2.initBigInt - assert (-a) mod b == 3.initBigInt - assert a mod (-b) == -3.initBigInt - assert (-a) mod (-b) == -2.initBigInt - var tmp: BigInt - division(tmp, result, a, b) - -func divmod*(a, b: BigInt): tuple[q, r: BigInt] = - ## Computes both the integer division and modulo (remainder) of two - ## `BigInt` numbers. - ## Raises a `DivByZeroDefect` if `b` is zero. - runnableExamples: - let - a = 17.initBigInt - b = 5.initBigInt - assert divmod(a, b) == (3.initBigInt, 2.initBigInt) - division(result.q, result.r, a, b) - -func countTrailingZeroBits(a: BigInt): int = - var count = 0 - for x in a.limbs: - if x == 0: - count += 32 - else: - return count + countTrailingZeroBits(x) - return count - -func gcd*(a, b: BigInt): BigInt = - ## Returns the greatest common divisor (GCD) of `a` and `b`. - runnableExamples: - assert gcd(54.initBigInt, 24.initBigInt) == 6.initBigInt - - # binary GCD algorithm - var - u = abs(a) - v = abs(b) - if u.isZero: - return v - elif v.isZero: - return u - let - i = countTrailingZeroBits(u) - j = countTrailingZeroBits(v) - k = min(i, j) - u = u shr i - v = v shr j - while true: - # u and v are odd - if u > v: - swap(u, v) - v -= u - if v.isZero: - return u shl k - v = v shr countTrailingZeroBits(v) - - -func toInt*[T: SomeInteger](x: BigInt): Option[T] = - ## Converts a `BigInt` number to an integer, if possible. - ## If the `BigInt` doesn't fit in a `T`, returns `none(T)`; - ## otherwise returns `some(x)`. - runnableExamples: - import std/options - let - a = 44.initBigInt - b = 130.initBigInt - assert toInt[int8](a) == some(44'i8) - assert toInt[int8](b) == none(int8) - assert toInt[uint8](b) == some(130'u8) - assert toInt[int](b) == some(130) - - if x.isZero: - return some(default(T)) # default(T) is 0 - when T is SomeSignedInt: - # T is signed - when sizeof(T) == 8: - if x.limbs.len > 2: - result = none(T) - elif x.limbs.len == 2: - if x.isNegative: - if x.limbs[1] > uint32(int32.high) + 1 or (x.limbs[1] == uint32(int32.high) + 1 and x.limbs[0] > 0): - result = none(T) - else: - let value = not T(x.limbs[1].uint64 shl 32 + x.limbs[0] - 1) - result = some(value) - else: - if x.limbs[1] > uint32(int32.high): - result = none(T) - else: - let value = T(x.limbs[1].uint64 shl 32 + x.limbs[0]) - result = some(value) - else: - if x.isNegative: - result = some(not T(x.limbs[0] - 1)) - else: - result = some(T(x.limbs[0])) - else: - if x.limbs.len > 1: - result = none(T) - else: - if x.isNegative: - if x.limbs[0] > uint32(T.high) + 1: - result = none(T) - else: - result = some(not T(x.limbs[0] - 1)) - else: - if x.limbs[0] > uint32(T.high): - result = none(T) - else: - result = some(T(x.limbs[0])) - else: - # T is unsigned - if x.isNegative: - return none(T) - when sizeof(T) == 8: - if x.limbs.len > 2: - result = none(T) - elif x.limbs.len == 2: - let value = T(x.limbs[1]) shl 32 + T(x.limbs[0]) - result = some(value) - else: - result = some(T(x.limbs[0])) - else: - if x.limbs.len > 1: - result = none(T) - elif x.limbs[0] > uint32(T.high): - result = none(T) - else: - result = some(T(x.limbs[0])) - -func calcSizes(): array[2..36, int] = - for i in 2..36: - var x = int64(i) - while x <= int64(uint32.high) + 1: - x *= i - result[i].inc - -const - digits = "0123456789abcdefghijklmnopqrstuvwxyz" - powers = {2'u8, 4, 8, 16, 32} - sizes = calcSizes() # `sizes[base]` is the maximum number of digits that fully fit in a `uint32` - -func toString*(a: BigInt, base: range[2..36] = 10): string = - ## Produces a string representation of a `BigInt` in a specified - ## `base`. - ## - ## Doesn't produce any prefixes (`0x`, `0b`, etc.). - runnableExamples: - let a = 55.initBigInt - assert toString(a) == "55" - assert toString(a, 2) == "110111" - assert toString(a, 16) == "37" - - if a.isZero: - return "0" - - let size = sizes[base] - if base.uint8 in powers: - let - bits = countTrailingZeroBits(base) # bits per digit - mask = (1'u32 shl bits) - 1 - totalBits = 32 * a.limbs.len - countLeadingZeroBits(a.limbs[a.limbs.high]) - result = newStringOfCap((totalBits + bits - 1) div bits + 1) - - var - acc = 0'u32 - accBits = 0 # the number of bits needed for acc - for x in a.limbs: - acc = acc or (x shl accBits) - accBits += 32 - while accBits >= bits: - result.add(digits[acc and mask]) - acc = acc shr bits - if accBits > 32: - acc = x shr (32 - (accBits - bits)) - accBits -= bits - if acc > 0: - result.add(digits[acc]) - else: - let - base = uint32(base) - d = base ^ size - var tmp = a - - tmp.isNegative = false - result = newStringOfCap(size * a.limbs.len + 1) # estimate the length of the result - - while tmp > 0: - var - c: uint32 - tmpCopy = tmp - unsignedDivRem(tmp, c, tmpCopy, d) - for i in 1..size: - result.add(digits[c mod base]) - c = c div base - - # normalize - var i = result.high - while i > 0 and result[i] == '0': - dec i - result.setLen(i+1) - - if a.isNegative: - result.add('-') - - result.reverse() - -func `$`*(a: BigInt): string = - ## String representation of a `BigInt` in base 10. - toString(a, 10) - -func parseDigit(c: char, base: uint32): uint32 {.inline.} = - result = case c - of '0'..'9': uint32(ord(c) - ord('0')) - of 'a'..'z': uint32(ord(c) - ord('a') + 10) - of 'A'..'Z': uint32(ord(c) - ord('A') + 10) - else: raise newException(ValueError, "Invalid input: " & c) - - if result >= base: - raise newException(ValueError, "Invalid input: " & c) - -func filterUnderscores(str: var string) {.inline.} = - var k = 0 # the amount of underscores - for i in 0 .. str.high: - let c = str[i] - if c == '_': - inc k - elif k > 0: - str[i - k] = c - str.setLen(str.len - k) - -func initBigInt*(str: string, base: range[2..36] = 10): BigInt = - ## Create a `BigInt` from a string. For invalid inputs, a `ValueError` exception is raised. - runnableExamples: - let - a = initBigInt("1234") - b = initBigInt("1234", base = 8) - assert a == 1234.initBigInt - assert b == 668.initBigInt - - if str.len == 0: - raise newException(ValueError, "Empty input") - - let size = sizes[base] - let base = base.uint32 - var first = 0 - var neg = false - - case str[0] - of '-': - if str.len == 1: - raise newException(ValueError, "Invalid input: " & str) - first = 1 - neg = true - of '+': - if str.len == 1: - raise newException(ValueError, "Invalid input: " & str) - first = 1 - else: - discard - if str[first] == '_': - raise newException(ValueError, "A number can not begin with _") - if str[^1] == '_': - raise newException(ValueError, "A number can not end with _") - - if base.uint8 in powers: - # base is a power of two, so each digit corresponds to a block of bits - let bits = countTrailingZeroBits(base) # bits per digit - var - acc = 0'u32 - accBits = 0 # the number of bits needed for acc - for i in countdown(str.high, first): - if str[i] != '_': - let digit = parseDigit(str[i], base) - acc = acc or (digit shl accBits) - accBits += bits - if accBits >= 32: - result.limbs.add(acc) - accBits -= 32 - acc = digit shr (bits - accBits) - if acc > 0: - result.limbs.add(acc) - result.normalize() - else: - var str = str - filterUnderscores(str) - let d = initBigInt(base ^ size) - for i in countup(first, str.high, size): - var num = 0'u32 # the accumulator in this block - if i + size <= str.len: - # iterator over a block of length `size`, so we can use `d` - for j in countup(i, i + size - 1): - if str[j] != '_': - let digit = parseDigit(str[j], base) - num = (num * base) + digit - unsignedAdditionInt(result, result * d, num) - else: - # iterator over a block smaller than `size`, so we have to compute `mul` - var mul = 1'u32 # the multiplication factor for num - for j in countup(i, min(i + size - 1, str.high)): - if str[j] != '_': - let digit = parseDigit(str[j], base) - num = (num * base) + digit - mul *= base - unsignedAdditionInt(result, result * initBigInt(mul), num) - - result.isNegative = neg - -when (NimMajor, NimMinor) >= (1, 5): - include bigints/private/literals - -func inc*(a: var BigInt, b: int = 1) = - ## Increase the value of a `BigInt` by the specified amount (default: 1). - runnableExamples: - var a = 15.initBigInt - inc a - assert a == 16.initBigInt - inc(a, 7) - assert a == 23.initBigInt - - if b in int32.low..int32.high: - var c = a - additionInt(a, c, b.int32) - else: - a += initBigInt(b) - -func dec*(a: var BigInt, b: int = 1) = - ## Decrease the value of a `BigInt` by the specified amount (default: 1). - runnableExamples: - var a = 15.initBigInt - dec a - assert a == 14.initBigInt - dec(a, 5) - assert a == 9.initBigInt - - if b in int32.low..int32.high: - var c = a - subtractionInt(a, c, b.int32) - else: - a -= initBigInt(b) - -func succ*(a: BigInt, b: int = 1): BigInt = - ## Returns the `b`-th successor of a `BigInt`. - result = a - inc(result, b) - -func pred*(a: BigInt, b: int = 1): BigInt = - ## Returns the `b`-th predecessor of a `BigInt`. - result = a - dec(result, b) - - -iterator countup*(a, b: BigInt, step: int32 = 1): BigInt = - ## Counts from `a` up to `b` (inclusive) with the given step count. - var res = a - while res <= b: - yield res - inc(res, step) - -iterator countdown*(a, b: BigInt, step: int32 = 1): BigInt = - ## Counts from `a` down to `b` (inclusive) with the given step count. - var res = a - while res >= b: - yield res - dec(res, step) - -iterator `..`*(a, b: BigInt): BigInt = - ## Counts from `a` up to `b` (inclusive). - var res = a - while res <= b: - yield res - inc res - -iterator `..<`*(a, b: BigInt): BigInt = - ## Counts from `a` up to `b` (exclusive). - var res = a - while res < b: - yield res - inc res - - -func modulo(a, modulus: BigInt): BigInt = - ## Like `mod`, but the result is always in the range `[0, modulus-1]`. - ## `modulus` should be greater than zero. - result = a mod modulus - if result < 0: - result += modulus - -func fastLog2*(a: BigInt): int = - ## Computes the logarithm in base 2 of `a`. - ## If `a` is negative, returns the logarithm of `abs(a)`. - ## If `a` is zero, returns -1. - if a.isZero: - return -1 - bitops.fastLog2(a.limbs[^1]) + 32*(a.limbs.high) - - -func invmod*(a, modulus: BigInt): BigInt = - ## Compute the modular inverse of `a` modulo `modulus`. - ## The return value is always in the range `[1, modulus-1]` - runnableExamples: - assert invmod(3.initBigInt, 7.initBigInt) == 5.initBigInt - - # extended Euclidean algorithm - if modulus.isZero: - raise newException(DivByZeroDefect, "modulus must be nonzero") - elif modulus.isNegative: - raise newException(ValueError, "modulus must be strictly positive") - elif a.isZero: - raise newException(DivByZeroDefect, "0 has no modular inverse") - else: - var - r0 = modulus - r1 = a.modulo(modulus) - t0 = zero - t1 = one - var rk, tk: BigInt # otherwise t1 is incorrectly inferred as cursor (https://github.com/nim-lang/Nim/issues/19457) - while r1 > 0: - let q = r0 div r1 - rk = r0 - q * r1 - tk = t0 - q * t1 - r0 = r1 - r1 = rk - t0 = t1 - t1 = tk - if r0 != one: - raise newException(ValueError, $a & " has no modular inverse modulo " & $modulus) - result = t0.modulo(modulus) - -func powmod*(base, exponent, modulus: BigInt): BigInt = - ## Compute modular exponentation of `base` with power `exponent` modulo `modulus`. - ## The return value is always in the range `[0, modulus-1]`. - runnableExamples: - assert powmod(2.initBigInt, 3.initBigInt, 7.initBigInt) == 1.initBigInt - if modulus.isZero: - raise newException(DivByZeroDefect, "modulus must be nonzero") - elif modulus.isNegative: - raise newException(ValueError, "modulus must be strictly positive") - elif modulus == 1: - return zero - else: - var - base = base - exponent = exponent - if exponent < 0: - base = invmod(base, modulus) - exponent = -exponent - var basePow = base.modulo(modulus) - result = one - while not exponent.isZero: - if (exponent.limbs[0] and 1) != 0: - result = (result * basePow) mod modulus - basePow = (basePow * basePow) mod modulus - exponent = exponent shr 1 diff --git a/research/aparith/src/bigints.git/private/literals.nim b/research/aparith/src/bigints.git/private/literals.nim deleted file mode 100644 index c58d551..0000000 --- a/research/aparith/src/bigints.git/private/literals.nim +++ /dev/null @@ -1,17 +0,0 @@ -# This is an include file, do not import it directly. -# It is needed as a workaround for Nim's parser for versions <= 1.4. - -proc `'bi`*(s: string): BigInt = - ## Create a `BigInt` from a literal, using the suffix `'bi`. - runnableExamples: - let - a = 123'bi - b = 0xFF'bi - c = 0b1011'bi - assert $a == "123" - assert $b == "255" - assert $c == "11" - case s[0..min(s.high, 1)] - of "0x", "0X": initBigInt(s[2..s.high], base = 16) - of "0b", "0B": initBigInt(s[2..s.high], base = 2) - else: initBigInt(s) diff --git a/research/aparith/src/bigints.git/random.nim b/research/aparith/src/bigints.git/random.nim deleted file mode 100644 index e4c7058..0000000 --- a/research/aparith/src/bigints.git/random.nim +++ /dev/null @@ -1,43 +0,0 @@ -import ../bigints -import std/sequtils -import std/options -import std/random - -func rand*(r: var Rand, x: Slice[BigInt]): BigInt = - ## Return a random `BigInt`, within the given range, using the given state. - assert(x.a <= x.b, "invalid range") - let - spread = x.b - x.a - # number of bits *not* including leading bit - nbits = spread.fastLog2 - # number of limbs to generate completely randomly - nFullLimbs = max(nbits div 32 - 1, 0) - # highest possible value of the top two limbs. - hi64Max = (spread shr (nFullLimbs*32)).toInt[:uint64].get() - while true: - # these limbs can be generated completely arbitrarily - var limbs = newSeqWith(nFullLimbs, r.rand(uint32.low..uint32.high)) - # generate the top two limbs more carefully. This all but guarantees - # that the entire number is in the correct range - let hi64 = r.rand(uint64.low..hi64Max) - limbs.add(cast[uint32](hi64)) - limbs.add(cast[uint32](hi64 shr 32)) - result = initBigInt(limbs) - if result <= spread: - break - result += x.a - -func rand*(r: var Rand, max: BigInt): BigInt = - ## Return a random non-negative `BigInt`, up to `max`, using the given state. - rand(r, 0.initBigInt..max) - -# backwards compatibility with 1.4 -when not defined(randState): - var state = initRand(777) - proc randState(): var Rand = state - -proc rand*(x: Slice[BigInt]): BigInt = rand(randState(), x) - ## Return a random `BigInt`, within the given range. - -proc rand*(max: BigInt): BigInt = rand(randState(), max) - ## Return a random `BigInt`, up to `max`. diff --git a/research/aparith/src/speedtest_bigint b/research/aparith/src/speedtest_bigint deleted file mode 100755 index ec55c9c..0000000 Binary files a/research/aparith/src/speedtest_bigint and /dev/null differ diff --git a/research/aparith/src/speedtest_bigint.nim b/research/aparith/src/speedtest_bigint.nim deleted file mode 100644 index 8e2a268..0000000 --- a/research/aparith/src/speedtest_bigint.nim +++ /dev/null @@ -1,35 +0,0 @@ -import bigints -import std/[options, times] - -func g(x: BigInt, n: BigInt): BigInt {.inline.} = - result = (x*x + 1.initBigInt) mod n - -func pollardRho(n: BigInt): Option[BigInt] = - var - x: BigInt = 2.initBigInt - y: BigInt = n - d: BigInt = 1.initBigInt - - while d == 1.initBigInt: - x = g(x, n) - y = g(g(y, n), n) - d = gcd(abs(x - y), n) - - if d == n: - return none(BigInt) - result = some(d) - - -when isMainModule: - let - # num = 535006138814359.initBigInt - # num = 12.initBigInt - num = 976043389537.initBigInt * 270351207761773.initBigInt - time = cpuTime() - divisor = pollardRho(num) - elapsed = cpuTime() - time - echo "Time taken: ", elapsed - if divisor.isSome: - echo "Result: ", divisor.get() - else: - echo "Result: None(BigInt)" diff --git a/src/imp.nim b/src/imp.nim deleted file mode 100644 index b7a2480..0000000 --- a/src/imp.nim +++ /dev/null @@ -1,7 +0,0 @@ -# This is just an example to get you started. A typical library package -# exports the main API in this file. Note that you cannot rename this file -# but you can remove it if you wish. - -proc add*(x, y: int): int = - ## Adds two numbers together. - return x + y diff --git a/src/imp/submodule.nim b/src/imp/submodule.nim deleted file mode 100644 index 638e90f..0000000 --- a/src/imp/submodule.nim +++ /dev/null @@ -1,12 +0,0 @@ -# This is just an example to get you started. Users of your library will -# import this file by writing ``import celeste/submodule``. Feel free to rename or -# remove this file altogether. You may create additional modules alongside -# this file as required. - -type - Submodule* = object - name*: string - -proc initSubmodule*(): Submodule = - ## Initialises a new ``Submodule`` object. - Submodule(name: "Anonymous")