Back to skill

Security audit

Gogetajob

Security checks for vulnerabilities and agentic risk

Overview

This skill supports a real open-source contribution workflow, but it gives delegated agents broad approval to change code and creates persistent follow-up and memory behaviors that need review before installation.

Install only if you are comfortable with an agent-driven GitHub workflow that can modify local repos, run commands, push branches, create PRs, and store lessons for future use. Avoid `gogetajob watch` unless you understand and can remove the cron job, and review all generated diffs and memory updates before pushing or reusing them.

Vulnerability Patterns
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • System PersistenceInstalls backdoors, hooks, services, or scheduled tasks that survive the run
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
Findings (4)

T06 · System Persistence

Error
Location
SKILL.md:45
Finding
Persistent Scheduled Execution Through Undisclosed Cron Configuration## Vulnerability Details **File Location**: `SKILL.md`, lines 45 and 119 **Vulnerability Type**: Persistent scheduled-task installation **Risk Level**: High ### Vulnerable Code ```text | `gogetajob watch` | Set up automatic sync via cron | ``` ```text Run `gogetajob sync` regularly (or use `gogetajob watch` for automatic cron). ``` ### Technical Analysis The skill recommends `gogetajob watch`, which creates a recurring cron task that survives the current workflow and agent session. The documentation does not disclose the exact cron entry, executable path, schedule, environment, permissions, log destination, or removal procedure. Because the scheduled command belongs to a separately installed third-party package, later package changes or executable replacement could alter what the persistent task runs. This crosses the boundary from a temporary contribution workflow into durable system modification. ### Attack Path 1. A user or agent follows the documented workflow and installs the GoGetAJob CLI. 2. The user or agent invokes `gogetajob watch`. 3. The CLI creates a cron entry under the user's account. 4. The cron entry continues executing after the original skill run ends. 5. If the package, executable, executable-resolution path, or configuration is later compromised, attacker-controlled behavior runs automatically on the cron schedule. ### Impact Assessment Exploitation could provide repeated code execution with the permissions of the account owning the cron entry. The effective scope may include that user's repositories, Git configuration, locally accessible credentials, authenticated CLI sessions, and writable files. The finding does not demonstrate root-level persistence, but it establishes cross-session persistence at user privilege.
Remediation
## Remediation Suggestions - Do not install a cron task by default; make synchronization an explicit, one-time operation. - Require informed user approval immediately before creating any scheduled task. - Display the exact cron expression, absolute executable path, arguments, environment, and output destination before installation. - Pin and verify the executable that the cron entry invokes. - Avoid relying on mutable `PATH` resolution in scheduled tasks. - Document commands for inspecting, disabling, and completely removing the cron entry. - Constrain the scheduled process to minimum filesystem and network permissions. - Prefer a user-visible scheduler with auditable configuration and expiration over indefinite persistence.

T08 · Insecure Dependencies

Warning
Location
SKILL.md:14
Finding
Unpinned Third-Party and Global Package Installation## Vulnerability Details **File Location**: `SKILL.md`, lines 14 and 21 **Vulnerability Type**: Mutable third-party dependency installation **Risk Level**: Medium ### Vulnerable Code ```text - **FlowForge skill** (workflow engine): `clawhub install agent-flowforge` ``` ```text - **GoGetAJob CLI** for stats/sync: `npm install -g @kagura-agent/gogetajob` - Verify: `gogetajob --help` - Not required for the core work loop — FlowForge handles that ``` ### Technical Analysis Both installation commands resolve mutable package versions without an immutable version, integrity hash, signed provenance requirement, or documented source review. The npm command additionally installs the package globally. Depending on npm configuration and package contents, installation can execute lifecycle scripts with the invoking user's permissions. Running `gogetajob --help` confirms only that an executable is present; it does not establish package integrity or publisher authenticity. A compromised publisher account, registry release, or package source could therefore introduce code that was not part of this audited project. ### Attack Path 1. A user follows the prerequisite instructions. 2. The package manager resolves the current package release rather than a reviewed immutable artifact. 3. An attacker compromises the package publisher, registry entry, distribution channel, or a future release. 4. The installation retrieves the attacker-controlled package. 5. Lifecycle scripts or subsequent CLI execution run the malicious code with the installing user's permissions. 6. For the globally installed npm package, the malicious executable remains available to later workflows. ### Impact Assessment A compromised dependency could execute commands, alter repositories, modify user-owned files, access credentials available to the process, or replace globally available tooling. The demonstrated instructions run at user privilege; adminis ...[truncated 147 chars]
Remediation
## Remediation Suggestions - Pin every dependency to a reviewed immutable version. - Verify registry integrity hashes, signatures, and publisher provenance. - Provide a lockfile or equivalent reproducible dependency manifest. - Avoid global npm installation; use a project-local, isolated environment. - Disable npm lifecycle scripts during installation unless they have been reviewed and are strictly necessary. - Prefer invoking a hash-pinned package artifact through an isolated runtime. - Document the authoritative source repository and validate package ownership against it. - Establish an update process requiring review before changing pinned versions.

T05 · Unauthorized Access and Privilege Escalation

