Applying Forwarding Concepts on Windows

A Windows foothold can reach an internal service that the testing workstation cannot reach directly. Applying forwarding concepts on Windows means keeping the traffic path clear while choosing among tools such as the Windows SSH client, Plink, or netsh. Their features differ, so…

A Windows foothold can reach an internal service that the testing workstation cannot reach directly. Applying forwarding concepts on Windows means keeping the traffic path clear while choosing among tools such as the Windows SSH client, Plink, or netsh. Their features differ, so a familiar tool name is not enough to establish the right design. We will identify the listener and destination-side connection first, then compare tool capabilities, privileges, and service-level validation.

The answer doesn’t begin with a command. It begins with the connection you need. Name the system where a new listener must accept traffic, the destination that should ultimately receive that traffic, and the system that can reach that destination. Then ask whether you need an SSH tunnel, a straightforward operating-system port redirection, or something else. Tool choice follows those requirements.

Keep the authorization boundary just as explicit. The Windows host, the internal destination, your workstation, and any SSH server involved must all be systems you’re permitted to use for this test. Forwarding can make a previously unreachable service reachable through an intermediate system. That’s useful in a deliberately vulnerable lab, but it doesn’t extend your permission to systems outside the agreed scope.

Suppose your testing workstation is called Operator, the Windows host is Pivot, and the internal application server is App. Operator can communicate with Pivot. Pivot can communicate with App on the application’s TCP port. Operator cannot communicate directly with App. Your question is specific: can Pivot provide a controlled path between Operator and that one authorized service on App?

Before creating anything, capture the baseline. Record that Operator’s direct connection to App fails, how you tested it, when you tested it, and what the failure looked like. On Pivot, separately establish whether App’s service is reachable. Those are two different observations. A failed connection from Operator doesn’t prove the service is down, and a successful connection from Pivot doesn’t prove that forwarding is already possible.

Now write the predicted result. If forwarding works, a connection to a particular address and port on the listener side should travel through the selected mechanism and reach the defined address and port on App. If you can’t name those four values, the listener address, listener port, destination address, and destination port, the design isn’t ready. Saying that traffic goes through Pivot is too vague to reproduce.

This distinction belongs to the current PEN-200 and OSCP+ topic area covering port redirection and SSH tunneling with Windows tools. The practical skill isn’t merely recognizing ssh.exe, Plink, or netsh. It’s understanding what each approach is doing, what conditions it depends on, and what evidence supports the conclusion that the path works.

The first option, ssh.exe, is the Windows OpenSSH client executable. In this context, it can establish an authenticated SSH connection and request forwarding through that connection. It’s the native SSH-oriented option when the executable and required capability are available in the Windows environment. Native doesn’t mean universally present, correctly configured, or automatically permitted. Availability and behavior still have to be checked on the actual host.

With SSH forwarding, identify the machine running the client and the SSH server it connects to. Those roles establish the tunnel’s direction. A listener created on the client side accepts traffic where the client is running.

The SSH connection carries that traffic to the server side, and the requested destination is reached from the context available there. If the listener is created on the server side instead, the placement and connection path are different. Labels such as local and remote only help when they’re tied to named machines.

For the Operator, Pivot, and App example, imagine ssh.exe runs on Pivot and connects outward to an authorized SSH service on Operator. If the required listener is on Operator, your notes should say that plainly. They should also state that the forwarded destination is App and that App is reached from the Pivot side of the SSH relationship. That description is far more useful than writing only, SSH tunnel created.

Several conditions must line up. Pivot needs a network path to the SSH service. Authentication has to succeed. The requested kind of forwarding must be accepted.

The listener’s address and port must be usable. The destination must be reachable from the side expected to make the final connection. Host protections, service configuration, and the user context running the process can also affect the result. A positive authentication message confirms only part of that chain.

Plink is a command-line SSH client associated with the PuTTY tool family. In Windows training environments, it commonly represents a legacy or separately supplied SSH option rather than the native Windows ssh.exe path. Conceptually, the forwarding questions remain the same. Which machine runs Plink?

Which SSH server does it authenticate to? Where is the listener created? From which side is the destination contacted? What user and network context apply?

That similarity matters because replacing ssh.exe with Plink doesn’t repair a mistaken network model. If Pivot can’t reach the SSH server, choosing another SSH client may leave the same failure. If the listener is bound somewhere Operator can’t reach, a different executable doesn’t move it automatically. If App isn’t reachable from the side making the destination connection, successful SSH authentication still won’t complete the application path.

The differences matter operationally. One client may already be available while another would have to be introduced into the lab. Their invocation, host-key handling, authentication options, and output aren’t identical. You should capture the exact executable and exact command actually used rather than documenting a generic SSH action. You should also preserve meaningful output while avoiding the disclosure of reusable secrets in notes or screenshots.

The third option, netsh, is the Windows network shell. Its port-proxy capability represents a different mechanism from an SSH tunnel. It can define a TCP listener that redirects accepted connections toward a configured TCP destination. The operating system performs the redirection according to that configuration. There’s no reason to describe that path as SSH when no SSH connection carries the traffic.

Return to Pivot and App. A netsh port-proxy arrangement could place the listener on an address and port associated with Pivot, then direct accepted TCP connections toward App’s address and application port. Operator connects to Pivot’s listener. Pivot makes the onward connection toward App. The notes therefore need two separate pairs: Pivot’s listening address and port, followed by App’s destination address and port.

Listener placement includes the binding address, not just the port number. A listener limited to a loopback address may be available to software on Pivot but unavailable from Operator. A listener bound to an address reachable from Operator has a different exposure. Neither observation alone establishes what Windows Firewall or another control will allow, so the listener configuration and an actual connection test both matter.

