Back to skill

Security audit

DanceTech Skill

Security checks for vulnerabilities and agentic risk

Overview

This skill is openly an autonomous posting bot, but it asks for broad scheduled access to credentials, public posting, GitHub repo creation, and wallet-capable resources with several unsafe implementation details.

Review this carefully before installing. Use only throwaway or narrowly scoped Moltbook, GitHub, OpenRouter, and Privy credentials; do not run the cron jobs on a primary account. Disable or rewrite the automated commenting, fix token handling and path validation, and avoid running the Privy wallet script unless you intentionally want persistent wallet resources created.

Vulnerability Patterns
  • Unauthorized Access and Privilege EscalationObtains permissions beyond the task's legitimate needs
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (6)

T09 · Insecure Skill Coding Practices

Error
Location
scripts/dancetech_post.js:360
Finding
Externally Generated File Paths Permit Writes Outside the Repository<![CDATA[ ## Vulnerability Details **File Location**: `scripts/dancetech_post.js:156-173, 360-364` **Vulnerability Type**: Path traversal through untrusted model output **Risk Level**: High ### Vulnerable Code ```javascript const response = await fetch('https://openrouter.ai/api/v1/chat/completions', { method: 'POST', headers: { 'Authorization': `Bearer ${env.OPENROUTER_API_KEY}`, 'Content-Type': 'application/json', 'HTTP-Referer': 'https://openclaw.ai', 'X-Title': 'DanceTech Code Gen' }, body: JSON.stringify({ model: 'qwen/qwen3-coder', messages: [{ role: 'user', content: prompt }], max_tokens: maxTokens, temperature: 0.2 }) }); if (!response.ok) { const err = await response.text(); throw new Error(`OpenRouter ${response.status}: ${err}`); } const data = await response.json(); let content = data.choices[0].message.content; content = content.replace(/^```json\s*|\s*```$/g, '').trim(); return JSON.parse(content); ``` ```javascript Object.entries(files).forEach(([filePath, content]) => { const fullPath = path.join(repoDir, filePath); fs.mkdirSync(path.dirname(fullPath), { recursive: true }); fs.writeFileSync(fullPath, content, 'utf8'); }); ``` ### Technical Analysis The file map returned by an external language model is accepted without schema or path validation. Each model-controlled object key is treated as a relative file path and joined to `repoDir`. `path.join()` normalizes traversal segments but does not guarantee that the result remains below the intended base directory. A key such as `../../scripts/start_all.js` can therefore resolve outside the generated repository and overwrite another writable project file. The security railcard runs only after the files have been written. It scans for secret patterns, not path traversal or unauthorized file changes, so it does not prevent this vulnerability. ### Attack Path 1. The scheduled script submits a code-generation prompt to OpenRouter. 2. A compromis ...[truncated 1057 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Resolve and validate every generated path before creating directories or writing files: ```javascript const base = path.resolve(repoDir); for (const [generatedPath, content] of Object.entries(files)) { if (path.isAbsolute(generatedPath) || generatedPath.includes('\0')) { throw new Error(`Invalid generated path: ${generatedPath}`); } const destination = path.resolve(base, generatedPath); if (!destination.startsWith(base + path.sep)) { throw new Error(`Generated path escapes repository: ${generatedPath}`); } fs.mkdirSync(path.dirname(destination), { recursive: true }); fs.writeFileSync(destination, String(content), { encoding: 'utf8', flag: 'wx' }); } ``` 2. Use a strict schema that requires a plain object whose keys and values are strings. 3. Maintain an allowlist of files expected for each generation track. 4. Reject `..`, absolute paths, drive-prefixed paths, control characters, symbolic-link destinations, and unexpected filenames. 5. Generate files in an isolated temporary directory with restrictive permissions and no sensitive files nearby. 6. Review or sandbox generated code before publishing it. 7. Add tests for traversal keys including `../`, nested traversal, absolute paths, Windows path forms, and symbolic-link escape attempts. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/heartbeat.js:110
Finding
GitHub Token Is Exposed in Shell Arguments and Repository Configuration<![CDATA[ ## Vulnerability Details **File Location**: `scripts/heartbeat.js:110-125` **Vulnerability Type**: Plaintext credential exposure in command arguments and Git remote URLs **Risk Level**: High ### Vulnerable Code ```javascript const newCloneUrl = `https://${env.GITHUB_PUBLIC_TOKEN}@github.com/arunnadarasa/${iterationName}.git`; const originalCloneUrl = `https://${env.GITHUB_PUBLIC_TOKEN}@github.com/${originalFull}.git`; // 2. Clone original to a temp dir const tmpDir = path.join(TMP_BASE, iterationName); try { execSync(`git clone --quiet ${originalCloneUrl} "${tmpDir}"`, { stdio: 'ignore' }); // 3. Add feedback response file const fbFile = path.join(tmpDir, 'FEEDBACK_RESPONSE.md'); const content = `# Iteration Response\n\nFeedback received from community:\n\n> ${feedbackText.replace(/\n/g, '\n> ')}\n\nThis iteration documents the feedback. Future updates will address specific improvements.\n`; fs.writeFileSync(fbFile, content, 'utf8'); // 4. Change remote to new repo and push execSync('git add FEEDBACK_RESPONSE.md', { cwd: tmpDir, stdio: 'ignore' }); execSync('git commit -m "Add feedback response"', { cwd: tmpDir, stdio: 'ignore' }); execSync(`git remote set-url origin ${newCloneUrl}`, { cwd: tmpDir, stdio: 'ignore' }); execSync('git push origin main', { cwd: tmpDir, stdio: 'ignore' }); } finally { try { execSync(`rm -rf "${tmpDir}"`); } catch (e) {} } ``` ### Technical Analysis The GitHub token is embedded directly into HTTPS URLs passed to shell commands. This exposes the secret through process command-line inspection on systems where other users or monitoring agents can read process arguments. The credential-bearing URL is also stored in the temporary repository's `.git/config` after cloning and after `git remote set-url`. Although cleanup is attempted, abrupt process termination, system failure, or unsuccessful cleanup can leave the token on disk. Using `stdio: 'ignore'` suppresses output but does not protect command argu ...[truncated 1057 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Never place credentials in Git URLs. 2. Use `GIT_ASKPASS`, a short-lived credential helper, or another mechanism that does not expose the token in process arguments. 3. Invoke Git with `spawnSync()` or `execFileSync()` and fixed argument arrays rather than through a shell. 4. Keep remote URLs credential-free: ```text https://github.com/arunnadarasa/repository.git ``` 5. Create temporary credential files with mode `0600` or `0700`, remove them in a `finally` block, and ensure they are outside generated repositories. 6. Use a fine-grained GitHub token restricted to the minimum repositories and permissions. 7. Prefer short-lived tokens, rotate the currently configured token, and audit GitHub logs for unexpected access. 8. Place temporary repositories in a mode-`0700` directory and perform startup cleanup of abandoned temporary directories. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/league_tracker.js:145
Finding
Moltbook API Key Is Interpolated into an Unsafe Shell Command<![CDATA[ ## Vulnerability Details **File Location**: `scripts/league_tracker.js:145-154` **Vulnerability Type**: Shell injection risk and command-line credential exposure **Risk Level**: High ### Vulnerable Code ```javascript function postToMoltbook(title, content) { const payload = { subdomain: 'krumpclaw', title, content, verification_required: false }; const cmd = `curl -s -X POST https://moltbook.com/api/posts/create \\\n -H 'Authorization: Bearer ${MOLTBOOK_API_KEY}' \\\n -H 'Content-Type: application/json' \\\n -d '${JSON.stringify(payload)}'`; const response = execSync(cmd).toString(); const parsed = JSON.parse(response); if (parsed.error) throw new Error(`Moltbook error: ${parsed.error}`); return parsed; } ``` ### Technical Analysis The code constructs a shell command by directly interpolating the Moltbook API key and a JSON payload. The command is then executed through `execSync()`, which invokes a shell. The single quotes surrounding the authorization value and payload are not an adequate escaping mechanism. A single quote in an interpolated value can terminate the quoted shell argument and allow additional shell syntax to be interpreted. Even in the absence of injection, the API key is placed in the shell command line and may be visible to local process inspection, monitoring, or diagnostic tooling. The project already requires a Node.js version with `fetch`, making shell-based `curl` unnecessary. ### Attack Path 1. The league tracker loads `MOLTBOOK_API_KEY` from `.env` and constructs a report payload. 2. A maliciously modified environment value or quote-bearing payload value is interpolated into the command. 3. The inserted single quote terminates the intended shell argument. 4. Additional shell operators and commands are interpreted by the shell started by `execSync()`. 5. The injected command executes with the permissions of the scheduled OpenClaw process. A separate disclosure path exists where ano ...[truncated 538 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Replace the shell command with Node.js `fetch`: ```javascript async function postToMoltbook(title, content) { const response = await fetch('https://moltbook.com/api/posts/create', { method: 'POST', headers: { Authorization: `Bearer ${MOLTBOOK_API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ subdomain: 'krumpclaw', title, content, verification_required: false }) }); const parsed = await response.json(); if (!response.ok || parsed.error) { throw new Error(`Moltbook request failed: ${response.status}`); } return parsed; } ``` Additional hardening: 1. Avoid logging response bodies that could contain sensitive platform details. 2. Apply request timeouts and response-size limits. 3. Rotate the current API key if it has been used with this implementation on a shared system. 4. Remove `curl` and unnecessary `process_exec` capability from this component. 5. If external execution is unavoidable, use a fixed executable with an argument array and never place secrets directly in process arguments. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
scripts/dancetech_post.js:539
Finding
Successful Posts Are Not Persisted Because of an Out-of-Scope Variable<![CDATA[ ## Vulnerability Details **File Location**: `scripts/dancetech_post.js:539-566` **Vulnerability Type**: State-management failure causing repeated external side effects **Risk Level**: Medium ### Vulnerable Code ```javascript if (DRY_RUN) { console.log('DRY RUN — would post:'); console.log('Title:', title); console.log('Content preview (first 500 chars):', content.substring(0, 500) + '...'); } else { // Post console.log('Posting to Moltbook...'); try { const postResponse = await postToMoltbook(title, content); if (postResponse.verification_required) { console.log('Verification required. Solving challenge...'); const answer = solveChallenge(postResponse.challenge); await verifyPost(postResponse.verification_code, answer); console.log('Verified!'); } console.log('Posted successfully:', postResponse.post?.id || postResponse.content_id); } catch (err) { console.error('Failed to post:', err.message); // Don't save state if post failed, so we can retry later process.exit(1); } } // Record success state.lastPostDate = today; state.lastTrack = track; saveState(state); const log = fs.existsSync(POSTS_LOG_PATH) ? JSON.parse(fs.readFileSync(POSTS_LOG_PATH, 'utf8')) : []; log.push({ timestamp: new Date().toISOString(), track, repoUrl: repoInfo.html_url, postId: DRY_RUN ? 'dry-run' : (postResponse?.post?.id || postResponse?.content_id), title, nonce }); fs.writeFileSync(POSTS_LOG_PATH, JSON.stringify(log, null, 2)); ``` ### Technical Analysis `postResponse` is declared with `const` inside the `else` block. It is therefore unavailable when the logging object later references it outside that block. During a real run, the GitHub repository and Moltbook post may already have been created successfully before the `ReferenceError` occurs. The state has been saved just before the failing expression, but the activity log is not updated. This creates inconsistent state and prevents downstrea ...[truncated 1130 chars]
Remediation
<![CDATA[ ## Remediation Suggestions Declare the variable in the surrounding scope and assign it in the posting branch: ```javascript let postResponse = null; if (DRY_RUN) { // Preview only } else { postResponse = await postToMoltbook(title, content); // Perform verification when required } ``` Additional measures: 1. Persist the external post identifier immediately after a successful post. 2. Use a transactional state model with statuses such as `pending`, `repo-created`, `posted`, and `complete`. 3. Implement idempotency keys where the external API supports them. 4. Reconcile remote resources before retrying after a crash. 5. Add automated tests for both dry-run and real-post control flow. 6. Ensure downstream logs and cooldown state are updated atomically, for example by writing to a temporary file and renaming it. ]]>

T05 · Unauthorized Access and Privilege Escalation

Warning
Location
scripts/test_privy.js:39
Finding
Privy Connectivity Test Creates Persistent Transaction-Capable Wallet Resources<![CDATA[ ## Vulnerability Details **File Location**: `scripts/test_privy.js:39-86`; `skill.yaml:5-10` **Vulnerability Type**: Excessive financial permissions and misleading side effects **Risk Level**: Medium ### Vulnerable Code ```javascript const policy = { version: '1.0', name: 'Agent testnet commerce policy', chain_type: 'ethereum', rules: [{ name: 'Max 0.1 Sepolia ETH per transaction', method: 'eth_sendTransaction', conditions: [{ field_source: 'ethereum_transaction', field: 'value', operator: 'lte', value: '100000000000000000' }], action: 'ALLOW' }, { name: 'Base Sepolia only', method: 'eth_sendTransaction', conditions: [{ field_source: 'ethereum_transaction', field: 'chain_id', operator: 'eq', value: '84532' }], action: 'ALLOW' }] }; console.log('Creating policy...'); const policyRes = await fetch('https://api.privy.io/v1/policies', { method: 'POST', headers: { 'Authorization': `Basic ${auth}`, 'privy-app-id': appId, 'Content-Type': 'application/json' }, body: JSON.stringify(policy) }); // ... console.log('Creating wallet...'); const walletRes = await fetch('https://api.privy.io/v1/wallets', { method: 'POST', headers: { 'Authorization': `Basic ${auth}`, 'privy-app-id': appId, 'Content-Type': 'application/json' }, body: JSON.stringify({ chain_type: 'ethereum', policy_ids: [policyId] }) }); ``` The optional Privy credentials are nevertheless declared as required: ```yaml requiredEnvVars: - MOLTBOOK_API_KEY - GITHUB_PUBLIC_TOKEN - OPENROUTER_API_KEY - PRIVY_APP_ID - PRIVY_APP_SECRET ``` ### Technical Analysis Despite being named `test_privy.js` and described as testing connectivity, the script performs persistent, state-changing API operations. It creates a Privy policy that authorizes `eth_sendTransaction` and then creates a wallet bound to that policy. These actions are not required for the Skill's core functions of posting dance content, trac ...[truncated 1622 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Rename the script to explicitly describe its side effects, such as `create_privy_test_wallet.js`. 2. Add a clear interactive confirmation and a separate explicit flag such as `--create-wallet`. 3. Provide a read-only connectivity test that authenticates through a non-mutating endpoint. 4. Make `PRIVY_APP_ID` and `PRIVY_APP_SECRET` optional in `skill.yaml`. 5. Separate wallet functionality into an independently enabled component with its own permissions. 6. Default test policies to no transaction capability. 7. Verify that amount and chain restrictions are combined with logical AND semantics. 8. Record created policy and wallet IDs and provide a cleanup command that deletes test resources. 9. Use dedicated test credentials with no production wallet access. 10. Avoid running wallet creation from any general orchestrator or scheduled task. ]]>

other

Warning
Location
scripts/engage_comments.js:140
Finding
Automated Engagement Produces High-Volume Generic Comments with Unbounded Rate-Limit Recursion<![CDATA[ ## Vulnerability Details **File Location**: `scripts/engage_comments.js:140-215` **Vulnerability Type**: Automated platform abuse and unbounded retry behavior **Risk Level**: Medium ### Vulnerable Code ```javascript async function postComment(postId, content) { const fetch = globalThis.fetch; const res = await fetch(`https://www.moltbook.com/api/v1/posts/${postId}/comments`, { method: 'POST', headers: { 'Authorization': `Bearer ${env.MOLTBOOK_API_KEY}`, 'Content-Type': 'application/json' }, body: JSON.stringify({ content }) }); const data = await res.json(); if (!res.ok) { if (res.status === 429) { const retry = data.retry_after_seconds || 20; console.log(`Rate limited. Retrying after ${retry}s`); await new Promise(r => setTimeout(r, retry * 1000)); return postComment(postId, content); // retry once } throw new Error(`Comment failed: ${res.status} ${JSON.stringify(data)}`); } return data; } // Main (async () => { const dailyTarget = 50; const perRun = Math.min(parseInt(process.env.COMMENTS_PER_RUN) || 2, dailyTarget); const log = loadLog(); const todayCount = countToday(log); if (todayCount >= dailyTarget) { console.log(`Already made ${todayCount} comments today. Goal ${dailyTarget} reached.`); process.exit(0); } // ... const submolts = ['krump', 'dance', 'dancetech', 'krumptech', 'krumpclaw']; const posts = await fetchRecentPosts(submolts); // Filter: not authored by us, and not already commented (log by postId) const commentedPostIds = new Set(log.entries.map(e => e.postId)); const candidates = posts.filter(p => p.author?.name !== ourName && !commentedPostIds.has(p.id)); // ... const selected = candidates.slice(0, toMake); for (const post of selected) { try { const commentText = generateComment(post); const result = await postComment(post.id, commentText); log.entries.push({ timestamp: new Date().to ...[truncated 2005 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Disable automated engagement by default and require explicit opt-in. 2. Reduce the daily limit substantially and document the exact effective schedule. 3. Require a semantic relevance threshold or human approval before commenting. 4. Restrict engagement to communities and posts explicitly selected by the user. 5. Replace recursive retry with bounded iteration: ```javascript async function postComment(postId, content, maxAttempts = 2) { for (let attempt = 1; attempt <= maxAttempts; attempt++) { const res = await fetch(/* request */); const data = await res.json(); if (res.ok) return data; if (res.status !== 429 || attempt === maxAttempts) { throw new Error(`Comment failed: ${res.status}`); } const delay = Math.min(Number(data.retry_after_seconds) || 20, 300); await new Promise(resolve => setTimeout(resolve, delay * 1000)); } } ``` 6. Add global request deadlines and a maximum process runtime. 7. Stop the run after repeated platform warnings or rate-limit responses. 8. Provide a preview-only mode that displays proposed comments without posting. 9. Ensure all templates are genuinely relevant and do not imply experience, collaboration, or project work that did not occur. ]]>
Vulnerability Patterns
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • YARA SignaturesMalware Match, Webshell Match, Cryptominer Match
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
Findings (95)

YARA rule 'backdoor_persistence': Backdoor persistence with malicious payloads (shell commands, SSH key injection, hidden root users) [malware]

High
Category
YARA Match
Content
*: Random 8-character string in title and footer.
- **Randomized templates**: Title arrays and content intros/outros selected randomly.
- **Timestamp footer**: Includes generation time and nonce for traceability.
- **No exact duplicates**: The combination of nonce and randomized content prevents Moltbook from flagging identical posts.

### Cron Recommendations
Adjust your OpenClaw cron jobs (see `crontab -e` or `openclaw cron`) to match:
- `0 9 * * * openclaw agent-run dance-agentic-engineer-skill scripts/dancetech_post.js --dry-run=false` (daily at 09:00)
- `0 10 * * 2,4,6 openclaw agent-run dance-agentic-engineer-skill scripts/krumpclab_post.js` (every other day, e.g., Tue/Thu/Sat)
- `0 11 * * 6 openclaw agent-run dance-agentic-engineer-skill scripts/krumpsession_post.js` (Saturdays at 11:00)

Important: Allow the script cooldown logic to run naturally; do not manually trigger more frequently.

### Testing
Use `--dry-run` to inspect output without posting:
- `node scripts/dancetech_p
Confidence
75% confidence
Finding
YARA rule matched a known malware signature (reverse shell, backdoor, ransomware, C2 framework, or info stealer).

YARA rule 'backdoor_persistence': Backdoor persistence with malicious payloads (shell commands, SSH key injection, hidden root users) [malware]

High
Category
YARA Match
Content
*: Random 8-character string in title and footer.
- **Randomized templates**: Title arrays and content intros/outros selected randomly.
- **Timestamp footer**: Includes generation time and nonce for traceability.
- **No exact duplicates**: The combination of nonce and randomized content prevents Moltbook from flagging identical posts.

### Cron Recommendations
Adjust your OpenClaw cron jobs (see `crontab -e` or `openclaw cron`) to match:
- `0 9 * * * openclaw agent-run dance-agentic-engineer-skill scripts/dancetech_post.js --dry-run=false` (daily at 09:00)
- `0 10 * * 2,4,6 openclaw agent-run dance-agentic-engineer-skill scripts/krumpclab_post.js` (every other day, e.g., Tue/Thu/Sat)
- `0 11 * * 6 openclaw agent-run dance-agentic-engineer-skill scripts/krumpsession_post.js` (Saturdays at 11:00)

Important: Allow the script cooldown logic to run naturally; do not manually trigger more frequently.

### Testing
Use `--dry-run` to inspect output without posting:
- `node scripts/dancetech_p
Confidence
75% confidence
Finding
YARA rule matched a known malware signature (reverse shell, backdoor, ransomware, C2 framework, or info stealer).

Credential Access

High
Category
Privilege Escalation
Content
- Use a dedicated GitHub account with minimal scopes (repo creation and push). Avoid using personal primary account tokens.
- The scripts embed the GitHub token in clone URLs; this can leak via process listings. Consider using SSH deploy keys or a short-lived token.
- Store all credentials in the skill's .env file; never commit them.
- Test with throwaway accounts before using production credentials.
Confidence
95% confidence
Finding
The README itself acknowledges that the scripts embed the GitHub token in clone URLs, which can expose credentials through process listings, logs, shell history, or error output. Because this skill automates scheduled execution and uses long-lived API credentials from `.env`, credential leakage could allow unauthorized access to GitHub or other connected services.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
---
name: dance-agentic-engineer
description: Complete agentic dance engineering system for Krump: automated posts, community engagement, league tracking, and portfolio building (969 repos). Includes 8 production-ready scripts for OpenClaw: daily labs, 3x daily DanceTech posts, Saturday battles, weekly league summaries, engagement, and tournament prep. Set up via OpenClaw cron; all scripts load .env credentials and post to Moltbook.
---

# Dance Agentic Engineer Skill
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Ae1

High
Category
analysis-evasion
Content
- `0 9 * * * openclaw agent-run dance-agentic-engineer-skill scripts/dancetech_post.js --dry-run=false` (daily at 09:00)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- `0 9 * * * openclaw agent-run dance-agentic-engineer-skill scripts/dancetech_post.js --dry-run=false` (daily at 09:00)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- `0 9 * * * openclaw agent-run dance-agentic-engineer-skill scripts/dancetech_post.js --dry-run=false` (daily at 09:00)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- `0 9 * * * openclaw agent-run dance-agentic-engineer-skill scripts/dancetech_post.js --dry-run=false` (daily at 09:00)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
chmod +x scripts/tools/security-check.js # Make executable (required on some systems)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
chmod +x scripts/tools/security-check.js # Make executable (required on some systems)
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
- **Skill docs:** See `SKILL.md` (this file) and `references/script-reference.md`
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Credential Access

High
Category
Privilege Escalation
Content
if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
});

// Load environment variables from .env
function loadEnv() {
  const content = fs.readFileSync(ENV_PATH, 'utf8');
  const env = {};
Confidence
90% confidence
Finding
The script reads raw credentials from .env for multiple services and uses them to perform external authenticated actions. In an agent skill, secret ingestion is security-relevant because compromise of the skill or accidental execution can immediately exercise those credentials against third-party services.

Credential Access

High
Category
Privilege Escalation
Content
const { execSync } = require('child_process');

const WORKSPACE = path.resolve(__dirname, '..');
const ENV_PATH = path.join(WORKSPACE, '.env');
const STATE_PATH = path.join(WORKSPACE, 'memory', 'heartbeat-state.json');
const FEEDBACK_PATH = path.join(WORKSPACE, 'memory', 'feedback.json');
const DANCETECH_POSTS_PATH = path.join(WORKSPACE, 'memory', 'dancetech-posts.json');
Confidence
91% confidence
Finding
The script loads secrets from a workspace-local .env file and then uses those credentials for API calls and embeds the GitHub token directly into clone/push URLs. In this agent context, that is dangerous because tokens may be exposed through process arguments, shell history, git remotes, crash output, or local repo configuration, increasing the likelihood of credential leakage and subsequent unauthorized access to GitHub or Moltbook.

Credential Access

High
Category
Privilege Escalation
Content
const path = require('path');

const WORKSPACE = path.resolve(__dirname, '..');
const ENV_PATH = path.join(WORKSPACE, '.env');
const IKS_LOG_PATH = path.join(WORKSPACE, 'memory', 'iks-log.json');

function loadEnv() {
Confidence
89% confidence
Finding
The script is designed to access a workspace .env file, which is a common store for sensitive credentials, and then uses those values for external authenticated requests. In a skill ecosystem, broad access to local secret stores is high risk because it normalizes secret harvesting from the workspace and can be repurposed to misuse credentials beyond the user's awareness.

Credential Access

High
Category
Privilege Escalation
Content
const path = require('path');

const WORKSPACE = path.resolve(__dirname, '..');
const ENV_PATH = path.join(WORKSPACE, '.env');
const COMM_LOG_PATH = path.join(WORKSPACE, 'memory', 'community-log.json');

function loadEnv() {
Confidence
78% confidence
Finding
Referencing and parsing the workspace .env file constitutes credential access because the code intentionally loads local secret material for later authenticated requests. In an agent skill, this is sensitive because any code path that can read shared secrets may be modified or abused to exfiltrate them or use them for unauthorized actions, especially when the script already performs network operations.

Credential Access

High
Category
Privilege Escalation
Content
const path = require('path');

const WORKSPACE = path.resolve(__dirname, '..');
const ENV_PATH = path.join(WORKSPACE, '.env');
const SESSION_LOG_PATH = path.join(WORKSPACE, 'memory', 'session-posts.json');
const STATE_PATH = path.join(WORKSPACE, 'memory', 'session-state.json');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Credential Access

High
Category
Privilege Escalation
Content
const path = require('path');

const WORKSPACE = path.resolve(__dirname, '..');
const ENV_PATH = path.join(WORKSPACE, '.env');
const SESSION_LOG_PATH = path.join(WORKSPACE, 'memory', 'session-posts.json');
const STATE_PATH = path.join(WORKSPACE, 'memory', 'session-state.json');
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.