Verifying Client-Side Delivery
A crafted file sitting on your own machine has not yet reached anyone. Verifying client-side delivery means connecting an approved lab recipient’s interaction to the result you claim. A document or shortcut workflow may offer a route, but delivery and execution remain separate events. Follow the artifact to the recipient, confirm the handling conditions, and then connect the resulting interaction to the intended user context.
Delivery is the controlled process used to place test content where an intended lab user or system can receive it. That content might exercise a Microsoft Office behavior, a Windows library file, or a shortcut that refers to other content. Delivery is only one part of the chain. The file must reach the intended environment, the relevant application or operating-system behavior must be present, any required user action must occur, and the expected technical result must be observed. If one link is missing, you can’t claim that the chain worked.
User interaction means an action required from the person operating the client system, such as opening a file, following a permitted link, or accepting a prompt in a controlled exercise. That requirement belongs in your technical finding. Saying that a file executes code hides an important condition if execution actually requires a particular person to open it in a particular application and make another choice. The interaction affects both reproducibility and risk.
There’s also a social engineering boundary. In this context, that’s the line between an authorized technical test using agreed lab identities and an attempt to influence uninvolved people. An authorization to assess a system doesn’t automatically authorize sending deceptive material to employees, customers, or other third parties.
For this lesson, the recipient is a synthetic lab identity or a participant explicitly included in the exercise. Delivery stays inside the authorized environment and uses only the agreed interaction. You don’t test whether an unsuspecting person can be persuaded to act.
Before creating anything, state the question. For example, can the designated lab workstation process the test file in a way that produces the expected connection under its current configuration? Then identify the target workstation, the controlled recipient, your present access, and the permitted effect. Capture a baseline showing that the resulting access or connection doesn’t already exist. Write down what you predict will happen and what observation would reject that prediction.
Suppose the predicted result is a new session from the lab workstation running in the controlled user’s context. A bounded test delivers one prepared artifact to that lab identity through the approved path. You preserve the time, artifact identity, destination, and required interaction.
If the expected session arrives after the recorded interaction, verify which host originated it and which identity and privilege context it represents. That gives you a defensible result. A tool message saying that a payload was generated would prove only generation, not delivery, interaction, or access.
This fits the current client-side portion of the OSCP+ body of knowledge, which includes target reconnaissance, Microsoft Office attack variations, and Windows library and shortcut concepts. The shared skill is not memorizing one file type. It’s identifying the client environment, predicting how a controlled artifact will be handled, validating the actual result, and documenting the conditions. Broader campaigns against real users, organizational persuasion studies, and uncontrolled delivery infrastructure are outside this lesson and outside an ordinary lab authorization.
To understand the evidence, follow the mechanism from one transition to the next. First, the artifact exists and matches the hypothesis. Second, it reaches the intended lab destination without being confused with an earlier copy.
Third, the designated user performs the recorded interaction. Fourth, the client application or operating system interprets the content under a particular configuration. Fifth, any referenced content or requested connection is reachable. Finally, you observe the resulting process, request, or session in the expected identity and permission context.
Each transition has dependencies. An Office-focused exercise may depend on the document format, the installed application, application settings, and the exact action taken by the controlled user. A library or shortcut exercise may depend on how Windows resolves a referenced path, whether that path is reachable, and what the user opens.
The current identity can determine whether content is readable or executable. Network controls can prevent a request even when the client-side artifact is otherwise correct. A difference in one condition can change the outcome without disproving the broader concept.
This is why output must be treated as evidence, not as a verdict. Imagine that your delivery service records a request for the artifact. That directly supports the statement that something requested a resource at a particular time.
It may also record a source address or a user-agent string. Those details can suggest which system or application made the request, but they don’t necessarily prove that code executed or that you gained a session. A security product, preview service, or other automated process could potentially generate a request without completing the rest of your intended chain. You need the observations from later transitions.
Now imagine that a listener receives a connection. That’s stronger evidence, but it still needs validation. Confirm that the connection belongs to the authorized target rather than another lab device. Establish the active identity and the access level.
Record whether the session appeared before or after the required interaction. Check whether the result persists long enough to perform the permitted validation. If the hypothesis predicted access as the controlled user but the observed process belongs to a different context, report the context you actually observed. Don’t silently rewrite the prediction to fit the result.
Negative evidence also needs careful language. No connection arrived during the test window. That is an observation.
It doesn’t, by itself, prove that the client is not susceptible. The file might not have reached the destination. The user might have opened a different copy.
A referenced path might have been unreachable. The client configuration might differ from reconnaissance. A local protection could have interrupted processing. Your notes should separate the absence of the expected result from any explanation that hasn’t yet been verified.
A useful evidence record therefore distinguishes three categories. There are facts you directly observed, such as a request in a log, a prompt on the lab workstation, or a verified session in a named identity context. There are interpretations supported by those facts, such as the conclusion that the approved interaction triggered the connection. Then there are unresolved assumptions, such as whether a particular application setting caused an unsuccessful attempt. Keeping those categories separate makes troubleshooting possible and prevents a positive-looking indicator from standing in for the whole chain.
Use a deliberate manual workflow before relying on automation. Record the baseline. Deliver one identifiable artifact through one approved route. Perform the exact permitted interaction once.
Preserve the output at both ends. Then validate the resulting host and identity context. Automation can be useful during authorized training, but it shouldn’t hide which step created the observation. You need enough understanding to reproduce the chain, explain its mechanism, and recognize when an automated result has skipped an important check.
Consider a failed library or shortcut test in the authorized lab. The artifact reaches the controlled workstation and the user opens it, but the expected network request never appears. It would be tempting to discard the technique or replace every component at once. That would erase the chance to learn which assumption was wrong. Return to the captured evidence and mark each prerequisite as observed or merely presumed.
Keep the sender, recipient, and observing system separate. An artifact must reach the approved recipient before the recipient’s application can act on it. A connection seen elsewhere is meaningful only when the evidence ties it to that interaction and the correct context.
You know that the artifact was delivered because its identifier matches the copy on the workstation. You know that the intended user opened it because the lab action and time were recorded. But you assumed that the referenced path was reachable from the workstation.
A lower-impact check can isolate that condition without repeating the complete delivery chain. Confirm the relevant network path or request behavior from the authorized client environment. If it isn’t reachable, you’ve found a condition that can explain the missing request, though you haven’t yet shown that it’s the only problem.
Correct that one condition and repeat the same bounded test. Keep the artifact, target, interaction, and observation method consistent where possible. If the request now arrives but no resulting session appears, the evidence has moved the failure point.
Delivery and path resolution are supported. The later execution or connection stage still needs investigation. You might next recheck the expected application behavior, the execution context, permissions, or another environmental dependency already part of your hypothesis. Change one relevant assumption at a time so each result teaches you something.
The same discipline applies to an Office-focused test. A file can arrive successfully and still be processed differently than expected because the application, format, settings, or user choice doesn’t match your plan. A visible prompt proves that a prompt appeared.
It doesn’t prove what the user selected. An interaction record can establish the selection, while host and connection evidence establish the result. If you can only confirm delivery and a prompt, report those observations. Don’t describe the test as successful code execution.
A failed first attempt is therefore not the same as an absent attack path. It may expose a target mismatch, an unreachable resource, a path error, unsuitable syntax, insufficient permissions, or a mistaken execution context. It can also reveal that the hypothesis itself was wrong. The important distinction is whether you tested the suspected prerequisite. Repeatedly generating new artifacts without isolating the failure only creates more variables and weaker notes.
Keep failed attempts in your record. Include the original prediction, the relevant settings, the interaction, the output, and the reason for the next adjustment. When the corrected attempt works, the earlier failure explains which condition mattered. When no attempt works, the record still shows what you ruled out. That’s much more useful than a final statement that the exploit failed, because another technically competent reader can see both the limits of your conclusion and the checks already performed.
Documentation begins before the successful result. Give the target an unambiguous identifier and note the lab identity involved. Record the authorization boundary and the delivery route you were allowed to use.
Identify the artifact precisely enough that you don’t confuse versions. Preserve the prerequisite client information that informed the test, including relevant application, operating-system, path, or configuration details that you actually verified. If a detail came from an assumption rather than observation, label it that way.
For the test itself, record the command or request that created each meaningful action, along with parameters that affect the outcome. Capture meaningful output rather than only a statement that a tool succeeded. Note where the artifact was placed, how it was delivered, what the controlled user did, and when that interaction occurred. Then preserve the resulting request, process, or session and validate the target identity, user context, and effective access. Screenshots may support the record where they’re needed, but they shouldn’t replace the written sequence and its explanation.
A reproducible account might say that the designated lab user received a specific artifact through the approved route, opened it with the identified client application, completed the recorded interaction, and caused the target to contact the controlled test system. It would then identify the evidence used to associate that request with the target. If a session resulted, the account would state how the host and user context were verified. This wording shows the required conditions. It doesn’t imply that passive receipt alone caused execution.
Explain why the result matters to the next penetration-testing decision. A verified session in the controlled user’s context may justify enumerating that context within authorization. A resource request without execution may justify examining the next unresolved transition rather than claiming access. Confirmed incompatibility with the target configuration may justify leaving this path and returning to other evidence. The technical result becomes useful when it changes a decision and your record shows why.
Ethical control belongs in those notes too. Identify the authorized recipient or synthetic identity and state that no uninvolved users were targeted. Record any agreed limits on communication, timing, data handling, and effects.
If the permitted exercise ends after proving a harmless callback or another bounded result, stop at that result. Technical capability doesn’t expand authorization. A client-side technique can be valid in a deliberately vulnerable lab and still be unacceptable against a person or system outside the approved scope.
The next decision should now be grounded in the strongest observation you have, not in the tool that produced it. If you verified access, continue only with actions allowed for that target and context. If you verified an intermediate request, investigate the next unresolved transition.
If you found that a prerequisite is absent, document that limit and reconsider the path. Whatever comes next, treat any code or tooling you might obtain as untrusted until you’ve examined its assumptions, dependencies, and side effects. Evidence should narrow your choices, not encourage an uncontrolled leap.
A client-side delivery test is complete only when the artifact reaches the intended user context and the resulting interaction is independently verified. Explain the decision in your own words: What observation proves that the delivered artifact reached the correct recipient context and caused the expected interaction? You can revisit the key explanations and answer guide in the companion study reference. This lesson was produced by Bare Metal Cyber dot com.