a ctfer on the load

1
import uuid
2
import hashlib
3

4
flag = "flag{XXX}"
5

6
def abcduuid(flag):
7

8
    for char in flag:
9
        md5_hash = hashlib.md5(char.encode('utf-8')).hexdigest()
10
        print(f"{md5_hash}")
11

12
if __name__ == "__main__":
13
    abcduuid(flag)

1
import hashlib
2

3
chars = 'abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ0123456789!@#$%^&*()-_=+[]{}|;:,.<>?/~`'
4

5
hash_to_char = {}
6
for char in chars:
7
    md5_hash = hashlib.md5(char.encode()).hexdigest()
8
    hash_to_char[md5_hash] = char
9

10
hashes=[]
11

12
flag = ''.join(hash_to_char.get(h, '?') for h in hashes)
13
print("恢复的 flag =", flag)

1
from Crypto.Util.number import *
2
from random import choice
3
from secret import flag
4

5
flag=flag.decode('utf-8')+ "1" * 30
6
def getMyPrime(nbits):
7
    while True:
8
        p = 1
9
        while p.bit_length() <= nbits:
10
            p *= choice(sieve_base)
11

12
        if isPrime(p-1):
13
            return p-1
14

15
p = getMyPrime(256)
16
q = getMyPrime(256)
17

18
n = p*q
19
e = 65537
20
m = bytes_to_long(flag.encode('utf-8'))
21

22
c = pow(m, e, n)
23

24
print(f'n = {n}')
25
print(f'e = {e}')
26
print(f'c = {c}')

1
from Crypto.Util.number import inverse, long_to_bytes
2

3
n = 628367984743024460258949874461149142010669513982134034370937872907905412845791373384712099210680007304553638206133651385921799225422417075701557994891635322641
4
e = 65537
5
c = 463865728618910033824119037781408268137675300311981183906046145489848078253770973845564931794701097695379503336925847137631988673327885373164114472241504247048
6
p=453934123611868315924584320396524007218781226845135310539625979436424296065501477
7
assert n%p==0
8
q=n//p
9
m=pow(c,inverse(65537,(p-1)*(q-1)),n)
10
print(m)
11
flag=long_to_bytes(m)
12
print(flag)
13
for i in range(2**20):
14
    mm=m+i*n
15
    if b'flag{' in long_to_bytes(mm):
16
        print(long_to_bytes(mm))
17
'''
18
import math
19
from itertools import count
20

21
from gmpy2 import *
22

23

24
def primegen():
25
    yield 2
26
    for odd in count(3, 2):
27
        if all(odd % p > 0 for p in primes[:int(math.sqrt(odd))]):
28
            yield odd
29

30
primes = [2]
31
def ilog(x, p):
32
    """ Computes the integer logarithm of x to the base p. """
33
    # This function calculates how many times we need to divide x by p
34
    e = 0
35
    while x >= p:
36
        x //= p
37
        e += 1
38
    return e
39
def mlucas(v, a, n):
40
    """ Helper function for williams_pp1().  Multiplies along a Lucas sequence modulo n. """
41
    v1, v2 = v, (v**2 - 2) % n
42
    for bit in bin(a)[3:]:
43
        v1, v2 = ((v1**2 - 2) % n, (v1*v2 - v) % n) if bit == "0" else ((v1*v2 - v) % n, (v2**2 - 2) % n)
44
    return v1
45

46
for v in count(1):
47
    for p in primegen():
48
        e = ilog(isqrt(n), p)
49
        if e == 0:
50
            break
51
        for _ in range(e):
52
            v = mlucas(v, p, n)
53
        g = gcd(v-2, n)
54
        if 1 < g < n:
55
            print(g)
56
        if g == n:
57
            break
58

59
'''

1
from crypto.util.number import *
2
from secret import flag
3

4
while true:
5
    p = getprime(512)
6
    q = getprime(512)
7

8
    if p > q and p % 4 == 3 and q % 4 == 3:
9
        break
10