A netsh port proxy is also not evidence of SSH encryption or SSH authentication. It’s a redirection rule, not an interchangeable name for every tunnel. Whether that difference is acceptable depends on the authorized lab task and the path you need. If you require an authenticated SSH connection across part of the route, a plain port-redirection mechanism doesn’t silently provide it. If you only need a bounded Windows TCP redirection and the conditions allow it, an SSH client may add a mechanism you don’t need.

This gives you a practical comparison. Start with what’s available, but don’t stop there. Check whether an SSH server exists at the appropriate end, whether Pivot can reach it, and whether the necessary authentication is authorized.

Decide where the listener must exist. Determine which side can reach App. For netsh, consider whether the Windows host can create and expose the required listener and whether its onward TCP connection reaches App. Also plan how temporary forwarding state will be identified and removed after the test.

The tool changes, but the path questions remain the same. Establish where the listener runs, which host opens the destination connection, and which traffic the mechanism actually supports. Then check the Windows-specific permissions and configuration needed to make that path work.

Then perform one bounded test. Use one known destination and one deliberate listener rather than creating several paths at once. Preserve the exact configuration or command, the user context, the relevant addresses and ports, and the output. From Operator, connect to the designated listener. On App, or through the application response when that’s the evidence available, determine whether the traffic reached the intended service.

A successful connection to the listener is not always enough. The listener might accept a TCP connection even though the onward connection fails. A familiar application response gives stronger evidence that the intended destination was reached, especially when it can be compared with a baseline obtained from Pivot. Even then, describe what you observed rather than claiming more than the observation proves.

For example, suppose Operator connects to Pivot’s forwarded port and receives App’s expected service banner. That supports the conclusion that the configured path reached a service behaving like the intended application endpoint. Pair it with the forwarding configuration, Pivot’s reachability to App, and the addresses involved.

Don’t inflate that result into proof of compromise, privilege escalation, or access to unrelated internal systems. Forwarding changed reachability. Any later security conclusion requires its own evidence.

Failure deserves the same discipline. Assume ssh.exe on Pivot successfully authenticates to the SSH service, but Operator can’t use the expected listener. Re-read the output and configuration. Was the listener actually requested?

Did it bind to the expected interface? Is Operator connecting to the right machine and port? Is that port reachable? Does the SSH side allowed to contact App have a working route to App’s service?

Check one assumption at a time. First verify that the listener exists where your notes say it should. If it exists only on a local interface, you’ve found a placement problem rather than evidence that App is unreachable. If Operator reaches the listener but the forwarded connection fails, test App’s service from the side responsible for the destination connection. That separates listener reachability from destination reachability.

Suppose Plink reports an authentication problem. That result doesn’t test the complete forwarding hypothesis because the SSH relationship wasn’t established. Confirm the executable being used, the authorized account, the authentication method, and the expected SSH endpoint. Don’t react by changing the listener port, destination, and client at the same time. Multiple simultaneous changes destroy the connection between cause and result.

Now consider a netsh rule that appears in the configuration, but Operator still can’t connect. The rule’s presence confirms configured state. It doesn’t prove that the intended address is active, that the listener is externally reachable, that a host firewall permits the connection, or that App accepts the onward connection. Check those conditions independently. A lower-impact reachability test often reveals more than repeatedly deleting and recreating the same rule.

Execution context can also explain different results. The account used to establish forwarding may lack a required permission, may see a different environment, or may not have access to an expected file or credential. The path to an executable may differ from what your notes assume. Record the identity and context that produced the observation. Running the same text under a different account isn’t necessarily the same test.

Keep failed attempts in your working record. A concise entry can state the hypothesis, the exact action, the result, and the assumption that was disproved. If changing the listener binding fixes the path, preserve both states. The failed state shows why the corrected configuration was necessary. It also prevents you from repeating the same mistake when rebuilding the path later.

Good documentation should let a technically competent reader reconstruct the traffic flow without guessing. Name Operator, Pivot, the SSH endpoint if one is involved, and App. Record their relevant addresses and roles. Identify where the forwarding process runs, where the listener exists, which system initiates the onward connection, and which destination receives it. Include the protocol and port at each stage.

Preserve the prerequisites too. Note the access level on Pivot, the tool and version information you actually observed, the authorized authentication method, and the baseline reachability results. Record the exact command or configuration used, meaningful output, and the time of the test. If a screenshot is needed, make sure it shows the target context and relevant result rather than a detached success message.

Your conclusion should distinguish observation from interpretation. An observation might be that Operator received App’s expected response through Pivot’s listener. Your interpretation is that the forwarding path provided Operator with access to App’s service through Pivot.

An unsupported claim would be that all traffic to App is now accessible. The first two statements are bounded by evidence. The third reaches beyond the test.

Documentation also helps with cleanup. Record any process, listener, or persistent redirection state created during the exercise. Once the authorized test is complete, remove temporary state when the lab instructions and your access permit it, then capture evidence that the listener or rule is no longer active. That keeps the environment understandable for the next test and supports a responsible assessment record.

Once the path is validated, the next decision should come from what it enables. If Operator can now reach the authorized application on App, you can perform the next permitted, target-specific test against that service. If the path still fails, your evidence should identify whether the remaining problem is the listener, the SSH relationship, the Windows configuration, the network route, the user context, or the destination service. Either result narrows the next move.

Windows forwarding tools differ in setup and features, but every path still requires a verified listener, destination, source context, and traffic result. Use this question to check what you would do next: Which Windows forwarding mechanism matches the available software, privileges, listener position, and destination path? The companion study reference provides a written recap and checks for your next review. This lesson was produced by Bare Metal Cyber dot com.

Applying Forwarding Concepts on Windows
Broadcast by