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

Read and join the discussion on Cyberr