Home Domain Help News About

How Are Cloud Servers Attacked? Replay, Source Routing, Data-Driven and Route Spoofing Explained

How Are Cloud Servers Attacked? Replay, Source Routing, Data-Driven and Route Spoofing Explained

Most people still picture a server attack as a flood: bandwidth saturates in seconds, pages stop loading, alerting lights up across the board. The attacks that are genuinely hard to investigate โ€” and far more likely to cost you data โ€” usually look nothing like that. They generate no traffic anomaly at all. Until somebody notices, the server appears to be working normally.

In one sentence: the four techniques in this article do not attack bandwidth. They attack gaps in protocol design, lapses in a program's memory handling, and a system's excessive trust in outside information. Because the attack surface is not traffic, scrubbing appliances do essentially nothing against them โ€” what works is closing those gaps, layer by layer.

This article helps operators recognise attack mechanisms and harden their own systems. Testing or attacking servers you do not own is illegal.

1. Replay Attacks: The Message Is Genuine, It Was Just Used Twice

A replay attack is disarmingly simple. The attacker captures a valid message on the wire, alters part of it or leaves it untouched, and sends it to the receiver again โ€” once or many times.

It works because the receiver is looking at a completely valid message with a correct signature, and its natural instinct is to accept it. No encryption has to be broken. All the attacker does is say the same thing a second time.

The damage depends on what was replayed. A resubmitted order causes a duplicate charge. A captured credential passes authentication again and again. A token that was supposed to be single-use, but never really was, gets used repeatedly. By the relationship between the receiver and the intended receiver, replays are classified as direct (sent back to the original verifier), reverse (sent back to the originator) and third-party (forwarded to another verifier in the same domain). By degree of alteration, they split into pure replays and "lightly modified" replays โ€” for instance, rewriting the timestamp so the message looks fresh.

The defence principle is to give every legitimate message both uniqueness and timeliness, and it usually comes as a set of three:

  • Timestamps. The message carries its creation time and the server accepts only requests inside a window (five minutes, say). Nothing has to be stored, but both clocks must agree โ€” and precise synchronisation across regions is not trivial.

  • Nonces. Every message carries a globally unique random value; the server records the ones it has seen and rejects repeats. No clock synchronisation is needed, but records must be stored, and the cost of storing and looking them up grows with the window.

  • Sequence numbers. Both sides maintain an incrementing integer, and a gap in the sequence signals an anomaly. No clock sync and little storage, but an attacker who can decrypt the message can read the number and forge a convincing increment.

In practice, timestamp plus nonce together is the sturdiest combination: you only store nonces for a short window, and the accuracy demanded of clock sync drops. Challengeโ€“response mechanisms and one-time passwords are just as widely deployed. At the transport layer, TLS itself has replay resistance built in โ€” provided you do not expose critical endpoints over a plaintext channel that has had those protections stripped away.

2. Protocol Weakness: How One Optional Field Slips Past a Firewall

The classic scenario here is an attacker trying to reach host X โ€” an internal machine sitting behind a firewall and unreachable from outside.

The mechanism uses the source-route option in the IP header (strict source routing, SSRR, and loose source routing, LSRR), which lets the sender name the intermediate routers a packet must traverse. The attacker builds a packet that does two things: the destination address is set to the firewall, so the firewall's own rules let it through; and the final address is placed in the source-route option, pointing at host X. The packet arrives and is permitted โ€” from the firewall's point of view this really is traffic addressed to it. Its IP layer then processes the source route, rewrites the destination and forwards the packet inward. The packet lands on a host that was supposed to be unreachable.

One widespread misconception needs correcting here. Source routing is decades old, and modern Linux kernels (since 2.6.39) ship with accept_source_route set to 0, so many people assume the issue passed them by. There are two reasons not to relax:

  • Some cloud images, container hosts and custom kernels โ€” and certain upgrade paths โ€” reset the value back to 1.

  • More importantly, source-route processing happens in the front of the kernel network stack, bypassing iptables entirely and producing no log entry. Even if the setting is open, a conventional firewall will tell you nothing.

