SC-18 Mobile code

SC-18 requires you to decide which downloadable code such as scripts, macros and browser plugins is acceptable, then authorize, monitor and control its use. This page covers what assessors test, the evidence that passes and what meeting it costs.

On this page

SC-18 mobile code: what the requirement asks for and why it is hard

An assessor or a FedRAMP-style baseline that selects SC-18 wants to see how the organization controls downloadable code that runs on its systems. SC-18 requires two lists: a definition of acceptable mobile code and mobile code technologies, and a definition of unacceptable ones. It then requires the organization to authorize, monitor and control the use of mobile code within the system. In NIST SP 800-53 Rev. 5, the control sits in the System and Communications Protection family, and SP 800-53B assigns it to the moderate and high security control baselines. Confirm the baseline assignment against the current SP 800-53B profiles before you cite it in a system security plan, since the profile is the document an assessor will check against.

The risk is an execution path that often sits outside the software inventory. Scripts embedded in documents, macros in office files, browser plugins, and scripts that a web page or a mail client can fetch and run all execute code on a user's device. A policy that says "mobile code is restricted" does not tell an assessor which technologies are permitted, which users may use them, or how a violation would be noticed. The work that usually decides the outcome is building the inventory of mobile code technologies actually present on endpoints and servers, approving or blocking each one, and keeping evidence that the monitoring catches exceptions. Review the lists against the authorization records and the system monitoring records that the SP 800-53A examine methods expect.

The Release 5.2.0 catalog lists five control enhancements for SC-18, and none of them is assigned to an SP 800-53B baseline. In practice, the base control is what most assessments test, so the reader's first priority is the base control's two lists, the authorization step and the monitoring evidence. Ask the team that owns endpoint management which mobile code technologies it can already report on, and whether it can show who approved each exception. Those answers reveal the gap faster than any policy review.

Which systems, teams and code types fall under mobile code rules

SC-18 applies wherever downloadable code can run inside the system boundary, and the scope decisions you make first determine how much work follows. The cards below cover the platforms, code types and third parties that usually change effort, along with the baseline requirements that put SC-18 in scope. Confirm each decision in writing before you inventory evidence.

Endpoints and browsers that run scripts

Every endpoint with a browser runs JavaScript, and that is usually the largest population in scope. Decide whether browser script execution is controlled by policy, by extension allowlists or by isolated browsers for specific sites. Each choice produces a different configuration baseline and a different set of monitoring records. Ask which browser versions and management tools the assessor will expect to see documented.

Office macros and document automation

Macros in word processors, spreadsheets and presentations are the mobile code type most often left out of scope by accident. Decide which macro sources are authorized, whether macros from internet-sourced files are blocked, and who approves exceptions. This decision affects every workstation with an office suite, so it should be settled before the list of unacceptable mobile code is written.

PowerShell and shell scripting on servers

Administrative scripts that run on servers, such as PowerShell and shell scripts pulled from repositories or file shares, meet the definition of mobile code when they are downloaded and executed. Scope the administrator workstations, jump hosts and build agents that run them. Confirm whether script execution policies are enforced centrally and whether execution events reach a log that an assessor can review.

Legacy Java applets and browser plugins

Java applets, Flash-style plugins and browser add-ons are usually retired, but a few legacy applications still depend on them. Inventory any remaining plugin, the systems that load it and the owners who accept the risk. Each one that remains is an authorized exception that needs its own monitoring and removal plan, so document it as an open item rather than assuming it is absent.

Developer workstations and build pipelines

Developer machines pull packages, run install scripts and execute code from pull requests, which places them squarely in scope when they connect to the system boundary. Decide which package sources and script hooks are approved, and whether build agents run in isolated environments. Teams often resist controls here, so agree on the scope in writing before the control design starts.

Third-party code and vendor-supplied scripts

Vendors deliver installers, agents, plugins and remote-management scripts that execute inside the boundary. Identify each third party that ships code, the mechanism it uses and whether you can review or sign it before execution. Vendor-supplied code often needs its own authorization record, so ask suppliers to document the code types they deliver and the update channels they use.

How an assessor tests SC-18 mobile code

This table sets out the seven SP 800-53A Release 5.2.0 determination statements for SC-18 by what the assessor examines, interviews and tests, what they ask you to produce, and where findings usually arise. Read each row as a question the assessor will put to your environment before a finding is written.

