skip to content

In an exploitation framework for authorised security testing, what kinds of module does it hold, and what does it give a tester and a defender?

level: juniorimportance: must knowfreq 62%

answer

  1. a catalogue, not one tool
  2. modules sharing one vocabulary
  3. exploit, payload, post, auxiliary
  4. repeatable runs, known detections

basics

~20 s

An exploitation framework is a catalogue of modules behind one shared interface: exploits for one flaw in one product, payloads that run afterwards, post-exploitation work on a compromised host, and auxiliary gathering or checking that does not exploit.

solid answer

~50 s

An exploitation framework packages offensive work as **modules** that share one vocabulary. An **exploit** module targets one flaw in one product and version and lets the framework run code on the target. A **payload** is the code that runs once the flaw is used, either as a single piece or as a small stager that loads a larger stage, and a **listener** is the framework's waiting endpoint that the payload reports back to. **Post-exploitation** modules do work on a host that is already compromised, and **auxiliary** modules gather data or check things without exploiting anything. For a tester the gain is repeatable, comparable runs instead of one-off code. The cost is that public modules are widely known, so defenders write detections for them, and a run is still a real action with consequences on the target.

go deeper

for a junior

Name the four module kinds and give each one's job in a sentence. Say what a payload is and that the listener is the waiting side of its connection.

for a middle

Explain single versus staged payloads and why a stager exists. State what shared vocabulary buys a tester and what it costs once modules are public.

for a senior

Tie the module kinds to review: which kind carries which risk to the target, and which leaves which evidence for a defender.

for a principal

Frame the framework as a trade a team chooses: comparability and metadata against being a known, detectable thing. Ask what standard keeps ease of use from lowering care.

## What an exploitation framework is An **exploitation framework** is a software platform that organises offensive-security work as a **catalogue of modules**. Each module does one job, and every module speaks the same vocabulary: how a target is described, how a module describes itself, how a result is reported. The best-known open-source example says in its own documentation that it is "based around the concept of modules". The idea matters more than the product. A framework is a set of interchangeable parts that an authorised tester can combine, repeat and compare, and that a defender can study and write detections for. ## The module kinds The documentation names four kinds as the most commonly used, and they are the ones interviewers ask about. Learn them as jobs, not as commands. | Kind | Its job | What a reviewer asks | |---|---|---| | **Exploit** | Code written for one flaw in one product and version, which lets the framework run code on the target | Which product, version and configuration was it written and tested for? | | **Payload** | The code that runs on the target once the flaw has been used | Is it a single piece or staged, and where does it report back to? | | **Post-exploitation** | Work done on a host that is already compromised, such as gathering or enumerating data from a session | What does it read or change on a live system? | | **Auxiliary** | Data gathering, checking or administrative tasks that do not exploit a target | Does it only look, or does it send traffic the target will log? | ## Payloads: pieces and the listener A payload is not always one blob. The documentation describes three kinds of piece: - **Single payloads** are "fire-and-forget". They may open a communications channel back to the framework, but they do not have to. - **Stagers** are a small stub that creates some form of communication and then passes execution to the next stage. That lets a small payload load a larger one with more functionality, and it separates the communications mechanism from the final stage. - **Stages** are the larger final piece the stager brings in. The framework's own side of that connection is the **listener**, also called a handler. The documentation says handlers are paired with payloads "so the framework will know how to create sessions with a given communications mechanism". Read the idea this way: the payload connects out from the target, and the framework waits. For a defender this is the useful part, because an exploited host that never used to start connections now starts one. How a listener is set up is not part of this answer. ## What a framework buys, and what it costs **It buys:** - Repeatable, comparable runs: the same module against the same build behaves the same way, so two testers or two quarters can be compared. - A shared interface instead of one-off code written per job. - Metadata a reviewer can read before anything runs, such as the module's description, its tested targets and its declared reliability. **It costs:** - Public modules are widely known, so defenders write detections for them. A framework run is easier to spot than custom code. - Ease of use can hide the risk. A module that runs from a menu is still a real action against a real system. ## Why a run is a risk, not just a result The security-testing standard published by NIST is blunt about this: 1. Target vulnerability validation "involves the greatest amount of risk in assessments", because it has more potential to impact the target than other techniques. 2. Penetration testing "poses a high risk" because it uses real exploits and attacks against production systems and data. 3. A successful attack verifies the vulnerability, but in many cases the exploit does not grant the maximum level of access. So an exploit run has three outcomes to think about: success or failure, what the target did while it was being exploited, and what the run left behind. The rest of this topic covers vetting, consequences and detection. ## What it is not A framework is not a vulnerability scanner, which only checks whether a flaw may exist, and it is not an operator command-and-control product or a library of per-technique tests. Written authorisation and the rules of the engagement are settled before any module runs, and the distribution that ships the framework is a separate subject. Keep those apart when you answer.

  • Why does an exploitation framework separate a stager from a stage in a payload?
    A stager is a small stub that sets up communication and hands execution to the next stage. That lets a small first piece load a larger payload with more functionality, and it separates the communications mechanism from the final stage, so one stage can be used over several transports without duplicating code.
  • Is an auxiliary module harmless because it does not exploit anything?
    No. It does not exploit the target, but it can still send traffic the target logs and can perform administrative tasks. It belongs in the same review as an exploit, with a lighter question: what does it send, and what will the monitoring team see?
  • If a framework is public, why would an authorised team still use it?
    Because repeatable, comparable runs and a shared interface are worth more to a team than custom code per job, and a documented module carries metadata a reviewer can read. The price is that defenders know it too, so detection of the tool is expected and should be planned for.

  • Treats the framework as a single exploit tool rather than a catalogue of module kinds
  • Says payloads and exploits are the same thing
  • Thinks auxiliary modules exploit the target and need a compromised host
  • Believes a framework run is safe because it is menu-driven and widely used
  • Calls the framework a vulnerability scanner