a ctfer on the load

1
strings iec104.pcapng                                                                                                                                                                                                   18:56
2
13th Gen Intel(R) Core(TM) i9-13900HX (with SSE4.2)
3
64-bit Windows (24H2), build 26100
4
Dumpcap (Wireshark) 4.0.7 (v4.0.7-0-g0ad1823cc090)
5
\Device\NPF_Loopback
6
port 2404
7
64-bit Windows (24H2), build 26100
8
O3b"2
9
3b",
10
75b"2
11
n5b",
12
sp=&2
13
p=&,
14
Wq=&2
15
q=&,
16
%p'2
17
%p',
18
+p'2
19
+p',
20
Zmxh
21
Z3s4h
22
NmQ4h
23
ZTg3h
24
Yi1hh
25
YTBjh
26
LTQ5h
27
MTkth
28
YmU1h
29
Mi01h
30
ZjI5
31
NzE2h
32
NmQ3h
33
ZjB9h
34
S9+2
35
T9+,
36
W9+2
37
.W9+,
38
<Gi22
39
Gi2,
40
Hi22
41
Hi2,
42
Counters provided by dumpcap

1
Zmxh
2
Z3s4h
3
NmQ4h
4
ZTg3h
5
Yi1hh
6
YTBjh
7
LTQ5h
8
MTkth
9
YmU1h
10
Mi01h
11
ZjI5
12
NzE2h
13
NmQ3h
14
ZjB9h

1
import base64
2
import sys
3
import time
4

5
import cv2
6
import numpy as np
7
import requests
8

9
base_url = sys.argv[1] if len(sys.argv)>1 else "http://47.98.117.93:55956"
10
session = requests.Session()
11
def b64_to_img(s):
12
    if s.startswith("data:"):
13
        s = s.split(",",1)[1]
14
    b = base64.b64decode(s)
15
    arr = np.frombuffer(b, dtype=np.uint8)
16
    img = cv2.imdecode(arr, cv2.IMREAD_UNCHANGED)
17
    return img
18
def find_x(slice_img, bg_img):
19
    if slice_img is None or bg_img is None:
20
        return 0
21
    if slice_img.ndim==3 and slice_img.shape[2]==4:
22
        alpha = slice_img[:,:,3]
23
        mask = (alpha>10).astype(np.uint8)*255
24
        tpl = cv2.cvtColor(slice_img[:,:,:3], cv2.COLOR_BGR2GRAY)
25
        bg = cv2.cvtColor(bg_img, cv2.COLOR_BGR2GRAY)
26
        res = cv2.matchTemplate(bg, tpl, cv2.TM_CCORR_NORMED, mask=mask)
27
    else:
28
        tpl = cv2.cvtColor(slice_img if slice_img.ndim==3 else slice_img, cv2.COLOR_BGR2GRAY) if slice_img.ndim==3 else slice_img
29
        bg = cv2.cvtColor(bg_img if bg_img.ndim==3 else bg_img, cv2.COLOR_BGR2GRAY) if bg_img.ndim==3 else bg_img
30
        res = cv2.matchTemplate(bg, tpl, cv2.TM_CCOEFF_NORMED)
31
    _, _, _, max_loc = cv2.minMaxLoc(res)
32
    return int(max_loc[0])
33
flag = None
34
for attempt in range(10):
35
    r = session.get(base_url.rstrip("/") + "/captcha", timeout=10)
36
    j = r.json()
37
    slice_b64 = j.get("slice") or j.get("suffle_slice_bg")
38
    bg_b64 = j.get("src_bg") or j.get("suffle_bg")
39
    y_pos = j.get("y_pos",0)
40
    slice_img = b64_to_img(slice_b64)
41
    bg_img = b64_to_img(bg_b64)
42
    x = find_x(slice_img, bg_img)
43
    payload = {"x_pos": x}
44
    r2 = session.post(base_url.rstrip("/") + "/validate", json=payload, timeout=10)
45
    resp = r2.json()
46
    if resp.get("code")==0 and resp.get("count") and resp.get("max") and resp.get("count")>=resp.get("max"):
47
        print(resp.get("msg"))
48
        flag = resp.get("msg")
49
        break
50
    if resp.get("code")==0 and resp.get("msg") and ("flag" in str(resp.get("msg")).lower()):
51
        print(resp.get("msg"))
52
        flag = resp.get("msg")
53
        break
54
    time.sleep(0.3)
