Resources · 95

File uploads: validate before processing or publishing

Control format, resources, access and states from receipt to download.

· 8 min

Empty digital forensics bench with storage devices and precision tools AI-generated editorial illustration

What this guide helps achieve

  • Define needs and limits
  • Validate on the server
  • Isolate received files
  • Bound processing
  • Control release and removal
  • Remove derivatives and handle late processing

Quick check

  • Is a valid extension enough?
  • Is antivirus sufficient?
  • What should pending analysis show?
  • Is storage outside the public document root sufficient?

Step-by-step method

  1. 01

    Define needs and limits

    Allow only formats needed for the task. Specify size, dimensions, duration, page or file count as appropriate. Bound processing time and memory as well as transfer size.

    Output: Format and resource contract.

  2. 02

    Validate on the server

    Browser accept hints assist selection but do not secure receipt. Check extension, declared type and content using maintained tools. No single signal establishes file safety.

    Output: Server-validation tests.

  3. 03

    Isolate received files

    Assign server identifiers rather than constructing paths from user filenames. Keep files outside the public document root with restricted access. Show a pending state until checks finish.

    Output: Isolated storage and explicit states.

  4. 04

    Bound processing

    Scan, convert or reconstruct permitted formats with suitable limits and isolation. Do not send sensitive documents to a public scanner without an explicit data-sharing decision. Scanner failure does not imply approval.

    Output: Bounded processing and failure scenario.

  5. 05

    Control release and removal

    Check access rights on every read. Trace rejection, approval, publication and deletion. Test limits, interruption, corrupt files and recovery without exposing quarantined content.

    Output: Access and removal acceptance tests.

  6. 06

    Remove derivatives and handle late processing

    Tie originals, previews, converted versions and processing jobs to the same access decision. Define retention for rejected files, deletion rules and documented exceptions. Test removal while processing is active: a late output must not republish a withdrawn file. Distinguish removal from normal access and erasure under the storage policy.

    Deliverable: derivative inventory, removal rules and late-output test.

Receipt is not publication

Each step produces a distinct state. Failure leaves the file isolated.

  1. Receipt

    Server identifier, permissions and limits.

  2. Validation

    Format, content and resources checked.

  3. Decision

    Approved, rejected or still pending.

  4. Release

    Access checked; removal and deletion traceable.

Fictional example: the scanner is unavailable. The file stays pending and no public link is created.

Fictional acceptance-test scenarios

These proposed cases are not client observations. Adapt data, permissions and acceptance criteria to your authorised environment.

Situation to exerciseResult to checkEvidence to retain
A file has an allowed extension but incompatible content.Reject or isolate according to server checks; do not trust only the filename or client-declared type.Validation result and no unauthorised processing or publication.
A large file or archive exceeds limits after decompression.Apply defined quotas and processing limits, with an understandable rejection and released resources.Sizes, duration, triggered limit and processing cleanup.
Two users upload the same filename.Use suitable storage identifiers and check access, replacement and downloads across accounts.Cross-account tests showing no overwrite or improper access.
The scanner becomes unavailable after receipt.Keep an unapproved state, bound recovery and inform without automatically publishing.Isolated file, explicit state and no normal download.
Withdrawal occurs before a conversion finishes.Recheck state before making the derivative available and apply cleanup policy.Late output not published, preview permissions and withdrawal-decision trace.

Reusable worksheet

Complete with your authorised observations. These fields are a working template, not observed results.

FieldInformation to record
ContractFormats, limits and upload rights
StorageIdentifier, location and access
ProcessingTools, isolation and failure behaviour
OutputDecision, download and deletion
AcceptanceInaccessible quarantine, traceable decision and consistent derivative removal

Worked example

Illustrative situation

Fictional example: an image has an accepted extension but cannot be decoded.

Decision and expected evidence

It remains isolated, processing returns a recoverable rejection and no public link is issued.

Distinguish the mechanisms

MechanismPurposeCheck or limitation
Browser selectionGuide file choiceCan be bypassed
Server validationCheck the contractNeeds multiple signals
QuarantineAwait a decisionMust block normal reading

Management indicators

