This weakness occurs when software sends sensitive data over a communication channel without verifying that the message hasn't been altered in transit. An…
This weakness occurs when software sends sensitive data over a communication channel without verifying that the message hasn't been altered in transit. An attacker positioned between the sender and receiver can intercept and modify the data without detection, compromising confidentiality and authenticity. This is distinct from encryption alone — even encrypted data can be modified if integrity checks are absent.
Communication integrity relies on cryptographic signatures or message authentication codes (MACs) that prove a message hasn't been tampered with. When software omits these checks, it assumes the channel is trustworthy or that encryption alone is sufficient. In reality, an attacker with network access (via man-in-the-middle positioning, DNS hijacking, or compromised infrastructure) can intercept packets, modify their contents, and forward them onward. The receiver has no way to detect the alteration because no integrity proof was included with the message.
This is especially dangerous when the modified data triggers critical actions — changing a payment amount, altering user permissions, or injecting malicious instructions into a configuration update.
Undetected message modification can lead to unauthorized transactions, privilege escalation, data corruption, or injection of malware into software updates. For example, if an API response containing user permissions is modified in transit without integrity verification, an attacker could elevate their own privileges. If a firmware update is intercepted and altered, devices could be compromised at scale. The attacker leaves no obvious trace because the application accepts the modified data as legitimate.
import socket
import json
def send_user_data(host, port, user_id, balance):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
message = json.dumps({"user_id": user_id, "balance": balance})
sock.sendall(message.encode())
response = sock.recv(1024).decode()
sock.close()
return responseWhy it's vulnerable:
The message is sent in plaintext (or even if encrypted) without any integrity check. An attacker on the network can intercept and modify the JSON payload — for example, changing the balance value — and the receiver will process the altered data without detecting the tampering.
import socket
import json
import hmac
import hashlib
SECRET_KEY = b"shared_secret_key"
def send_user_data(host, port, user_id, balance):
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((host, port))
message = json.dumps({"user_id": user_id, "balance": balance})
mac = hmac.new(SECRET_KEY, message.encode(), hashlib.sha256).hexdigest()
payload = json.dumps({"data": message, "mac": mac})
sock.sendall(payload.encode())
response = sock.recv(1024).decode()
sock.close()
return response<?php
$user_id = $_POST['user_id'];
$balance = $_POST['balance'];
$message = json_encode(['user_id' => $user_id, 'balance' => $balance]);
$ch = curl_init('https://api.example.com/update');
curl_setopt($ch, CURLOPT_POSTFIELDS, $message);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Why it's vulnerable:
The message is sent without a signature or MAC. Even over HTTPS, if the endpoint doesn't verify message integrity, a compromised intermediary or a man-in-the-middle attacker can modify the JSON before it reaches the server.
<?php
$user_id = $_POST['user_id'];
$balance = $_POST['balance'];
$secret_key = 'shared_secret_key';
$message = json_encode(['user_id' => $user_id, 'balance' => $balance]);
$mac = hash_hmac('sha256', $message, $secret_key);
$payload = json_encode(['data' => $message, 'mac' => $mac]);
$ch = curl_init('https://api.example.com/update');
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload);
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
$response = curl_exec($ch);
curl_close($ch);
echo $response;
?>Monitor for unexpected changes to critical data (user permissions, account balances, configuration values) that occur without corresponding audit logs or user actions. Check application logs for integrity verification failures or rejected messages. If you observe data corruption or unauthorized modifications that correlate with network traffic patterns, integrity checks may be missing.
