Back to skill

Security audit

briefing

Security checks for vulnerabilities and agentic risk

Overview

This skill performs a plausible video-briefing function, but its automatic installer downloads and executes mutable remote code while making privileged and persistent system changes without clear user control.

Install only if you are comfortable with a first-run setup that can run shell commands, request sudo, change system packages, download current code from GitHub, install Python packages, create a persistent launcher, and edit shell startup files. Prefer reviewing or pinning the remote repository and dependencies, running installation manually, and using a user-local install path before enabling this skill.

Vulnerability Patterns
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Skill Instruction HijackingAlters the agent's session goals or safety constraints when the skill loads
  • Agent Memory PoisoningWrites attacker-controlled rules into memory that affect later sessions
Findings (3)

T03 · Remote Payload Retrieval and Execution

Error
Location
install.sh:100
Finding
Automatic Retrieval and Execution of Mutable Remote Code<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:26-31`; `install.sh:4, 100-124, 193-194` **Vulnerability Type**: Remote payload retrieval and execution **Risk Level**: Critical ### Vulnerable Code ```markdown 1. **Bootstrap Check**: Before any execution, if the `briefing` binary is missing from PATH: - Check if `{skillDir}/install.sh` exists. - If found, execute `bash {skillDir}/install.sh` to initialize the environment. ``` ```bash REPO_URL="${REPO_URL:-https://github.com/YutaiGu/skill-briefing.git}" ``` ```bash sync_repo() { mkdir -p "$(dirname "$INSTALL_DIR")" if [ -d "$INSTALL_DIR/.git" ]; then log "Updating existing repo in $INSTALL_DIR" git -C "$INSTALL_DIR" pull else if [ -e "$INSTALL_DIR" ] && [ -n "$(ls -A "$INSTALL_DIR" 2>/dev/null || true)" ]; then echo "INSTALL_DIR exists and is not a git repo: $INSTALL_DIR" echo "Use an empty directory or pass INSTALL_DIR=/path/to/dir" exit 1 fi log "Cloning repo to $INSTALL_DIR" git clone "$REPO_URL" "$INSTALL_DIR" fi } setup_python_env() { log "Creating virtual environment" "$PYTHON_BIN" -m venv "$VENV_DIR" log "Installing Python dependencies" "$VENV_DIR/bin/pip" install -U pip setuptools wheel "$VENV_DIR/bin/pip" install -r "$INSTALL_DIR/requirements.txt" } ``` ```bash verify_install() { "$VENV_DIR/bin/python" -c "import sys; sys.path.insert(0, '$INSTALL_DIR'); import main" >/dev/null ``` ### Technical Analysis The skill instructions direct the agent to execute `install.sh` automatically whenever the `briefing` command is unavailable. The installer then clones or updates a mutable Git repository without pinning a commit, tag, or verified content digest. The resulting remote source is trusted immediately. Its dependency manifest is passed to `pip`, and its `main.py` module is explicitly imported. Python imports execute module-level statements, so the verification step is itself a direct execution sink for remotely retr ...[truncated 1629 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Bundle the reviewed CLI implementation with the skill instead of downloading executable source during first use. 2. If remote retrieval is unavoidable, pin an immutable Git commit hash and verify the checked-out commit before executing any file. 3. Verify downloaded source using a trusted cryptographic signature or a digest distributed independently of the repository. 4. Remove or strictly validate the `REPO_URL` override in automatic installation paths. 5. Do not run `git pull` against an unconstrained branch. Fetch and check out only the approved immutable revision. 6. Replace the executable import check with a non-executing validation where possible. If execution is required, perform it only after source verification in a restricted sandbox. 7. Require explicit user approval before downloading or executing external code, and clearly display the repository and revision that will be used. ]]>

T08 · Insecure Dependencies

Error
Location
install.sh:117
Finding
Installation of Unreviewed and Unpinned Remote Python Dependencies<![CDATA[ ## Vulnerability Details **File Location**: `install.sh:117-124` **Vulnerability Type**: Insecure dependency installation **Risk Level**: High ### Vulnerable Code ```bash setup_python_env() { log "Creating virtual environment" "$PYTHON_BIN" -m venv "$VENV_DIR" log "Installing Python dependencies" "$VENV_DIR/bin/pip" install -U pip setuptools wheel "$VENV_DIR/bin/pip" install -r "$INSTALL_DIR/requirements.txt" } ``` ### Technical Analysis The installer upgrades packaging tools from the active package index and installs a `requirements.txt` file obtained from the mutable remote repository. The audited skill package does not contain that manifest, so its package names, versions, hashes, transitive dependencies, and build behavior cannot be reviewed from the supplied project. No `--require-hashes` option or equivalent integrity control is used. If dependencies are not exactly pinned and hash-verified, package resolution can select content that changed after review. Python source distributions and some build processes may execute package-controlled code while metadata or wheels are being built. This creates a supply-chain execution path through the Git repository, package index, or one of the referenced dependencies. ### Attack Path 1. The automatic bootstrap invokes `install.sh`. 2. The installer clones or updates the external repository. 3. An attacker modifies its `requirements.txt`, compromises a listed package, publishes a malicious version accepted by an unpinned constraint, or exploits dependency confusion involving an unsafe package source. 4. `pip install -r` resolves and downloads the malicious component. 5. Package build or installation behavior executes attacker-controlled code, or the malicious component executes when the application imports it. 6. The payload gains the permissions of the user running the installer or application. ### Impact Assessment Exploitation can result in arbitrary code execution in the installation ...[truncated 382 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Include a reviewed dependency lock file in the audited package. 2. Pin every direct and transitive dependency to an exact version. 3. Record approved distribution hashes and install with `pip --require-hashes`. 4. Use a controlled package index or an internal mirror containing only approved artifacts. 5. Prefer prebuilt, verified wheels and prohibit unexpected source builds. 6. Pin `pip`, `setuptools`, and `wheel` rather than upgrading them to the latest available releases during installation. 7. Generate and review a software bill of materials, and continuously scan locked dependencies for known vulnerabilities or ownership changes. 8. Treat any modification to the lock file or artifact hashes as a security-sensitive change requiring a new audit. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
install.sh:23
Finding
Automatic Elevated and Persistent System Modification<![CDATA[ ## Vulnerability Details **File Location**: `install.sh:23-65, 128-190` **Vulnerability Type**: Excessive privileges and persistent host modification **Risk Level**: High ### Vulnerable Code ```bash install_deps_linux() { local ffmpeg_needed=1 if ffmpeg_already_installed; then ffmpeg_needed=0 log "Detected existing ffmpeg, skip ffmpeg package install" fi if require_cmd apt-get; then sudo apt-get update if [ "$ffmpeg_needed" -eq 1 ]; then sudo apt-get install -y git curl python3.12 python3.12-venv ffmpeg else sudo apt-get install -y git curl python3.12 python3.12-venv fi ``` ```bash if require_cmd sudo; then sudo mkdir -p "$target_dir" sudo install -m 0755 "$tmpfile" "$target_path" rm -f "$tmpfile" LAUNCHER_PATH="$target_path" return fi ``` ```bash ensure_path() { local launcher_dir launcher_dir="$(dirname "$LAUNCHER_PATH")" export PATH="$launcher_dir:$PATH" local line="export PATH=\"$launcher_dir:\$PATH\"" local profiles=("$HOME/.zshrc" "$HOME/.bashrc" "$HOME/.profile") for profile in "${profiles[@]}"; do if [ ! -f "$profile" ]; then continue fi if grep -Fq "$line" "$profile"; then return fi done local target="$HOME/.profile" if [ -n "${SHELL:-}" ] && [[ "$SHELL" == *"zsh"* ]]; then target="$HOME/.zshrc" elif [ -n "${SHELL:-}" ] && [[ "$SHELL" == *"bash"* ]]; then target="$HOME/.bashrc" fi touch "$target" printf "\n%s\n" "$line" >> "$target" log "Added PATH entry to $target" } ``` ### Technical Analysis The installer requests administrative privileges to modify system package state and, where necessary, write the `briefing` launcher to `/usr/local/bin`. It also permanently modifies a user shell startup file to prepend the launcher directory to `PATH`. These operations occur as part of the automatic bootstrap workflow described in `SKILL.md`, rather than through a separately confirmed administrative installation ...[truncated 1759 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Default to installation under a user-owned directory such as `$HOME/.local/share/briefing` with a launcher in `$HOME/.local/bin`. 2. Do not invoke `sudo` automatically. Detect missing prerequisites, list them, and require the user to perform system package installation separately. 3. Request explicit confirmation before any global executable placement or shell profile modification. 4. Avoid editing `.bashrc`, `.zshrc`, or `.profile`; instead, print a command that the user may review and apply manually. 5. Clearly disclose all persistent changes before installation and provide a complete uninstall procedure. 6. Separate trusted system dependency setup from retrieval and execution of application source. 7. Verify ownership and permissions of installation directories and refuse unsafe paths, including paths writable by untrusted users. 8. Perform remote source and dependency verification before creating any global launcher that references them. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
Findings (18)

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The manifest describes a content-tracking/transcription skill, but the observed behavior includes broad installation and persistence actions such as package management, cloning code, creating environments, writing launchers, and modifying shell startup files. That mismatch is dangerous because it hides privileged system changes behind a benign-looking description, increasing the chance a user consents without understanding the real risk.

Lp3

Medium
Category
MCP Least Privilege
Confidence
90% confidence
Finding
The skill clearly authorizes shell-based execution (`bash {skillDir}/install.sh` and running the `briefing` binary), but the manifest does not declare any corresponding tool scope or permission boundaries. This creates a transparency and least-privilege problem: operators may invoke a skill with execution capabilities that are not explicitly disclosed in metadata.

Context-Inappropriate Capability

Medium
Confidence
93% confidence
Finding
The instructions tell the agent to automatically execute an installer shell script if the binary is missing, which expands the skill from using a CLI to running arbitrary code from the skill directory. In this context, installer execution is especially risky because shell scripts can perform unrestricted system modifications, fetch remote code, or establish persistence unrelated to video transcription.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The skill instructs the agent to run an install script automatically, without any prompt, warning, or confirmation to the user. Silent installation is dangerous because it can trigger package installs, PATH changes, repository cloning, or other persistent system modifications without informed consent.

Context-Inappropriate Capability

Medium
Confidence
85% confidence
Finding
The manifest presents the skill as a briefing pipeline for tracking creator channels and transcribing videos, but the documentation mandates using bash/exec to run commands. While invoking the bundled CLI may be implementation-related, requiring unrestricted shell execution is a broader capability than the stated purpose itself justifies.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The script performs privileged package installation and later system-level launcher installation via sudo, but it does not present an upfront warning that elevated privileges and system modifications will be requested. This is risky because users may run the installer without understanding it will change system packages and write into shared binary locations.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
fi

  if require_cmd apt-get; then
    sudo apt-get update
    if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo apt-get install -y git curl python3.12 python3.12-venv ffmpeg
    else
Confidence
90% confidence
Finding
Running sudo apt-get update triggers privileged system package metadata updates as part of the installer workflow. In context this is expected installer behavior, but it is still security-relevant because it executes with elevated privileges and expands the blast radius if the script or its environment is tampered with.

External Transmission

Medium
Category
Data Exfiltration
Content
if require_cmd apt-get; then
    sudo apt-get update
    if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo apt-get install -y git curl python3.12 python3.12-venv ffmpeg
    else
      sudo apt-get install -y git curl python3.12 python3.12-venv
    fi
Confidence
70% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if require_cmd apt-get; then
    sudo apt-get update
    if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo apt-get install -y git curl python3.12 python3.12-venv ffmpeg
    else
      sudo apt-get install -y git curl python3.12 python3.12-venv
    fi
Confidence
91% confidence
Finding
This line installs system packages with sudo, giving the installer root-level ability to change host software state. Even though the packages are ordinary dependencies, automatic privileged installation from a third-party script increases risk if the script is modified or run in an unexpected environment.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo apt-get install -y git curl python3.12 python3.12-venv ffmpeg
    else
      sudo apt-get install -y git curl python3.12 python3.12-venv
    fi
    if ! require_cmd "$PYTHON_BIN"; then
      echo "python3.12 not found after install. Please install Python 3.12 manually."
Confidence
91% confidence
Finding
This is another privileged apt-get install path that executes as root without a separate warning at the point of use. The main danger is not the specific packages but the pattern of a network-capable installer making root-level system changes automatically.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if require_cmd dnf; then
    if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo dnf install -y git curl python3.12 ffmpeg
    else
      sudo dnf install -y git curl python3.12
    fi
Confidence
90% confidence
Finding
The installer uses sudo dnf install for dependencies, which is standard but still a privileged operation from third-party code. This can materially affect the system if the script, package sources, or environment are compromised.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo dnf install -y git curl python3.12 ffmpeg
    else
      sudo dnf install -y git curl python3.12
    fi
    if ! require_cmd "$PYTHON_BIN"; then
      echo "python3.12 not found after install. Please install Python 3.12 manually."
Confidence
90% confidence
Finding
This alternate dnf branch performs root-level package installation automatically. The security concern is the elevation itself and the trust placed in an external installer to modify system state, not evidence of overtly malicious behavior.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if require_cmd yum; then
    if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo yum install -y git curl python3.12 ffmpeg
    else
      sudo yum install -y git curl python3.12
    fi
Confidence
89% confidence
Finding
The yum-based dependency installation path also performs privileged package changes under sudo. This is expected in cross-platform installers, but it remains a true security concern because the script is not just configuring the application; it is modifying the host as root.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if [ "$ffmpeg_needed" -eq 1 ]; then
      sudo yum install -y git curl python3.12 ffmpeg
    else
      sudo yum install -y git curl python3.12
    fi
    if ! require_cmd "$PYTHON_BIN"; then
      echo "python3.12 not found after install. Please install Python 3.12 manually."
Confidence
89% confidence
Finding
This is the alternate yum install path with the same root-execution risk profile. If a user runs the installer casually, this line gives it authority to alter system packages without granular review.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
fi

  if require_cmd sudo; then
    sudo mkdir -p "$target_dir"
    sudo install -m 0755 "$tmpfile" "$target_path"
    rm -f "$tmpfile"
    LAUNCHER_PATH="$target_path"
Confidence
92% confidence
Finding
Creating the target binary directory with sudo enables the installer to write into a system-wide executable path. This increases risk because the script is installing a command that all users may later execute, and any compromise in the repository or install path would gain broad reach.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
if require_cmd sudo; then
    sudo mkdir -p "$target_dir"
    sudo install -m 0755 "$tmpfile" "$target_path"
    rm -f "$tmpfile"
    LAUNCHER_PATH="$target_path"
    return
Confidence
93% confidence
Finding
Using sudo install to place an executable launcher into a system binary directory is a privileged persistence mechanism, even if intended for convenience. In combination with cloning code from a remote repository, it creates a trusted command entry point that could be abused if upstream content changes or installation variables are manipulated.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The installer persistently modifies the user's shell startup files to prepend a PATH entry without any explicit opt-in or warning before doing so. While common in installers, this creates a lasting environment change that can affect future command resolution and may surprise users or enable unintended execution precedence if the target directory later contains other binaries.

Missing User Warnings

Low
Confidence
84% confidence
Finding
`briefing -delete <source_url>` removes a tracked source, which is a destructive configuration change. The markdown lists the command but does not warn that it deletes tracking state or suggest confirmation before performing the action.

Static analysis

No suspicious patterns detected.