file-storage-processing

Design secure file upload and object storage workflows with malware scanning.

4|Updated May 16, 2026
One-click install
npx skills add https://github.com/machenjie/rd-skills --skill file-storage-processing
Or copy as Structured Prompt for Agent
Please help me install this Agent Skill.
Skill: file-storage-processing
Source: https://github.com/machenjie/rd-skills/tree/main/src/foundation/capabilities/file-storage-processing
Command: npx skills add https://github.com/machenjie/rd-skills --skill file-storage-processing

SYSTEM DOCUMENTATION & REQUIREMENTS

💡 This Skill includes references (resource) components.

What problem does it solve?

It prevents unsafe file and object-storage flows that can lead to malware distribution, cross-tenant data leaks, corrupted downloads, and runaway storage costs.

Core Features & Use Cases

  • Secure file intake and validation: designs upload/download handling with streaming transfer, MIME allowlisting, magic-byte verification, and archive safety (no zip-slip, bounded entries, and decompression caps).
  • Malware scanning and quarantine states: ensures no content becomes referenceable until it passes scanning gates, with quarantine, lifecycle, and cleanup for failed transforms and expired artifacts.
  • Safe media processing and delivery controls: specifies sandboxed image/media transforms with hardened processing policies, metadata stripping (EXIF/GPS), and download headers (attachment disposition, nosniff, tenant-safe caching).
  • Use Case: Build a product workflow where users upload images or exports to object storage, scan them, transform them into safe derivatives, and serve them back with strict authorization and predictable retention.

Quick Start

Design a secure upload-to-processed pipeline for user files in your product by applying file intake validation, malware scanning gates, signed-URL scoping, sandboxed transforms, and lifecycle cleanup rules.

Frequently Asked Questions about file-storage-processing

High-intent search queries and answers about installing and using this skill.

FAQPage Schema
How do I securely handle file uploads to object storage and prevent malware distribution?

Secure file uploads require streaming transfers, MIME allowlisting, magic-byte verification, and malware scanning with quarantine-before-availability to prevent infected content from becoming referenceable. This approach also enforces archive-structure caps to stop decompression abuse and zip-slip attacks.

What is the best way to issue signed URLs for object storage downloads without causing cross-tenant data leaks?

Signed URLs for object storage downloads must be scoped with tenant-scoped authorization and strict download headers, including attachment disposition and nosniff directives, to prevent cross-tenant data exposure and ensure tenant-safe caching.

How does magic-byte verification work when validating user-generated content uploads?

Magic-byte verification validates user-generated content uploads by inspecting the file's underlying binary signature rather than trusting the declared MIME type, ensuring the actual file structure matches expectations before accepting the transfer.

Can I use sandboxed media processing to strip EXIF metadata and generate safe derivatives?

Sandboxed media processing applies hardened processing policies to generate safe derivatives while stripping metadata like EXIF and GPS data, ensuring transformed media is safe for delivery and preventing inadvertent exposure of sensitive location information.

How do I manage object storage lifecycle cleanup for expired artifacts and failed transforms?

Object storage lifecycle cleanup manages retention and automatically handles quarantine, deletion, and cleanup for failed transforms and expired artifacts, creating observability-ready state transitions from uploading through deletion to control runaway storage costs.

What are the limitations of relying solely on declared MIME type for content validation?

Relying solely on declared MIME type for content validation is unsafe because clients can spoof headers, requiring magic-byte enforcement to verify the actual binary structure and prevent malicious file masquerading during object storage intake.