11
assert p > q
12
assert p % 4 == 3 and q % 4 == 3
13
n = p*q
14
e = 256
15
m = bytes_to_long(flag)
16
num1 = (pow(p,e,n)-pow(q,e,n)) % n
17
num2 = pow(p-q,e,n)
18
c = pow(m,e,n)
19

20
print("num1=",num1)
21
print("num2=",num2)
22
print("n=",n)
23
print("c=",c)

1
from Crypto.Util.number import *
2

3
tmp=num1+num2
4
p=GCD(tmp,n)
5
print(p)
6
q=n//p
7

8
inv_p = inverse(p, q)
9
inv_q = inverse(q, p)
10

11
cs = [c]
12
for i in range(8):
13
    ps = []
14
    for c2 in cs:
15
        r = pow(c2, (p + 1) // 4, p)
16
        s = pow(c2, (q + 1) // 4, q)
17

18
        x = (r * inv_q * q + s * inv_p * p) % n
19
        y = (r * inv_q * q - s * inv_p * p) % n
20
        if x not in ps:
21
            ps.append(x)
22
        if n - x not in ps:
23
            ps.append(n - x)
24
        if y not in ps:
25
            ps.append(y)
26
        if n - y not in ps:
27
            ps.append(n - y)
28
    cs = ps
29

30
for m in cs:
31
    print(long_to_bytes(m))

1
#!/usr/bin/env python3
2
import os
3
import secrets
4
import random
5
from typing import List, Tuple
6

7
from secret import FLAG
8

9
def _miller_rabin_witness(a: int, d: int, n: int, s: int) -> bool:
10
    x = pow(a, d, n)
11
    if x == 1 or x == n - 1:
12
        return False
13
    for _ in range(s - 1):
14
        x = (x * x) % n
15
        if x == n - 1:
16
            return False
17
    return True
18

19

20
def is_probable_prime(n: int, rounds: int = 64) -> bool:
21
    if n < 2:
22
        return False
23
    small_primes = [2, 3, 5, 7, 11, 13, 17, 19, 23, 29]
24
    for p in small_primes:
25
        if n == p:
26
            return True
27
        if n % p == 0:
28
            return False
29
    d = n - 1
30
    s = 0
31
    while d % 2 == 0:
32
        d //= 2
33
        s += 1
34
    for _ in range(rounds):
35
        a = secrets.randbelow(n - 3) + 2
36
        if _miller_rabin_witness(a, d, n, s):
37
            return False
38
    return True
39

40

41
def random_odd_bits(bits: int) -> int:
42
    x = secrets.randbits(bits) | 1
43
    x |= (1 << (bits - 1))
44
    return x
45

46

47
def get_prime(bits: int) -> int:
48
    while True:
49
        n = random_odd_bits(bits)
50
        if is_probable_prime(n):
51
            return n
52

53

54
R_BITS = 190
55
Q_BITS = 215
56
G_BITS = 128
57
P_BITS = 170
58
K_BITS = 16
59

60
NUM_CAL_FRAMES = 5
61

62

63
def encode_payload(payload_byte: int, base: int, key: int, modulus: int) -> int:
64
    return (payload_byte * pow(base, key, modulus)) % modulus
65

66

67
def build_frames(flag_bytes: bytes) -> Tuple[int, int, List[Tuple[str, int]]]:
68
    modulus = get_prime(P_BITS)
69
    base = get_prime(G_BITS)
70
    frame_scale = get_prime(Q_BITS)
71

72
    epoch_key = secrets.randbits(K_BITS)
73

74
    frames: List[Tuple[str, int]] = []
75

76
    for _ in range(NUM_CAL_FRAMES):
77
        bin_id = get_prime(R_BITS)
78
        codeword = frame_scale * bin_id + encode_payload(1, base, epoch_key, modulus)
79
        frames.append(("CAL", codeword))
80

81
    for b in flag_bytes:
82
        bin_id = get_prime(R_BITS)
83
        codeword = frame_scale * bin_id + encode_payload(b, base, epoch_key, modulus)
84
        frames.append(("DATA", codeword))
85

86
    return modulus, base, frames
87

88

89
def main() -> None:
90
    p, g, frames = build_frames(FLAG)
91

92
    banner = (
93
        "# Telemetry Aggregation Report\n"
94
        "# - Aggregator bins sensor frames into coarse buckets (FRAME_SCALE)\n"
95
        "# - Each frame carries a 1-byte payload, calibrated by an ephemeral EPOCH_KEY\n"
96
        "# - The calibration uses modular arithmetic against a system MODULUS and BASE\n"
97
        "#\n"
98
        "# Field notes: CAL frames are health-check beacons; DATA frames are actual readings.\n"
99
        "# Your task: reconstruct the DATA payload stream.\n"
100
    )
101

102
    with open("output.txt", "w") as f:
103
        f.write(banner)
104
        f.write(f"p = {p}\n")
105
        f.write(f"g = {g}\n")
106
        f.write(f"frames = {len(frames)}\n")
107
        for idx, (kind, cw) in enumerate(frames):
108
            f.write(f"frame[{idx}]: type={kind}, codeword={cw}\n")
109

110
    print("Challenge written to output.txt")
111

112

113
if __name__ == "__main__":
114
    main()

1
from math import gcd
2
from typing import List, Tuple
3

4

5
def mod_inverse(a: int, m: int) -> int:
6
    def extended_gcd(a: int, b: int) -> Tuple[int, int, int]:
7
        if a == 0:
8
            return b, 0, 1
9
        gcd, x1, y1 = extended_gcd(b % a, a)
10
        x = y1 - (b // a) * x1
11
        y = x1
12
        return gcd, x, y
13

14
    g, x, _ = extended_gcd(a, m)
15

16
    return (x % m + m) % m
17

18
p = 1059044419481232265210084377746088723503596941462371
19
g = 248096840098994800035575976902189528491
20

21
cal_cws = []
22

23
data_cws = []
24

25
def compute_frame_scale(cal_cws: List[int]) -> int:
26
    diffs = [abs(cal_cws[i] - cal_cws[0]) for i in range(1, len(cal_cws))]
27
    g = diffs[0]
28
    for d in diffs[1:]:
29
        g = gcd(g, d)
30

31
    q_cand = g // 2
32
    m_test = cal_cws[0] % q_cand
33
    consistent = all(cw % q_cand == m_test for cw in cal_cws)
34
    return q_cand
35

36
def main():
37
    q = compute_frame_scale(cal_cws)
38
    m_cal = cal_cws[0] % q
39

40
    h = m_cal % p
41
    inv_h = mod_inverse(h, p)
42
    flag_bytes = []
43
    for i, cw in enumerate(data_cws):
44
        m = cw % q
45
        b = (m * inv_h) % p
46
        flag_bytes.append(int(b))
47
    flag_str = ''.join(chr(b) for b in flag_bytes)
48
    print(flag_str)
49

50
if __name__ == "__main__":
51
    main()

1
import gmpy2
2
from Crypto.Util.number import *
3
from secret import flag
4

5

6
p = getPrime(120)
7
q = getPrime(120)
8
n = p*q
9
phi = (p-1)*(q-1)
10
e = 65537
11
d = inverse(e, phi)
12
print("p =", p&((1<<70) - 1))
13

14
m = bytes_to_long(flag)
15
c = pow(m, e, n)
16
print(f'n = {n}')
17
print(f'c = {c}')
18

19

20
d = gmpy2.invert(e,(p-1)*(q-1))
21
c = pow(c, d, n)
22
print(long_to_bytes(c))
23

24
# p = 829064032203044318119
25
# n = 888793085913638480142106830358726592244023109092031700691387625262343693
26
# c = 523374243374032613886373469767323066972468234216292915827334155059267433
27
# b'T\x14\xae\xea\x0b*Z6\x92\x19\xe6\xc8\xde\x8f!T"\xb7[3\x9c\t\x92\x14Y\xe4\xa3\x8a\xd4\xe4'