55
if flag is None:
56
    last = resp.get("msg") if 'resp' in locals() and isinstance(resp,dict) else "未获得flag"
57
    print(last)

1
s_box = [
2
]
3
inv_s_box = [0]*256
4
for i,v in enumerate(s_box):
5
    inv_s_box[v]=i
6
rcon = []
7

8
cc = b'\xbb\x0f\n\t\x11\xbd\xec~\xbb\x1d\xcf\xe1\xd0\xfd\x14q'
9
rk9_c0 = [127,106,114,135]
10
rk10_c0 = [201,200,41,139]
11
rk9_c2 = [156,228,163,135]
12
rk10_c2 = [209,238,234,51]
13

14
def build_prev_new(a0,a8,b0,b8):
15
    prev=[0]*16
16
    new=[0]*16
17
    for i in range(4):
18
        prev[i]=a0[i]
19
        new[i]=b0[i]
20
    for i in range(4):
21
        prev[8+i]=a8[i]
22
        new[8+i]=b8[i]
23
    temp=[new[i]^prev[i] for i in range(4)]
24
    temp0_before = temp[0] ^ rcon[9]
25
    prev[13]=inv_s_box[temp0_before]
26
    prev[14]=inv_s_box[temp[1]]
27
    prev[15]=inv_s_box[temp[2]]
28
    prev[12]=inv_s_box[temp[3]]
29
    for i in range(4):
30
        new[12+i]= new[8+i] ^ prev[12+i]
31
    for i in range(4):
32
        new[4+i]= new[8+i] ^ prev[8+i]
33
    for i in range(4):
34
        prev[4+i]= new[i] ^ new[4+i]
35
    return prev,new
36

37
def invert_round(new_key, idx):
38
    prev=[0]*16
39
    for j in range(4,16):
40
        prev[j]= new_key[j] ^ new_key[j-4]
41
    temp = [ s_box[prev[13]], s_box[prev[14]], s_box[prev[15]], s_box[prev[12]] ]
42
    temp[0] ^= rcon[idx-1]
43
    for i in range(4):
44
        prev[i] = new_key[i] ^ temp[i]
45
    return prev
46

47
prev9, new10 = build_prev_new(rk9_c0, rk9_c2, rk10_c0, rk10_c2)
48
cur = new10[:]
49
for r in range(10,0,-1):
50
    cur = invert_round(cur, r)
51
original_key = bytes(cur)
52

53
class AES_local:
54
    s_box = s_box
55
    inv_s_box = inv_s_box
56
    rcon = rcon
57
    def __init__(self,key):
58
        self.key=key
59
        self.round_keys=self._key_expansion(key)
60
    def _key_expansion(self,key):
61
        round_keys=[list(key)]
62
        for i in range(10):
63
            prev_key=round_keys[-1]
64
            new_key=[0]*16
65
            temp=prev_key[13:16]+[prev_key[12]]
66
            temp=[self.s_box[b] for b in temp]
67
            temp[0]^=self.rcon[i]
68
            for j in range(4):
69
                new_key[j]=prev_key[j]^temp[j]
70
            for j in range(4,16):
71
                new_key[j]=new_key[j-4]^prev_key[j]
72
            round_keys.append(new_key)
73
        return round_keys
74
    def _inv_shift_rows(self,state):
75
        matrix=[state[i:i+4] for i in range(0,16,4)]
76
        return [matrix[0][0],matrix[3][1],matrix[2][2],matrix[1][3],matrix[1][0],matrix[0][1],matrix[3][2],matrix[2][3],matrix[2][0],matrix[1][1],matrix[0][2],matrix[3][3],matrix[3][0],matrix[2][1],matrix[1][2],matrix[0][3]]
77
    def _inv_sub_bytes(self,state): return [self.inv_s_box[b] for b in state]
78
    def _inv_mix_columns(self,state):
79
        def gmul(a,b):
80
            p=0
81
            for _ in range(8):
82
                if b&1: p^=a
83
                hi=a&0x80
84
                a=(a<<1)&0xFF
85
                if hi: a^=0x1b
86
                b>>=1
87
            return p
88
        result=[0]*16
89
        for i in range(4):
90
            col=state[i*4:(i+1)*4]
91
            result[i*4]=gmul(0x0e,col[0])^gmul(0x0b,col[1])^gmul(0x0d,col[2])^gmul(0x09,col[3])
92
            result[i*4+1]=gmul(0x09,col[0])^gmul(0x0e,col[1])^gmul(0x0b,col[2])^gmul(0x0d,col[3])