What you can actually do:

  • Explicitly set net.ipv4.conf.all.accept_source_route = 0 and net.ipv4.conf.default.accept_source_route = 0; do the same for IPv6.

  • Changing all alone is not enough: newly created interfaces (Docker bridges, Kubernetes CNI links and the like) inherit the default value, so both must be covered.

  • Put the settings in a dedicated file under /etc/sysctl.d/ so other configuration or later changes do not overwrite them.

  • Afterwards, sweep every interface to confirm: cat /proc/sys/net/ipv4/conf/*/accept_source_route should read 0 across the board.

  • Turn off the companion parameters as well: rp_filter = 1 (reverse-path filtering, dropping packets whose source is unreachable), accept_redirects = 0 (no ICMP redirects, so the routing table cannot be silently rewritten) and ip_forward = 0 (a host that is not a router should not forward).

  • At the boundary, reject packets carrying source-route options outright. This is the single most effective measure.

One closing thought: source routing itself is deprecated, but the idea behind it โ€” using a protocol's "helper" feature to slip around boundary controls โ€” is very much alive. Any mechanism that lets an intermediate device rewrite your path or destination deserves its own review.

3. Data-Driven Attacks: When Data Gets Executed as Code

A data-driven attack is one in which the attacker sends or copies data or a program that looks harmless, and the attack begins when the target executes it. The lens for analysing this class is unusual: the real flaw is not in the network but in how a program handles input. Once such an attack succeeds, the attacker can modify security-related files and make the next intrusion easier, so the damage persists.

The usual family members:

  • Buffer overflow. More data is written than the buffer holds, and the excess overwrites adjacent memory โ€” including a function's return address โ€” changing the program's flow of execution. The classic case.

  • Format string. The program passes user input straight into a format string. Placeholders such as %s and %n let an attacker read memory and even write to an arbitrary address.

  • Weak input validation. A parameter that should be a number carries a command or path fragment instead, and that fragment is concatenated into a system call โ€” command injection or path traversal follows.

  • Race condition (TOCTOU). A window exists between the check and the use. Inside that window the attacker swaps out the object that already passed inspection โ€” replacing a regular file with a symbolic link, typically โ€” so what the program finally uses is not what was checked.

  • Trust flaws. The system trusts a party it should not. An IP-address-based trust relationship meets an impersonated peer, and the trust itself becomes the way in.

Defence works on three levels too:

  • Make overflows hard to exploit. Enable NX/DEP (non-executable data), ASLR (address randomisation), stack canaries and the compiler's hardening flags; for components with high memory-safety requirements, prefer an implementation in a memory-safe language.

  • Make input impossible to abuse. Validate every external input; invoke system commands through parameterised calls rather than string concatenation; use prepared statements for database access; normalise paths before validating them; re-check an object immediately before use to close the check-to-use window.

  • Limit the damage once something lands. Run services with least privilege, keep service accounts separate from privileged ones, verify the integrity of executables entering and leaving, and keep an audit trail of changes to critical configuration.

4. Route Spoofing: Making Traffic Detour Through the Attacker

The goal of this class is not to knock the server over; it is to read data in the middle of the path. The attacker forges routing information to construct a false path between source and destination, drawing traffic first through equipment they control and then on to the real destination โ€” capturing accounts, passwords and other sensitive content from the packets on the way. This is the textbook man-in-the-middle attack and route hijack.

The source text describes it as "sending forged router information". In today's terms, this corresponds mainly to carrier-scale BGP hijacking: rather than targeting your server, the attacker announces an IP prefix at the routing layer that does not belong to them, pulling global traffic toward their network. BGP was designed in an era of mutual trust โ€” when one network claims a block, others believe it by default โ€” and a more specific prefix (longer mask) usually wins, so announcing a single /25 can overshadow a /24 that somebody else is actually using.

The good news is that this route is being closed off. RPKI (Resource Public Key Infrastructure) answers a fundamental question cryptographically: "Is this address block really announced by this AS?" The holder signs an ROA (Route Origin Authorisation) through its RIR; networks enable ROV (Route Origin Validation) to compare, and discarding mismatches outright.

Here is where things actually stand in 2026. Among IPv4 routes observed in the global BGP table, 70.87% are RPKI-valid (NIST RPKI Monitor, October 2026), with 27.66% NotFound and only 1.47% Invalid; IPv6 coverage is higher still. China has been the key variable in this jump, moving its IPv4 valid-route ratio from single digits to over eighty percent.

But there is a gap that has to be seen clearly: ROA coverage measures how much authorisation data exists, while the ROV filter rate measures how many networks actually act on it โ€” and the two are not the same thing. Measured data puts the global ROV filter rate at just 26.92% on average (APNIC Labs, July 2026), and as low as 13.2% in the APNIC region. In other words, interception coverage has holes, and bad traffic flows through them โ€” the control plane shows nothing wrong while the data plane has already been redirected.

For cloud server users, the options split two ways:

  • If you hold your own address blocks and AS (enterprise lines, IDCs, cloud providers): publish ROAs, enable ROV filtering, and watch newer path-validation work such as ASPA.

  • If you simply rent a cloud server (the overwhelming majority): do not rest your security on routing. Assume the path may be redirected at any time, and make sure a redirect reads nothing useful โ€” force HTTPS site-wide, validate certificates, enable HSTS, encrypt sensitive data end to end, turn on DNSSEC on the DNS side and keep an eye on certificate transparency logs.

5. What the Four Have in Common

Look back and the resemblance is plain: none of them relies on volume. Replay leans on a legitimate message used twice, source routing on a rarely inspected protocol option, data-driven attacks on an input mistaken for code, route spoofing on the routing system's native trust.

That explains a question operators ask often: why do we still get hit with scrubbing in place and a high-protection plan purchased? Because scrubbing appliances, extra bandwidth and IP-ban thresholds do almost nothing against these four. What works is a different set of moves โ€” close the protocol switches properly, validate input properly, turn memory protections on, and make encryption the default.

6. Quick Reference

Attack

What it exploits

Fastest effective action

Replay

A message can be reused

Timestamp + nonce + signature checks

Protocol weakness (source routing)

A protocol option can bypass boundary control

Explicitly disable all and default, verify every interface reads 0

Data-driven

Data gets executed as code

Input validation + parameterisation + NX/ASLR/stack canaries

Route spoofing (BGP hijack)

The routing system trusts by default

HTTPS site-wide + DNSSEC + certificate validation

7. Hardening Order (by Return on Effort)

  1. Close the protocol switches first. Source routing, ICMP redirects, IP forwarding. One line of configuration, effective immediately, almost no side effects.

  2. Then fix input and memory. Validation, parameterisation, compiler hardening flags. The work sits in your code, but this is the class with the worst consequences.

  3. Then add encryption. HTTPS and HSTS, DNSSEC. This turns "the path might be redirected" into something you no longer have to worry about.

  4. Finally, put process in place. Anti-replay policy per endpoint, change auditing, and periodic re-checks of configuration โ€” because cloud images and system upgrades can quietly restore insecure values.

8. FAQ

Q1: Are these the same thing as DDoS?No. DDoS attacks the width of the pipe and wins by volume; these four attack the gaps in the rules, often with very little traffic โ€” sometimes a single packet is enough. Scrubbing is close to useless against them, and the work belongs in configuration, code and encryption.

Q2: My server is managed by a provider โ€” do I still need to worry about source routing?Yes. The default comes from the provider's image, but as soon as your own system or container platform is able to change it back, the risk sits on your side. The check is cat /proc/sys/net/ipv4/conf/*/accept_source_route โ€” all zeros is the pass mark.

