Back to skill

Security audit

OpenClaw AWS Deploy

Security checks for vulnerabilities and agentic risk

Overview

This AWS deployment skill is mostly purpose-aligned, but it creates broad cloud permissions, handles long-lived secrets unsafely, and installs mutable code as root, so it needs careful review before use.

Install only after reviewing and narrowing the IAM policy, avoiding IAM user access keys, pinning the OpenClaw package version, adding restrictive file permissions for generated secret files, and explicitly opting in to any heartbeat checks of email, calendar, repositories, or memory.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • Insecure DependenciesIntroduces malicious components through unsafe dependency sources
  • Insecure Skill Coding PracticesFinds exploitable flaws such as hardcoded secrets or command injection
  • 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 (5)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/setup_deployer_role.sh:150
Finding
Deployer IAM Policy Permits Privilege Escalation Through Arbitrary Role Policies<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup_deployer_role.sh`, lines 150-171 **Vulnerability Type**: Excessive IAM role-management and role-passing permissions **Risk Level**: High ### Vulnerable Code ```bash { "Sid": "IAMRoleManagement", "Effect": "Allow", "Action": [ "iam:CreateRole", "iam:DeleteRole", "iam:GetRole", "iam:TagRole", "iam:PutRolePolicy", "iam:DeleteRolePolicy", "iam:AttachRolePolicy", "iam:DetachRolePolicy", "iam:CreateInstanceProfile", "iam:DeleteInstanceProfile", "iam:AddRoleToInstanceProfile", "iam:RemoveRoleFromInstanceProfile", "iam:PassRole", "iam:SimulatePrincipalPolicy", "iam:ListRoleTags", "iam:ListRolePolicies", "iam:ListAttachedRolePolicies" ], "Resource": [ "arn:aws:iam::${ACCOUNT_ID}:role/*-role", "arn:aws:iam::${ACCOUNT_ID}:instance-profile/*-instance-profile", "arn:aws:iam::aws:policy/AmazonSSMManagedInstanceCore" ] } ``` ### Technical Analysis The generated deployer policy permits `iam:CreateRole`, `iam:PutRolePolicy`, and `iam:PassRole` for every account role whose name ends in `-role`. The `iam:PutRolePolicy` permission allows the deployer to supply arbitrary inline policy documents; no permissions boundary constrains the maximum privileges assignable to a newly created role. The deployer also has `ec2:RunInstances` on all resources. Combining role creation, arbitrary inline policy assignment, role passing, instance-profile management, and EC2 launch privileges creates a conventional IAM privilege-escalation chain. The permissions are broader than necessary to manage the single `${NAME}-role` required by an OpenClaw deployment. ### Attack Path 1. Obtain or compromise credentials for the OpenClaw deployer identity. 2. Create an IAM role with a permitted suffix, such as `attacker-role`. 3. Use `iam:PutRolePolicy` to assign that role an administrator-equivalent inline policy. 4. Create an instance profile and ...[truncated 606 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Restrict role and instance-profile resources to an exact controlled prefix, such as `arn:aws:iam::<account>:role/openclaw-*`. - Require a permissions boundary on every created role and deny creation or modification without that boundary. - Restrict `iam:PassRole` with both an exact role ARN and: ```json "Condition": { "StringEquals": { "iam:PassedToService": "ec2.amazonaws.com" } } ``` - Separate role provisioning from routine deployment. A trusted administrator should provision a fixed instance role in advance, while the deployer should only be able to pass that role. - Remove `iam:PutRolePolicy`, `iam:CreateRole`, and instance-profile creation from the routine deployer wherever possible. - Add explicit deny guardrails through an SCP or permissions boundary to prevent administrator, IAM-management, organization-management, and security-control privileges from being assigned. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
scripts/setup_deployer_role.sh:174
Finding
Deployer Policy Grants Account-Wide SSM Secret Access and Remote Command Execution<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup_deployer_role.sh`, lines 174-188 **Vulnerability Type**: Unscoped SSM parameter, command, and session permissions **Risk Level**: High ### Vulnerable Code ```bash { "Sid": "SSMParameterStore", "Effect": "Allow", "Action": [ "ssm:PutParameter", "ssm:GetParameter", "ssm:GetParameters", "ssm:DeleteParameter", "ssm:DescribeInstanceInformation", "ssm:SendCommand", "ssm:GetCommandInvocation", "ssm:StartSession" ], "Resource": "*" } ``` ### Technical Analysis The deployer receives SSM permissions against `"Resource": "*"`. The legitimate deployment needs to manage only its own parameter namespace and interact only with the EC2 instance created for that deployment. In contrast, this policy allows the identity to request unrelated Parameter Store values, delete unrelated parameters, execute SSM commands, and start sessions on other SSM-managed instances accessible to the account. SecureString parameters may also be disclosed when the caller has the corresponding KMS decrypt permission, including through a permissive default or customer-managed KMS key policy. ### Attack Path 1. Obtain the deployer credentials. 2. Enumerate managed instances with `ssm:DescribeInstanceInformation`. 3. Use `ssm:SendCommand` with an AWS shell document against an unrelated managed instance. 4. Execute commands under the SSM Agent's operating-system privileges, commonly root or `SYSTEM`. 5. Alternatively, request unrelated parameters with `ssm:GetParameter --with-decryption`. 6. Use recovered application credentials or host access to move laterally. ### Impact Assessment The policy can expose unrelated application secrets and enables remote command execution or interactive sessions on SSM-managed systems across the AWS account. On typical Linux EC2 instances, SSM command execution occurs with root privileges, making host compromise possible. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Scope Parameter Store access to a dedicated hierarchy, for example: ```json "Resource": "arn:aws:ssm:<region>:<account>:parameter/openclaw/<deployment>/*" ``` - Separate parameter permissions from SSM command and session permissions. - Restrict `ssm:SendCommand` and `ssm:StartSession` to instances tagged for the relevant OpenClaw deployment. - Restrict command execution to an approved SSM document rather than allowing arbitrary documents. - Use conditions such as `ssm:resourceTag/Project` or corresponding EC2 tag conditions. - Use a dedicated customer-managed KMS key for OpenClaw SecureStrings and scope `kms:Decrypt` to the instance role that needs those values. - Remove `ssm:DeleteParameter` for namespaces not created by the deployment. ]]>