93
            result[i*4+2]=gmul(0x0d,col[0])^gmul(0x09,col[1])^gmul(0x0e,col[2])^gmul(0x0b,col[3])
94
            result[i*4+3]=gmul(0x0b,col[0])^gmul(0x0d,col[1])^gmul(0x09,col[2])^gmul(0x0e,col[3])
95
        return result
96
    def _add_round_key(self,state,round_key): return [state[i]^round_key[i] for i in range(16)]
97
    def decrypt(self,ciphertext):
98
        state=list(ciphertext)
99
        state=self._add_round_key(state,self.round_keys[10])
100
        state=self._inv_shift_rows(state)
101
        state=self._inv_sub_bytes(state)
102
        for round_num in range(9,0,-1):
103
            state=self._add_round_key(state,self.round_keys[round_num])
104
            state=self._inv_mix_columns(state)
105
            state=self._inv_shift_rows(state)
106
            state=self._inv_sub_bytes(state)
107
        state=self._add_round_key(state,self.round_keys[0])
108
        return bytes(state)
109

110
pt = AES_local(original_key).decrypt(cc)
111
print(pt)

1
from cryptography.hazmat.backends import default_backend
2
from cryptography.hazmat.primitives.ciphers import Cipher, algorithms, modes
3

4
M = 38873
5
CHECKSUMS = [30328, 18774, 1692, 31709]
6
CIPHERTEXT_HEX = ""
7
CIPHERTEXT = bytes.fromhex(CIPHERTEXT_HEX)
8
CT_BLOCK_1 = CIPHERTEXT[:16]
9

10
C = CHECKSUMS
11
c4 = C[2]
12
b4 = C[1]
13
a4 = C[0]
14

15
d4 = C[3]
16
d3 = (C[3] - 5 * c4) % M
17
c3 = (C[2] - 5 * b4) % M
18
d2 = (d3 - 4 * c3) % M
19
b3 = (C[1] - 5 * a4) % M
20
c2 = (c3 - 4 * b3) % M
21
d1 = (d2 - 3 * c2) % M
22

23
def unpad_pkcs7(data):
24
    if not data:
25
        return b''
26
    padding_len = data[-1]
27
    if padding_len > len(data) or padding_len == 0:
28
        return data
29
    if data[-padding_len:] != bytes([padding_len]) * padding_len:
30
        return data
31
    return data[:-padding_len]
32

33
found = False
34
for d0_guess in range(M):
35
    if d0_guess % 5000 == 0:
36
        print(f"  ... F_CHECK: 正在尝试 d0 = {d0_guess}")
37

38
    state_vector = [d0_guess, d1, d2, d3, d4]
39

40
    key_material = 0
41
    for element in state_vector:
42
        key_material = (key_material + element) * 65536
43

44
    byte_length = (key_material.bit_length() + 7) // 8
45
    if byte_length == 0:
46
        byte_length = 1
47
    key_bytes = key_material.to_bytes(byte_length, 'big')
48

49
    block_size = 16
50
    padding_length = block_size - (len(key_bytes) % block_size)
51
    if padding_length == 0:
52
        padding_length = block_size
53
    padding_byte = padding_length.to_bytes(1, 'big')
54
    key_candidate = key_bytes + padding_byte * padding_length
55

56
    if len(key_candidate) not in [16, 24, 32]:
57
        continue
58

59
    try:
60
        cipher = Cipher(algorithms.AES(key_candidate), modes.ECB(), backend=default_backend())
61
        decryptor = cipher.decryptor()
62

63
        pt_block_1 = decryptor.update(CT_BLOCK_1)
64

65
        flag_found = False
66
        if pt_block_1.startswith(b'VCTF'):
67
            flag_found = True
68
            prefix = "VCTF"
69
        elif pt_block_1.startswith(b'flag'):
70
            flag_found = True
71
            prefix = "flag"
72

73
        if flag_found:
74

75
            full_decryptor = cipher.decryptor()
76
            padded_flag = full_decryptor.update(CIPHERTEXT) + full_decryptor.finalize()
77

78
            try:
79
                flag = unpad_pkcs7(padded_flag)
80
                print(f"Flag: {flag.decode('utf-8')}")
81
            except Exception as e:
82
                print(f"Flag: {padded_flag}")
83

84
            print("="*30)
85
            found = True
86
            break
87

88
    except Exception:
89
        continue
90

91
if not found:
92
    print("0")

