Claude Skill

authorization-testing

Use this skill when you need evidence-bounded authorization-testing analysis and validation preparation; triggers include 授权测试 and authorization-testing.

LLM Mart · 0 points · 0 views 0 listing impressions 0 install-command copies
Virus-scanned Reviewed automatically before listing.

Full trust report

Download naodeng-awesome-qa-skills-skills_en_testing-types_authorization-testing-c44b892.zip · 6 KB
Part of naodeng/awesome-qa-skills — 97 skills

Install

skills CLI npx skills add https://github.com/naodeng/awesome-qa-skills/tree/main/skills/en/testing-types/authorization-testing
Claude Code claude plugin marketplace add https://llmmart.ai/marketplace.json && claude plugin install naodeng-awesome-qa-skills@llmmart
Git git clone https://github.com/naodeng/awesome-qa-skills.git

The skills CLI installs just this skill, for any of its supported agents. Claude Code installs the whole naodeng/awesome-qa-skills collection as a plugin from our marketplace. Git is the plain clone.

Skill manifest

Authorization Testing

When to Use

  • Use this Skill when the work needs evidence-bounded analysis of subject-resource-action relations, permission boundaries, denial paths, and delegation.
  • Use it when input is incomplete but a reviewable draft with assumptions and gaps is still useful.
  • Use it when static security evidence must remain separate from planned validation and completed execution.

Output Format Options

  • Default to Markdown organized by security risk, evidence, and priority.
  • If the user asks for a table, CSV, JSON, or ticket format, preserve the same finding fields and evidence states.
  • Confirm the schema, enum values, and required fields before feeding the output to automation.

How to Use

  1. Read prompts/authorization-testing.md and follow its input audit, coverage checklist, and output contract.
  2. Extract scope, environment, version, roles, data, dependencies, constraints, and available evidence.
  3. Model subject-resource-action relations, permission boundaries, denial paths, and delegation with reviewable scenarios, separating known facts, inferences, and candidate validation.
  4. Record impact, priority, owner role, close condition, and validation method for each item.
  5. With incomplete input, deliver a bounded draft; do not turn a risk assumption into a confirmed vulnerability or security pass.

Reference Files

  • Read prompts/authorization-testing.md for every invocation.
  • Read evals/eval.yaml and matching evals/cases/ when evaluating the Skill.
  • Read references/, examples/, scripts/, or output-formats.md only when the directory exists and the task needs it.

Core Constraints

  • Analyze only subject-resource-action relations, permission boundaries, denial paths, and delegation; do not log in, call real APIs, or read credentials.
  • Do not invent vulnerabilities, exploit success, remediation completion, scan coverage, or security-pass claims.
  • Mark unsupported evidence as pending, blocked, or unassessed and provide an isolated validation method.
  • Leave risk acceptance, exception authorization, and release judgment to a Human.

Delivery Self-Check

  • Complete the known, missing, conflicting, stale, out_of_scope, and assumptions audit.
  • Cover the authorization decision, triggers, expected concerns, and evidence state.
  • Separate facts, inferences, recommendations, gaps, and Human decisions.
  • Do not turn static findings or a dry-run into a real exploit, absence-of-vulnerability, or release-approval claim.

Common Pitfalls

  • Treating broad security review or API contract checking as a complete substitute for Authorization Testing.
  • Listing attack names without applicability, evidence, expected results, or close conditions.
  • Declaring a system secure with incomplete input, or reading real credentials for completeness.

Best Practices

  • Start with high-impact, hard-to-detect, permission-sensitive, or data-sensitive paths.
  • Use redacted material, least privilege, isolated environments, and reversible validation suggestions.
  • Make each security conclusion reviewable by another engineer from its source and boundary.
