Reverse Shells, Bind Shells, Backdoors, and Web Shells

An authorized test system makes an outbound connection to your controlled listener, and you receive a working command shell. You can execute a harmless validation command and confirm which test account is active. Have you established persistence? Not necessarily. This episode ex…

An authorized test system makes an outbound connection to your controlled listener, and you receive a working command shell. You can execute a harmless validation command and confirm which test account is active. Have you established persistence? Not necessarily.

You’ve proved that a control channel works at this moment. If the process ends, the connection drops, or the system restarts, that access might disappear completely. Connection direction, command execution, and survival across restarts are separate properties. Keeping those properties separate is the key to understanding reverse shells, bind shells, backdoors, web shells, Trojans, rootkits, and browser extensions.

These mechanisms appear within the PenTest+ objective concerned with establishing and maintaining persistence, but sharing an objective doesn’t make them interchangeable. A mechanism can support several kinds of behavior at once. It might execute commands, provide a communications channel, evade defenses, or preserve access. The specific evidence determines which claims you can make.

A command that runs once supports an execution claim. A network connection supports a claim about communication. Neither observation, by itself, proves that access will return after a process ends or a device restarts. Persistence requires some continuing condition that makes later access possible, and that condition needs its own validation.

A reverse shell is named for the direction of its connection. The test system initiates an outbound connection to the controlling system, then exposes a shell through that connection. A bind shell reverses those network roles. A shell service listens on the target, and the controlling system connects inbound to it.

This distinction affects expected network evidence and whether the path is likely to work through the authorized environment. It doesn’t tell you whether either shell survives a restart. A one-time process can provide a reverse or bind shell while it’s running, then vanish when stopped. A separate startup mechanism could relaunch one later, but the shell’s direction still isn’t the persistence mechanism.

Imagine that both shells are launched by an approved startup condition in the lab. The reverse shell would still initiate the control connection, while the bind shell would still wait for one. Both could now be durable, but durability would come from the startup condition, not from reverse or bind behavior. Remove that condition and leave only the running processes, and each shell may work until its process ends without returning.

This comparison prevents two opposite mistakes. An outbound connection isn’t proof of persistence, and an inbound listener isn’t proof that access is temporary. For either shell, the claim about later access depends on separate evidence showing what relaunches it or keeps it available.

The other terms describe different placement or behavior. A backdoor is a broad concept for an alternate means of access that bypasses the normal path. Its placement depends on how it was implemented, so the label alone doesn’t reveal the channel, privileges, durability, or cleanup method. A web shell is placed in a web application or its server-side content so requests to that application can trigger actions on the host.

Its control channel is therefore associated with the web service rather than a separately exposed shell listener. Its continued availability depends on whether the server-side artifact remains present and usable. Observing a suspicious file doesn’t automatically prove successful command execution, and observing one response doesn’t prove the artifact will survive an application redeployment or restoration.

A Trojan describes software presented in a misleading way while it performs an unwanted or concealed function. It might deliver or contain another mechanism, but calling something a Trojan doesn’t answer whether it opens a reverse connection, listens for an inbound connection, modifies startup behavior, or survives a restart. A rootkit has a different emphasis.

It’s intended to maintain privileged, stealthy control by modifying or subverting system behavior. That brings persistence and defense evasion close together, but they still require distinct evidence. Evidence that behavior is hidden isn’t automatically evidence that it returns after reboot, and evidence of privileged execution isn’t enough to prove stealth.

A browser extension is placed in the browser environment, often in relation to a browser or user profile. From a classification perspective, you’d ask whether the extension remains installed, when it becomes active, which user context it belongs to, and what browser behavior provides evidence of its operation. Don’t treat every extension as a persistence finding merely because extensions can remain installed. The relevant claim concerns an authorized test artifact or an observed unauthorized artifact and the behavior actually verified.

Compared with a rootkit, the placement is much narrower. Compared with a web shell, it’s associated with a browser context rather than server-side web content. Compared with a reverse shell, its name describes placement, not network direction.

Suppose an isolated lab contains four approved test artifacts. One launches a temporary process that connects outbound to your listener. One exposes a shell service that waits for an inbound connection. One resides in the lab web application’s server-side content.

The last is installed in a dedicated browser profile. Before touching anything, predict what evidence each classification should produce. The first should show the lab system initiating the connection. The second should show a listening service and an inbound connection from the controller.