Determination focusExamine, interview and testEvidence requestedCommon findings
Acceptable mobile code and technologies are definedExamine the list of acceptable mobile code and mobile code technologies. Interview the owner of the list about how new script types are added.Approved list of mobile code types (for example, scripting languages, macro types, browser script engines) with an owner and review dateList is missing, lists technologies by name only, or does not cover script types used by internal applications
Unacceptable mobile code and technologies are definedExamine the list of unacceptable mobile code and mobile technologies. Test whether a blocked type can be run on a sample endpoint.Prohibited list with the reason for each entry, plus configuration showing how the block is enforcedList exists but nothing enforces it, or the list conflicts with the acceptable list
Mobile code is authorized before useExamine authorization records for a sample of mobile code in use. Interview system owners about the approval path.Signed or ticketed approvals linking each code item to a business need, a risk decision and an approverCode already running with no approval record, or approvals that do not name the specific code item
Mobile code use is monitoredExamine system monitoring records for mobile code execution. Test whether a blocked or unapproved script generates an event.Sample logs or alerts showing execution, blocks and reviews, with timestamps and host identifiersMonitoring covers only some endpoints, or logs are collected but never reviewed
Mobile code use is controlledTest a sample of endpoints and servers against the acceptable and unacceptable lists. Interview administrators on exceptions.Configuration evidence, policy exports and a record of exceptions with expiry datesControls differ between platforms, or exceptions have no end date
Acceptable and unacceptable lists are kept currentExamine the review history of both lists. Interview the owner about triggers for updates.Revision history, review minutes or change tickets for each listLists have not been reviewed since they were first written
Authorization and monitoring records agree with the listsCompare a sample of authorization records and monitoring records against the current lists. Test whether each observed mobile code type appears on one list.Reconciliation output showing each observed mobile code type mapped to an approved or prohibited entryObserved code types appear in neither list, or approvals refer to retired list entries

Steps to implement mobile code controls, with the output of each step

This sequence turns SC-18 from a policy statement into a working control: the organization knows which mobile code it runs, decides what is allowed, authorizes exceptions, enforces the decisions and reviews them on a schedule. Each step ends with a record an assessor can examine.

  1. Inventory the mobile code in use

    Identify every script, macro and downloadable code type that runs in the system, including browser scripts, office macros, PowerShell and Python scripts, Java or ActiveX-style components where they still exist, and code embedded in email or collaboration tools. Owners of each platform or business application should confirm what they run, and the security team should cross-check the list against endpoint and server telemetry. The output is a mobile code inventory listing each technology, where it runs, who uses it and which system owns it. The step is complete when the platform owners have signed off on the inventory.

  2. Define acceptable and unacceptable lists with owners

    Using the inventory, classify each mobile code technology as acceptable, acceptable with conditions or unacceptable, and state the conditions for the middle category, such as signed content, a specific source or a restricted user group. Assign a named owner to each entry who answers for accuracy and for changes. The outputs are the list of acceptable mobile code and mobile code technologies and the list of unacceptable mobile code and mobile technologies, the two lists that the SP 800-53A examine methods ask for. The step is done when both lists are approved by the authorizing official or the designated risk owner and stored under document control.

  3. Set the authorization workflow and records

    Define how a team requests use of a mobile code technology that is not on the acceptable list, who reviews the request, which risks must be addressed and how the decision is recorded. The workflow should name approvers, required justifications and an expiry or review trigger for each approval. Each decision produces an authorization record that identifies the code, the system, the approver, the date and any conditions. The step is complete when a test request has moved through the workflow and produced a record that an assessor could examine.

  4. Configure monitoring of mobile code use

    Enable logging and collection for the mobile code technologies on the acceptable and unacceptable lists, so that execution, installation and blocked attempts are visible. Open-source options include osquery, which exposes running processes, loaded modules, network connections and file hashes as SQL tables that can be scheduled across a fleet, and Wazuh, which runs configuration assessments with YAML policies and can be extended with custom checks. The output is a system monitoring record set, such as scheduled query results or assessment reports, tied to the lists from the earlier steps. The step is complete when a known unacceptable item produces a visible event in the monitoring platform.

  5. Enforce the lists on endpoints and servers

    Translate the approved and prohibited lists into enforcement: application control or script restrictions on endpoints, browser and office policy settings, and server configuration that blocks unacceptable technologies. Fleet policies can express yes or no checks as osquery queries, showing which devices pass or fail each rule, which helps confirm that enforcement is in place across the fleet. Record the configuration baseline so changes are traceable under the configuration management controls. The output is an enforcement configuration and a pass or fail report per device. The step is complete when failing devices appear in the report and are routed to remediation.

  6. Investigate and respond to unauthorized mobile code

    When monitoring finds unapproved or unexpected mobile code, the security team should confirm whether the event is an incident, a policy violation or an authorized exception that was never recorded. Velociraptor can collect defined forensic artifacts from affected endpoints through hunts across a group of systems, including machines that were offline and collect when they reconnect, and it creates a notebook per hunt to analyze the combined results. Findings should feed the incident response process and, where a control has failed, the plan of action and milestones. The output is an investigation record for each event. The step is complete when each event is closed with a documented disposition.

  7. Run a recurring review of exceptions and lists

    On a schedule the organization sets and documents, the control owner reviews the lists, open authorization records, exceptions and monitoring results. The review checks whether each approved technology is still needed, whether conditions still hold, whether new mobile code types have appeared in the inventory and whether any exception has passed its expiry. Changes to the lists trigger updates to the enforcement configuration and the monitoring rules. The output is a dated review record with decisions and follow-up actions. The step is complete when the review record is signed and the changes it requires are tracked to closure.

  8. Prepare the evidence package for assessment

    Gather the artifacts produced in the previous steps into one package that maps each determination statement in SP 800-53A for SC-18 to the evidence that answers it. The package should include the two lists, authorization records, monitoring and enforcement reports, investigation records and review records, along with a short description of who performs each activity. The organization owns the control and the evidence, and an independent assessor decides whether the control is satisfied. Ask any implementation partner to confirm in writing which artifacts they will prepare and which the organization must produce itself. The step is complete when the package has been checked against the assessment procedure and gaps are logged.

