Posted in Threat Intelligence
This Is What Pre-Attack Reconnaissance Looks Like From Inside the Deception While reviewing data from my…
Pete — Honeypot Operator / Cybersecurity / Threat Researcher / Breaker of All Things /
This Is What Pre-Attack Reconnaissance Looks Like From Inside the Deception
While reviewing data from my weekly platform sweep, I caught something that stood out from the noise — a two-stage pre-attack reconnaissance framework operating against my deception infrastructure.
NOTE This is long, IOC's are provided at the end
November 4, 03:35 UTC
Stage 1 — the automated sweep, the token pattern, the OS fingerprint commands
session.connect
login.success root admin
echo ZqbpuytizwQz
cat /proc/version 2>/dev/null;echo VEND
ls / 2>&1 | head -5;echo LEND
login.success root 1234
echo Zqa2szg1qxQz
cat /proc/version 2>/dev/null;echo VEND
ls / 2>&1 | head -5;echo LEND
login.success root 12345
echo Zqamb8ec0gQz
cat /proc/version 2>/dev/null;echo VEND
ls / 2>&1 | head -5;echo LEND
What happened: There was 20+ sessions in 70 seconds. Every successful password-based login gets the exact same 3 commands. Unique Zq...Qz token per session. Connect, fingerprint, move on. But let's highllight about something about that..
We see that there is a pattern.. for every successful login at this stage, there is a VEND, and then a LEND. The last session captured, there was a VEND, but no LEND. Was it a timeout? Was it deliberate? Can we trace it? Let's look at the timestamps
Below, we see that the everage time of each complete session is approx 6-7 seconds.. The last one, shows that the session dropped before 6 seconds, so
something could have happened along the way, a hiccup, anything. The point being, the framework they were using, has a strict window.
Why is this important: Because, it reveals something about the actor's framework - It is not waiting for responses. Spits out the command, collects and parses what it gets back, and moves on, all while listening within a fixed window. It's volume vs selective targetting.
This is reconnaissance at scale. The goal is not to deeply compromise one target. The goal is to map as many assets as possible, as fast as possible, and feed that data back to the operator for triage
03:35:43 — session.connect
03:35:45 — login.success root admin
03:35:46 — echo ZqbpuytizwQz
03:35:48 — cat /proc/version;echo VEND
03:35:49 — ls /;echo LEND
03:35:52 — session.connect
03:35:53 — login.success root default (no commands)
03:35:56 — session.connect
03:35:57 — login.success root 1234
03:35:57 — echo Zqa2szg1qxQz
03:35:59 — cat /proc/version;echo VEND
03:36:00 — ls /;echo LEND
03:36:02 — session.connect
03:36:03 — login.success root 12345
03:36:03 — echo Zqamb8ec0gQz
03:36:05 — cat /proc/version;echo VEND
← NO LEND. Session dropped.
03:36:09 — next session.connect
Stage 2 — the deliberate return, deeper recon, shell validation
Let's see what happened in Stage 2
Stage 2. November 5. One day later. One session
2026-11-05T01:02 — session.connect
login.success root root
echo Zq69pxyaujQz
id 2>/dev/null;ls /dev 2>/dev/null|head -8;cat /etc/passwd 2>/dev/null|head -2;cat /proc/version 2>/dev/null;echo $((17*3));echo Zz""END
What happened: The actor came back, and used credentials of root:root from one of the prior successful sessions from Stage 1.
root:root hits: 3
2026-11-04T16:58:11 root root a90ff041a34268c2 <-- Nov 4th
2026-11-04T19:15:44 root root c639c8c067b826b4 <-- Nov 4th
2026-11-05T01:02:44 root root bcb7e9e6f237e3c0 <-- Stage 2
This time, the command set was different once authenticated successfully:
id 2>/dev/null;ls /dev 2>/dev/null|head -8;cat /etc/passwd 2>/dev/null|head -2;cat /proc/version 2>/dev/null;echo $((17*3));echo Zz""END
Let's breakdowm what all this means?
id — who am I? What user, what group, what privileges. Are they root or a limited user.
ls /dev | head -8 — what devices are attached. Disks, TTYs, network interfaces. Tells them about the hardware environment.
cat /etc/passwd | head -2 — first two lines of the user database. Confirms the OS type and sees what system accounts exist.
cat /proc/version — OS version and kernel. Same as Stage 1 but now combined into one command string instead of separate.
echo $((17*3)) — shell arithmetic validation. If the shell returns 51 the shell is fully functional and can execute logic, not just echo strings. This is testing whether the environment can run a payload.
echo Zz""END — session closure marker. Tells the C2 the Stage 2 sequence completed successfully. Notice it’s different from Stage 1’s Zq...Qz tokens — Stage 2 has its own marker. The framework knows which stage it’s in
The key difference from Stage 1:
Stage 1 — broad strokes. OS version. Filesystem exists.
Stage 2 — specific. Who am I. What’s attached. Who else is here. Can I run code.
Stage 2 is pre-payload validation. They’re checking if this target is worth deploying something
They came back for a reason. Stage 1 told them this target was alive. Stage 2 was them deciding whether it was worth attacking
Now, the question is.. was there a Stage 3?
Honest Verdict: No. Atleast not yet.
As one of my managers use to ask to push our thinking was "What is this means?" English wasn't his strong suit :P
I can't help but think.. One session in Stage 1 returned incomplete data — the OS version came back but the filesystem listing never completed. Did the framework flag this target because of that incomplete response? Was Stage 2 triggered by an anomaly in the data, not by a successful one?
Is the framework is designed to follow up on incomplete or unexpected responses — if so, that’s a sophisticated triage mechanism. It’s not just collecting data. It’s identifying targets that behaved differently from the rest
We can’t confirm what triggered Stage 2. But the question is worth asking
Does Stage 2 involve more of the human aspect? We COULD validate that with the timing of commands and their timestamps..
01:02:43.800 — connect
01:02:44.930 — login success (1.1 seconds)
01:02:45.560 — echo token (0.6 seconds)
01:02:46.126 — full command string (0.6 seconds)
This can see here that this is automated/pre-loaded like Stage 1 behaviour. It's highly probable though, that the human factor may have selected the target , but didn't do the work.
This confidently shows that this is not a dumb trivial bot. Here's why:
Here’s what separates it from a dumb bot:
A dumb bot:
Sprays credentials, drops a backdoor or miner, moves on
No second stage
No behavioral change between visits
No structured output parsing
This one:
Stage 1 is automated — but the framework is engineered. Unique session tokens. Structured delimiters. Tight timeouts. Data goes back to a C2 for processing.
Stage 2 is a return visit — 22 hours later. Different command set. Single session. Deeper enumeration. $((17*3)) shell validation — that’s checking if the shell can execute arithmetic, not just echo strings. That’s testing shell capability for a follow-on payload.
Zz""END closure marker —
Stage 2 has a different closing marker than Stage 1. The framework knows which stage it’s in
To me, this looks more like an engineered workflow , not a script kiddie. Stage 2 has a different closing marker than Stage 1. The framework knows which stage it’s in. They never came back for Stage 3. At least not yet. The deception is still running.”
══════════════════════════════════════════════════════
INDICATORS OF COMPROMISE
══════════════════════════════════════════════════════
Source IP: 217.60.102.31
First seen: 2026-11-04T03:35 UTC
Last seen: 2026-11-05T01:02 UTC
Protocol: Telnet
── Stage 1 Fingerprints ──────────────────────────
Session token pattern: Zq[8-10 alphanum]Qz
Output delimiter 1: echo VEND (follows /proc/version)
Output delimiter 2: echo LEND (follows ls /)
Session window: ~6-7 seconds per session
Credential spray: root:admin, root:1234, root:12345,
root:default, root:888888, root:vizxv
── Stage 2 Fingerprints ──────────────────────────
Session token pattern: Zq[8-10 alphanum]Qz
Closure marker: echo Zz""END
Shell validation: echo $((17*3))
Command chain: id;ls /dev|head -8;cat /etc/passwd|head -2;
cat /proc/version;echo $((17*3));echo Zz""END
── Detection Opportunities ───────────────────────
Hunt for: Zq.*Qz token pattern in shell logs
Hunt for: VEND / LEND output delimiters
Hunt for: echo $((17*3)) shell validation
Hunt for: Zz""END closure marker
MITRE: T1021, T1078.001, T1592
4 reactions · 0 comments