The web-based artifact should be associated with requests handled by the web application. The extension should be associated with the designated browser context. Those predictions concern channel and placement. None of them yet proves restart survival.

Walk those four artifacts through the same decision. For the first, seeing an outbound session confirms the predicted direction, but ending the process tests whether anything continues. For the second, finding the target waiting for the controller supports the bind classification, while later availability remains a different question.

For the web artifact, a request reaching the application connects the observation to server-side placement, but you still need evidence that the artifact is usable and remains present. For the extension, installation in the dedicated profile establishes where to look, not what privileges or system-wide control it has. The method is consistent across all four: predict the channel or placement, observe only what the authorization permits, and keep durability as an unanswered claim until evidence supports it.

Now add the engagement constraints. The lab authorization names the systems, permits only a scheduled test window, and requires every created artifact to be removed. That means the next action isn’t simply whichever test would produce the most dramatic evidence. You first confirm that the intended target is named, the chosen channel is allowed, dependencies are understood, and the action won’t create unacceptable operational impact.

If establishing evidence through an existing process is enough, there’s no reason to escalate immediately to a deeper or more durable modification. A technically possible rootkit test, for example, would be a poor choice if a lower-impact method can answer the approved question. Authorization is part of technical correctness, not an administrative detail added afterward.

For each artifact, record three separate answers. Which side initiates or receives control communication? Where is the controlling artifact placed? What verified condition, if any, lets it remain available later?

Then add a fourth answer for cleanup. A temporary reverse-shell process might require terminating the process and confirming the listener no longer receives a connection. A web shell test requires accounting for the authorized server-side artifact and verifying its removal.

A browser-extension test requires removing the test extension from the correct profile and checking that the tested behavior is gone. The exact cleanup depends on what was created. A generic note saying cleanup completed is weaker than an artifact record that identifies the target, placement, test window, observed result, removal action, and verification result.

Imagine the temporary reverse shell disconnects when the process exits. Someone reports that persistence was successfully established because the shell worked earlier. The report has combined two different conclusions. The successful session validates execution and the outbound control channel.

The failed reconnection after process termination weakens the persistence claim. Before declaring either a security failure or a testing failure, check the assumptions. Was the correct system tested? Was the expected process still running?

Did the connection attempt occur within the authorized window? Was a restart or relaunch condition ever part of the approved setup? Are the observations current, or are you relying on an earlier session?

The least disruptive verification may be to observe the process ending and confirm that no authorized reconnection occurs. If the engagement explicitly permits restart testing, restart survival can be tested under those conditions. If it doesn’t, don’t restart a production system merely to settle the question. Record that persistence wasn’t validated under the permitted test conditions.

An unresolved condition is more defensible than an unsupported claim. The important correction is simple: reverse shell and persistence aren’t synonyms. A reverse shell can be temporary because its name tells you which system initiates the connection, not what causes the shell to return later.

Conflicting evidence deserves the same care. Suppose a web request reaches the expected application location, but no command result returns. That could mean the artifact is inactive, the request is wrong, prerequisites aren’t met, privileges are insufficient, or the application has changed. It could also mean a control blocked the behavior.

One failed output doesn’t tell you which explanation is correct. Compare the observation with the prediction, verify the intended target and authorized configuration, and use the lowest-impact corroboration available. You’re separating a validated security finding from a stale artifact, a configuration mistake, or an unresolved test condition.

The same reasoning applies when an artifact appears durable. If a browser extension is visible after the browser closes and reopens, that supports continued presence in that browser context. It doesn’t prove system-wide privileged control, and it doesn’t turn the extension into a rootkit. If a suspicious component conceals activity, that supports investigating defense-evasion behavior.

It doesn’t establish restart survival without evidence of that property. If a Trojan delivers a backdoor, the deceptive software, the alternate access path, the control channel, and the persistence condition may be related parts of one operation. They’re still different analytical claims, and each can have different evidence and remediation.

When several labels apply to one chain, reporting them separately makes the result clearer. Suppose the approved Trojan contains a backdoor that produces a reverse shell. Trojan describes the deceptive presentation, backdoor describes the alternate access path, and reverse shell describes the outbound direction of the live channel. None of those three labels identifies a continuing condition by itself.

If the same chain also becomes available later, the tester must identify and validate whatever made that happen rather than assigning durability to the best-known label. The separation also sharpens remediation. Removing one delivered component may interrupt current access, but cleanup has to account for every authorized artifact actually created and verify the tested behavior is gone.