Evidence that passes SC-18 and how to keep it current

An assessor testing SC-18 looks for a defined boundary around mobile code, proof that the boundary is enforced, and proof that someone revisited it. The cards below cover the artifacts that carry that story and how each one stays accurate between assessments. The organization sets and documents its own review cadence and change triggers for each artifact.

Acceptable mobile code list

This is the register of scripts, macros and mobile code technologies the organization permits, with the purpose, owner and permitted contexts for each entry. Assessors examine it against the determination statement on acceptable mobile code, so every entry needs a named business reason. Keep it current by linking changes to the change management process: a new script type or browser plugin cannot enter the system without a dated update to this list. Confirm the review interval in your own policy and record each review in the review record.

Unacceptable mobile code list

This list names mobile code and technologies the organization prohibits, such as script types or macro formats that the environment will not run. Assessors look for it as a separate artifact from the acceptable list, so each category is explicitly decided rather than left implied. Tie entries to threat intelligence and incident findings, and add an entry whenever a blocked type appears in a detection or an exception request. Record the date and reason for each addition so the list shows how it changed over time.

Authorization records for exceptions

When a team needs a mobile code type that falls outside the acceptable list, the approval record shows who authorized it, the scope, the compensating controls and the expiry or review date. Assessors test whether authorization happened before use and whether the record matches what is deployed. Keep exceptions in the same ticketing or governance system as other change approvals, and close any exception whose business need has ended. The organization decides who holds approval authority and how long an exception may run.

System monitoring records

Monitoring records show that the enforced rules are watched in operation, including alerts on blocked execution, unexpected script activity and deviations from the acceptable list. The SC-18 assessment expects evidence that use of mobile code is monitored, so retained logs and alert histories matter as much as the rule set itself. Confirm which audit events reach central storage, how long they are retained under the organization's policy, and who reviews them. Sample alerts periodically to check that the monitoring still covers the current list.

Configuration assessment outputs

Configuration assessment reports show whether endpoints and servers match the approved settings for mobile code. Wazuh's Security Configuration Assessment scans monitored endpoints for misconfigurations using YAML policies, which can be extended with custom checks for the organization's own mobile code rules. Fleet policies can ask yes or no questions of devices as osquery queries, and its policies page shows which devices pass or fail each policy. Schedule scans, keep the policy files under version control, and treat a policy change as a change requiring the same review as the list it enforces.