IndicatorWhat it measuresFirst action
Explained rejectionsRejected cases with reasonsImprove help and limits
Pending timeTime without final decisionInvestigate stalled processing
Denied accessReads rejected outside scopeReplay cross-account cases

Common pitfalls

  • Can be bypassed
  • Needs multiple signals
  • Must block normal reading

Frequently asked questions

Is a valid extension enough?

No. It proves neither content nor safety for processing and readers.

Is antivirus sufficient?

No. It is one layer alongside format, resource, access and publication controls.

What should pending analysis show?

An explicit pending or failed state. Receipt is not completed publication.

Is storage outside the public document root sufficient?

No. It reduces direct exposure, but downloads, previews and converted results must also check permissions. A processing link must not bypass quarantine or withdrawal state.

Files: quarantine and withdrawal

Quarantine: control the right version through every read

A received document may await analysis, be replaced during conversion or be withdrawn before a preview finishes. The journey therefore depends on current state, version and access decisions when the result is served. An old successful task must not restore an outdated decision.

Teaching simulation: three journeys, 35 ordered events and fictional owner OWNER-A. USER-B is another test identity; WORKER represents internal processing. This exercise creates, receives, scans and serves no actual file. Check values are fictional model inputs and make no claim about antivirus results or security certification.

Digital media isolated in a glass inspection enclosure, without staff AI-generated editorial illustration
Generated conceptual illustration: an empty digital-media inspection and isolation bay.

Five signals to interpret within their scope

Five signals to interpret within their scope
SignalUseful scopeLimit to preserve
accept attributeHelp the browser offer expected file types.Replaces no server-side check.
Extension and claimed typeCompare declarations with allowed formats.Names and Content-Type can mislead.
Signature or decodingInspect structure with an appropriate format and tool.One signal alone establishes no absence of risk.
No threat detectedRetain the result, tool version and file it concerns.Establishes neither harmlessness nor release permission.
Available statePermit a read only while identity, state, version and generation still match.Originals, previews and other derivatives still need checks.

Four distinct references in the model

Four distinct references in the model
ReferenceWhat changes itWhat it prevents here
Content version · V1/V2The owner replaces content.Applying a V1 analysis result to V2.
Control generation · g1/g2/g3Replacement, a new policy or withdrawal.Reusing an earlier decision even when the content version identifier stays the same.
Active task · J1/J2…A new attempt replaces the expected attempt.Accepting J1 after J2 was selected, even for the same version and generation.
Current stateReceipt, completed checks, explicit release or withdrawal.Confusing completed checks, availability and withdrawal.

These names and states describe a local editorial contract. The model checks withdrawal first, then content version, generation and active attempt before accepting a task result. Rejection preserves current state. Even when all three required checks match, task completion only moves to “checks complete”; authorized explicit release is still necessary.

The exercise’s three required check results

format=pass, resources=pass and scan=no_threat_detected are all required. unknown, fail and error are not passes. Real size, time, memory, decompression or page-count limits depend on the service; no universal threshold is invented here.

Recheck when recording availability

Reading permission and later writing unconditionally leaves a concurrency window. The transition needs to enforce conditions on the current version where the decision is recorded. PostgreSQL 18 describes re-evaluating a WHERE condition against an updated row for certain concurrent UPDATE operations under Read Committed. A condition on one control row can contribute to this protection; an earlier check is insufficient.

The simulation executes each event sequentially and demonstrates no real transaction. A metadata transaction does not make external storage copying, CDN purging or an already completed delivery atomic. Test those boundaries, retries and copies outside the service’s control. Withdrawing normal access and erasing all copies are separate operations.

Three computed journeys, 35 visible decisions

Each disclosure retains input, decision and post-event state. Reasons are internal teaching diagnostics; they do not define messages to expose to an unauthorized caller. States and access outcomes concern only the fictional model.

Q1 · Explicit release, identity separation, then withdrawal

Completed checks make the version eligible for an explicit release. The owner can then read the current result, USER-B is refused, and withdrawal blocks even an old reference held by the owner.

Q1 · Explicit release, identity separation, then withdrawal
Event and inputModel decisionPost-event state
01 · Receive

OWNER-A

Version: V1

Received into quarantineQuarantined

V1 · g1
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
02 · Start task

WORKER

Task: J1