This distinction improves reporting. Instead of writing that a persistent reverse shell was found, state what was actually observed. The authorized lab host initiated an outbound shell connection during the test window. The shell ended when its process was terminated.

No automatic reconnection was observed, and restart survival wasn’t established. That language tells a reader what succeeded, what didn’t, and what remains unknown. If a separate authorized artifact did restore access later, document that artifact and the condition that activated it. Don’t let the more familiar shell name hide the actual source of durability.

Reporting should also preserve placement because placement guides investigation and cleanup. A server-side web artifact leads the authorized team toward the affected application content and related records. A browser extension leads toward the applicable browser and user context. A listening bind shell leads toward the target-side listener and inbound connection evidence.

A reverse shell leads toward the initiating process and outbound connection evidence. A rootkit claim requires evidence consistent with privileged subversion or modification of system behavior, not merely an unfamiliar process name. Good log collection can help correlate these observations, but a log entry is still evidence to analyze, not an automatic conclusion.

Consider a final engagement decision. You’re authorized to validate whether a test application permits durable unauthorized access, but the rules exclude operating-system modification and disruptive restart tests. Two choices appear plausible. One is to install a deeply privileged stealth mechanism because it would provide strong persistence evidence.

The other is to use an approved, removable application-level artifact, verify only the behavior allowed during the test window, and document any restart-survival question that remains untested. The second choice fits the scope. The first might demonstrate more technical capability, but it violates the operational boundary and adds risk that the engagement didn’t authorize.

The answer could change if the written authorization specifically included operating-system persistence, defined the target, approved the test window, addressed operational dependencies, and supplied a cleanup and recovery plan. Without those conditions, you can’t silently expand an application test into a rootkit test. This is especially important on systems where availability, reliability, or safety consequences are significant. The more invasive the mechanism, the stronger the need for an explicit purpose, controlled validation, and a credible removal plan.

Cleanup isn’t complete when access merely stops working. The controlling system might be unavailable while the target-side artifact remains. A blocked network path could hide a listener without removing it. Closing a browser could end current activity while leaving an extension installed.

Removing a web-accessible route might still leave server-side content behind. Verification should address the artifact that was created, its placement, and the behavior it enabled. If complete removal can’t be confirmed, report that limitation and escalate through the engagement process rather than assuming the environment has returned to its original state.

A cleanup check can fail even when the controller can no longer connect. Suppose the test listener is shut down first. The absence of a new reverse-shell session now proves only that this connection isn’t occurring. It doesn’t prove that the target-side process, web artifact, or browser extension was removed.

Reverse the reasoning during verification: start from the placement record, confirm the authorized artifact is gone from that location or context, and then confirm that its tested behavior no longer occurs. If those checks disagree, preserve both observations. A missing connection may reflect a stopped controller or blocked path, while a remaining artifact still represents incomplete cleanup. Reporting that uncertainty is safer than converting silence on the network into evidence of removal.

By the end of the task, your evidence should support a bounded statement. You should be able to identify the mechanism, describe its channel or placement, distinguish present execution from continued access, and explain how the result was verified. Your records should also show that the action was authorized and that each tester-created artifact was removed or formally handed over for remediation. That makes the work useful beyond the moment when a shell opens. It gives the system owner enough detail to understand the exposure, reproduce the reasoning safely, investigate related evidence, and confirm that the test itself hasn’t left behind a new access path.

Reverse shells and bind shells tell you about connection direction, while web shells, browser extensions, backdoors, Trojans, and rootkits describe other aspects of placement or behavior. None of those labels, by itself, proves that access survives a restart. A defensible persistence finding comes from identifying the continuing condition, predicting its evidence, and validating that evidence within the written authorization.

The same discipline applies to cleanup. Remove the actual artifact, confirm that its behavior is gone, and document anything that remains uncertain. When you separate execution, communication, stealth, and durability, you can choose a safer test and report exactly what the evidence supports.

One final question should stay with you: Have you established persistence? The companion episode reference provides exact terminology, named tools or standards, source-derived evidence checkpoints, and review material for Reverse Shells, Bind Shells, Browser Extensions, and Persistence Evidence. This lesson was produced by Bare Metal Cyber dot com.

Reverse Shells, Bind Shells, Backdoors, and Web Shells

headphones Listen Anywhere

More Options »
Broadcast by