Review record for the lists

The review record proves the acceptable and unacceptable lists were revisited on a defined schedule and after relevant events. It should show the reviewer, the date, the outcome and any changes made, and it should cover periodic reviews as well as event-driven reviews after incidents or new technology adoption. Assessors look for evidence that reviews happened, not only that a review interval exists on paper. The organization sets its own review frequency and documents it, then keeps each signed review in the same repository as the lists so the history stays attached to them.

Open-source tools that produce SC-18 monitoring evidence

Wazuh's Security Configuration Assessment module scans monitored endpoints against policies written in YAML. Each policy checks files, directories, registry keys and running processes, reports which checks pass or fail, and recommends remediation. For SC-18, the acceptable and unacceptable mobile code lists your organization defines can be translated into checks, such as whether a prohibited script runtime is installed or whether a disallowed process is running.

  • Policy content: Shipped policies are based mostly on CIS benchmarks. You can add custom YAML policies that reflect your own mobile code list, which is where most SC-18 checks will live.
  • Coverage: Checks reach files, directories, registry keys and processes. Confirm whether browser extensions and office macro settings are covered by a shipped policy or need a custom check.
  • Evidence output: Scan results per agent, with pass or fail status and remediation text, can be exported and retained as dated records of the configuration state.
  • Ongoing operation: Scans run on a schedule, so the evidence shows the configuration over time rather than at one moment.
  • License: Wazuh is GPL-2.0-only. Ask counsel how those terms apply to your deployment and to any changes you make to policies or code.

Before relying on this tool for SC-18, confirm on a test endpoint that it detects your browser and macro cases, and document the result in the test record.

What meeting the mobile code requirement costs

This table compares the cost components of meeting SC-18 Mobile code, showing who is paid for each, whether it is one-time or recurring, what drives it, and how to keep it down. No prices or durations are stated because none are supplied for this control, so use the drivers to build the questions you put to a quote.

Cost componentOne-time or recurringWhat drives itHow to keep it down
Tooling and licensesRecurringWhether the endpoint or monitoring platform is commercial or open source, and how many devices it coversSelf-hosted open-source tools such as Wazuh, Fleet, osquery and Velociraptor remove license spend, but hosting and operating them still take staff time. Ask the quote to separate license fees from operating effort.
Engineering time for acceptable and unacceptable listsOne-time, then periodic reviewNumber of script engines, macro types, browser extensions and mobile code technologies in use, and how many business owners must approve themStart from the software actually present in the environment, group items by technology, and record each decision with a reason so later reviews only address changes.
Enforcement configurationOne-time, then ongoing tuningHow many systems must be checked, how many policy exceptions are granted, and whether checks run on endpoints, servers or bothWrite yes or no policies as osquery queries or Wazuh checks, reuse existing CIS-based policies where they fit, and keep exception handling in one documented workflow.
Authorization and monitoring recordsRecurringVolume of authorization requests, frequency of monitoring reports, and how long records must be retainedRoute requests through a single ticket type and automate exports of monitoring results so assessors can sample records without manual collection.
Evidence upkeepRecurringHow often the acceptable list changes, how often the system is reassessed, and how many evidence artifacts each assessment cycle requiresKeep the list, authorization records and monitoring output in version control or a governed repository, and set a review date for each list entry.
External testing or reviewRecurring or per engagementScope of the review, whether mobile code controls are tested alongside SC-7, SC-8 and SI-3, and whether the review tests bypass attemptsAgree the scope in writing before work starts, include SC-18 in an existing test plan where possible, and ask for the test cases to be reused in later cycles.
Auditor samplingPer assessment cycleNumber of systems in scope, the seven determination statements to be tested, and the depth of examination the assessor choosesPrepare a single evidence pack per system with the allowed list, authorization records and monitoring records so samples can be pulled quickly.
Staff training and exception handlingRecurringNumber of developers and users who request mobile code, and how often exceptions are requestedPublish the allowed list where users look for it, and keep the exception path short so users do not seek workarounds.

Who does what for mobile code: your team, a partner and the auditor

