Back to skill

Security audit

Near Getpay - Accept crypto payments with payment page using PingPay or HOT PAY

Security checks for vulnerabilities and agentic risk

Overview

This payment skill has a coherent purpose, but it exposes payment-related actions too broadly and gives unsafe credential/security guidance.

Review carefully before installing. Do not paste API keys into chat; use a local secret file or secret manager and prefer scoped/test provider keys. Do not expose the tunnel publicly until privileged link/session creation is authenticated and rate-limited, webhook signatures are actually verified, callback URLs use a trusted configured origin, dependencies are updated, and SSH setup uses a dedicated protected key with host-key verification.

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 (8)

T05 · Unauthorized Access and Privilege Escalation

Error
Location
server-simple.ts:1143
Finding
HOT PAY Webhook Events Are Accepted Without Authentication<![CDATA[ ## Vulnerability Details **File Location**: `server-simple.ts:1143-1162` **Vulnerability Type**: Unauthenticated webhook processing **Risk Level**: High ### Vulnerable Code ```typescript // HOT PAY Webhook endpoint app.post('/webhook/hotpay', (req, res) => { try { const payload = req.body; console.log('\n🔔 HOT PAY Webhook Received'); console.log('='.repeat(70)); console.log(JSON.stringify(payload, null, 2)); console.log('='.repeat(70)); if (payload.type === 'PAYMENT_STATUS_UPDATE' && payload.status === 'SUCCESS') { console.log(`✅ Payment Confirmed!`); console.log(` Item ID: ${payload.item_id}`); console.log(` Amount: $${payload.amount_float} (${payload.amount_usd} USD)`); console.log(` Memo: ${payload.memo || 'N/A'}`); console.log(` TX Hash: ${payload.near_trx}`); console.log(` Verify: https://nearblocks.io/txns/${payload.near_trx}`); } res.status(200).json({ received: true }); } catch (error: any) { console.error('❌ Webhook Error:', error.message); res.status(500).json({ error: 'Webhook processing failed' }); } }); ``` ### Technical Analysis The webhook endpoint trusts arbitrary JSON without verifying a provider signature, shared secret, timestamp, event identifier, transaction status, or replay state. Any party that can access the public tunnel can submit an object containing `type: "PAYMENT_STATUS_UPDATE"` and `status: "SUCCESS"`, causing it to be treated as a confirmed payment. This contradicts the webhook signature-verification claim in `SKILL.md:290`. Although the current handler primarily logs the event, it establishes an unsafe payment-confirmation boundary and would become directly exploitable for unauthorized fulfillment if business logic were subsequently attached. ### Attack Path 1. The operator starts the Skill and exposes it through the localhost.run tunnel. 2. An attacker obtains or guesses the public tunnel URL. 3. The ...[truncated 846 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Verify HOT PAY signatures over the unmodified raw request body using a dedicated webhook secret. - Reject requests with missing, malformed, or invalid signatures before parsing or processing event fields. - Validate signed timestamps within a narrow tolerance to prevent delayed replay. - Persist unique event or transaction identifiers and reject duplicates. - Verify payment status and transaction details independently against the provider or blockchain before fulfillment. - Compare the item ID, amount, token, recipient, and transaction hash against an expected local payment record. - Update the documentation so signature-verification claims accurately reflect the implementation. ]]>

T05 · Unauthorized Access and Privilege Escalation

Error
Location
server-simple.ts:953
Finding
Public Endpoints Permit Unauthenticated Use of the Operator's PingPay API Credential<![CDATA[ ## Vulnerability Details **File Location**: `server-simple.ts:953-1036`, `server-simple.ts:1040-1139`; equivalent behavior at `server.ts:410-472` **Vulnerability Type**: Missing authorization and rate limiting on privileged API operations **Risk Level**: High ### Vulnerable Code ```typescript // Quick link generator endpoint - creates both links at once app.get('/quick-link', async (req, res) => { try { const amount = parseFloat(req.query.amount as string || '0'); const token = (req.query.token as string || 'USDC').toUpperCase(); const chain = 'near'; if (!amount || amount <= 0) { return res.json({ success: false, error: 'Invalid amount. Usage: /quick-link?amount=5&token=USDC' }); } // ... if (config.provider === 'pingpay' && client) { // ... const session = await client.createCheckoutSession({ amount: amountSmallest, asset: { chain, symbol: token }, successUrl: `${baseUrl}/success`, cancelUrl: `${baseUrl}/cancel`, metadata: { amount: amount.toString(), token, chain, timestamp: Date.now() } }); checkoutUrl = session.sessionUrl; } // ... } catch (error: any) { console.error('❌ Error:', error.message); res.json({ success: false, error: error.message }); } }); // Create payment session app.post('/create-session', async (req, res) => { try { const { amount, token, chain } = req.body; if (!amount || amount <= 0) { return res.json({ success: false, error: 'Invalid amount' }); } // ... const session = await client.createCheckoutSession({ amount: amountSmallest, asset: { chain, symbol: token }, successUrl: `${req.protocol}://${req.get('host')}/success`, cancelUrl: `${req.protocol}://${req.get('host')}/cancel`, metadata: { amount: amount.toString(), token, chain, timestamp: D ...[truncated 1751 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Separate anonymous payment viewing from privileged payment-session creation. - Require a cryptographically strong administrative token or authenticated session for link-generation operations. - If public creation is essential, issue narrowly scoped, signed, short-lived payment intents server-side rather than accepting arbitrary parameters. - Add per-IP and global rate limits, provider quotas, request-size limits, and abuse monitoring. - Enforce strict token, chain, amount, precision, and maximum-value allowlists. - Use a PingPay credential restricted to checkout creation only, if the provider supports scoped credentials. - Return appropriate HTTP status codes and avoid exposing raw provider errors to untrusted clients. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
server-simple.ts:980
Finding
Untrusted Host Header Is Used to Construct Payment Callback URLs<![CDATA[ ## Vulnerability Details **File Location**: `server-simple.ts:980-991`, `server-simple.ts:1064`, `server-simple.ts:1110-1111`; equivalent behavior at `server.ts:448-449` **Vulnerability Type**: Host header injection into third-party redirect URLs **Risk Level**: High ### Vulnerable Code ```typescript const baseUrl = `${req.protocol}://${req.get('host')}`; const paymentPageUrl = `${baseUrl}/?amount=${amount}&token=${token}`; const session = await client.createCheckoutSession({ amount: amountSmallest, asset: { chain, symbol: token }, successUrl: `${baseUrl}/success`, cancelUrl: `${baseUrl}/cancel`, metadata: { amount: amount.toString(), token, chain, timestamp: Date.now() } }); ``` The same pattern is used in the session endpoint: ```typescript successUrl: `${req.protocol}://${req.get('host')}/success`, cancelUrl: `${req.protocol}://${req.get('host')}/cancel`, ``` ### Technical Analysis The application derives externally trusted payment callback URLs from the HTTP `Host` header. The header is controlled by the requester unless a trusted reverse proxy validates and replaces it. Express does not provide an allowlist in this code. An attacker can therefore request a valid PingPay checkout session while supplying an attacker-owned hostname. The provider receives the poisoned hostname as the success and cancellation destination. ### Attack Path 1. The attacker sends a request to the public endpoint with a manipulated header: ```http POST /create-session HTTP/1.1 Host: attacker.example Content-Type: application/json {"amount":10,"token":"USDC","chain":"NEAR"} ``` 2. The server constructs `https://attacker.example/success` and `https://attacker.example/cancel` or equivalent URLs based on the request protocol. 3. These URLs are submitted to PingPay as trusted checkout callbacks. 4. The attacker distributes the valid checkout URL to a victim. 5. After payment or cancellation, the victim is redirected to the ...[truncated 456 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Define a canonical public origin in trusted configuration, such as `PUBLIC_BASE_URL`. - Parse the configured value with the platform URL parser and require HTTPS. - Restrict the hostname to an explicit allowlist. - Never derive provider callback URLs from `Host`, `X-Forwarded-Host`, or similar request headers. - Configure Express proxy trust narrowly if a reverse proxy is used. - Configure the payment provider to allow only pre-registered callback domains when supported. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
start-tunnel.ts:27
Finding
SSH Tunnel Explicitly Disables Host-Key Verification<![CDATA[ ## Vulnerability Details **File Location**: `start-tunnel.ts:27-34` **Vulnerability Type**: Disabled SSH server authentication **Risk Level**: Medium ### Vulnerable Code ```typescript const tunnel = spawn('ssh', [ '-R', `80:localhost:${PORT}`, 'localhost.run', '-o', 'StrictHostKeyChecking=no' ]); ``` ### Technical Analysis `StrictHostKeyChecking=no` tells SSH not to require confirmation of the remote server's identity. This removes an important protection against DNS spoofing, network interception, and impersonation of the tunnel service. Opening an SSH reverse tunnel is consistent with the declared functionality. Disabling server authentication, however, is not required to provide that functionality and exceeds a safe minimum-trust configuration. ### Attack Path 1. The operator launches the Skill on a hostile or compromised network. 2. An attacker redirects or intercepts the connection intended for `localhost.run`. 3. The attacker presents an arbitrary SSH host key. 4. Because strict checking is disabled, the client accepts the impersonated endpoint. 5. The reverse tunnel is established through attacker-controlled infrastructure, exposing the local payment service and its traffic to that infrastructure. ### Impact Assessment A network-positioned attacker may impersonate the tunnel endpoint and gain visibility into or control over the public forwarding path to the local Express service. This weakens confidentiality and integrity around payment-page traffic and increases exposure of all publicly reachable endpoints. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `StrictHostKeyChecking=no`. - Pin localhost.run's verified host key in a Skill-specific `known_hosts` file. - Invoke SSH with `StrictHostKeyChecking=yes` and an explicit `UserKnownHostsFile`. - Fail closed when the host key is unknown or changes. - Document how operators can verify and rotate the pinned key through an authenticated channel. - Consider a tunnel mechanism with explicit service authentication and narrowly scoped credentials. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:266
Finding
Documentation Recommends Creating an Unencrypted Account-Wide Default SSH Key<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:266-270`; duplicate guidance at `README.md:266-268` **Vulnerability Type**: Unsafe SSH credential creation and excessive filesystem scope **Risk Level**: Medium ### Vulnerable Content ```markdown ### "Permission denied (publickey)" (localhost.run) Run: `ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa -N ""` ``` The README contains equivalent guidance: ```markdown | "Permission denied" (SSH) | Run `ssh-keygen -t rsa -f ~/.ssh/id_rsa -N ""` | ``` ### Technical Analysis The command creates or attempts to replace the user's account-wide default RSA identity at `~/.ssh/id_rsa` and assigns it an empty passphrase. A tunnel-specific identity may be appropriate, but modifying the default SSH identity is broader than necessary for the Skill's payment-page functionality. The default path may already be used for unrelated systems. An unencrypted private key is immediately usable after theft, and later reuse or authorization of this key can extend the consequences beyond the Skill. ### Attack Path 1. A user encounters the documented tunnel authentication error. 2. The user executes the recommended command. 3. A persistent, unencrypted private key is created at the default SSH identity path, or the user is prompted regarding an existing key. 4. The same key may later be authorized for unrelated hosts or services. 5. Malware, another local user, an unsafe backup, or filesystem disclosure obtains the key and uses it without needing a passphrase. ### Impact Assessment The instruction can endanger unrelated SSH access and creates a persistent credential outside the project directory. If stolen and subsequently trusted elsewhere, the key could enable unauthorized access to other systems under the user's identity. The Skill itself does not automatically run `ssh-keygen`, but its operational instructions encourage unsafe privilege scope. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Use a Skill-specific key path, such as `~/.ssh/near-getpay_localhost_run`. - Check for an existing file and never overwrite a key automatically. - Prefer a modern key type, such as Ed25519, if supported by the tunnel provider. - Protect the key with a passphrase where unattended operation is not required. - Select the dedicated key explicitly with `ssh -i`. - Enforce restrictive file permissions and document how to revoke and remove the key. - Explain whether localhost.run actually requires a persistent client identity before asking users to create one. ]]>

T09 · Insecure Skill Coding Practices

Warning
Location
SKILL.md:158
Finding
Skill Instructions Encourage Disclosure of the Payment API Key in Agent Chat<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:158-166` **Vulnerability Type**: Sensitive credential exposure through conversation history **Risk Level**: Medium ### Vulnerable Content ```text 3. Get an API key from Dashboard → API Keys 4. Share it with me (or add to .env yourself) Let me know when you have the API key! User: Got it: sk_test_abc123... Agent: Perfect! Starting your payment server... ``` ### Technical Analysis The instructions explicitly invite the user to place a payment-provider API key into an agent conversation. Conversation content may be retained in transcripts, telemetry, logs, memory systems, debugging data, or third-party integrations. Direct local secret configuration is sufficient, so disclosure to the agent does not satisfy a minimum-privilege requirement. The implementation loads the key from `.env`; it does not need the key to appear in natural-language chat. ### Attack Path 1. The user follows the example and posts the PingPay API key in the conversation. 2. The credential becomes part of agent context and potentially persistent transcripts, logs, or telemetry. 3. A party with access to those records retrieves the key. 4. The key is used directly against PingPay according to the privileges assigned to it. ### Impact Assessment Exposure may permit unauthorized checkout creation or any other PingPay operation allowed by the credential. The exact scope depends on provider-side key permissions. Even if the key is test-only, the pattern teaches unsafe handling that may later be used with production credentials. ]]>
Remediation
<![CDATA[ ## Remediation Suggestions - Remove all instructions asking users to share API keys in chat. - Instruct users to enter the key directly into a protected local secret store or `.env` file. - Recommend restrictive permissions for secret files and exclude them from version control, backups, and diagnostic output. - Prefer scoped, revocable provider credentials. - Warn users not to paste secrets into conversations, issue reports, screenshots, or logs. - Rotate any credential that has already been disclosed through chat. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
scripts/payment-orchestrator.ts:58
Finding
Invoice Payment Flow Reuses the USDC Invoice Amount as the Source-Token Quantity<![CDATA[ ## Vulnerability Details **File Location**: `scripts/payment-orchestrator.ts:58-76`, with transaction execution at `index.ts:54-73` **Vulnerability Type**: Incorrect cryptocurrency amount calculation **Risk Level**: High ### Vulnerable Code ```typescript const usdcAmount = new Decimal(invoice.amount); console.log(`💰 Invoice amount: ${usdcAmount.toString()} USDC`); // Step 2: Execute NEAR intent (swap + bridge) const intentResult = await nearIntentsExecutor({ fromToken: sourceToken, toToken: 'USDC', amount: usdcAmount.toString(), fromChain: 'NEAR', toChain: 'Base', toAddress: invoice.recipient_address }); ``` The executor interprets that value as the source-token amount: ```typescript const swapResult = await executeIntent({ operation: 'swap', fromToken: intentParams.fromToken, toToken: 'USDC', amount: intentParams.amount, chain: 'NEAR', nearAccount: params.nearAccount }); const bridgeResult = await executeIntent({ operation: 'withdraw', token: 'USDC', amount: intentParams.amount, fromChain: 'NEAR', toChain: 'Base', toAddress: intentParams.toAddress, nearAccount: params.nearAccount }); ``` ### Technical Analysis The invoice amount is denominated in USDC, but the same numeric value is passed to a swap whose input is `sourceToken`. No conversion based on market price, decimals, fees, or a provider quote is performed. For example, a 10-USDC invoice paid from NEAR results in a request to swap 10 NEAR rather than the quantity of NEAR required to obtain 10 USDC. The project contains a separate `calculateRequiredAmount` helper, but this payment path does not use it. The code also bridges the original invoice number rather than the actual swap output. ### Attack Path 1. A user chooses a source token whose unit price differs from one USDC. 2. The Skill retrieves an invoice amount, such as `10 USDC`. 3. The Skill requests a swap of `10` units of the source token. 4. The wallet or intent implementation signs and ex ...[truncated 545 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Obtain a validated swap quote that specifies the required source-token quantity and expected USDC output. - Correctly account for token decimals, fees, price impact, and bounded slippage. - Set a strict maximum source-token spend. - Display the exact source amount, expected output, recipient, fees, and slippage to the user before requesting wallet approval. - Require explicit confirmation immediately before execution. - Bridge the verified actual swap output rather than the invoice's original numeric value. - Abort if the final received amount cannot satisfy the invoice without exceeding the approved maximum. - Add tests covering tokens with prices above and below one US dollar. ]]>

T09 · Insecure Skill Coding Practices

Error
Location
index.ts:41
Finding
Caller-Controlled Module Path Can Execute Arbitrary Accessible Local Modules<![CDATA[ ## Vulnerability Details **File Location**: `index.ts:10-16`, `index.ts:41-43` **Vulnerability Type**: Unsafe dynamic module loading **Risk Level**: High ### Vulnerable Code ```typescript export interface PayInvoiceParams { invoiceId: string; nearAccount: string; sourceToken?: string; // Default: "NEAR" nearIntentsSkillPath?: string; // Path to near-intents skill } ``` ```typescript // Import NEAR Intents skill const nearIntentsPath = params.nearIntentsSkillPath || '../near-intents'; const { executeIntent } = await import(nearIntentsPath); ``` ### Technical Analysis The exported `payInvoice` API permits its caller to choose the module specifier passed to dynamic `import()`. Importing a JavaScript module executes its top-level initialization code. If an untrusted caller can influence `nearIntentsSkillPath` and can reference a malicious or otherwise dangerous module accessible to the process, this becomes code execution with the Skill process's privileges. The default path is fixed, and no public HTTP route was found that directly exposes this parameter. Exploitation therefore depends on a host application passing untrusted input to the exported function or on an attacker being able to place a module at a reachable path. ### Attack Path 1. A host application exposes `payInvoice` parameters to an untrusted caller or insufficiently validates integration input. 2. The attacker supplies a path or module specifier referencing attacker-controlled code. 3. `await import(nearIntentsPath)` resolves and loads that module. 4. The module's top-level code executes before `executeIntent` is invoked. 5. The malicious module accesses environment variables, files, network resources, or transaction capabilities available to the Skill process. ### Impact Assessment Successful exploitation provides code execution with the permissions of the Node.js process. This may include access to `PINGPAY_API_KEY`, local Skill files, other environment secrets, and any ...[truncated 174 chars]
Remediation
<![CDATA[ ## Remediation Suggestions - Remove `nearIntentsSkillPath` from caller-controlled parameters. - Import a fixed, reviewed dependency using a static module specifier. - If multiple implementations are required, expose an allowlisted identifier and map it internally to fixed module paths. - Resolve the candidate path and verify that it remains inside a trusted directory. - Reject URL-based, package-name, parent-directory, and absolute-path specifiers unless explicitly required and trusted. - Run transaction integrations in a process with minimal environment secrets and filesystem permissions. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Privilege EscalationExcessive Permissions, Sudo/Root Execution, Credential Access
  • Supply ChainUnpinned Dependencies, External Script Fetching, Obfuscated Code
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
  • Prompt InjectionInstruction Override, Hidden Instructions, Exfiltration Commands
Findings (64)

Credential Access

High
Category
Privilege Escalation
Content
1. Sign up at [pingpay.io](https://pingpay.io)
2. Set your NEAR wallet in Dashboard → Settings
3. Get API key from Dashboard → Settings → API Keys
4. Add to `.env`:

```env
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
1. Sign up at [pingpay.io](https://pingpay.io)
2. Set your NEAR wallet in Dashboard → Settings
3. Get API key from Dashboard → Settings → API Keys
4. Add to `.env`:

```env
Confidence
70% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Ssd 3

High
Confidence
99% confidence
Finding
The example conversation has the agent solicit a live API key and then accept it directly in chat, normalizing insecure secret-handling behavior. In the context of an agent skill, this is particularly dangerous because users may trust the workflow and expose production credentials that can be retained in history, analytics, or debugging logs.

Missing User Warnings

High
Confidence
98% confidence
Finding
The README explicitly encourages the user to paste a live API key into the chat, but provides no warning that chat transcripts may be stored, logged, or visible to other systems. This creates a direct path for credential disclosure to the agent platform and any downstream logging or monitoring infrastructure.

Credential Access

High
Category
Privilege Escalation
Content
| Issue | Solution |
|-------|----------|
| "No provider configured" | Visit `/setup` page for instructions |
| "Permission denied" (SSH) | Run `ssh-keygen -t rsa -f ~/.ssh/id_rsa -N ""` |
| "Tunnel closed" | Restart server (localhost.run has timeouts) |
| "Token not configured" | Create payment link for that token in HOT PAY |
| Provider errors | Verify API key / item_ids are correct |
Confidence
90% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The declared purpose omits the fact that the skill starts server and tunneling processes, which is a material operational and security behavior. This mismatch is more dangerous in context because the skill targets payment handling, where hidden internet exposure can lead to abuse, phishing, unwanted traffic, or compromise of adjacent local services.

Tp4

High
Category
MCP Tool Poisoning
Confidence
96% confidence
Finding
The declared purpose omits the fact that the skill starts server and tunneling processes, which is a material operational and security behavior. This mismatch is more dangerous in context because the skill targets payment handling, where hidden internet exposure can lead to abuse, phishing, unwanted traffic, or compromise of adjacent local services.

Tp4

High
Category
MCP Tool Poisoning
Confidence
95% confidence
Finding
The declared purpose omits the fact that the skill starts server and tunneling processes, which is a material operational and security behavior. This mismatch is more dangerous in context because the skill targets payment handling, where hidden internet exposure can lead to abuse, phishing, unwanted traffic, or compromise of adjacent local services.

Tp4

High
Category
MCP Tool Poisoning
Confidence
97% confidence
Finding
The declared purpose omits the fact that the skill starts server and tunneling processes, which is a material operational and security behavior. This mismatch is more dangerous in context because the skill targets payment handling, where hidden internet exposure can lead to abuse, phishing, unwanted traffic, or compromise of adjacent local services.

Tp4

High
Category
MCP Tool Poisoning
Confidence
89% confidence
Finding
The declared purpose omits the fact that the skill starts server and tunneling processes, which is a material operational and security behavior. This mismatch is more dangerous in context because the skill targets payment handling, where hidden internet exposure can lead to abuse, phishing, unwanted traffic, or compromise of adjacent local services.

Credential Access

High
Category
Privilege Escalation
Content
Copy `.env.example` to `.env`:

```bash
cp .env.example .env
```

Edit `.env`:
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
Copy `.env.example` to `.env`:

```bash
cp .env.example .env
```

Edit `.env`:
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
Copy `.env.example` to `.env`:

```bash
cp .env.example .env
```

Edit `.env`:
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
Copy `.env.example` to `.env`:

```bash
cp .env.example .env
```

Edit `.env`:
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
1. Sign up at https://pingpay.io
2. Add your NEAR wallet address in settings
3. Get an API key from Dashboard → API Keys
4. Share it with me (or add to .env yourself)

Let me know when you have the API key!
Confidence
96% confidence
Finding
This line explicitly asks the user to share an API key with the agent, which is credential solicitation. In a payment-processing context, exposing API keys can allow unauthorized invoice creation, account abuse, and potential redirection or monitoring of payment activity.

Ae1

High
Category
analysis-evasion
Content
Edit preset amounts in `server-simple.ts`:
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Ae1

High
Category
analysis-evasion
Content
Edit preset amounts in `server-simple.ts`:
Confidence
100% confidence
Finding
Referenced artifact was not completely inspected

Credential Access

High
Category
Privilege Escalation
Content
### "Permission denied (publickey)" (localhost.run)

Run: `ssh-keygen -t rsa -b 2048 -f ~/.ssh/id_rsa -N ""`

### "Tunnel closed"
Confidence
90% confidence
Finding
The troubleshooting step instructs generating an SSH key at the default private-key path `~/.ssh/id_rsa`, which touches credential material and may overwrite or conflict with an existing identity if followed carelessly. While not overtly malicious, encouraging key creation for a payment skill's tunneling setup increases credential-handling risk and may cause users to expose or misuse SSH identities.

Known Vulnerable Dependency: axios==1.13.5 — 16 advisory(ies): CVE-2026-44494 (axios Vulnerable to Full Man-in-the-Middle via Prototype Pollution Gadget in `co); CVE-2026-44495 (axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollut); CVE-2025-62718 (Axios has a NO_PROXY Hostname Normalization Bypass that Leads to SSRF) +13 more

High
Category
Supply Chain
Confidence
95% confidence
Finding
The lockfile pins axios 1.13.5, and the referenced advisories include SSRF-related proxy bypasses and prototype-pollution-driven request/response manipulation risks. In a payment-processing skill that likely makes outbound API calls to PingPay, HOT PAY, or blockchain services, HTTP client flaws are especially relevant because they can expose credentials, redirect requests, or let attacker-controlled inputs influence backend network access.

Known Vulnerable Dependency: form-data==4.0.5 — 1 advisory(ies): CVE-2026-12143 (form-data: CRLF injection in form-data via unescaped multipart field names and f)

High
Category
Supply Chain
Confidence
88% confidence
Finding
form-data 4.0.5 is flagged for CRLF injection via unescaped multipart field names or filenames. If this skill ever forwards user-supplied files or metadata to payment or support backends, an attacker may be able to manipulate multipart boundaries or injected headers, potentially altering server-side interpretation of requests or smuggling unintended content.

Known Vulnerable Dependency: axios==0.21.4 — 16 advisory(ies): CVE-2026-44495 (axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollut); CVE-2025-62718 (Axios has a NO_PROXY Hostname Normalization Bypass that Leads to SSRF); CVE-2026-25639 (Axios is Vulnerable to Denial of Service via __proto__ Key in mergeConfig) +13 more

High
Category
Supply Chain
Confidence
98% confidence
Finding
The bundled localtunnel dependency pulls in axios 0.21.4, a much older version with multiple high-severity advisories including SSRF, prototype pollution, and denial-of-service issues. This is particularly concerning because localtunnel exposes local services to the internet, increasing attack surface and making any HTTP client weakness in that component more dangerous in a payment-related environment.

Known Vulnerable Dependency: path-to-regexp==0.1.12 — 1 advisory(ies): CVE-2024-45296 (path-to-regexp vulnerable to Regular Expression Denial of Service via multiple r)

High
Category
Supply Chain
Confidence
91% confidence
Finding
path-to-regexp 0.1.12 is flagged for ReDoS, and Express routing depends on it. In an externally reachable payment page or webhook handler, crafted paths can potentially trigger excessive backtracking and tie up the Node.js event loop, causing degraded service or temporary outage.

Known Vulnerable Dependency: axios==1.13.5 — 16 advisory(ies): CVE-2026-44494 (axios Vulnerable to Full Man-in-the-Middle via Prototype Pollution Gadget in `co); CVE-2026-44495 (axios Vulnerable to Credential Theft and Response Hijacking via Prototype Pollut); CVE-2025-62718 (Axios has a NO_PROXY Hostname Normalization Bypass that Leads to SSRF) +13 more

High
Category
Supply Chain
Confidence
95% confidence
Finding
The manifest permits installation of an axios version identified by the scanner as having multiple high-severity advisories, including SSRF-related and request-handling issues. In a payment-processing skill that likely makes outbound HTTP requests to payment providers and may handle secrets or callbacks, a vulnerable HTTP client materially increases the risk of request forgery, credential leakage, response tampering, or other compromise paths.

Credential Access

High
Category
Privilege Escalation
Content
import * as dotenv from 'dotenv';
import * as path from 'path';

dotenv.config({ path: path.join(__dirname, '.env') });

const app = express();
const PORT = process.env.PORT || 3000;
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
import * as dotenv from 'dotenv';
import * as path from 'path';

dotenv.config({ path: path.join(__dirname, '.env') });

const app = express();
const PORT = process.env.PORT || 3000;
Confidence
60% confidence
Finding
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.

Static analysis

Detected: suspicious.dangerous_exec, suspicious.env_credential_access

Shell command execution detected (child_process).

Critical
Code
suspicious.dangerous_exec
Location
start-tunnel.ts:15

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
server-simple.ts:9

Environment variable access combined with network send.

Critical
Code
suspicious.env_credential_access
Location
server.ts:9