T05 · Unauthorized Access and Privilege Escalation
- Location
scripts/summarize.py:170- Finding
Authenticated Browser Requests Are Made with TLS Certificate Verification Disabled
- Content
View full analysis
- Remediation
View remediation
Security audit
Security checks for vulnerabilities and agentic risk
The skill is a real video summarizer, but it automatically uses sensitive browser cookies and sends transcripts to external LLM services in ways users should review carefully.
Review this skill before installing. It is suitable only if you are comfortable with video transcripts and metadata being sent to configured or fallback LLM providers, and with Bilibili mode reading Chrome browser cookies. Avoid using it on private, licensed, internal, or account-restricted videos unless you first disable external fallback behavior and browser-cookie use, and prefer pinned dependencies plus a private temporary work directory.
scripts/summarize.py:170Authenticated Browser Requests Are Made with TLS Certificate Verification Disabled
scripts/summarize.py:552Video Transcripts Are Automatically Disclosed to an Anonymous Third-Party LLM
setup.sh:40Setup Installs Unpinned Third-Party Dependencies Without Integrity Verification
scripts/summarize.py:153Predictable Shared Temporary Files Permit Symlink Overwrites and Persistent Data Exposure
External input (network, user) flows to a code execution sink. This enables remote code execution or command injection.
url = f"https://www.youtube.com/@{channel_id}/videos"
try:
result = subprocess.run(
[
"yt-dlp",
"--flat-playlist",
Credentials or environment variables flow to a network sink. This is a high-confidence indicator of credential exfiltration.
def get_copilot_session_token(gh_token: str) -> Optional[str]:
try:
import requests
r = requests.get(
"https://api.github.com/copilot_internal/v2/token",
headers={
"Authorization": f"token {gh_token}",
The skill sends full prompts containing video transcript content to an API endpoint controlled by environment variables, and can attach bearer credentials to that request. In an agent environment, this creates a data-exfiltration path where sensitive transcript content and API keys may be transmitted to an arbitrary external service without explicit validation or user confirmation.
}
if api_key:
headers["Authorization"] = f"Bearer {api_key}"
response = requests.post(
api_url,
headers=headers,
json={
The skill also performs frame extraction, image insertion, AI-based frame selection, and persistent local configuration writes that are not clearly captured by the summary-focused description. While not inherently malicious, these extra behaviors increase data processing scope and storage footprint beyond what a user may reasonably infer.
The skill also performs frame extraction, image insertion, AI-based frame selection, and persistent local configuration writes that are not clearly captured by the summary-focused description. While not inherently malicious, these extra behaviors increase data processing scope and storage footprint beyond what a user may reasonably infer.
Accessing browser cookies from Chrome is behavior commonly associated with credential harvesting because it reads sensitive authentication material from the user's browser profile. Although the apparent goal is to bypass Bilibili restrictions for downloading, in a skill context this is still dangerous because it reaches into unrelated credentials and session state.
.path.join(output_dir, f"bili_{video_id}_audio.mp3")
frames_dir = os.path.join(output_dir, f"bili_{video_id}_frames")
transcript_path = os.path.join(output_dir, f"bili_{video_id}_transcript.txt")
print(f"🎬 Bilibili: {video_id}", file=sys.stderr)
# Step 1: Download video
print(" 📥 Downloading video...", file=sys.stderr)
download_cmd = [
"yt-dlp",
"--cookies-from-browser", "chrome",
"--no-check-certificates",
"-f", "bestvideo[height<=720]+bestaudio/best[height<=720]",
"--merge-output-format", "mp4",
"-o", video_path,
url,
]
subprocess.run(download_cmd, check=True, timeout=300)
# Step 2: Extract audio
print(" 🎵 Extracting audio...", file=sys.stderr)
subprocess.run([
"ffmpeg", "-y", "-i", video_path,
"-vn", "-acodec", "libmp3lame", "-q:a", "2",
audio_path,
], check=True, timeout=120, capture_output=True)
# Step 3: Whisper transcription
print
The use of --no-check-certificates disables TLS certificate verification during video download, making the tool susceptible to man-in-the-middle interception or content tampering. That weakens transport security precisely when downloading untrusted remote media and potentially authenticated resources.
download_cmd = [
"yt-dlp",
"--cookies-from-browser", "chrome",
"--no-check-certificates",
"-f", "bestvideo[height<=720]+bestaudio/best[height<=720]",
"--merge-output-format", "mp4",
"-o", video_path,
The summarization flow transmits transcript content to external LLM providers, including fallback to anonymous and environment-configured services, without a clear warning that user data is leaving the local environment. Transcripts may contain proprietary, personal, or sensitive content, so silent transmission meaningfully increases privacy and compliance risk.
The manifest description says the skill handles both YouTube and Bilibili video transcript extraction and summarization. However, the README explicitly states '此 Skill 仅支持 YouTube' ('this skill only supports YouTube'), which is a direct mismatch in declared behavior and supported platforms.
The README states that extracted transcripts and content may be sent automatically to multiple third-party LLM endpoints, including anonymous/free services, without an explicit warning about data disclosure. In a summarization skill, users may paste or process sensitive, copyrighted, or private material, so silent transmission can lead to confidentiality, compliance, or policy violations.
The skill advertises significant capabilities—shell execution, network access, filesystem reads/writes, and environment-variable use—without declaring an explicit tool scope or permission boundary. That makes review and runtime governance harder, and increases the chance an agent invokes the skill with broader access than users expect.
The skill contains substantial end-user instructions in Chinese, but it does not indicate that language is selectable or that the skill is intentionally limited to Chinese-speaking users. This can violate a language/locale policy when a skill implicitly forces one language without user opt-in.
The documentation notes Chrome cookies are used to bypass Bilibili anti-scraping, but does not present this as a clear security/privacy warning. Reading browser cookies can expose authenticated session material and may surprise users who did not intend to grant access to local browser state.
The Bilibili download path invokes yt-dlp with --cookies-from-browser chrome, which accesses locally stored browser session cookies without an explicit warning or consent step. In a skill ecosystem, reading browser cookies is highly sensitive because it touches authentication material unrelated to the stated summarization task and can expose account-bound data or session secrets.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
"-o", video_path,
url,
]
subprocess.run(download_cmd, check=True, timeout=300)
# Step 2: Extract audio
print(" 🎵 Extracting audio...", file=sys.stderr)
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
# Step 2: Extract audio
print(" 🎵 Extracting audio...", file=sys.stderr)
subprocess.run([
"ffmpeg", "-y", "-i", video_path,
"-vn", "-acodec", "libmp3lame", "-q:a", "2",
audio_path,
The Whisper transcription call forces language="zh", which constrains processing to Chinese regardless of the actual audio language or user preference. This is a natural-language locale policy issue because the file does not offer language selection or explain a justified region-specific limitation.
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
if not skip_frames:
print(f" 🖼️ Extracting keyframes (every {frame_interval}s)...", file=sys.stderr)
os.makedirs(frames_dir, exist_ok=True)
subprocess.run([
"ffmpeg", "-y", "-i", video_path,
"-vf", f"fps=1/{frame_interval}", "-q:v", "2",
os.path.join(frames_dir, "frame_%03d.jpg"),
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
url = f"https://www.youtube.com/@{channel_id}/videos"
try:
result = subprocess.run(
[
"yt-dlp",
"--flat-playlist",
subprocess module calls execute external commands. Without careful input validation, this enables command injection.
def get_video_details(video_id: str) -> Optional[Dict]:
"""Get detailed video metadata using yt-dlp"""
try:
result = subprocess.run(
[
"yt-dlp",
"--no-warnings",
Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.
def _download_caption(url: str) -> Optional[str]:
try:
import requests
r = requests.get(url, timeout=15)
if r.status_code == 200 and r.text.strip():
return r.text
except Exception:
This request exchanges a locally available GitHub token for a Copilot session token, extending use of ambient credentials to a third-party service. While the destination is GitHub rather than an arbitrary host, silently consuming developer tokens in a summarization skill expands credential exposure and may surprise users.
try:
import requests
r = requests.get(
"https://api.github.com/copilot_internal/v2/token",
headers={
"Authorization": f"token {gh_token}",
"Editor-Version": "vscode/1.95.0",
This external POST sends the summarization prompt, which includes transcript text, to a remote API and may include authorization credentials. Because the endpoint can be environment-controlled and multiple fallback services are tried automatically, the skill creates a significant outbound data channel beyond what a user may reasonably expect.
}
if api_key:
headers["Authorization"] = f"Bearer {api_key}"
response = requests.post(
api_url,
headers=headers,
json={
The skill harvests multiple environment-provided credentials and uses them to obtain third-party model access beyond simple local processing. In an agent context, this broadens the trust boundary substantially and may cause unintended use of ambient credentials, especially when users invoke the skill expecting only transcript extraction and summarization.
This call sends user-derived transcript content to the GitHub Copilot chat completions API after obtaining a session token, creating external disclosure of processed content. In the context of a summarizer skill, this is sensitive because remote transmission is automatic and tied to ambient credentials rather than explicit user authorization.
if copilot_token:
copilot_model = os.environ.get("LLM_MODEL", "claude-haiku-4.5")
result = _call_llm(
"https://api.githubcopilot.com/chat/completions",
copilot_token,
copilot_model,
prompt