Your organization owns SC-18. The control asks you to define which mobile code and mobile code technologies are acceptable and which are not, and to authorize, monitor and control their use in the system. Those decisions depend on business needs, risk appetite and which applications your users depend on, so they cannot be delegated to a vendor or consultant without losing accountability.

  • Approved and prohibited lists: Decide which script types, macro formats, browser-executed code and similar technologies are permitted, and record the reasons for each entry. The assessment procedure looks for a list of acceptable and a list of unacceptable mobile code and technologies.
  • Authorization decisions: Approve exceptions, such as a finance team needing a specific macro, and keep the signed authorization records that an assessor will examine.
  • Policy owner and review cycle: Name the person who maintains the lists and sets how often they are reviewed, aligned with your SC-1 policy.
  • Monitoring oversight: Review the monitoring results and decide what happens when a prohibited code type appears on an endpoint.
  • Quote scope: When you ask a partner for help, the written scope should state that list ownership and approvals stay with your staff.

Before engaging anyone, confirm that you have a named owner, a current approved list and a documented exception process.

Common gaps in mobile code control and how to close them

Most SC-18 programs fail at the joins between the allowlist, the authorization record and the devices that actually run the code. The cards below cover six gaps that assessors commonly find, each paired with a closure step tied to an artifact the assessor can examine. Closing them is mostly a matter of connecting records that already exist.

Allowlists not tied to authorizations

The organization may have a list of acceptable mobile code, but nothing links each entry to an authorization record showing who approved it, for which systems and under what conditions. SC-18 assessors examine both the list of acceptable mobile code and the authorization records, so a list without approvals is incomplete. Close the gap by giving every allowlist entry an identifier that appears in a signed authorization record. Check that a sample of entries traces in both directions.

Browser and office macro policies split

Browser script controls, office macro settings and plugin rules are often managed by different teams in different consoles, so no one can answer what is permitted across the estate. Assessors looking at the list of unacceptable mobile code and mobile technologies will expect one consistent answer. Closing this means exporting each tool's effective policy into one inventory with the owning team recorded. Review the inventory on a set cadence and reconcile differences.

Configuration checks without execution monitoring

Configuration scans confirm that a setting is present, but they do not show whether blocked code actually ran. SC-18 requires monitoring of mobile code use, so a passing configuration report alone leaves a gap. Pair configuration baselines with query-based checks for running processes, loaded modules and network connections on endpoints. Retain the monitoring records and tie alerts to the unacceptable code list.

Exceptions with no expiry or owner

Temporary exceptions for a script or macro often outlive the business reason that created them, and nobody is accountable for ending them. An exception without an owner, an expiry date and a compensating control is hard to defend during assessment. Require every exception to carry these three fields in the authorization record. Schedule a recurring review that lists expired or unowned exceptions and records the decision made on each.

Third-party plugins bypassing review

Extensions, add-ins and plugins frequently arrive through user self-service or vendor updates rather than the approval path used for other mobile code. That makes the authorization process incomplete even when the written policy is sound. Inventory installed extensions on every managed device and compare them with approved entries. Treat any unlisted extension as a finding and route it through the same authorization step.

No owner for the mobile code policy

When the policy defining acceptable and unacceptable mobile code has no named owner, updates lag behind new technologies and nobody answers assessor questions consistently. SC-18 requires the organization to define these categories, so the definition needs a responsible role. Assign an owner in the system security plan, record the review date and keep the revision history. Confirm that the owner can produce the current lists and the monitoring records on request.

SC-18 mobile code questions buyers ask before hiring help

How much effort does SC-18 Mobile code take to implement?

The effort depends less on the control text than on how many kinds of downloadable code your systems run. SC-18 asks you to define which mobile code and mobile code technologies are acceptable and which are not, then authorize, monitor and control their use. A organization with a short list of browser scripts and one office macro policy has a small job. A large environment with browser extensions, email macros, PDF scripting, build-time plugins and vendor-supplied scripts has a larger inventory, approval workflow and monitoring task. Ask any partner to size the work from your asset inventory and software list, and to state which assumptions the estimate depends on.

Can one person handle SC-18 in-house?