Error
Location
SKILL.md:66
Finding
Approval-Free Coding Agent Processes Untrusted Repository and Review Content## Vulnerability Details **File Location**: `SKILL.md`, lines 66–74; supporting workflow at `references/workloop-overview.md`, lines 53–57 **Vulnerability Type**: Unrestricted autonomous tool execution and unsafe instruction composition **Risk Level**: High ### Vulnerable Code ```bash cd <repo> && acpx --approve-all claude exec "<task description with full context>" ``` ```text Task descriptions must include: issue context, reviewer feedback, architecture notes, maintainer preferences from knowledge-base, and a verification suffix: > "Before committing: 1) grep for all test files that import/mock the interfaces you changed, update their mocks. 2) Run the project's test/lint commands. 3) git diff --stat to confirm no files were missed." ``` Supporting workflow instructions: ```text 1. Delegate code work to Claude Code via `acpx --approve-all claude exec` 2. Task must include: issue context, reviewer feedback, architecture info, maintainer prefs 3. Task must end with verification instructions (test, mock sync, diff check) 4. Review Claude Code's commits after completion 5. **Pre-push self-check**: `git diff --stat`, interface changes → grep mock sync, run tests ``` ### Technical Analysis The `--approve-all` option removes interactive authorization checks for actions performed by the delegated coding agent. At the same time, the task is required to include issue context and reviewer feedback, both of which may originate from untrusted GitHub users. This creates an indirect prompt-injection path: attacker-authored natural-language content is placed into the context of an agent authorized to modify files and execute commands. The instructions do not require external text to be quoted as untrusted data, filtered for embedded directives, or separated from controlling instructions. The shell example also interpolates a free-form task description inside a quoted command without defining safe s ...[truncated 1684 chars]
Remediation
## Remediation Suggestions - Remove `--approve-all` and require explicit authorization for shell commands, network access, commits, pushes, and access outside the selected repository. - Run the coding agent in an isolated sandbox restricted to the checked-out repository. - Use command allowlists and deny access to credential stores, home-directory files, SSH keys, environment secrets, and unrelated repositories. - Treat issue bodies, comments, review feedback, repository documents, and commit messages as untrusted data. - Place external content in clearly delimited data sections and instruct the agent never to follow directives contained within those sections. - Summarize and validate external content before passing it to an execution-capable agent. - Pass arguments through a structured process API rather than constructing a shell command string. - Require a human-readable diff and explicit approval before commit or push. - Block outbound network access unless a specific destination is required and approved. - Record tool calls and filesystem changes in an auditable execution log.

T02 · Agent Memory Poisoning

Error
Location
SKILL.md:113
Finding
Untrusted External Content Can Be Promoted Into Persistent Agent Knowledge## Vulnerability Details **File Location**: `SKILL.md`, lines 113–116; supporting workflow at `references/workloop-overview.md`, lines 98–103 **Vulnerability Type**: Persistent memory poisoning **Risk Level**: High ### Vulnerable Code ```text ### 6. Knowledge accumulation - Before working on a repo: read `knowledge-base/projects/<repo>.md` (field notes) - After finishing: update field notes with lessons, maintainer preferences, CI quirks - Cross-project insights → memex cards - Behavioral patterns → beliefs-candidates.md ``` Supporting workflow instructions: ```text ### reflect End-of-round reflection: 1. **Update field notes** (mandatory) — add PR result, maintainer style, CI notes, lessons 2. **Distill insights**: project-level → field notes, cross-project → memex cards, behavioral → beliefs-candidates.md 3. **Tool check**: any bugs in gogetajob/flowforge/gh? File issues or fix Continues to → `done` ``` ```text ### done Record to daily memory. Report results. Terminal node. ``` ### Technical Analysis The workflow mandates writing lessons, maintainer preferences, behavioral patterns, and session results into storage that later tasks consume. These conclusions may derive from repository documents, issue discussions, pull-request reviews, or comments controlled by external users. The skill provides no provenance schema, trust classification, validation step, expiration policy, or rule preventing instruction-like text from being stored as a behavioral belief. Repository-specific observations can also be promoted into cross-project memex cards or general behavioral candidates. This creates a path by which attacker-authored guidance can persist after the original task and influence unrelated future sessions. ### Attack Path 1. An attacker adds persuasive or instruction-like content to a repository document, issue, review, or pull-request discussion. 2. The workflow processes that content ...[truncated 1049 chars]
Remediation
## Remediation Suggestions - Treat all conclusions derived from repositories, issues, comments, and reviews as untrusted until independently verified. - Store observations as quoted facts with source URLs, author identity, timestamp, repository scope, and confidence level. - Prohibit external text from being stored verbatim as an executable instruction, global rule, or behavioral belief. - Require explicit human approval before promoting project observations into cross-project memory or behavioral state. - Keep repository-specific notes isolated from global memory. - Add expiration and revalidation policies for maintainer preferences and CI observations. - Scan proposed memory updates for imperative language, tool directives, credential requests, and attempts to override safety controls. - Ensure future agents consume memory as advisory data, not higher-priority instructions. - Maintain an auditable history and rollback mechanism for all persistent-memory changes.
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
Findings (2)

Missing User Warnings

Medium
Confidence
97% confidence
Finding
The skill instructs sub-agents to run `acpx --approve-all claude exec`, which combines autonomous code generation with blanket approval for actions that can modify repository contents. In this skill's context, the agent is designed to scan external repositories, clone them, make changes, and submit PRs, so auto-approval significantly increases the risk of unintended code edits, destructive commands, or unsafe actions occurring without meaningful human review.

Missing User Warnings

Low
Confidence
86% confidence
Finding
The skill explicitly recommends `gogetajob watch` to set up automatic cron-based syncing, but it does not clearly warn that this creates persistent background execution on the user's machine. That can cause unexpected recurring network activity, state changes, or privacy/operational issues, especially in an agent context where users may not realize the task persists beyond the current session.

Static analysis

No suspicious patterns detected.