Q3: Replay protection sounds easy, so why does it still go wrong?The mechanism is simple; covering everything is not. Payment, checkout and coupon endpoints โ€” any place where a repeat execution costs money โ€” must each be covered, and a single gap is an open door. Reliable clock synchronisation matters too, or legitimate requests get rejected by mistake.

Q4: RPKI coverage is already 70% โ€” can I stop worrying about route hijacking?That does not follow. Coverage says there is plenty of authorisation data; it does not say interception is carried out. The real filter rate averages under a third globally. For anyone renting cloud servers, the practical posture is to assume the path is never trustworthy and rely on end-to-end encryption as the backstop.

Q5: Data-driven attacks sound very low-level โ€” does a small site need to care?Yes, though the priorities shift. Most of the time your site runs on software somebody else wrote (a CMS, plugins, a framework), so the first job is patching promptly, the second is reducing publicly exposed functionality, and only the third is your own code. Fixing a buffer overflow is the component author's responsibility; deciding whether to run an outdated version is yours.


About SixCVM

SixCVM is a cloud server provider built for cross-border business and latency-sensitive applications, operating six core nodes across Hong Kong, Japan, the United States, Korea, Singapore and Vietnam on CN2 GIA and BGP optimised routes, with Hong Kong latency as low as under 10ms. Its portfolio covers cloud servers (VPS), GPU servers (NVIDIA A100 / H100 / RTX series), dedicated servers, bare metal servers and domain registration, all on NVMe SSD with minute-level provisioning, elastic resizing, snapshot backup and load balancing.

Against the four risks discussed here, what SixCVM contributes is concrete. Protocol-layer hazards such as source routing and ICMP redirects are disabled by default at the image level, and kernel parameters remain customisable, so your security baseline survives a reinstall or a system upgrade. Part of the defence against data-driven attacks comes from continuously updated image components, and part from snapshots โ€” once a compromise is confirmed you can roll the whole instance back to a clean state instead of repeatedly restoring from a contaminated backup. At the routing layer, CN2 GIA and BGP optimised routes are themselves vetted, stable paths, and the bundled domain registration service includes full DNS record management, making it straightforward to consolidate records, enable DNSSEC and enforce HTTPS. Combined with a 99.9% SLA and 24/7 technical support, it adds another layer of assurance for business continuity.

ย 


This article is intended solely to help users recognise attack mechanisms and harden their own systems. Attacking servers without authorisation is illegal โ€” please do not attempt it.


Related: Visit the SixCVM Server Security Center for the complete guide to protecting, detecting, and responding to server attacks.