Attempt recordedQuarantined

V1 · g1
Active attempt: J1

  • format=unknown
  • resources=unknown
  • scan=unknown
03 · Task result

WORKER

Task: J1

Declared checks:

  • format=pass
  • resources=pass
  • scan=no_threat_detected
Checks complete; no release performedChecks complete

V1 · g1
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
04 · Request release

OWNER-A

Version: V1

Generation: 1

Release recorded for the current versionAvailable

V1 · g1
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
05 · Request read

OWNER-A

Version: V1

Generation: 1

Read permitted in the modelAvailable

V1 · g1
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
06 · Request read

USER-B

Version: V1

Generation: 1

Reject: unauthorized identityAvailable

V1 · g1
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
07 · Withdraw access

OWNER-A

Access withdrawn; generation incrementedWithdrawn

V1 · g2
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
08 · Request read

OWNER-A

Version: V1

Generation: 1

Reject: withdrawn documentWithdrawn

V1 · g2
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown

Withdrawal increments generation and closes normal access. Current checks become unverified again; earlier results remain in previous steps. The model does not claim to retrieve a copy downloaded before withdrawal.

Final state: Withdrawn · V1 / g2

Q2 · Scanner failure, retry and replacement of V1 by V2

A scanner failure leaves V1 quarantined. Retry J2 is still running when the owner supplies V2. Its result is rejected; only J3’s checks on V2 and release targeting V2/g2 can make that version available.

Q2 · Scanner failure, retry and replacement of V1 by V2
Event and inputModel decisionPost-event state
01 · Receive

OWNER-A

Version: V1

Received into quarantineQuarantined

V1 · g1
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
02 · Start task

WORKER

Task: J1

Attempt recordedQuarantined

V1 · g1
Active attempt: J1

  • format=unknown
  • resources=unknown
  • scan=unknown
03 · Task result

WORKER

Task: J1

Declared checks:

  • format=pass
  • resources=pass
  • scan=error
Keep quarantinedQuarantined

V1 · g1
Active attempt: None

  • format=pass
  • resources=pass
  • scan=error
04 · Request release

OWNER-A

Version: V1

Generation: 1

Reject: incomplete checksQuarantined

V1 · g1
Active attempt: None

  • format=pass
  • resources=pass
  • scan=error
05 · Start task

WORKER

Task: J2

Attempt recordedQuarantined

V1 · g1
Active attempt: J2

  • format=pass
  • resources=pass
  • scan=error
06 · Replace content

OWNER-A

Version: V2

New version quarantinedQuarantined

V2 · g2
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
07 · Task result

WORKER

Task: J2

Declared checks:

  • format=pass
  • resources=pass
  • scan=no_threat_detected
Reject: old content versionQuarantined

V2 · g2
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
08 · Start task

WORKER

Task: J3

Attempt recordedQuarantined

V2 · g2
Active attempt: J3

  • format=unknown
  • resources=unknown
  • scan=unknown
09 · Task result

WORKER

Task: J3

Declared checks:

  • format=pass
  • resources=pass
  • scan=no_threat_detected
Checks complete; no release performedChecks complete

V2 · g2
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
10 · Request release

OWNER-A

Version: V1

Generation: 1

Reject: old content versionChecks complete

V2 · g2
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
11 · Request release

OWNER-A

Version: V2

Generation: 2

Release recorded for the current versionAvailable

V2 · g2
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
12 · Request read

OWNER-A

Version: V1

Generation: 1

Reject: old content versionAvailable

V2 · g2
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected
13 · Request read

OWNER-A

Version: V2

Generation: 2

Read permitted in the modelAvailable

V2 · g2
Active attempt: None

  • format=pass
  • resources=pass
  • scan=no_threat_detected

The old V1/g1 reference remains refused. No analysis result implicitly migrates between content versions.

Final state: Available · V2 / g2

Q3 · Concurrent attempts, a new policy and a post-withdrawal result

J1 and J2 initially carry the same version and generation, but only J2 is expected. Resetting checks then invalidates J2 without changing V1. J3 leaves a resource limit unchecked. Finally J4 returns after withdrawal and cannot reactivate the document.

