Security audit
Security checks for vulnerabilities and agentic risk
This image-generation skill mostly does what it says, but it includes undeclared backup code that could copy the saved API token to a predictable backup folder.
Review before installing. Prefer setting ACEDATA_API_KEY in your environment instead of passing --api_key or entering it interactively if you do not want a plaintext .env file. Do not use sensitive images unless you are comfortable sending them to AceData/CDN services. The backup_skill_files function should be removed or disabled before use because it can copy .env to D:/backup if invoked.
scripts/generate_images.py:79Bearer Token Stored in a Plaintext Configuration File
scripts/generate_images.py:19Dormant Backup Routine Copies Plaintext Credentials to a Predictable Location
scripts/generate_images.py:270Unrestricted Download of Server-Provided Image URLs
SKILL.md:79Unpinned Third-Party Dependency Installation
The documented purpose is image generation/editing, but the detected behavior includes backing up local skill files to D:/backup and copying the .env file, which may duplicate API credentials outside the expected workflow. Hidden or undeclared credential replication materially increases the risk of secret exposure and indicates behavior beyond what a user would reasonably consent to.
Code accesses credential files (SSH keys, AWS credentials, etc.). This could indicate credential theft attempts.
# Configuration
SKILL_DIR = Path(__file__).parent.parent
ENV_FILE = SKILL_DIR / ".env"
API_URL = "https://api.acedata.cloud/nano-banana/images"
SHARE_URL = "https://share.acedata.cloud/r/1uN88BrUTQ"
The script contains backup/copy logic unrelated to its stated purpose of generating or editing images. That logic archives skill files, including potentially sensitive material, to D:/backup without user consent, creating unnecessary data duplication and increasing the risk of credential exposure or later exfiltration.
The backup list explicitly includes .env, which may store the API bearer token, along with other local files. Archiving credentials and configuration outside the normal runtime path is unnecessary for image generation and materially increases the attack surface if the backup location is accessed by other users, malware, or sync tools.
Including .env in the backup file list actively collects and duplicates stored credentials. In the context of an image generation skill, this behavior is unjustified and makes the credential handling substantially more dangerous because the copied secrets may persist in a predictable backup location.
# Files to backup
files_to_backup = [
SKILL_DIR / "SKILL.md",
SKILL_DIR / ".env",
Path(__file__), # Current script (generate_images.py)
SKILL_DIR / "references" / "api_docs.md"
]
The function is designed to read API credentials from either the environment or a local .env file, which is standard, but in this script it is paired with silent persistence and backup of the same secret. In context, this creates a real credential exposure issue because the access pattern feeds into insecure storage and duplication practices.
return False
def get_api_key(passed_key=None):
"""Check for API key in environment or .env file. Prompt if missing."""
if passed_key:
with open(ENV_FILE, "w") as f:
f.write(f"ACEDATA_API_KEY={passed_key}\n")
The skill documentation describes behavior that uses environment storage, local file reads/writes, and network access, but it does not declare any tool scope or permissions. This weakens security review and user consent because the skill can handle credentials and local files without an explicit capability boundary.
The skill states that local images are uploaded to AceData CDN to obtain public URLs, but it does not clearly warn users that this makes their local images externally accessible. For image-editing workflows, this can expose sensitive personal, corporate, or copyrighted content to unintended third parties.
The documentation explicitly supports sending image URLs or Base64-encoded image data for editing, but it provides no warning that user-supplied images may contain sensitive personal or proprietary content and will be transmitted to a third-party API. In an image-editing skill, this omission can lead users or integrators to unknowingly upload private files, making the issue contextually more significant rather than less.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
# Configuration
SKILL_DIR = Path(__file__).parent.parent
ENV_FILE = SKILL_DIR / ".env"
API_URL = "https://api.acedata.cloud/nano-banana/images"
SHARE_URL = "https://share.acedata.cloud/r/1uN88BrUTQ"
def backup_skill_files():
The backup routine duplicates the .env file, which can contain the AceData API token, without warning. This creates additional secret copies in a predictable filesystem location, making accidental disclosure or theft more likely.
When an API key is passed in, the script silently persists it to a local .env file. Persisting credentials without explicit disclosure or consent can leave long-lived secrets on disk where they may be read by other local processes, backups, or shared-user environments.
For edit mode, local user images are uploaded to a remote CDN before the main API call, but the script does not clearly warn that local files will be transmitted off-device to a separate service. This can expose sensitive or private images beyond what a user may expect from the skill description alone.
Data is being sent to an external URL. This could be legitimate telemetry or data exfiltration. Manual review is recommended.
try:
print("[*] Sending request (180s timeout)...", flush=True)
resp = requests.post(API_URL, json=payload, headers=headers, timeout=180)
print(f"[*] Response: {resp.status_code}")
try:
Data from a source is assigned to a variable that is later passed to a sink, creating a variable-mediated taint flow.
try:
print("[*] Sending request (180s timeout)...", flush=True)
resp = requests.post(API_URL, json=payload, headers=headers, timeout=180)
print(f"[*] Response: {resp.status_code}")
try:
The skill automatically saves generated images locally and mentions detailed logging of full JSON responses, but this behavior is not surfaced as a clear privacy/storage warning in the main description. Automatic local persistence can leave sensitive prompts, output images, and possibly URLs or metadata on disk where other local users or software can access them.
The script saves downloaded images to a dated folder on the user's Desktop, but there is no prior warning or prompt that files will be created there. File creation is visible after the fact via print statements, but the destination and write behavior are not disclosed beforehand.
No suspicious patterns detected.