PayloadGuard
Version: 1.6.0 | Status: Production | Updated: October 2026
Formally verified — 36 CrossHair contracts • 10 Z3 SMT proofs • 12 Dafny postconditions • 330 tests pass (100%) • 3 independent proof methods. → PROOFS.md
PayloadGuard is a GitHub Action and pre-merge consequence analysis engine that forensically scans pull requests for destructive, deceptive, or supply-chain payloads before they reach your default branch.
It was engineered for the class of attacks and human errors that slip past standard linters, test runners, and merge queues: branches held open for months that land as a "minor fix" and wipe the codebase in a single merge, tests that pass only because assertions were silently replaced with tautologies (assert True), database migrations that permanently wipe production data without rollback procedures, CI workflows modified to execute untrusted PR expressions, and security guards neutralized with boolean short-circuits (if not verify() and False:).
Wire PayloadGuard to your branch protection rules, and catastrophic pull requests are blocked automatically.
Key Benefits
- Deterministic & Instant CI Integration: Runs in seconds directly inside GitHub Actions with zero LLM dependency, zero external API latency, and zero non-determinism.
- Semantic Change Graph (SCG) Consequence Engine (
consequence.v1): Understands high-level program structure across Python, JavaScript (.js,.jsx,.mjs,.cjs), TypeScript (.ts,.tsx,.mts,.cts), Go, Rust, and Java. Changes to source code in other languages are reported as incomplete coverage (D01). Distinguishes benign symbol renames and cross-file moves from hollow stubs, broken callers, and deleted capabilities. - Catches What Test Suites and Linters Miss:
- Test Erosion (
D09): Flags tests gutted into tautologies (assert True,expect(true).toBe(true)) or newly skipped (@pytest.mark.skip,t.Skip()). - CI Workflow Integrity (
D08): Blocks untrusted expression injection inrun:shell blocks,pull_request_targetuntrusted checkout ("Pwn Request"), action SHA pin downgrades, andcontinue-on-error: truegate weakening. - Migration & Persistence Protection (
D10): BlocksTRUNCATEandDROP DATABASE/SCHEMAin automated migrations; isolates forward migration drops from rollback procedures across Alembic, Knex, Rails, Goose, and Django. - Security Guard Regressions (
D06): Detects removed auth decorators, dropped transaction rollbacks, inverted guard polarities, andand False/|| trueshort-circuits. - Build Wrapper Tampering (
D05): Detects unauthorized remote downloads or reverse shells (curl | sh) insidemvnw,gradlew,Makefile, andbuild.sh.
- Test Erosion (
- Formally Verified Decision Engine: Scoring thresholds, severity floors, and verdict bijections are mathematically proven across CrossHair symbolic execution, Z3 SMT theorem proving, and Dafny machine-checked proofs.
- Actionable Remediation Guidance: Every finding includes exact line numbers, source snippets, affected symbols, and precise remediation advice formatted in interactive, collapsible GitHub markdown comments and SARIF 2.1.0 output.
What PayloadGuard Detects
| Threat Category | Detector / Layer | Real-World Attack / Error Scenario | Default Policy |
|---|---|---|---|
| Mass Deletion Disguised as Refactor | L1, L2, L4 |
312-day-old branch submitted as "minor syntax fix", deleting 60 files and 11,967 lines | BLOCK |
| Structural Gutting & Stub Replacement | D02_BODY_WEAKENING |
Security or authentication methods renamed and gutted into pass, ..., or return None stubs |
BLOCK |
| Distributed Loss & Threshold Gaming | D03_COMPOUND_LOSS |
Removing 1 security function per file across 5 files (A03) or padding deleted methods with trivial getters (A06) |
BLOCK |
| Broken Cross-File Callers & API Breaks | D04_PUBLIC_API_BREAK |
Deleting exported functions or tightening required parameters while surviving callers (including aliased imports) still invoke the old contract | BLOCK |
| Build Wrapper Script Tampering | D05_BUILD_DEPENDENCY_DELTA |
Remote script execution or reverse shell (curl | sh) injected into mvnw, gradlew, Makefile, or build.sh |
BLOCK |
| Manifest Dependency Drift | D05_BUILD_DEPENDENCY_DELTA |
Dependency added to package.json or pyproject.toml without accompanying lockfile update |
REVIEW |
| Security Guard & Rollback Regression | D06_GUARD_REGRESSION |
Removing @require_auth, dropping self._rollback(), inverting guard polarity (if not verify() $ o$ if verify()), or inserting and False short-circuits |
BLOCK |
| Untrusted CI Expression Injection | D08_WORKFLOW_INTEGRITY |
Interpolating untrusted context (${{ github.event.pull_request.title }}) directly inside run: shell blocks (W02 / CWE-78) |
BLOCK |
| Pwn Request Checkout | D08_WORKFLOW_INTEGRITY |
Combining privileged pull_request_target trigger with checkout of untrusted pull request head ref (W01) |
BLOCK |
| Action SHA Pin Downgrade | D08_WORKFLOW_INTEGRITY |
Action downgraded from an immutable 40-character commit SHA to a mutable tag or branch (@v4, @main) |
REVIEW |
| CI Gate Weakening | D08_WORKFLOW_INTEGRITY |
Adding continue-on-error: true to required test/lint steps or adding broad permissions: write-all |
REVIEW |
| Privileged Artifact Poisoning | D08_WORKFLOW_INTEGRITY |
Privileged workflow_run trigger downloading and unpacking untrusted artifacts without sandboxing |
REVIEW |
| Test Assertion Erosion | D09_TEST_EROSION |
Substantive test assertions replaced with tautologies (assert True, expect(true).toBe(true)), keeping CI green while gutting coverage |
BLOCK |
| Newly Skipped Tests | D09_TEST_EROSION |
Adding test-skip decorators (@pytest.mark.skip, @pytest.mark.xfail, it.skip) or runtime skip calls (pytest.skip(), t.Skip()) |
REVIEW |
| Catastrophic Persistence Wipe-Out | D10_MIGRATION_PERSISTENCE_LOSS |
Migration executing TRUNCATE TABLE or DROP DATABASE / DROP SCHEMA on persistent data |
BLOCK |
| Irreversible Schema Drop | D10_MIGRATION_PERSISTENCE_LOSS |
Dropping tables or columns with empty/missing downgrade(), Rails change without block, or Django RunSQL without reverse_sql |
BLOCK |
| Destructive Migration Drop | D10_MIGRATION_PERSISTENCE_LOSS |
Dropping persistent table or column in forward migration (with working rollback procedure) | REVIEW |
| Workflow Actions Poisoning & OIDC | L2c |
Workflow files modified to exfiltrate secrets, steal OIDC tokens, or forge CI identities | BLOCK |
| AI Tooling Config Poisoning | L2d |
Malicious .claude/settings.json, .cursor/rules/*.mdc, .vscode/tasks.json, or lifecycle scripts executing on folder open |
BLOCK |
| Deceptive PR Descriptions | L5b |
PR description says "minor copy fix" while the diff alters authentication or drops database tables | BLOCK |
Analysis Tiers
PayloadGuard operates across three analysis tiers. Each tier builds on the one before it:
┌─────────────────────────────────────────────────────────────┐
│ CORE (L1 • L2 • L2b • L3) │
│ Surface scan → Forensic file analysis → Weighted scoring │
│ Zero external dependencies (GitPython, PyYAML, PyJWT) │
└──────────────────────────────┬──────────────────────────────┘
│
┌──────────────────────────────▼──────────────────────────────┐
│ STANDARD (adds L2c • L2d • L4 • L5a • L5b • consequence.v1│
│ + CI workflow integrity (D08) & Actions poisoning (L2c) │
│ + AI tooling configuration poisoning (L2d) │
│ + Semantic Change Graph Consequence Engine (D01–D10) │
│ + Test erosion (D09) & Migration persistence loss (D10) │
│ + Temporal drift (L5a) & Semantic transparency (L5b) │
│ Dependencies: Tree-sitter multi-language grammars │
└──────────────────────────────┬──────────────────────────────┘
│
┌──────────────────────────────▼──────────────────────────────┐
│ FULL (adds L5c) │
│ + eBPF runner runtime agent (execve, egress, ptrace) │
│ Dependencies: Linux runner with kernel BPF support │
└─────────────────────────────────────────────────────────────┘
SCG Consequence Engine (consequence.v1)
The Consequence Engine (consequence_engine.py) matches base and head symbols through a 5-stage Semantic Change Graph (SCG) pipeline:
- Exact ID Match: Matches qualified symbols unchanged in name and container.
- Body Hash & Signature Match: Detects symbols moved across files or renamed within the same container when their normalized AST tokens match.
- Cross-File Move Resolution: Tracks symbols transferred across module boundaries.
- Fuzzy Container / Member Match: Distinguishes genuine refactoring from structural gutting.
- Residual Classification: Emits symbol transitions (
ADDED,MODIFIED,DELETED,RENAMED,MOVED).
Consequence Detectors Reference
| Detector ID | Consequence Classes | Epistemic Tier | Default Policy | Description |
|---|---|---|---|---|
D01_PARSER_INCOMPLETE |
ANALYSIS_INCOMPLETE |
ANALYSIS_INCOMPLETE |
WARN / REVIEW |
File syntax errors, missing grammar packages, or unsupported extensions. |
D02_BODY_WEAKENING |
BODY_GUTTED, RENAME_WITH_BODY_WEAKENING, AMBIGUOUS_REFACTOR |
VERIFIED_CONSEQUENCE |
BLOCK / WARN |
Surviving or renamed symbols gutted to no-op stubs (pass, ..., return None, empty {}). |
D03_COMPOUND_LOSS |
DISTRIBUTED_SYMBOL_LOSS, THRESHOLD_GAMING_DELETION |
VERIFIED_CONSEQUENCE |
BLOCK / REVIEW |
Cross-file sub-threshold deletion (A03) and deletion-ratio dilution via trivial getters (A06). |
D04_PUBLIC_API_BREAK |
UNRESOLVED_CALLER, PUBLIC_API_REMOVAL, PUBLIC_API_SIGNATURE_BREAK |
VERIFIED_CONSEQUENCE |
BLOCK / REVIEW |
Deleted symbols with surviving callers (including aliased imports) or broken signatures. |
D05_BUILD_DEPENDENCY_DELTA |
BUILD_WRAPPER_TAMPERING, BUILD_SCRIPT_MODIFICATION, DEPENDENCY_LOCKFILE_MISMATCH |
VERIFIED_CONSEQUENCE |
BLOCK / REVIEW |
Remote script execution in build wrappers (mvnw, gradlew), lifecycle scripts, or unpinned dependencies. |
D06_GUARD_REGRESSION |
SECURITY_GUARD_REMOVED, SECURITY_GUARD_WEAKENED |
VERIFIED_CONSEQUENCE |
BLOCK |
Removed auth decorators, dropped transaction rollbacks, inverted polarities, or and False short-circuits. |
D08_WORKFLOW_INTEGRITY |
UNTRUSTED_WORKFLOW_EXPRESSION_INJECTION, PULL_REQUEST_TARGET_UNTRUSTED_CHECKOUT, ACTION_PIN_DOWNGRADE, CI_GATE_WEAKENED, WORKFLOW_RUN_UNTRUSTED_ARTIFACT, ACTION_PIN_UNPINNED |
VERIFIED_CONSEQUENCE |
BLOCK / REVIEW / WARN |
Untrusted expression injection, Pwn Request checkout, SHA pin downgrade, gate weakening, and unpinned 3rd-party actions. |
D09_TEST_EROSION |
TEST_ASSERTION_EROSION, TEST_SKIPPED_NEWLY |
VERIFIED_CONSEQUENCE |
BLOCK / REVIEW |
Test assertions replaced with tautologies (assert True) or newly skipped test decorators/calls. |
D10_MIGRATION_PERSISTENCE_LOSS |
CATASTROPHIC_DATA_WIPEOUT, IRREVERSIBLE_PERSISTENCE_DROP, DESTRUCTIVE_PERSISTENCE_MIGRATION |
VERIFIED_CONSEQUENCE |
BLOCK / REVIEW |
Automated TRUNCATE, DROP DATABASE, irreversible table/column drops, or forward schema removals. |
GitHub Action Installation & Setup
1. Add Workflow to Your Repository
Create .github/workflows/payloadguard.yml in your default branch:
name: PayloadGuard Analysis
on:
pull_request:
types: [opened, synchronize, reopened]
jobs:
scan:
name: PayloadGuard Pre-Merge Consequence Analysis
runs-on: ubuntu-latest
permissions:
contents: read
pull-requests: write # Required to post interactive review comments
security-events: write # Required if saving SARIF to GitHub Code Scanning
steps:
- name: Checkout repository
uses: actions/checkout@v4
with:
fetch-depth: 0 # Required: full git history needed for merge-base analysis
- name: Run PayloadGuard Scan
id: payloadguard
uses: PayloadGuard-PLG/payload-consequence-analyser@main
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
pr-description: ${{ github.event.pull_request.body }}
save-markdown: payloadguard-report.md
- name: Enforce Merge Policy
if: always()
env:
EXIT_CODE: ${{ steps.payloadguard.outputs.exit-code }}
run: |
echo "PayloadGuard scan exited with code: $EXIT_CODE"
if [ "$EXIT_CODE" = "2" ]; then
echo "::error::PayloadGuard detected verified DESTRUCTIVE code consequences. Merge is blocked."
exit 2
fi
if [ "$EXIT_CODE" = "1" ]; then
echo "::error::PayloadGuard encountered an analysis error."
exit 1
fi
echo "PayloadGuard verdict is SAFE or REVIEW. Proceed with review."
2. Configure Branch Protection (Enforce Blocking)
To prevent pull requests with destructive payloads from merging:
- In your GitHub repository, navigate to Settings → Branches → Branch protection rules.
- Select your default branch (e.g.,
main). - Check Require status checks to pass before merging.
- Search for and select the
scan(orPayloadGuard Pre-Merge Consequence Analysis) check. - Save changes. Any PR with verified destructive consequences (
exit code 2) will now fail the check and block the merge button.
3. Consequence Modes
PayloadGuard supports three policy enforcement modes. The mode is taken from the action's consequence-mode input (the CLI's --consequence-mode), then the PAYLOADGUARD_CONSEQUENCE_MODE environment variable, then payloadguard.yml:
| Mode | Behavior | Use Case |
|---|---|---|
shadow (default) |
Runs all consequence detectors, logs findings in JSON, PR comments, and SARIF, but does not escalate the exit code to 2. |
Initial trial / baseline observation in existing repositories. |
advisory |
Emits findings, labels findings in PR comments, requests human review for POLICY_REVIEW / POLICY_WARN, but allows override. |
Team transition / soft enforcement. |
enforce |
Verified blocking consequences (POLICY_BLOCK) immediately set the exit code to 2, blocking CI merge checks. |
Production repositories requiring strict pre-merge safety guarantees. |
To enforce blocking mode via your workflow:
- name: Run PayloadGuard Scan (Enforce)
uses: PayloadGuard-PLG/payload-consequence-analyser@main
with:
repo-token: ${{ secrets.GITHUB_TOKEN }}
pr-description: ${{ github.event.pull_request.body }}
consequence-mode: enforce
Or place a payloadguard.yml in your repository root:
consequence:
mode: enforce
payloadguard.yml is read from the target branch, so a pull request cannot change it for its own scan. The consequence-mode input is only as trusted as the workflow file; on pull_request events that file comes from the pull request, so protect it with required workflows or CODEOWNERS.
The action's verdict output is SAFE, REVIEW, CAUTION or DESTRUCTIVE, or ERROR when the analysis failed (including an invalid consequence-mode, which exits 1).
Local CLI Usage
You can run PayloadGuard locally or in custom CI pipelines without GitHub Actions:
Installation via pip
pip install payloadguard-plg
From Source
git clone https://github.com/PayloadGuard-PLG/payload-consequence-analyser.git
cd payload-consequence-analyser
pip install -r requirements.txt
Running Scans
# Basic scan of a feature branch against main
python analyze.py . feature/my-branch main
# Scan with PR description for Semantic Transparency analysis (Layer 5b)
python analyze.py . feature/my-branch main --pr-description "Add user profile endpoint and migrate session table"
# Run in strict consequence enforcement mode
python analyze.py . feature/my-branch main --consequence-mode enforce
# Generate JSON, GitHub Markdown, and SARIF 2.1.0 reports
python analyze.py . feature/my-branch main --save-json reports/scan.json --save-markdown reports/scan.md --save-sarif reports/scan.sarif
Exit Codes
| Exit Code | Meaning | Action in CI |
|---|---|---|
0 |
SAFE, REVIEW, or CAUTION |
Proceed with standard peer review |
1 |
ANALYSIS_ERROR |
Infrastructure or git execution error |
2 |
DESTRUCTIVE |
Merge blocked — verified destructive consequence detected |
Configuration (payloadguard.yml)
Place payloadguard.yml in your repository root to customize rules and thresholds. All fields are optional.
payloadguard.yml and allowlist.yml are read from the target branch (for example main), not from the branch being scanned. A pull request cannot change the policy its own scan runs under; edits to either file take effect once merged.
# Consequence Engine Configuration
consequence:
mode: enforce # shadow | advisory | enforce
max_repo_files: 500 # max head files indexed for cross-file caller verification
# Structural & Deletion Thresholds
thresholds:
branch_age_days: [90, 180, 365] # days → +1/+2/+3 score
files_deleted: [10, 20, 50] # files → +1/+2/+3 score
lines_deleted: [5000, 10000, 50000]
temporal:
stale: 250 # drift_score threshold (STALE)
dangerous: 1000 # drift_score threshold (DANGEROUS)
structural:
deletion_ratio: 0.20 # 20% of symbols deleted → CRITICAL
min_deleted_nodes: 3
# Software Composition Analysis (SCA)
sca:
fail_on_unknown: true # Unverified package in manifest → +3 score
# GitHub Actions Security
actions:
enabled: true
critical_signal_score: 5
high_signal_score: 3
trusted_oidc_consumers:
- my-org/custom-deploy-action
# Semantic Transparency Analysis
semantic:
micro_scope_churn_limit: 50
insertion_ratio_fix_threshold: 0.9
Approved Dependencies Allowlist (allowlist.yml)
If sca.fail_on_unknown: true is configured, dependencies added in package manifests (package.json, requirements.txt, pyproject.toml, Gemfile, go.mod) are checked against allowlist.yml:
packages:
- requests
- pydantic
- sqlalchemy
- tree-sitter
Test Suite & Formal Verification
PayloadGuard's consequence and scoring logic is mathematically proven to eliminate non-deterministic scoring errors. A flaw would have to produce an identical error across three independent mathematical frameworks simultaneously:
| Method | Specification & Tool | What is Proven |
|---|---|---|
| SMT Prover | Z3 | Score upper bounds, verdict bijection, safety-critical floors, empty-input guarantees (P1–P10). |
| Symbolic Execution | CrossHair | Postcondition contracts across consequence scoring, structural drift, temporal drift, and semantic transparency (C1–C12, S1–S7, T1–T7, M1–M9). |
| Machine-Checked Proofs | Dafny | Full input domain coverage and 12 machine-checked postconditions verified with zero verification errors (POST-1–12). |
Test Metrics
# Run complete test suite
python -m pytest test_analyzer.py test_consequence_engine.py -q
# 330 passed in 2.39s
- Core & Consequence Test Suite: 330 passed, 0 failed (
test_analyzer.py+test_consequence_engine.py). - Mutation Suite: 16 / 16 passed with 0 False Positives and 0 False Negatives (
run_mutation_suite.py). - Harness Manifest Oracle: 41 / 41 passed across schema validations and Consequence Engine v1 assertions (
validate_manifest.py).
Detailed specifications and mathematical proofs are documented in VERIFICATION.md and PROOFS.md.
What's New in v1.6.0
PayloadGuard v1.6.0 fixes the defects found in an audit of v1.5.0 (AUDIT_LOG.md §V1–§V10) and is the first release published to PyPI since 1.3.0:
- Policy cannot be changed by the pull request it judges:
payloadguard.ymlandallowlist.ymlare read from the target branch, not the scanned branch. - Fork pull requests are scanned correctly: the Action scans the pull request head commit instead of resolving the head branch name, which failed for fork branches or matched the base repository's same-named branch.
consequence-modeAction input:shadow|advisory|enforce; theverdictoutput now reportsREVIEWandCAUTION.- Coverage reporting: changed source in languages without a structural parser is reported by
D01as incomplete coverage;.mjs,.cjs,.mtsand.ctsare parsed with the JavaScript/TypeScript grammars. - Packaging: the distribution builds again (
consequence_engineis shipped);requires-pythonis now>=3.11. - Temporal drift: non-finite branch age or target velocity raises
ValueErrorinstead of producing a NaN score classifiedCURRENT. - CLI exit codes on Windows: a console that cannot encode the report's symbols (redirected output on Windows) no longer turns the verdict into exit code 1.
- Verification: Dafny, CrossHair and Z3 re-run against the current specifications; results in
PROOFS.md.
What's New in v1.5.0
PayloadGuard v1.5.0 introduces major enhancements across CI/CD pipeline integrity, test suite preservation, database persistence security, and AST parsing robustness:
D08_WORKFLOW_INTEGRITY:- Detects untrusted expression injection in
run:shell blocks (${{ github.event.pull_request.title }}). - Blocks
pull_request_targetworkflows checking out untrusted PR head code ("Pwn Request"). - Flags immutable 40-character commit SHA pin downgrades to mutable refs.
- Detects CI gate weakening via added
continue-on-error: trueflags or broadpermissions: write-all. - Flags privileged
workflow_runtriggers downloading untrusted PR artifacts without sandboxing. - Flags newly introduced unpinned third-party actions while excluding official
actions/*andgithub/*namespaces.
- Detects untrusted expression injection in
D09_TEST_EROSION:- Detects test assertions gutted into tautologies (
assert True,expect(true).toBe(true)), preventing silent test coverage destruction. - Detects newly introduced test-skip decorators (
@pytest.mark.skip,@pytest.mark.xfail) and runtime skip calls (pytest.skip(),t.Skip()).
- Detects test assertions gutted into tautologies (
D10_MIGRATION_PERSISTENCE_LOSS:- Blocks catastrophic
TRUNCATE TABLEandDROP DATABASE/DROP SCHEMAstatements in automated migrations. - Tokenizer-based multi-line SQL statement parsing handling inline comments (
/* ... */,--), whitespace, and quoted identifiers (ALTER TABLE ... DROP COLUMN). - Forward-vs-rollback boundary isolation across Alembic, Knex/TypeORM/Sequelize, Rails ActiveRecord, Goose/sql-migrate, and Django. Drops inside rollback functions emit zero false positives.
- Framework-aware irreversibility analysis flagging Rails
changedrops without blocks and DjangoRunSQLwithoutreverse_sqlasBLOCK.
- Blocks catastrophic
D05Build Wrapper Tampering:- Detects remote script execution and reverse shell patterns (
curl | sh,wget | bash) inside build wrappers (mvnw,gradlew,Makefile,build.sh).
- Detects remote script execution and reverse shell patterns (
- Parser Scope Hardening:
- Fixed
_collect_python_const_boolsinstructural_parser.pyto traverse nested function scopes, correctly identifying variables mutated vianonlocalor nested assignment and eliminating false-positive short-circuit flags on inner helper functions.
- Fixed
Contributing & Development
# Clone the repository
git clone https://github.com/PayloadGuard-PLG/payload-consequence-analyser.git
cd payload-consequence-analyser
# Install development dependencies
pip install -r requirements.txt
# Run full test suite
python -m pytest test_analyzer.py test_consequence_engine.py -q
All new detectors require corresponding test cases in test_consequence_engine.py. Open findings and vulnerability disclosures are tracked in AUDIT_LOG.md.
PayloadGuard is engineered and maintained by PayloadGuard-PLG.
Metadata
Release files for payloadguard-plg 1.6.0
For a detailed explanation of source distributions (sdists) and built distributions (wheels), please see the package formats documentation.
Source distribution (sdist)
| File | Size | Uploaded | Provenance | Actions |
|---|---|---|---|---|
| payloadguard_plg-1.6.0.tar.gz | 112.5 kB | Without provenance | Details for payloadguard_plg-1.6.0.tar.gz |
Built distribution (wheel)
| File | Interpreter | ABI | Platform | Actions Reset |
|---|---|---|---|---|
| payloadguard_plg-1.6.0-py3-none-any.whl | Python 3 | none | any | Details for payloadguard_plg-1.6.0-py3-none-any.whl |
Total release size: 218.1 kB
Release files / payloadguard_plg-1.6.0.tar.gz
| Download URL | payloadguard_plg-1.6.0.tar.gz |
|---|---|
| Size | 112.5 kB |
| Tags | Source |
|
SHA-256 checksum How to use checksums |
49d4237e6dce78f27478ae584650d3d28fa5aae5cb5e5757528a259aee70957d
|
|
BLAKE2b-256 checksum How to use checksums |
c2cf83d3460432c31b4cb62688d6add2d61e72df70891a3ef41d5b9308aa7d61
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.11.17
|
Release files / payloadguard_plg-1.6.0-py3-none-any.whl
| Download URL | payloadguard_plg-1.6.0-py3-none-any.whl |
|---|---|
| Size | 105.6 kB |
| Tags | Python 3 |
|
SHA-256 checksum How to use checksums |
958462f999712810fed6377cdafaf00acff6a7bab05382b5ea4b8cad8c324419
|
|
BLAKE2b-256 checksum How to use checksums |
a9a038f7375b19eec9fdab1123e3d096396a46d8da8f332276823269eb730a60
|
| Upload date | |
|
Uploaded using Trusted Publishing? What is trusted publishing? |
No |
| Uploaded via |
twine/7.0.0 CPython/3.11.17
|
Security for payloadguard-plg 1.6.0
Provenance
Provenance describes where a file came from. On PyPI, provenance is shared via attestations, which provide a verifiable record of the build or publishing details. View details, limitations and caveats.
No provenance found
None of the files in this release were uploaded with provenance metadata.
A note on package security
PyPI is a repository for distributing packages, not a service for auditing them. While third-party security researchers and our staff do their best to detect and remove malicious packages, PyPI cannot guarantee the quality, security or suitability of any given package.
To learn more about protecting yourself from malicious actors, visit our package security documentation.