Q3 · Concurrent attempts, a new policy and a post-withdrawal result
Event and inputModel decisionPost-event state
01 · Receive

OWNER-A

Version: V1

Received into quarantineQuarantined

V1 · g1
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
02 · Start task

WORKER

Task: J1

Attempt recordedQuarantined

V1 · g1
Active attempt: J1

  • format=unknown
  • resources=unknown
  • scan=unknown
03 · Start task

WORKER

Task: J2

Attempt recordedQuarantined

V1 · g1
Active attempt: J2

  • format=unknown
  • resources=unknown
  • scan=unknown
04 · Task result

WORKER

Task: J1

Declared checks:

  • format=pass
  • resources=pass
  • scan=no_threat_detected
Reject: unexpected attemptQuarantined

V1 · g1
Active attempt: J2

  • format=unknown
  • resources=unknown
  • scan=unknown
05 · Reset policy

OWNER-A

New generation; checks pending againQuarantined

V1 · g2
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
06 · Task result

WORKER

Task: J2

Declared checks:

  • format=pass
  • resources=pass
  • scan=no_threat_detected
Reject: old control generationQuarantined

V1 · g2
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
07 · Start task

WORKER

Task: J3

Attempt recordedQuarantined

V1 · g2
Active attempt: J3

  • format=unknown
  • resources=unknown
  • scan=unknown
08 · Task result

WORKER

Task: J3

Declared checks:

  • format=pass
  • resources=unknown
  • scan=no_threat_detected
Keep quarantinedQuarantined

V1 · g2
Active attempt: None

  • format=pass
  • resources=unknown
  • scan=no_threat_detected
09 · Request release

OWNER-A

Version: V1

Generation: 2

Reject: incomplete checksQuarantined

V1 · g2
Active attempt: None

  • format=pass
  • resources=unknown
  • scan=no_threat_detected
10 · Start task

WORKER

Task: J4

Attempt recordedQuarantined

V1 · g2
Active attempt: J4

  • format=pass
  • resources=unknown
  • scan=no_threat_detected
11 · Withdraw access

OWNER-A

Access withdrawn; generation incrementedWithdrawn

V1 · g3
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
12 · Task result

WORKER

Task: J4

Declared checks:

  • format=pass
  • resources=pass
  • scan=no_threat_detected
Reject: withdrawn documentWithdrawn

V1 · g3
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
13 · Request release

OWNER-A

Version: V1

Generation: 2

Reject: withdrawn documentWithdrawn

V1 · g3
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown
14 · Request read

OWNER-A

Version: V1

Generation: 2

Reject: withdrawn documentWithdrawn

V1 · g3
Active attempt: None

  • format=unknown
  • resources=unknown
  • scan=unknown

Version, generation and attempt cover different situations. Withdrawal remains decisive and incomplete checks never become authorization.

Final state: Withdrawn · V1 / g3

Six records for an authorized acceptance review

  • Versioned format and processing-limit contracts, including failure behavior.
  • Links between received object, version, task, derivatives and release decision.
  • Distinct check results, including unverified states, and the exact file each concerns.
  • Cross-identity read tests on originals and derivatives before and after withdrawal.
  • Evidence of late-result rejection without unnecessarily copying document content into logs.
  • Withdrawal scope, retention, active tasks and external cache or copy handling.

OWASP motivates validation layers, isolated storage and permission checks on every request. WHATWG defines accept as a selection hint. PostgreSQL documents concurrency behavior. The journeys, generations and decisions are a local method; they validate no real product’s security.

Primary sources and model limits

Sources reviewed on

Product identity: GTIN and variants

Import identifiers without losing zeros

Keep references as strings and document rejection rules; an accepted import certifies no GS1 allocation.

  • Preserve zeros and raw values useful for acceptance checks.
  • Test the URL preselecting each variant.
  • Compare identity, price and availability on the page and in the cart.

Explore identifiers and check a GTIN digit →

GS1 · 2D Barcodes at Retail POS Implementation Guideline · Release 1.1.0 · ratified December 2025 · §4.3 / Table 4-2

Google Search Central · Product variant structured data · Updated 2026-09-08 · consulted 2026-10-23

Official references

References consulted: . The method and worksheet propose checks to adapt to your context; they do not constitute certification.