One capable person can usually write the mobile code policy and the acceptable list, but the control also needs authorization records and monitoring evidence that depend on endpoint, browser and email administration. In practice, the policy owner, the endpoint or platform team, and whoever runs security monitoring each hold part of the evidence. A single person can coordinate it, but the work fails when that person lacks administrative access to the systems where enforcement happens. Confirm early which teams must sign off on each acceptable entry and who can change the configuration.

What does the client team need to provide for an SC-18 engagement?

The client team must own the decisions and supply the inputs that no outside party can make for it. Expect to provide:

  • A current inventory of endpoints, browsers, office suites, email clients and the mobile code technologies they run
  • Named approvers for the acceptable and unacceptable lists and the authorization process
  • Read access to configuration management, endpoint management and logging platforms
  • Confirmation of which systems fall in the authorization boundary and at what impact level

Without these, an implementation partner can prepare tooling, but cannot produce authorization records that reflect real decisions.

How long does SC-18 work usually take?

In general terms, the duration follows the size of the mobile code inventory, how many approval decisions are needed, and whether monitoring already exists. Work that starts with a documented policy and an existing endpoint management platform typically moves faster than work that must first establish inventory and logging. No duration is set by NIST for this control, and any timeline should come from a written scope with named milestones. Ask for the sequence of deliverables and what each one depends on from your team.

Does SC-18 apply to low-baseline systems?

No. SP 800-53B assigns SC-18 to the moderate and high security control baselines, so a system categorized at the low impact level does not need it as a baseline control. Confirm the categorization in your system security plan before scoping, because a system that inherits requirements from a contract, a FedRAMP class or a stricter internal policy may still need the control. Tailoring decisions must be documented and approved, not assumed.

What do FedRAMP Classes C and D require for SC-18?

FedRAMP's Rev5 baselines require SC-18 at Classes C and D, as recorded in the Consolidated Rules for 2026. Confirm the exact class and the parameter expectations with the FedRAMP documentation and your authorizing official, because the rules and the reference text change between releases. Expect the assessor to ask for the acceptable and unacceptable lists, authorization records and monitoring output for the systems in boundary. Treat FedRAMP as a source of requirements to confirm, not a substitute for your own assessment plan.

Does DeployOpen issue the SC-18 assessment result?

No. DeployOpen prepares systems, configurations, monitoring and evidence for SC-18, but it does not issue audit reports, attestations or certifications. Your organization owns the control, and an independent assessor or certification body tests it and issues any report. Engagements are usually fixed-scope, with deliverables agreed in writing before work starts. Ask any partner to show which evidence it will prepare and which parts the independent assessor will test directly.

How DeployOpen works on this

DeployOpen plans, implements, hardens, documents and supports self-hosted open-source platforms inside the client's own infrastructure, and runs security testing alongside them. For SC-18, we help the organization define its mobile code rules, then prepare the monitoring and evidence an assessor will examine, while the organization keeps ownership of its decisions and an independent assessor reaches the conclusion.

How we scope

  • Confirm which systems fall under SC-18 and which SP 800-53B baseline applies to each.
  • Record the mobile code types in use, such as scripts, macros and browser-executed code, for the written scope.
  • Agree in writing which deliverables the organization owns, which DeployOpen prepares, and which an independent assessor reviews.

How we build

  • Help the organization draft its acceptable and unacceptable mobile code lists and the authorization workflow behind them.
  • Deploy and configure monitoring on endpoints and servers so records of mobile code use can be produced on request.
  • Test the configured controls against the SC-18 examine and test objects before handing them over.

How we hand over

  • Deliver a documented mapping from each SC-18 determination statement to the system component and the evidence that shows it.
  • Provide the authorization records, approved and prohibited code lists, and monitoring exports in a format the assessor can review.
  • Document known gaps in a plan of action with owners and dates the organization sets, so the assessor sees them clearly.

How we support

  • Engagements are fixed-scope, with scope, deliverables and timelines agreed in writing before work starts.
  • Ongoing support, upgrades and continuous testing of the mobile code controls are available as a retainer.
  • Ask for the written scope and a quote before engaging, since no price list is published and the quote follows from that scope.

Talk to our team.

Tell us what you're working on, whether it's a deployment, an audit, a security test or a cyber range. You'll speak with an engineer who can help you scope it.

  • 30-minute call: free, with no obligation.
  • NDA on request: we can sign before you share details.
  • Clear next steps: a scope and plan after the call.