Files (awesome-qa-skills)
  • agents
    • openai.yaml 328 B
      version: 1
      metadata:
        key: authorization-testing
      interface:
        display_name: "Authorization Testing"
        short_description: "Evidence-bounded authorization-testing analysis and validation preparation"
        default_prompt: "Use the authorization-testing skill for evidence-bounded analysis."
      policy:
        allow_implicit_invocation: true
      
  • evals
    • cases
      • basic-success.yaml 1.4 KB
        id: basic-success
        title: "Authorization Testing: security output with complete input"
        description: |
          Verify that the Skill produces an evidence-based, prioritized, reviewable security result about subject-resource-action relations, permission boundaries, denial paths, and delegation.
        
        input:
          prompt: |
            Use the authorization-testing Skill to analyze permission decisions when operations staff access orders and admin APIs. System scope, test environment, roles, and security constraints are provided. Produce authorization decision risks, expected results, evidence gaps, priorities, and open questions.
        
        expect:
          must_contain:
            - "object/rule"
            - "source"
            - "trigger or applicability"
            - "expected concern/rationale"
            - "evidence state"
            - "impact/priority"
            - "owner role"
            - "close condition"
            - "validation method"
            - "AZT-"
            - "authorization decision"
            - "priority"
            - "evidence"
          must_not_contain:
            - "TODO"
            - "I cannot"
        
        judge:
          type: rule_based
          success:
            - output_contains:
                all:
                  - "object/rule"
                  - "source"
                  - "trigger or applicability"
                  - "expected concern/rationale"
                  - "evidence state"
                  - "impact/priority"
                  - "owner role"
                  - "close condition"
                  - "validation method"
                  - "AZT-"
                  - "authorization decision"
                  - "open"
        
      • edge-incomplete-input.yaml 804 B
        id: edge-incomplete-input
        title: "Authorization Testing: bounded draft with incomplete input"
        description: |
          Verify that missing environment, version, or evidence still yields a bounded draft with explicit assumptions and gaps.
        
        input:
          prompt: |
            Use authorization-testing. I only know that permission decisions when operations staff access orders and admin APIs needs review; code, configuration, version, and history are missing. Give a bounded draft and list known, missing, conflicting, stale, out_of_scope, assumptions, and required follow-up information.
        
        expect:
          must_contain:
            - "assumption"
            - "gap"
            - "open"
          must_not_contain:
            - "TODO"
            - "I cannot"
        
        judge:
          type: rule_based
          success:
            - output_contains:
                all:
                  - "assumption"
                  - "gap"
        
      • edge-scope-boundary.yaml 915 B
        id: edge-scope-boundary
        title: "Authorization Testing: security-claim boundary"
        description: |
          Verify that without execution evidence the Skill rejects “tests were executed”, “all tests passed”, and “release approved”, while preserving the authorization decision validation boundary.
        
        input:
          prompt: |
            Use authorization-testing to review static material for permission decisions when operations staff access orders and admin APIs. There is no execution record. Explain why “tests were executed”, “all tests passed”, or “release approved” cannot be asserted, and give stop conditions and the next isolated validation.
        
        expect:
          must_contain:
            - "authorization decision"
            - "cannot"
            - "open"
          must_not_contain:
            - "TODO"
            - "I cannot"
        
        judge:
          type: rule_based
          success:
            - output_contains:
                all:
                  - "authorization decision"
                  - "cannot"
        
    • eval.yaml 441 B
      schema_version: v1alpha1
      
      environment:
        type: none
      
      skills:
        - source: local_path
          path: .
      
      engine:
        name: claude_code
      
      cases:
        files:
          - evals/cases/basic-success.yaml
          - evals/cases/edge-incomplete-input.yaml
          - evals/cases/edge-scope-boundary.yaml
        defaults:
          timeout_seconds: 180
          max_turns: 8
          expect:
            exit_code: 0
            must_not_contain:
              - "TODO"
              - "I cannot"
      
      report:
        formats: [json]
      
    • local-rules.json 140 B
      {
        "skill": "authorization-testing",
        "max_commands": 20,
        "max_total_tokens": 100000,
        "permissions": {
          "max_escalations": 0
        }
      }
      
    • trigger-prompts.csv 474 B · in bundle
  • prompts
    • authorization-testing.md 4 KB
      # Authorization Testing Prompt
      
      ## Input
      
      Start with an input audit and record known, missing, conflicting, stale, out_of_scope, and assumptions:
      
      - known: scope, authorization decision, roles, or constraints directly supported by a source.
      - missing: material needed to judge subject-resource-action relations, permission boundaries, denial paths, and delegation that has not been supplied.
      - conflicting: incompatible objectives, conditions, roles, or behaviors across sources.
      - stale: architecture, version, policy, log, or scan evidence that may be out of date.
      - out_of_scope: work outside this Skill, unauthorized actions, or actions requiring a real environment.
      - assumptions: temporary assumptions used for a bounded draft; include a validation method.
      
      ## What to do
      
      1. Restate the security objective, object, scope, and success criteria.
      2. Model scenarios, triggers, expected concerns, and evidence needs around subject-resource-action relations, permission boundaries, denial paths, and delegation.
      3. Separate static review, candidate validation, and unauthorized real-system actions.
      4. Record priority, owner role, close condition, and validation method for every finding.
      5. Separate facts, evidence-backed inferences, candidate recommendations, and Human decisions.
      
      ## Execution Rules
      
      - Audit known, missing, conflicting, stale, out_of_scope, and assumptions first.
      - Trace every conclusion to a source; mark unsupported evidence as pending, blocked, or a validation recommendation.
      - Use authorization decision as the domain anchor and AZT-## as the finding identifier.
      - Each scenario needs preconditions, stimulus or action, expected result, evidence, and stop condition.
      - Do not log in, call real APIs, read credentials, or perform destructive security actions.
      - Do not upgrade files, names, templates, or dry-runs into absence-of-vulnerability, exploit success, or release-approval evidence.
      
      ## Minimum Coverage Checklist
      
      - authorization decision and applicability
      - Primary risks or failure modes and triggers
      - Data, permissions, impact, and priority
      - Existing controls, dependencies, trust boundaries, and evidence freshness
      - Expected result, evidence state, and validation method
      - Close condition, residual risk, and Human decision
      - facts, evidence-backed inferences, candidate recommendations, Human decisions
      
      ## Output
      
      ### 1. Scope and Task Understanding
      
      State the objective, object, included and excluded work, success criteria, and unauthorized actions.
      
      ### 2. Input Audit
      
      List known, missing, conflicting, stale, out_of_scope, and assumptions with source and freshness.
      
      ### 3. authorization decision and Security Risk Model
      
      Describe subject-resource-action relations, permission boundaries, denial paths, and delegation scenarios, triggers, expected behavior, impact, priority, and evidence gaps.
      
      ### AZT-## Finding Contract
      
      Every finding must include:
      
      - object/rule
      - source
      - trigger or applicability
      - expected concern/rationale
      - evidence state
      - impact/priority
      - owner role
      - close condition
      - validation method
      
      ### 4. Candidate Validation and Residual Risk
      
      Separate candidate recommendations from completed execution. State the smallest isolated validation, stop/escalation conditions, residual risks, and open questions.
      
      ### 5. Human Decisions
      
      List only items requiring Human confirmation, risk acceptance, exception authorization, or release judgment.
      
      The output must preserve: facts, evidence-backed inferences, candidate recommendations, Human decisions.
      
      ## Quality Bar
      
      - The content must target subject-resource-action relations, permission boundaries, denial paths, and delegation, not a generic template with a substituted title.
      - Without direct evidence, never write “tests were executed”, “all tests passed”, or “release approved”.
      - Vulnerabilities, impact, thresholds, exploit success, and remediation status require sources.
      - Make the next action clear to the executor and the boundaries of facts, inferences, recommendations, and Human decisions reviewable.
      
  • SKILL.md 3.3 KB
    ---
    name: authorization-testing
    description: Use this skill when you need evidence-bounded authorization-testing analysis and validation preparation; triggers include 授权测试 and authorization-testing.
    ---
    
    # Authorization Testing
    
    ## When to Use
    
    - Use this Skill when the work needs evidence-bounded analysis of subject-resource-action relations, permission boundaries, denial paths, and delegation.
    - Use it when input is incomplete but a reviewable draft with assumptions and gaps is still useful.
    - Use it when static security evidence must remain separate from planned validation and completed execution.
    
    ## Output Format Options
    
    - Default to Markdown organized by security risk, evidence, and priority.
    - If the user asks for a table, CSV, JSON, or ticket format, preserve the same finding fields and evidence states.
    - Confirm the schema, enum values, and required fields before feeding the output to automation.
    
    ## How to Use
    
    1. Read prompts/authorization-testing.md and follow its input audit, coverage checklist, and output contract.
    2. Extract scope, environment, version, roles, data, dependencies, constraints, and available evidence.
    3. Model subject-resource-action relations, permission boundaries, denial paths, and delegation with reviewable scenarios, separating known facts, inferences, and candidate validation.
    4. Record impact, priority, owner role, close condition, and validation method for each item.
    5. With incomplete input, deliver a bounded draft; do not turn a risk assumption into a confirmed vulnerability or security pass.
    
    ## Reference Files
    
    - Read prompts/authorization-testing.md for every invocation.
    - Read evals/eval.yaml and matching evals/cases/ when evaluating the Skill.
    - Read references/, examples/, scripts/, or output-formats.md only when the directory exists and the task needs it.
    
    ## Core Constraints
    
    - Analyze only subject-resource-action relations, permission boundaries, denial paths, and delegation; do not log in, call real APIs, or read credentials.
    - Do not invent vulnerabilities, exploit success, remediation completion, scan coverage, or security-pass claims.
    - Mark unsupported evidence as pending, blocked, or unassessed and provide an isolated validation method.
    - Leave risk acceptance, exception authorization, and release judgment to a Human.
    
    ## Delivery Self-Check
    
    - [ ] Complete the known, missing, conflicting, stale, out_of_scope, and assumptions audit.
    - [ ] Cover the authorization decision, triggers, expected concerns, and evidence state.
    - [ ] Separate facts, inferences, recommendations, gaps, and Human decisions.
    - [ ] Do not turn static findings or a dry-run into a real exploit, absence-of-vulnerability, or release-approval claim.
    
    ## Common Pitfalls
    
    - Treating broad security review or API contract checking as a complete substitute for Authorization Testing.
    - Listing attack names without applicability, evidence, expected results, or close conditions.
    - Declaring a system secure with incomplete input, or reading real credentials for completeness.
    
    ## Best Practices
    
    - Start with high-impact, hard-to-detect, permission-sensitive, or data-sensitive paths.
    - Use redacted material, least privilege, isolated environments, and reversible validation suggestions.
    - Make each security conclusion reviewable by another engineer from its source and boundary.
    

Comments (0)

Sign in to join the conversation.

No comments yet.

Reviews (0)

No reviews yet.

Related