1
myprime = [864119, 989837, 698437, 724469, 543379, 833281, 916537, 864221, 920743, 906539, 878719, 532331, 694619, 769357, 787181, 723257, 812213, 983519, 737747, 1017031]
2
cc = [423083, 495840, 544283, 571240, 289138, 194415, 271148, 348295, 209494, 533624, 530740, 519792, 673659, 533658, 765468, 193697, 258028, 354419, 279321, 855351]
3
from functools import reduce
4

5
from sympy import mod_inverse
6

7

8
def crt(vals, mods):
9
    M = reduce(lambda x, y: x*y, mods)
10
    x = 0
11
    for v, m in zip(vals, mods):
12
        Mi = M // m
13
        x += v * Mi * mod_inverse(Mi, m)
14
    return x % M
15

16
c = crt(cc, myprime)

1
import itertools
2

3
from sage.all import *
4

5

6
def small_roots(f, bounds, m=1, d=None):
7
    if not d:
8
        d = f.degree()
9

10
    if isinstance(f, Polynomial):
11
        x, = polygens(f.base_ring(), f.variable_name(), 1)
12
        f = f(x)
13

14
    R = f.base_ring()
15
    N = R.cardinality()
16

17
    leading = 1 / f.coefficients().pop(0)
18
    f = f.map_coefficients(lambda x: x * leading)
19
    f = f.change_ring(ZZ)
20

21
    G = Sequence([], f.parent())
22
    for i in range(m+1):
23
        base = N^(m-i) * f^i
24
        for shifts in itertools.product(range(d), repeat=f.nvariables()):
25
            g = base * prod(map(power, f.variables(), shifts))
26
            G.append(g)
27

28
    B, monomials = G.coefficient_matrix()
29
    monomials = vector(monomials)
30

31
    factors = [monomial(*bounds) for monomial in monomials]
32
    for i, factor in enumerate(factors):
33
        B.rescale_col(i, factor)
34

35
    B = B.dense_matrix().LLL()
36

37
    B = B.change_ring(QQ)
38
    for i, factor in enumerate(factors):
39
        B.rescale_col(i, 1/factor)
40

41
    H = Sequence([], f.parent().change_ring(QQ))
42
    for h in filter(None, B*monomials):
43
        H.append(h)
44
        I = H.ideal()
45
        if I.dimension() == -1:
46
            H.pop()
47
        elif I.dimension() == 0:
48
            roots = []
49
            for root in I.variety(ring=ZZ):
50
                root = tuple(R(root[var]) for var in f.variables())
51
                roots.append(root)
52
            return roots
53

54
    return []
55

56
n =
57

58
r =
59
c =
60

61
ZmodN = Zmod(n)
62
R.<x, y> = PolynomialRing(ZmodN, 2)
63

64
inv_c = ZmodN(c)^(-1)
65

66
G = x^2 + (inv_c*y^2 - r*y)*x + c*y
67

68
X = 2^512
69
Y = 2^256
70
roots =small_roots(f=G,bounds=(X,Y))print(roots)
71
'''
72
[(4517960149743617262479387554928775714727358431637482848368601283360363012782928055092350531203736992717754528773032259622659840441122191051128801652187517, 102390112361178369459644705765764088479767980533301036145930310111420575040527), (0, 0)]
73
'''
74

75
from Crypto.Util.number import *
76

77
print(long_to_bytes(4517960149743617262479387554928775714727358431637482848368601283360363012782928055092350531203736992717754528773032259622659840441122191051128801652187517))

1
 ls                                                                                                                                                                                                                     Alice.csv  Bob.csv  encrypt.py  final_task.enc  hint.png

1
import csv
2
import hashlib
3
import statistics
4

5
from Crypto.Cipher import AES
6
from Crypto.Util.Padding import unpad
7

8
G = int("163d", 16)
9
P = int("17fe488340020cf9ac3016a2ec2baaa199d09bd77a7eb7d7920e6269093c62173", 16)
10

11

12

13
def load_times(path: str):
14
    with open(path, newline='') as f:
15
        return [int(row[0]) for row in csv.reader(f)]
16

17

18
def reshape_traces(flat, n_traces=50):
19
    assert len(flat) % n_traces == 0
20
    n_steps = len(flat) // n_traces
21
    return [flat[i * n_steps:(i + 1) * n_steps] for i in range(n_traces)]
22

23

24
def kmeans_1d(data, iters=30):
25
    c0, c1 = min(data), max(data)
26
    for _ in range(iters):
27
        s0, s1 = [], []
28
        for x in data:
29
            (s0 if abs(x - c0) <= abs(x - c1) else s1).append(x)
30
        c0 = sum(s0) / len(s0)
31
        c1 = sum(s1) / len(s1)
32
    return (c0, c1) if c0 < c1 else (c1, c0)
33

34

35
def recover_bits_from_matrix(mat):
36
    cols = list(zip(*mat))  # 列
37
    means = [statistics.mean(col) for col in cols]
38

39
    low, high = kmeans_1d(means)
40
    bits = [1 if abs(m - high) < abs(m - low) else 0 for m in means]
41

42
    return bits, (low, high)
43

44

45
def bits_to_int_lsb(bits):
46
    v = 0
47
    for i, b in enumerate(bits):
48
        if b:
49
            v |= 1 << i
50
    return v
51

52

53

54
def main():
55
    alice_times = load_times("/Users/zsm/Downloads/crypto_碰碰碰，撞撞撞/Alice.csv")
56
    bob_times = load_times("/Users/zsm/Downloads/crypto_碰碰碰，撞撞撞/Bob.csv")
57
    alice_mat = reshape_traces(alice_times, 50)
58
    bob_mat = reshape_traces(bob_times, 50)
59
    alice_bits, _ = recover_bits_from_matrix(alice_mat)
60
    bob_bits, _ = recover_bits_from_matrix(bob_mat)
61

62
    alice_int = bits_to_int_lsb(alice_bits + [1])
63
    bob_int = bits_to_int_lsb(bob_bits + [1])
64
    session_key = pow(G, alice_int * bob_int, P)
65

66
    with open("/Users/zsm/Downloads/crypto_碰碰碰，撞撞撞/final_task.enc", "rb") as f:
67
        ciphertext = f.read()
68

69
    key_bytes = hashlib.md5(hex(session_key)[2:].encode()).digest()
70
    cipher = AES.new(key_bytes, AES.MODE_ECB)
71
    plaintext_padded = cipher.decrypt(ciphertext)
72

73
    try:
74
        plaintext = unpad(plaintext_padded, 16)
75
    except ValueError:
76
        return
77
    with open("task.py", "wb") as f:
78
        f.write(plaintext)
79

80
    print(plaintext[:100].decode("utf-8", "ignore"))
81

82

83
if __name__ == "__main__":
84
    main()

1
# -*- coding: utf-8 -*-
2

3
from Crypto.Util.number import long_to_bytes, bytes_to_long, getPrime, inverse
4
from hashlib import md5
5
from os import urandom
6
from secret import FLAG
7

8
import base64
9
import random
10
import threading
11
import socketserver
12
import string
13

14
class Challenge:
15

16
    def __init__(self):
17
        self.p = getPrime(1024)
18
        self.q = getPrime(1024)
19
        self.n = self.p * self.q
20
        self.phi = (self.p - 1) * (self.q - 1)
21
        self.user_db = []
22

23
    def save(self, username, keyint):
24
        key = long_to_bytes(keyint)
25
        key_commit = md5(key).digest()
26
        username_int = bytes_to_long(username)
27
        username_enc = pow(username_int, keyint, self.n)
28
        self.user_db.append((username_enc, key_commit))
29

30
    def check(self, index, keyint):
31
        key = long_to_bytes(keyint)
32
        assert md5(key).digest() == self.user_db[index][1], "Invalid key"
33
        username_enc = self.user_db[index][0]
34
        d = inverse(keyint, self.phi)
35
        username_dec = pow(username_enc, d, self.n)
36
        username = base64.b64encode(long_to_bytes(username_dec)).decode()
37
        assert "VCTF" in username, "Not Admin"
38

39
class Task(socketserver.BaseRequestHandler):
40

41
    def __init__(self, *args, **kargs):
42
        super().__init__(*args, **kargs)
43
        self.timeout_timer = None
44

45
    def timeout_handler(self):
46
        raise TimeoutError("Connection timed out (600s)")
47

48
    def dosend(self, msg):
49
        try:
50
            self.request.sendall(msg.encode("utf-8") + b"\n")
51
        except:
52
            pass
53

54
    def register(self):
55
        self.dosend(f"Give me your key >>>")
56
        buf = b""
57
        while len(buf) < 1000:
58
            recv_data = self.request.recv(1)
59
            if not recv_data:
60
                return
61
            buf += recv_data
62
            if buf[-1:] == b"\n":
63
                break
64
        your_key = buf.decode().strip()
65

66
        try:
67
            your_key_int = int(your_key, 16)
68
        except ValueError:
69
            self.dosend("Error: Key must be hexadecimal (e.g., a1b2c3)")
70
            return
71

72
        self.dosend(f"Give me your username >>>")
73
        buf = b""
74
        while len(buf) < 10:
75
            recv_data = self.request.recv(1)
76
            if not recv_data:
77
                return
78
            buf += recv_data
79
            if buf[-1:] == b"\n":
80
                break
81
        buf = buf[:-1].strip()
82

83
        try:
84
            assert "vctf" in buf, "Not admin."
85
            assert len(buf) <= 5, "Too long."
86
            self.chall.save(buf, your_key_int)
87
            self.dosend("Register success! Your index is: " + str(len(self.chall.user_db) - 1))
88
        except AssertionError as e:
89
            self.dosend(f"Register failed: {e}")
90
            return
91

92
    def get_flag(self):
93
        self.dosend(f"Give me your key >>>")
94
        buf = b""
95
        while len(buf) < 1000:
96
            recv_data = self.request.recv(1)
97
            if not recv_data:
98
                return
99
            buf += recv_data
100
            if buf[-1:] == b"\n":
101
                break
102
        your_key = buf.decode().strip()
103

104
        try:
105
            your_key_int = int(your_key, 16)
106
        except ValueError:
107
            self.dosend("Error: Key must be hexadecimal (e.g., a1b2c3)")
108
            return
109

110
        self.dosend(f"Give me your index >>>")
111
        buf = b""
112
        while len(buf) < 1000:
113
            recv_data = self.request.recv(1)
114
            if not recv_data:
115
                return
116
            buf += recv_data
117
            if buf[-1:] == b"\n":
118
                break
119
        index_str = buf.decode().strip()
120

121
        try:
122
            index = int(index_str)
123
            assert index >= 0 and index < len(self.chall.user_db), f"Invalid index (must be 0~{len(self.chall.user_db)-1})"
124
        except ValueError:
125
            self.dosend("Error: Index must be an integer (e.g., 0)")
126
            return
127
        except AssertionError as e:
128
            self.dosend(f"Index error: {e}")
129
            return
130

131
        try:
132
            self.chall.check(index, your_key_int)
133
            self.dosend(f"馃帀FLAG: {FLAG}")
134
        except AssertionError as e:
135
            self.dosend(f"Get flag failed: {e}")
136
            return
137

138
    def handle(self):
139
        try:
140
            self.timeout_timer = threading.Timer(600, self.timeout_handler)
141
            self.timeout_timer.start()
142

143
            self.chall = Challenge()
144
            self.dosend(f"p = {self.chall.p}")
145
            self.dosend(f"q = {self.chall.q}")
146

147
            while True:
148
                self.dosend(f"[R]egister")
149
                self.dosend(f"[G]et Flag")
150
                self.dosend(f"[E]xit")
151
                self.dosend(f"Your choice >>>")
152

153
                buf = b""
154
                while len(buf) < 1000:
155
                    recv_data = self.request.recv(1)
156
                    if not recv_data:
157
                        return
158
                    buf += recv_data
159
                    if buf[-1:] == b"\n":
160
                        break
161
                choice_str = buf.decode().strip()
162

163
                try:
164
                    choice = choice_str
165
                except ValueError:
166
                    self.dosend("Error: Invalid input.")
167
                    continue
168

169
                if choice.upper() == "R":
170
                    self.register()
171
                elif choice.upper() == "G":
172
                    self.get_flag()
173
                elif choice.upper() == "E":
174
                    self.dosend("Goodbye!")
175
                    self.timeout_timer.cancel()
176
                    self.request.close()
177
                    return
178
                else:
179
                    self.dosend("Error: Invalid input.")
180
        except TimeoutError as e:
181
            self.dosend(f"Timeout: {e}")
182
            return
183
        except Exception as e:
184
            return
185
        finally:
186
            if self.timeout_timer:
187
                self.timeout_timer.cancel()
188
            self.request.close()
189

190

191
class SimpleServer(socketserver.TCPServer):
192
    pass
193

194

195
if __name__ == "__main__":
196
    HOST, PORT = "0.0.0.0", 8888
197
    try:
198
        server = SimpleServer((HOST, PORT), Task)
199
        server.allow_reuse_address = True
200
        server.serve_forever()
201
    except OSError as e:
202
        print(f"Error: {e}")
203
    except KeyboardInterrupt:
204
        print("Server have died.")