Checkpoint Lab — Secrets, Credentials, Environment Isolation, and Security Hygiene

1. Checkpoint architecture

flowchart TD
  A["Parent shell — RF23_FAKE_TOKEN"] --> B["Robot ${TOKEN: Secret}"]
  B --> C{"Target allowlisted?"}
  C -->|no| X["FAIL before secret use"]
  C -->|yes| D["Secret-aware custom keyword"]
  D --> E["Safe non-secret status"]
  E --> F["Safe output.xml / log.html / report.html"]
  B --> G["Unsafe demo unwraps .value"]
  G --> H["Unsafe artifact"]
  F --> I["Artifact scanner: 0 hits"]
  H --> J["Artifact scanner: hit -> policy FAIL"]
  I --> K["Cleanup + threat model"]
  J --> K

The safe and unsafe branches share the same fake source but must produce different evidence. This is intentional: the checkpoint demonstrates that Robot functional PASS cannot replace a security artifact gate.

2. Preflight and exact assumptions

• Python 3.8+ and Robot Framework 7.4.2 in an isolated virtual environment.
• No real credentials. Use exactly the fake sentinel RF23_FAKE_ONLY_7z9q.
• No network target. The only allowed target is local-synthetic.
• Run from a disposable rf23-checkpoint directory you own.
• Do not upload evidence/unsafe anywhere; it intentionally contains the fake disclosure.

python --version
python -m robot --version
python -c "from robot.api.types import Secret; print(Secret('FAKE'))"
python -c "import os; print('source present:', 'RF23_FAKE_TOKEN' in os.environ)"

3. Predict before acting

4. Build the checkpoint files

Reuse the secret_guard.py and scan_artifacts.py from Lesson 2. Add this suite:

*** Settings ***
Library    libraries/secret_guard.py

*** Variables ***
${TOKEN: Secret}    %{RF23_FAKE_TOKEN}

*** Test Cases ***
Safe Pipeline
    [Tags]    safe
    Assert Allowed Target    local-synthetic
    ${result}=    Use Fake Secret Safely    ${TOKEN}
    Should Be Equal    ${result}    synthetic-operation-accepted
    Log    SECURITY_EVIDENCE target=local-synthetic secret_representation=masked

Wrong Target Is Blocked
    [Tags]    guard-negative
    Run Keyword And Expect Error
    ...    Target 'production' is not allowlisted.
    ...    Assert Allowed Target    production

Unsafe Fake Disclosure
    [Tags]    unsafe-demo
    Assert Allowed Target    local-synthetic
    ${raw}=    Unsafe Unwrap For Demonstration    ${TOKEN}
    Log    INTENTIONAL_FAKE_DISCLOSURE=${raw}

Run Keyword And Expect Error is acceptable here because the guard failure itself is the expected test outcome; it does not swallow a real authentication/TLS failure. The unsafe test remains isolated by tag.

5. Run the safe and guard-negative slice

mkdir -p evidence/safe
python -m robot --include safe --include guard-negative --outputdir evidence/safe checkpoint.robot
python tools/scan_artifacts.py evidence/safe
# Expected: Robot PASS, scanner PASS (exit 0).

Capture an evidence ledger with only non-secret facts: Robot/Python versions, target name, selected tags, result status, artifact paths, scanner exit code, and cleanup status.

6. Inject and detect the fake disclosure

mkdir -p evidence/unsafe
python -m robot --include unsafe-demo --outputdir evidence/unsafe checkpoint.robot
python tools/scan_artifacts.py evidence/unsafe
# Expected: Robot test may PASS; scanner MUST exit 1.

Record only the contaminated filenames in the evidence ledger. Do not copy the fake raw token into the ledger. The scanner demonstrates a policy failure independently of Robot's execution status.

7. Evidence packet

api-version-manifest.txt
  python=<captured version>
  robot=7.4.2

security-evidence.txt
  source=environment (value not recorded)
  target=local-synthetic
  target_guard=PASS
  safe_robot_status=PASS
  safe_scan_exit=0
  unsafe_robot_status=PASS (expected demonstration)
  unsafe_scan_exit=1 (expected policy detection)
  parent_environment_cleanup=VERIFIED

threat-model.md
  source / process / downstream / network / logs / reports / CI / retention

Keep the unsafe Robot artifacts local to the disposable lab until the comparison is complete, then remove them. In a real incident, retention and access decisions belong to the security/incident process rather than a lesson cleanup script.

8. Threat-model checklist

9. Cleanup and rollback proof

# Bash/zsh
unset RF23_FAKE_TOKEN
python -c "import os; print('source present:', 'RF23_FAKE_TOKEN' in os.environ)"
# Expected: False
rm -rf evidence/unsafe
# Keep or remove safe evidence according to your local learning needs.

Remove-Item Env:RF23_FAKE_TOKEN -ErrorAction SilentlyContinue
python -c "import os; print('source present:', 'RF23_FAKE_TOKEN' in os.environ)"
Remove-Item evidence/unsafe -Recurse -Force -ErrorAction SilentlyContinue

10. Verification checklist

• Exactly Robot Framework 7.4.2 (or explicitly documented compatible 7.4.x) was used.
• No real secret or public/production target was introduced.
• Safe branch passed target allowlist before secret use.
• Safe scan found zero literal fake-token occurrences.
• Wrong-target test proved guard failure before secret use.
• Unsafe branch created a deliberate fake disclosure and scanner caught it.
• Evidence ledger contains no raw secret value.
• Parent environment variable was removed from the launching shell.
• Unsafe artifacts were not uploaded and were removed after analysis.
• Threat model distinguishes Robot masking from external security controls.

11. Production operating model added by Chapter 23

A production Robot platform now needs a credential contract alongside its execution contract: governed source, least-privilege identity, Secret-aware Robot paths, narrow unwrapping adapters, authenticated/verified downstream transport, target allowlists, artifact scanning, controlled retention, and incident-ready rotation. Chapter 24 adds parallel execution with Pabot, where these same principles must be applied per worker and per mutable resource rather than assuming one shared secret/state is safe.

Knowledge check

References and version anchors

• Robot Framework 7.4.2 User Guide — Secret variables — creation, masking, command-line and programmatic use, and limitations.
• Robot Framework 7.4.2 User Guide — Secret type — typed library arguments and disclosure boundary.
• Robot Framework 7.4.2 OperatingSystem — environment/file operations including Secret-aware arguments.
• Robot Framework 7.4.2 Process — process arguments/environment and result evidence.
• Robot Framework PyPI — stable and prerelease version status and Python requirement.