1.  
2. import socket
3. import threading
4. import configparser
5. from struct import *
6.  
7. PORT = 25565
8. maxpolaczenia = 20
9. server = socket.socket()
10. server.bind(('', PORT))
11.  
12.  
13. def varint_pack(d):
14.     o = b''
15.     while True:
16.         b = d & 0x7F
17.         d >>= 7
18.         o += pack("B", b | (0x80 if d > 0 else 0))
19.         if d == 0:
20.             break
21.     return o
22.  
23.  
24. def varint_unpack(s):
25.     d, l = 0, 0
26.     length = len(s)
27.     if length > 5:
28.         length = 5
29.     for i in range(length):
30.         l += 1
31.         b = s[i]
32.         d |= (b & 0x7F) << 7 * i
33.         if not b & 0x80:
34.             break
35.     return (d, s[l:])
36.  
37.  
38. def data_pack(data):
39.     return varint_pack(len(data)) + data
40.  
41.  
42. def data_unpack(bytes):
43.     length, bytes = varint_unpack(bytes)
44.     return bytes[:length], bytes[length:]
45.  
46.  
47. def string_pack(string):
48.     return data_pack(string.encode())
49.  
50.  
51. def string_unpack(bytes):
52.     string, rest = data_unpack(bytes)
53.     return string.decode(), rest
54.  
55. """
56. def struct_unpack(format, struct):
57.     data = unpack_from(format, struct)
58.     rest = struct[calcsize(format):]
59.     return data, rest
60. """
61.  
62. def sendd(se, id, data):
63.     packid = varint_pack(int(id, 16))
64.     se.send(data_pack(packid + data))
65.  
66.  
67. def handShake(version, host, port, next):
68.     if next == 2:
69.         global mode
70.         mode = "login"
71.  
72.     version = varint_pack(version)
73.     host = string_pack(host)
74.     port = pack('!H', port)
75.     next = varint_pack(next)
76.     return version + host + port + next
77.  
78.  
79. def Login(name):
80.     name = string_pack(name)
81.     return name
82.  
83. def _send_data(connection, *args):
84.     """ Send the data on the connection """
85.     data = b''
86.  
87.     for arg in args:
88.         data += data_pack(arg)
89.  
90.     connection.send(varint_pack(len(data)) + data)
91.  
92.  
93. class listener(threading.Thread):
94.     def __init__(self):
95.         threading.Thread.__init__(self)
96.  
97.     def run(self):
98.         while True:
99.             addr = server.listen(maxpolaczenia)
100.             local_socket, local_address = server.accept()
101.             print(str(local_address[0]) + ":" + str(local_address[1]) + " " + "Connected to the proxy!")
102.             user = client(local_socket).start()
103.  
104.  
105.  
106. #            local_socket.close()
107.  
108. #     print(str(local_address[0] + ":" + local_address[1]))
109.  
110. class client(threading.Thread):
111.     def __init__(self, s):
112.         threading.Thread.__init__(self)
113.         self.s = s
114.  
115.     def run(self):
116.         user = socket.socket()
117.         try:
118.             print("Laczenie..")
119.             user.connect(("localhost", 25567))
120.         except:
121.             print("Nie udalo sie polaczyc z serwerem!")
122.  
123.         while 1:
124.             data = self.s.recv(4096)
125.             if data  == b"":
126.                 pass
127.             elif data == b"\x06\x00/\x00c\xdd\x02\n\x00\x08Masloids":
128.                 user.sendall(data)
129.                 print(data)
130.                 #p = player(user, self.s)
131.             else:
132.                 user.sendall(data)
133.                 print(str(data))
134.  
135.  
136.  
137. """
138.         elif data == b"\x06\x00/\x00c\xdd\x02\n\x00\x08Masloids":
139.             print("Przechwycono handshake!")
140.             print("Zamieniam...")
141.             try:
142.                 user.sendall(data)
143.                 while 1:
144.                     lol = user.recv(1024)
145.                     self.s.sendall(lol)
146.                     # print(str(lol))
147.                 # sendd(user, "0x00", Login("Masloids"))
148.             except:
149.                 print("Nie zamieniono!")
150.  
151.  
152.         else:
153.             print(data)
154.             user.send(data)
155.             # self.s.sendall(data)
156.  
157. """
158. class player(threading.Thread):
159.  
160.     def __init__(self, soc, s):
161.         threading.Thread.__init__(self)
162.         self.soc = soc
163.         self.s = s
164.  
165.     def run(self):
166.         while 1:
167.             lol = self.soc.recv(1024)
168.             self.s.sendall(lol)
169.  
170.  
171. listener = listener().start()
172.  
173.