T08 · Insecure Dependencies

Error
Location
scripts/deploy_minimal.sh:879
Finding
Mutable npm Latest Release Is Installed Globally as Root<![CDATA[ ## Vulnerability Details **File Location**: `scripts/deploy_minimal.sh`, line 879 **Vulnerability Type**: Unpinned third-party dependency with privileged installation **Risk Level**: High ### Vulnerable Code ```bash # Install OpenClaw (must use @latest to avoid placeholder package) echo "[$(date)] Installing OpenClaw..." retry_cmd npm install -g openclaw@latest 2>&1 | tail -20 echo "[$(date)] OpenClaw path: $(which openclaw)" ``` ### Technical Analysis The EC2 user-data bootstrap runs as root and installs `openclaw@latest` globally. The `latest` npm distribution tag is mutable, so the code installed during a future deployment can differ from the code reviewed during this audit. npm packages can define lifecycle scripts that run during installation. Because the installation is performed by root, a compromised package release, maintainer account, or transitive dependency can execute arbitrary commands with root privileges. The script does not pin an exact version, verify a package integrity value, or constrain lifecycle scripts. ### Attack Path 1. An attacker compromises the npm package, a maintainer account, or a dependency included by a future `latest` release. 2. The attacker publishes a malicious release and moves the `latest` tag to it. 3. A user runs the deployment script. 4. EC2 user-data executes `npm install -g openclaw@latest` as root. 5. Malicious package installation code executes with root privileges. 6. The payload can modify the host, steal instance-role credentials, retrieve SSM secrets, or install additional persistence. ### Impact Assessment Successful exploitation provides root-level control over newly deployed EC2 instances. The attacker can access the instance role, OpenClaw configuration, Telegram token, gateway token, optional Gemini key, and all AWS resources permitted to the instance role. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Pin OpenClaw to an exact reviewed version instead of `@latest`. - Verify the expected package integrity or artifact digest before installation. - Maintain an explicit release-update process in which version and integrity changes are reviewed. - Prefer a prebuilt, signed, immutable image or artifact from a controlled repository. - Run package installation in a restricted build stage rather than in production user-data. - Evaluate use of `--ignore-scripts` where package functionality permits it. - Lock and audit all transitive dependencies, and use npm provenance or equivalent signature verification. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/deploy_minimal.sh:922
Finding
Generated Configuration Files Containing Secrets Lack Explicit Restrictive Permissions<![CDATA[ ## Vulnerability Details **File Location**: `scripts/deploy_minimal.sh`, lines 922-1013 **Vulnerability Type**: Locally readable plaintext credential files **Risk Level**: Medium ### Vulnerable Code ```bash # Write openclaw.json (overwritten each start — ephemeral) cat > /home/openclaw/.openclaw/openclaw.json <<OCEOF { "gateway": { "mode": "local", "bind": "loopback", "port": 18789, "auth": { "mode": "token", "token": "${GW_TOKEN}" } }, ... "channels": { "telegram": { ... "accounts": { "default": { "name": "${AGENT_NAME}", "dmPolicy": "pairing", "botToken": "${TELEGRAM_TOKEN}", "groupPolicy": "allowlist", "streamMode": "partial" } } } } } OCEOF if [[ "$HAS_GEMINI_KEY" == "true" && -n "$GEMINI_KEY" ]]; then cat > /home/openclaw/.openclaw/agents/main/agent/auth-profiles.json <<APEOF { "version": 1, "profiles": { "amazon-bedrock:default": { "type": "aws", "provider": "amazon-bedrock", "awsRegion": "${AWS_REGION}" }, "google:default": { "type": "token", "provider": "google", "token": "${GEMINI_KEY}" } } } APEOF fi # Ensure ownership chown -R openclaw:openclaw /home/openclaw/.openclaw ``` ### Technical Analysis The service writes the gateway token, Telegram bot token, and optional Gemini API key into plaintext JSON files. It changes ownership but does not set a restrictive `umask`, file mode, or parent-directory mode. Under the common default umask of `022`, shell redirection creates files with mode `0644`. Ownership alone therefore does not prevent other local users from reading the credentials. The files are described as ephemeral because they are rewritten at service start, but they remain stored on disk while the service operates. ### Attack Path 1. Obtain any local low-privilege account or code-execution foothold on the EC2 host. 2. Traverse the OpenCla ...[truncated 614 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Set `umask 077` at the start of `openclaw-startup.sh`. - Explicitly apply mode `0600` after writing each credential-bearing file: ```bash chmod 600 /home/openclaw/.openclaw/openclaw.json chmod 600 /home/openclaw/.openclaw/agents/main/agent/auth-profiles.json ``` - Set credential-containing parent directories to mode `0700`. - Write files atomically through securely created temporary files, set ownership and mode, and then rename them into place. - Where OpenClaw supports it, pass secrets through protected runtime credential mechanisms instead of persistent JSON files. - Ensure backups, diagnostics, and support bundles exclude these files. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/setup_deployer_role.sh:308
Finding
Long-Lived AWS Secret Access Key Is Printed to Terminal and Logs<![CDATA[ ## Vulnerability Details **File Location**: `scripts/setup_deployer_role.sh`, lines 308-328 **Vulnerability Type**: Plaintext credential disclosure **Risk Level**: High ### Vulnerable Code ```bash ACCESS_KEY=$(echo "$KEYS" | python3 -c "import sys,json; print(json.load(sys.stdin)['AccessKey']['AccessKeyId'])") SECRET_KEY=$(echo "$KEYS" | python3 -c "import sys,json; print(json.load(sys.stdin)['AccessKey']['SecretAccessKey'])") log "" log "==========================================" log " ✅ Deployer user ready: $NAME" log "==========================================" log "" log " Access Key ID: $ACCESS_KEY" log " Secret Access Key: $SECRET_KEY" log "" log " ⚠️ Save these now — the secret key won't be shown again!" log "" log " Option 1: Add to .env.aws:" log " AWS_ACCESS_KEY_ID=$ACCESS_KEY" log " AWS_SECRET_ACCESS_KEY=$SECRET_KEY" log " AWS_DEFAULT_REGION=$REGION" log "" log " Option 2: Add to ~/.aws/credentials:" log " [openclaw-deployer]" log " aws_access_key_id = $ACCESS_KEY" log " aws_secret_access_key = $SECRET_KEY" ``` ### Technical Analysis The script creates a long-lived IAM user access key and prints the secret access key repeatedly. Terminal output may be retained in CI/CD logs, shell-session recordings, remote administration transcripts, support bundles, or copied command output. The leaked key belongs to a deployer with broad EC2, IAM, SSM, CloudWatch, and log-management permissions. Consequently, disclosure of this secret is substantially more severe than disclosure of a narrowly scoped application token. ### Attack Path 1. Run the setup script in a recorded terminal, CI job, managed shell, or other environment that stores standard output. 2. Obtain access to the resulting log or transcript. 3. Extract the access key ID and secret access key. 4. Configure the stolen credentials in the AWS CLI or SDK. 5. Use the deployer's IAM, EC2, and SSM permissions. 6. Escalate through the role-creation and role-passin ...[truncated 355 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Prefer AWS IAM Identity Center, role assumption, or another short-lived credential mechanism instead of IAM user keys. - Remove or disable the IAM-user creation mode by default. - Do not print secret access keys to standard output or standard error. - If key creation must remain supported, write the credential directly to a user-selected file with mode `0600`, after confirming that the destination is not a shared or repository directory. - Warn users not to run key creation in CI or recorded sessions. - Rotate and deactivate any key that may already have appeared in retained logs. - Narrow the deployer policy independently so that credential compromise has a smaller blast radius. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • Rogue AgentSelf-Modification, Session Persistence
  • Trigger AbuseOverly Broad Trigger, Shadow Command Trigger, Keyword Baiting Trigger
Findings (49)

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The code substantially matches the core deployment description: it securely deploys OpenClaw on AWS, creates networking and an ARM64 EC2 instance, uses SSM-only management with no SSH rules, and supports configurable models including Bedrock and Gemini. However, there are material description/behavior mismatches. First, the description says the skill can be used for tearing down deployments, but this code chunk is a deploy script only; rollback/cleanup depends on an external teardown.sh and teardown is not implemented here. Second, 'Creates ... Telegram channel' is misleading: the code provisions Telegram bot token configuration inside OpenClaw and optionally approves pairing, but does not create a Telegram channel in Telegram itself. Third, the script also sets up optional CloudWatch alarms/log shipping, which is an undeclared additional capability. Because of these materially inaccurate claims, this should be flagged as a mismatch.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The description claims an operational deployment tool that securely deploys OpenClaw on AWS and can also tear down an existing deployment. The actual code chunk is a preparatory preflight checker only. While its inputs align with the broader deployment domain (region, auth mode, channel/model/cost profiles), its behavior is limited to validation and report generation using AWS read-only identity and capability checks. This is a materially different primary purpose from deployment/teardown, so the description does not accurately represent this code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The description claims this skill deploys OpenClaw on AWS and manages the full runtime environment. The supplied code chunk instead is a preparatory IAM bootstrap script whose purpose is to create a minimally privileged deployer identity (role or user) for later use by deployment scripts. While the policy permissions align with supporting AWS deployment/teardown operations, the code itself does not perform the declared primary function of deploying OpenClaw infrastructure. It also introduces undeclared IAM identity-management behavior, including user creation and access-key generation, which is materially different and security-sensitive. Therefore the description does not accurately represent this code chunk.

Tp4

High
Category
MCP Tool Poisoning
Confidence
99% confidence
Finding
The declared description is about AWS deployment and teardown of OpenClaw infrastructure and related integrations. The supplied code chunk does none of that: it is a standalone smoke-test script that checks an already-running service's /health endpoint and an authenticated path, records pass/fail results in JSON, and exits accordingly. This is a materially different primary purpose and uses different resources and inputs than described, so it is a clear mismatch.

Chaining Abuse

High
Category
Tool Misuse
Content
**Solution:** Use systemd EnvironmentFile:
```bash
# Create env file
echo "GEMINI_API_KEY=your-key" | sudo tee /etc/openclaw/env
sudo chmod 600 /etc/openclaw/env

# Add to systemd service (under [Service])
Confidence
75% confidence
Finding
Tool calls are chained to bypass individual safety checks or escalate capabilities beyond what any single tool call would allow.

Credential Access

High
Category
Privilege Escalation
Content
log "=========================================="
  log ""
  log "  To use with deploy script:"
  log "    # Add to ~/.aws/config:"
  log "    [profile openclaw-deployer]"
  log "    role_arn = $ROLE_ARN"
  log "    source_profile = default"
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
log "    AWS_SECRET_ACCESS_KEY=$SECRET_KEY"
  log "    AWS_DEFAULT_REGION=$REGION"
  log ""
  log "  Option 2: Add to ~/.aws/credentials:"
  log "    [openclaw-deployer]"
  log "    aws_access_key_id = $ACCESS_KEY"
  log "    aws_secret_access_key = $SECRET_KEY"
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Lp3

Medium
Category
MCP Least Privilege
Confidence
91% confidence
Finding
The skill explicitly instructs users to run shell scripts that can create, modify, and destroy AWS infrastructure, but it declares no tool scope or allowed-tools metadata. That omission weakens review and enforcement boundaries, making it easier for an agent to use shell access in broader-than-expected ways when handling cloud credentials and deployment actions.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- `.env.starfish` in workspace root (recommended) or skill directory:
  ```
  TELEGRAM_BOT_TOKEN=...     # from @BotFather (required)
  TELEGRAM_USER_ID=...       # your Telegram user ID (optional, enables auto-approve pairing)
  GEMINI_API_KEY=...         # from aistudio.google.com (optional, for Gemini models)
  ```
- `aws` CLI installed OR Docker for sandboxed access
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- `.env.starfish` in workspace root (recommended) or skill directory:
  ```
  TELEGRAM_BOT_TOKEN=...     # from @BotFather (required)
  TELEGRAM_USER_ID=...       # your Telegram user ID (optional, enables auto-approve pairing)
  GEMINI_API_KEY=...         # from aistudio.google.com (optional, for Gemini models)
  ```
- `aws` CLI installed OR Docker for sandboxed access
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- `.env.starfish` in workspace root (recommended) or skill directory:
  ```
  TELEGRAM_BOT_TOKEN=...     # from @BotFather (required)
  TELEGRAM_USER_ID=...       # your Telegram user ID (optional, enables auto-approve pairing)
  GEMINI_API_KEY=...         # from aistudio.google.com (optional, for Gemini models)
  ```
- `aws` CLI installed OR Docker for sandboxed access
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
- `.env.starfish` in workspace root (recommended) or skill directory:
  ```
  TELEGRAM_BOT_TOKEN=...     # from @BotFather (required)
  TELEGRAM_USER_ID=...       # your Telegram user ID (optional, enables auto-approve pairing)
  GEMINI_API_KEY=...         # from aistudio.google.com (optional, for Gemini models)
  ```
- `aws` CLI installed OR Docker for sandboxed access
Confidence
85% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
91% confidence
Finding
The teardown examples include `--yes`, which suppresses confirmation for destructive actions, yet the surrounding text does not prominently warn that this will delete AWS resources. In a cloud-deployment skill, that raises the risk of accidental irreversible deletion, especially when an agent or user copies commands verbatim.

Session Persistence

Medium
Category
Rogue Agent
Content
### Model
- **Gemini 2.0 Flash** — recommended (free tier: 15 RPM, 1M tokens/day, supports tools)
- **Auth profiles required** — create `auth-profiles.json` in agent dir
- **Bedrock format** — `amazon-bedrock/MODEL_ID` (not `bedrock/`)
- **Bedrock models need console enablement** — Anthropic requires use case form
Confidence
78% confidence
Finding
The guidance to create `auth-profiles.json` in the agent directory implies local persistence of provider credentials or auth configuration on disk. In a deployment skill handling API keys and cloud access, persistent auth material increases exposure through file disclosure, backup leakage, or compromised service accounts, especially since the document also notes some hardening was removed for reliability.

Autonomous Decision Making

Medium
Category
Excessive Agency
Content
## Safety

- Don't exfiltrate private data. Ever.
- Don't run destructive commands without asking.
- `trash` > `rm`
- When in doubt, ask.
Confidence
75% confidence
Finding
Skill enables autonomous high-impact decisions without human-in-the-loop verification. Critical operations (destructive commands, financial transactions, data deletion) should require explicit user confirmation.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The heartbeat instructions explicitly direct the agent to access email, calendar, project repositories, and memory files on a recurring basis without any requirement for user consent, data minimization, or contextual authorization. In an autonomous agent deployment skill, this creates a real privacy and overreach risk because the agent is being told to proactively inspect potentially sensitive personal and organizational data outside an explicit user-triggered request.

Vague Triggers

Medium
Confidence
89% confidence
Finding
The description says to 'Monitor what you're asked to monitor' across broad domains like systems, markets, and news, but does not define clear activation conditions, explicit trigger phrases, or exclusions. In a markdown skill description, this ambiguity can cause unintended invocation because the scope overlaps with many common monitoring-related requests.

Session Persistence

Medium
Category
Rogue Agent
Content
Gateway service check failed: Error: systemctl --user unavailable: Failed to connect to bus
```

**Cause:** `openclaw gateway start` tries to create a user-level systemd service

**Solution:** Use foreground mode instead:
```bash
Confidence
60% confidence
Finding
Skill establishes unauthorized persistence across sessions via cron jobs, startup scripts, or state files. Session persistence allows an attacker to maintain access beyond the current interaction.

Missing User Warnings

Medium
Confidence
86% confidence
Finding
The troubleshooting step tells users to kill processes and restart the service without any warning about service interruption, possible termination of unrelated matching processes, or need to verify the target first. In an ops runbook this can cause avoidable denial of service or disrupt production sessions if copied blindly.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Solution:** Kill existing gateway before restart:
```bash
sudo pkill -f openclaw-gateway
sleep 2
sudo systemctl restart openclaw
```
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Solution:** Kill existing gateway before restart:
```bash
sudo pkill -f openclaw-gateway
sleep 2
sudo systemctl restart openclaw
```
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Solution:** Kill existing gateway before restart:
```bash
sudo pkill -f openclaw-gateway
sleep 2
sudo systemctl restart openclaw
```
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Solution:** Kill existing gateway before restart:
```bash
sudo pkill -f openclaw-gateway
sleep 2
sudo systemctl restart openclaw
```
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Solution:** Kill existing gateway before restart:
```bash
sudo pkill -f openclaw-gateway
sleep 2
sudo systemctl restart openclaw
```
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Sudo/Root Execution

Medium
Category
Privilege Escalation
Content
**Solution:** Kill existing gateway before restart:
```bash
sudo pkill -f openclaw-gateway
sleep 2
sudo systemctl restart openclaw
```
Confidence
70% confidence
Finding
Commands invoke sudo or root privileges. Verify this elevated access is necessary and justified.

Static analysis

No suspicious patterns detected.