Back to skill

Security audit

salute speech

Security checks for vulnerabilities and agentic risk

Overview

The skill mostly matches its transcription purpose, but it sends API credentials and audio to Sber with SSL certificate checks disabled by default.

Review before installing. Use only with media you are allowed to send to Sber's service, protect SALUTE_AUTH_DATA, prefer a version that enables SSL verification or supports a trusted CA bundle, and treat the saved JSON/transcript files as sensitive content.

Vulnerability Patterns
  • 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
  • Remote Payload Retrieval and ExecutionFetches external code whose behavior can change after review
Findings (2)

T09 · Insecure Skill Coding Practices

Error
Location
salute_transcribe.py:29
Finding
TLS Certificate Verification Disabled for Sensitive API Traffic<![CDATA[ ## Vulnerability Details **File Location**: `salute_transcribe.py:29-35, 89-91, 140-145, 219-224, 265-270, 346-351`; documented in `SKILL.md:16` **Vulnerability Type**: Improper certificate validation **Risk Level**: High ### Vulnerable Code ```python def __init__( self, auth_data: str | tuple[str, str], scope: str = "SALUTE_SPEECH_PERS", verify_ssl=False ): ``` The insecure setting is passed to all API operations, including authentication and audio upload: ```python response = requests.post( self.oauth_url, headers=headers, data=data, verify=self.verify_ssl ) ``` ```python with open(audio_file_path, "rb") as audio_file: response = requests.post( self.upload_url, headers=headers, data=audio_file, verify=self.verify_ssl, ) ``` It is also used for recognition-task creation, status polling, and result download: ```python response = requests.post( self.recognize_url, headers=headers, json=payload, verify=self.verify_ssl, ) ``` ```python response = requests.get( self.task_status_url, headers=headers, params=params, verify=self.verify_ssl, ) ``` ```python response = requests.get( self.download_url, headers=headers, params=params, verify=self.verify_ssl, ) ``` ### Technical Analysis The client defaults `verify_ssl` to `False`, disabling server certificate and hostname validation for every HTTPS request. The script additionally suppresses the resulting `InsecureRequestWarning`. Encryption without peer authentication does not protect against an active man-in-the-middle attacker. A forged certificate will be accepted, allowing an attacker in a privileged network position to impersonate the configured Sber endpoints. The affected traffic includes: - The Base64-encoded Basic authorization credential used to request an access token - The resulting bearer access token - User-selected audio or video content - Recognition configuration and task ide ...[truncated 2184 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Enable certificate verification by default: ```python def __init__( self, auth_data: str | tuple[str, str], scope: str = "SALUTE_SPEECH_PERS", verify_ssl: bool | str = True, ): ``` 2. If the provider requires a nonstandard certificate authority, obtain the official CA certificate through a trusted channel and pass its local path to Requests: ```python client = SaluteSpeechClient( auth_data=AUTH_DATA, verify_ssl="/path/to/trusted-sber-ca-bundle.pem", ) ``` 3. Do not suppress `InsecureRequestWarning` globally. Certificate failures should stop execution and produce a clear error. 4. Do not offer an insecure mode as the default. If an emergency override is retained, require an explicit command-line option with a prominent warning and avoid its use in automated workflows. 5. Validate that all configured service URLs use HTTPS and remain restricted to the documented provider hosts. 6. Rotate `SALUTE_AUTH_DATA` if the script has previously been used over an untrusted network while certificate verification was disabled. 7. Update `SKILL.md` to document installation of the trusted CA bundle instead of recommending disabled verification. ]]>

T08 · Insecure Dependencies

Warning
Location
SKILL.md:43
Finding
Unpinned Dependency Resolved and Installed at Runtime<![CDATA[ ## Vulnerability Details **File Location**: `SKILL.md:43` **Vulnerability Type**: Unpinned runtime dependency and supply-chain exposure **Risk Level**: Medium ### Vulnerable Code ```bash uv run --with requests {baseDir}/salute_transcribe.py \ --file /path/to/audio.mp3 \ --output_dir ~/.openclaw/workspace/transcriptions \ --lang ru-RU ``` ### Technical Analysis The documented execution command asks `uv` to resolve `requests` dynamically without specifying an audited version, lockfile, or artifact hash. Consequently, the dependency graph can change between executions even when the Skill source remains unchanged. This is not evidence that the legitimate `requests` package is malicious. The risk arises because runtime resolution makes execution dependent on mutable package-index state and the configured package source. A compromised registry, account, mirror, DNS path, or package-index configuration could supply malicious or unexpectedly changed package code. Because the script imports `requests` immediately, a malicious resolved package can execute Python code in the Skill's process. That process has access to the environment containing `SALUTE_AUTH_DATA`, the user-selected audio file, local output directories, and the current user's operating-system permissions. ### Attack Path 1. An attacker compromises or controls the package source, configured index, mirror, dependency resolution path, or an upstream release. 2. The victim executes the documented `uv run --with requests` command. 3. `uv` resolves and obtains an uncontrolled version of `requests` or one of its transitive dependencies. 4. The script executes `import requests`. 5. Malicious package initialization code runs in the same process and security context as the transcription script. 6. That code could read `SALUTE_AUTH_DATA`, inspect accessible files, modify transcription output, or initiate arbitrary network requests using the current user's permissions. This exploitation path de ...[truncated 685 chars]
Remediation
<![CDATA[ ## Remediation Suggestions 1. Declare dependencies in a project configuration and generate a reviewed `uv.lock` file. 2. Pin an audited `requests` version and its transitive dependency versions. 3. Execute with locked resolution so unexpected dependency changes fail rather than being accepted: ```bash uv run --locked salute_transcribe.py \ --file /path/to/audio.mp3 \ --output_dir ~/.openclaw/workspace/transcriptions \ --lang ru-RU ``` 4. Configure only trusted package indexes and require HTTPS with valid certificate verification. 5. Where supported by the deployment workflow, verify downloaded artifacts with hashes and retain the lockfile in version control. 6. Use automated dependency scanning and controlled update reviews before changing pinned versions. 7. Avoid exposing unrelated secrets or files to the process; provide only `SALUTE_AUTH_DATA` and file access needed for the selected transcription operation. ]]>
Vulnerability Patterns
  • Data ExfiltrationExternal Transmission, Env Variable Harvesting, File System Enumeration
  • Excessive AgencyUnrestricted Tool Access, Autonomous Decision Making, Scope Creep
  • Tool MisuseTool Parameter Abuse, Chaining Abuse, Unsafe Defaults
  • MCP Least PrivilegeUnderdeclared Capability, Wildcard Permission, Missing Permission Declaration
  • MCP Tool PoisoningHidden Instructions, Unicode Deception, Parameter Description Injection
Findings (13)

Lp3

Medium
Category
MCP Least Privilege
Confidence
93% confidence
Finding
The skill performs sensitive actions—reading credentials from the environment, writing files, and sending data over the network—but does not declare any explicit tool scope or permission boundaries. This increases the chance of overbroad execution in agent environments and makes the skill's actual capabilities less transparent to reviewers and users.

Missing User Warnings

Medium
Confidence
96% confidence
Finding
The skill description says it transcribes files via an async REST API but does not clearly warn that user audio/video content is uploaded to a third-party service. Users may unknowingly send sensitive conversations, personal data, or regulated content off-host, creating privacy, compliance, and data handling risks.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
## Requirements

- **API Key**: Environment variable `SALUTE_AUTH_DATA` must be set (Base64-encoded `client_id:client_secret` or raw authorization key from https://developers.sber.ru/studio/).
- **SSL note**: The script disables SSL verification by default (`verify_ssl=False`) because Sber's certificate chain is non-standard. This is expected.

## Supported formats & encodings
Confidence
99% confidence
Finding
Disabling SSL certificate verification by default removes server identity validation for the API connection. An attacker positioned on the network could intercept credentials and uploaded audio, alter responses, or impersonate the transcription service, which is especially dangerous because the skill transmits authentication material and potentially sensitive recordings.

Missing User Warnings

Medium
Confidence
94% confidence
Finding
The skill stores raw JSON recognition output and formatted transcripts on disk, but the description does not warn that these files may contain sensitive speech content, timestamps, confidence data, and metadata. This can lead to inadvertent local data exposure, especially in shared workspaces or long-lived directories.

Ae4

Medium
Category
analysis-evasion
Confidence
80% confidence
Finding
Suspicious Unicode normalization or mixed-script content

Context-Inappropriate Capability

Medium
Confidence
99% confidence
Finding
SSL certificate verification is disabled by default for all outbound API requests, which enables man-in-the-middle attacks against token exchange, file upload, task polling, and result download. An attacker on the network path could intercept credentials, bearer tokens, audio content, or tamper with transcription responses.

Unsafe Defaults

Medium
Category
Tool Misuse
Content
self,
        auth_data: str | tuple[str, str],
        scope: str = "SALUTE_SPEECH_PERS",
        verify_ssl=False
    ):
        """
        Инициализация клиента
Confidence
99% confidence
Finding
An insecure default that disables certificate verification weakens all network interactions out of the box, even for users who do not realize they are operating in unsafe mode. In this skill, the context increases danger because bearer tokens, API credentials, and potentially sensitive audio/transcripts are all transmitted to remote services.

External Transmission

Medium
Category
Data Exfiltration
Content
]

        try:
            response = requests.post(
                self.recognize_url,
                headers=headers,
                json=payload,
Confidence
80% confidence
Finding
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.

Cloud Storage Exfiltration

Medium
Category
Data Exfiltration
Content
self.get_access_token()

            # Шаг 2: Загрузка файла
            request_file_id = self.upload_file(audio_file_path, content_type)

            # Шаг 3: Создание задания
            task_id = self.create_recognition_task(
Confidence
55% confidence
Finding
Data is uploaded to cloud storage (S3 / GCS / Azure Blob). This may be a legitimate backup or exfiltration to an external bucket. Manual review is recommended.

Missing User Warnings

Medium
Confidence
95% confidence
Finding
The tool uploads user-provided media to an external cloud transcription service without an explicit runtime warning or consent flow, creating a privacy and data-handling risk. In a transcription skill this behavior is expected, but it is still dangerous when users may process sensitive recordings without clear notice of network transmission and third-party processing.

Natural-Language Policy Violations

Low
Confidence
78% confidence
Finding
The file's natural-language interface and documentation strings are primarily in Russian, and the transcription language also defaults to ru-RU. While alternative recognition languages are supported, the user-facing messaging does not offer locale choice and may impose a specific language by default.

Description-Behavior Mismatch

Low
Confidence
82% confidence
Finding
The manifest describes an audio transcription skill, while the CLI description and --file help text explicitly claim support for audio/video files, and the program always saves JSON and text outputs locally. Local file output may be useful, but the broader advertised behavior goes beyond the manifest's narrower description of transcribing audio files.

Missing User Warnings

Low
Confidence
82% confidence
Finding
The code accesses the sensitive environment variable SALUTE_AUTH_DATA and uses it to authenticate against a remote API. While this is functionally necessary, there is no visible warning or documentation in this file telling users that they must supply and protect credentials for external service access.

Static analysis

No suspicious patterns detected.