lda/snippets
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

delete that

Browse Source 
its in usth/crypto now
This commit is contained in:
lda committed 2026-01-30 20:57:16 +07:00
1 parent a455587ad0
commit dae367bab1
5 files changed
-560
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

crypto/a51.py
-154
View File
@@ -1,154 +0,0 @@
from collections.abc import Sequence, Iterable, Iterator
from typing import Literal
from functools import reduce
from itertools import chain
from operator import xor
def maj(a, b, c):
a, b, c = bool(a), bool(b), bool(c)
return 1 * (a + b + c >= 2)
class Bih(Sequence):
def __init__(
self, length: Literal[19, 22, 23], initializer: Iterable | None = None
):
match length:
case 19:
self.m = 8
self.n = (13, 16, 17, 18)
self.g = 18
case 22:
self.m = 10
self.n = (20, 21)
self.g = 21
case 23:
self.m = 10
self.n = (7, 20, 21, 22)
self.g = 22
case _:
raise ValueError()
self.len = length
if initializer is None:
initializer = [0] * length
self.q = list(initializer)
if len(self.q) != length:
raise ValueError()
def __len__(self):
return len(self.q)
def __str__(self):
return str(self.q)
@property
def maj(self):
return self[self.m]
@property
def st(self):
return self[self.g]
@property
def element_new(self):
return tuple(self[n] for n in self.n)
@property
def n_new(self):
return reduce(xor, self.element_new)
def roll(self):
assert len(self) == self.len
self.q = [self.n_new, *self[:-1]]
def __getitem__(self, bro):
return self.q[bro]
def dihcheese(n: int, length: int):
return map(int, f"{n:b}".zfill(length))
def dih(n: int, length: int):
return Bih(length, dihcheese(n, length))
def majroll(a: Bih, b: Bih, c: Bih):
r = maj(a.maj, b.maj, c.maj)
for i in (a, b, c):
if i.maj == r:
i.roll()
def s(a: Bih, b: Bih, c: Bih):
return reduce(xor, (i.st for i in (a, b, c)))
def cih(n: int):
n = [int(i) for i in str(n)]
return Bih(len(n), n)
def op(a: Bih, b: Bih, c: Bih, n: int):
for i in range(n):
majroll(a, b, c)
yield s(a, b, c)
def opdih(a, b, c, n):
a = dih(a, 19)
b = dih(b, 22)
c = dih(c, 23)
return op(a, b, c, n)
def opcih(a, b, c, n):
a = cih(a)
b = cih(b)
c = cih(c)
return op(a, b, c, n)
def main1(fahh=True):
a = dih(513365, 19)
b = dih(3355443, 22)
c = dih(7401712, 23)
d = op(a, b, c, 10)
if not fahh:
return d
return list(d)
def render(dih: Iterator[int]):
bih = " ".join(str(i) for i in reversed(list(dih)))
return f"-> {bih}"
def dihrender(dih: Iterator[int]):
ar = "->"
cih = []
for i in dih:
cih.append(str(i))
yield " ".join(chain((ar,), reversed(cih)))
def main2():
e = list(
opcih(
1010101010101010101,
1100110011001100110011,
11100001111000011110000,
8,
)
)
return e
if __name__ == "__main__":
print(main1())
print(main2())
print(*dihrender(main1(False)), sep="\n")
print(render(main1()))
crypto/lw1.py
-95
View File
@@ -1,95 +0,0 @@
def e1(eh=True):
a = 123
b = 543
ab = a ^ b
if not eh:
return a, b, ab
return f"{a = :b}, {b = :b}, {a^b = :b} ({a ^ b})"
def e2():
a = [
105,
110,
116,
114,
111,
50,
99,
114,
121,
112,
116,
111,
123,
119,
51,
108,
99,
48,
109,
51,
95,
116,
48,
95,
106,
48,
117,
114,
110,
51,
121,
125,
]
return "".join(map(chr, a))
def e3():
b = [
99,
100,
126,
120,
101,
56,
105,
120,
115,
122,
126,
101,
113,
59,
121,
126,
57,
122,
85,
58,
100,
85,
96,
58,
127,
120,
100,
57,
115,
119,
]
k = 10
return "".join(map(lambda n: chr(n ^ k), b))
if __name__ == "__main__":
import a51
print("#1:", e1())
print("#2:", e2())
print("#3:", e3())
print("#4:", a51.render(a51.main1()))
crypto/lw2.py
-198
View File
@@ -1,198 +0,0 @@
from math import gcd as mathgcd
from itertools import combinations
from functools import wraps
import random
# home grown gcd
def gcd(a, b):
return a if b == 0 else gcd(b, a % b)
def cooked(s: set[int]):
for a, b in combinations(s, 2):
if mathgcd(a, b) == 1:
yield a, b
printingTs = False
def printTs(f):
@wraps(f)
def ff(*a, **kw):
if printingTs:
if a:
print(*a)
if kw:
print(*kw.items())
r = f(*a, *kw)
if printingTs:
print(r)
return r
return ff
@printTs
def smx(x, e, n, r=1): # this is not it cuh
return (
smx(inv(x, n), -e, n, r)
if e < 0
else r
if e == 0
else smx(x * x % n, e >> 1, n, r * x % n if e & 1 else r)
)
def realsmx(x, e, n):
r = x
for bro in map(int, bin(e)[3:]):
r = (r * r) % n
if bro:
r = (r * x) % n
return r
@printTs
def theREALsmx(x, e, n):
"locked in"
return (
theREALsmx(inv(x, n), -e, n)
if e < 0
else x**e
if e <= 1
else theREALsmx(x, e >> 1, n) ** 2 % n
if not e & 1
else (x * theREALsmx(x, e & ~1, n)) % n
)
def realest(x=None, y=None, n=None):
x = x or random.randint(-10e9, 10e9)
y = y or random.randint(-10e9, 10e9)
n = n or random.randint(2, 10e9)
# print(x, y, n)
if y < 0:
try:
p = pow(x, -1, n)
except ValueError:
p = None
else:
assert (p * x) % n == 1, f"{p = }, {(p*x)%n = }"
try:
i = inv(x, n)
except ValueError:
i = None
else:
assert (i * x) % n == 1, f"{i = }, {(i*x)%n = }"
assert i == p, f"{i = }, {p = }"
if gcd(x, n) != 1:
return # not doing ts
p = pow(x, y, n)
s = smx(x, y, n)
t = theREALsmx(x, y, n)
assert p == s == t, f"{p = }, {s = }, {t = }"
def xgcd(a, b) -> tuple[int, tuple[int, int]]:
"answer at index 0, wiki ripoff"
s, ps, r, pr = 0, 1, b, a
# shit = 0
while r != 0:
# shit += 1
# if shit > 1000:
# raise RecursionError("SHIT")
q = pr // r
pr, r = r, (pr - q * r)
ps, s = s, (ps - q * s)
bt = 0 if b == 0 else (pr - ps * a) % b
return (pr, (ps, bt))
def inv(a, n):
"also wiki ripoff"
t, nt, r, nr = 0, 1, n, a % n
# shit = 0
while nr != 0:
# shit += 1
# if shit > 1000:
# raise RecursionError("SHIT")
q = r // nr
r, nr = nr, (r - q * nr)
t, nt = nt, (t - q * nt)
# print(t, nt, r, nr)
if r > 1:
raise ValueError("base is not invertible for the given modulus")
if t < 0:
return t + n
return t
def fahhh(x, e, n):
"only works for this specific thing"
eb = f"{e:b}"
print(f"x^H mod n = {x}^{e} mod {n}")
print()
print(f"H = {e}_10 = {eb}_2")
print(
",\n".join(reversed([f"h_{i} = {ie}_2" for i, ie in enumerate(reversed(eb))]))
)
r = x
ee = 1
print()
print(f"x = x^{{{eb[0]}_2}}")
print(f"h_{len(eb)-1} = {eb[0]}")
print()
print(f"r <- {x = }")
print()
for ie, i in zip(range(len(eb) - 2, -1, -1), eb[1:]):
print(f"(x^{ee})^2 = x^{2*ee} = x^{{{2*ee:b}_2}}")
print(f"SQ, h_{ie}")
print()
ee *= 2
r *= r
print(f"r <- r*r = {r}")
print(f"r <- r mod n = {r%n}")
r %= n
print()
if int(i):
print(f"x^{ee}*x = x^{ee+1} = x^{{{ee+1:b}_2}}")
print(f"MUL, h_{ie} = 1")
print()
ee += 1
r *= x
print(f"r <- r * x = {r}")
print(f"r <- r mod n = {r%n}")
r %= n
else:
print(f"h_{ie} = 0")
print()
print(f"x^H mod n = {x}^{e} mod {n} = {r}")
return r
if __name__ == "__main__":
print("#1:", f"{gcd(52698, 61430) = }")
E2 = {
290345,
218585,
143231,
164172,
155768,
423151,
239707,
153544,
287390,
480837,
}
dih = [f"gcd({m}, {n}) = {gcd(m,n)}" for m, n in cooked(E2)]
print("#2:", *dih, sep="\n")
print(f"pairs = {len(dih)}")
print("#3:")
fahhh(856, 25, 7)
print(f"{pow(856, 25, 7) = }")
print("#4:", f"{inv(65537, 35256) = }")
crypto/lw3.py
-40
View File
@@ -1,40 +0,0 @@
def e1():
s = "flow"
return int(bytes(s, encoding="ascii").hex(), 16)
def dec_ascii(i: int):
b = bytes.fromhex(f"{i:x}")
return b.decode("ascii")
def e2():
i = 14445
return dec_ascii(i)
from proto_rsa import LdaRsahh
def e3():
a = LdaRsahh(p=251, q=191, e=65537).enc(26729)
b = LdaRsahh(p=233, q=151, d=9473).dec(29600)
return a, b
def e4():
C = 412589464
M = LdaRsahh(p=81401, q=27109, e=65537).dec(C)
return dec_ascii(M)
if __name__ == "__main__":
print("#1:", e1())
print("#2:", e2())
C, M = e3()
print("#3:", f"{C = }, {M = }")
print("#4:", e4())
crypto/proto_rsa.py
-73
View File
@@ -1,73 +0,0 @@
def inv(a, n):
return pow(a, -1, n)
import math
from functools import cached_property
from typing import Callable
import warnings
class LdaRsahh:
def __init__(
self,
p,
q,
d: int | None = None,
e: int | None = None,
ln_ops: Callable[[int, int], int] | None = None,
):
# operator.mul or math.lcm
self._lnops = ln_ops or math.lcm
self._p, self._q = p, q
if d is None and e is None:
raise ValueError("at least d or e needs to be math.gcd(e, phi)fed in")
ln = self.ln
if e is None:
e = inv(d, ln)
if not 1 < e < ln:
warnings.warn(
f"{e = }, {ln = }, 1 < e < ln not satisfied, e rebinds to e % ln",
UserWarning,
)
e %= ln
if not 1 < e < ln:
raise ValueError(f"{e = }, {ln = }, 1 < e < ln not satisfied")
if math.gcd(e, ln) != 1:
raise ValueError(
f"{e = }, {ln = }, gcd(e, ln) == 1 (coprime) not satisfied"
)
if d is None:
d = inv(e, ln)
self._d, self._e = d, e
@cached_property
def n(self):
return self.p * self.q
@cached_property
def ln(self):
return self._lnops((self.p - 1), (self.q - 1))
@property
def p(self):
return self._p
@property
def q(self):
return self._q
@property
def d(self):
return self._d
@property
def e(self):
return self._e
def enc(self, m: int):
return pow(m, self.e, self.n)
def dec(self, c: int):
return pow(c, self.d, self.n)