Public Link vs Private Link: Cryptographic Entropy, Bearer Tokens, and Access Governance

Modern cloud storage platforms offer users two basic categories of security options for sharing files, videos, and images with other people on the Internet: public links and private links. On the MediaToURL homepage, you can generate public unlisted links or secure private URLs tailored to your specific sharing workflow. However, there is a large number of additional security features available under both of these headings, including cryptographic protections, network isolation, and session authentication..

When you create a "public" link, it will not necessarily be crawled by search engines. A lot of platforms use a random token that is hidden from view to create "public" links. On the other hand, when you create a "private" link, it is typically protected by an expiring cryptographic signature, which allows anyone who has the signed query string to view the content for a limited time.

The confusion of these mechanisms results in serious security breaches in the real world. Every year, corporate audit teams find out that they have stored confidential financial projections, customer invoices and medical records behind unlisted links which can be accessed by anyone on the internet with no need to log-in..

The Anatomy of an Unlisted Public Link

An unlisted public link depends upon being obscure via generating a random token. It will allow access to the resource without requiring a valid user session, cookie, or API key. Once someone enters the full URL into their web browser, they can download the file..

GET /a/e4b9c1d2-7a8f-4b3e-9c12-3a4d5e6f7a8b.pdf HTTP/1.1
Host: files.mediatourl.com

A bearer token (or "HTTP bearer token") is what this URL does behind the scenes. According to RFC 6750, a bearer token is defined as a form of authorization or security credentials, where whoever possesses the token is granted access to the associated resources. This means, if you send someone a link to the file via email, they will be able to retrieve the file. Also, if they forward the email containing the link to other individuals (i.e., 50 people), then each of those individuals will have access to download the file.

Cryptographic Entropy of UUIDv4 Tokens

The security of an unlisted public link rests entirely on the mathematical impossibility of guessing the token.

The current version of modern media platforms creates "unlisted" paths with UUIDv4 (Version 4 Universally Unique Identifier) which are generated per the standards of RFC 4122. A UUIDv4 string has 128 bits.

Six bits are reserved for variant and version metadata.

The other 122 bits represent pseudorandom entropy that has been generated in a manner that provides a high degree of confidence that it cannot be guessed.

The total keyspace equals 2 to the power of 122:

Total Keyspace = 2^122 ≈ 5.316 × 10^36 unique combinations

To visualize this number, imagine an attacker writing an automated scanner that queries the server at a rate of one billion requests per second:

Guesses per Second: 1,000,000,000 (10^9)
Seconds per Year: 31,536,000 (~3.15 × 10^7)
Guesses per Year: 3.15 × 10^16

Years to Exhaust 0.001% of Keyspace: > 1.68 × 10^17 years

Brute-force enumeration against a true UUIDv4 endpoint is practically impossible under known laws of computation. The danger of unlisted public links stems not from mathematical guessing, but from unintended token leakage across network layers.

The Threat of Sequential Identifiers (IDOR)

While UUIDv4 strings provide high entropy, legacy or poorly designed applications frequently generate links using predictable sequential database keys:

<!-- Dangerous: Predictable Integer IDs -->
https://example.com/invoices/10041.pdf
https://example.com/invoices/10042.pdf
https://example.com/invoices/10043.pdf

This vulnerability is known in cybersecurity as Insecure Direct Object References (IDOR), ranked as the top risk in the OWASP API Security Top 10.

When an application exposes sequential identifiers without verifying user permissions, an attacker needs zero cryptographic skill. A simple shell loop can download an entire customer database in minutes:

# Automated enumeration of predictable IDs
for id in $(seq 10000 10500); do
  curl -s -O "https://example.com/invoices/${id}.pdf"
done

If an asset URL contains an auto-incrementing integer or a short alphanumeric slug (like six characters from base62), the link is not secure. True unlisted links require at least 128 bits of cryptographically generated entropy.

How Unlisted Bearer Links Leak in Practice

Even when a URL contains an unguessable 128-bit token, the link behaves like a password printed directly on an envelope. Once the link traverses the internet, multiple systems inspect, log, and cache the complete string.

               User Pastes Link in Slack / Teams
                              │
                              ▼
                  Link Unfurling Webhook
               (Server Downloads Metadata)
                              │
                              ▼
            Proxy Logs & Enterprise Middleboxes
            (Full URL Recorded in Access Logs)
                              │
                              ▼
            Recipient Browser Opens Embedded Page
                              │
                              ▼
                Referer Header Transmission
            (Third-Party Analytics Learns Token)

1. HTTP Referer Header Leakage

When a user opens an unlisted HTML document in their browser and clicks an external link (such as a link to an external font, stylesheet, or third-party partner), the browser automatically transmits the full current URL inside the Referer header to the destination server.

Unless the document enforces a strict Referrer-Policy: no-referrer header, the external third-party server records your private token in its access logs.

2. Corporate Proxy and TLS Termination Logs

In enterprise office environments, corporate firewalls and forward proxies intercept employee web traffic for security inspection. These appliances log every outbound URL query. System administrators, internal compliance crawlers, and automated security scanners can inspect these logs and discover unlisted links.

3. Messaging Link Preview Bots (Unfurlers)

When you paste an unlisted link into Slack, Discord, Microsoft Teams, or WhatsApp, the messaging application server immediately sends an automated bot crawler to fetch the page title, description, and preview thumbnail.

Your unlisted URL is now stored in the database of the messaging provider, processed by third-party image microservices, and displayed in shared chat channels.

4. Browser History and Synchronization

Web browsers automatically store every visited URL in local browser history and synchronize that history across laptops, phones, and tablets tied to the user account. If an employee logs into a personal device, the unlisted link becomes accessible on that unmanaged hardware.

Private Links: Authenticated IAM and HMAC Presigned Tokens

Unlike unlisted public links, a genuine private link enforces active cryptographic verification at the edge rather than relying on URL secrecy alone.

Private link architectures fall into two primary designs:

1. Session-Authenticated Access (Zero-Trust)

Under session-based private access, the storage origin checks whether the incoming HTTP request carries a verified identity credential:

GET /internal/financial-report.pdf HTTP/1.1
Host: enterprise.mediatourl.com
Cookie: session_id=s%3A7a8f4b3e.9c123a4d5e6f7a8b
Authorization: Bearer eyJhbGciOiJIUzI1NiIsInR5cCI...

The edge proxy intercepts the request before contacting the object storage bucket. It validates the session cookie against an identity provider (such as Supabase Auth, Auth0, or Okta).

If the session is missing, invalid, or belongs to a user lacking read permissions for that specific file tenant, the proxy terminates the request with HTTP 401 Unauthorized or HTTP 403 Forbidden. Even if an employee publishes the URL on social media, external visitors cannot read the contents.

2. Time-Bounded HMAC Presigned URLs

When applications need to distribute private assets without forcing recipients to create login accounts (such as sending a time-sensitive client contract), they use cryptographically signed URLs.

Popularized by AWS S3 and adopted by Cloudflare R2 and Google Cloud Storage, presigned URLs bind the request to a specific HTTP method, an expiration timestamp, and a cryptographic hash signature:

https://storage.mediatourl.com/exports/q3-summary.xlsx?
X-Amz-Algorithm=AWS4-HMAC-SHA256&
X-Amz-Credential=APIKEYID%2F20261103%2Fus-east-1%2Fs3%2Faws4_request&
X-Amz-Date=20261103T160000Z&
X-Amz-Expires=300&
X-Amz-SignedHeaders=host&
X-Amz-Signature=d3b07384d113edec49eaa6238ad5ff00...

The storage server calculates the expected signature using its private secret key:

Signature = HMAC-SHA256(SecretKey, StringToSign)

The StringToSign combines the HTTP verb (GET), the URI path, the date timestamp, and the validity window (X-Amz-Expires=300).

If an attacker attempts to alter the expiration parameter from 300 seconds to 300,000 seconds, the cryptographic hash verification fails immediately. Once the five-minute window closes, the URL expires permanently.

Implementing a Cryptographic Presigned URL Generator in TypeScript

You can implement time-bounded private links in your backend using Node.js crypto libraries. The following TypeScript service generates HMAC-SHA256 signed delivery URLs that expire automatically:

import { createHmac } from 'node:crypto';

export interface PresignedUrlOptions {
  assetId: string;
  secretKey: string;
  expiresInSeconds: number;
  deliveryDomain: string;
}

export function generatePresignedMediaUrl({
  assetId,
  secretKey,
  expiresInSeconds,
  deliveryDomain,
}: PresignedUrlOptions): string {
  const expiresAt = Math.floor(Date.now() / 1000) + expiresInSeconds;
  const path = `/a/${assetId}`;

  // Construct payload canonical string
  const payload = `${path}\n${expiresAt}`;

  // Generate cryptographic signature
  const signature = createHmac('sha256', secretKey)
    .update(payload)
    .digest('hex');

  const url = new URL(`https://${deliveryDomain}${path}`);
  url.searchParams.set('exp', expiresAt.toString());
  url.searchParams.set('sig', signature);

  return url.toString();
}

export function verifyPresignedSignature(
  urlPath: string,
  searchParams: URLSearchParams,
  secretKey: string
): boolean {
  const exp = searchParams.get('exp');
  const sig = searchParams.get('sig');

  if (!exp || !sig) return false;

  const expirationTimestamp = parseInt(exp, 10);
  const currentTimestamp = Math.floor(Date.now() / 1000);

  // Reject expired links
  if (currentTimestamp > expirationTimestamp) {
    return false;
  }

  // Verify HMAC signature
  const expectedPayload = `${urlPath}\n${exp}`;
  const expectedSignature = createHmac('sha256', secretKey)
    .update(expectedPayload)
    .digest('hex');

  return sig === expectedSignature;
}

This implementation allows edge workers to validate asset requests in less than one millisecond without querying a central database.

AWS Signature Version 4 Canonical Request Construction

To understand enterprise-grade presigned URLs, examine how AWS Signature Version 4 constructs signed parameters. SigV4 avoids transmitting private secrets by having both the client and server independently compute an identical cryptographic hash.

The signing process requires assembling a standardized canonical request string:

HTTPMethod + "\n" +
CanonicalURI + "\n" +
CanonicalQueryString + "\n" +
CanonicalHeaders + "\n" +
SignedHeaders + "\n" +
HashedPayload

Each component is strictly sanitized:

First, the HTTP method specifies the exact verb allowed, typically GET or HEAD. An attacker cannot reuse a signed GET link to overwrite the file using PUT or DELETE.

Second, the CanonicalURI normalizes percent-encoding and directory slashes, preventing path traversal attacks such as referencing parent directories.

Third, the CanonicalQueryString sorts query parameters in lexicographical order. The signature algorithm computes an SHA-256 hash over this string:

CanonicalRequestHash = SHA256(CanonicalRequest)

The next step of the algorithm is to create a unique signing key based on the secret key, date, region, and service identifier. After this process has completed, the algorithm will compute the HMAC-SHA256 signature. A proxy that intercepts the request and alters even one character of the query string will cause the signature validation to fail when verified by the edge server..

Early Revocation Protocols for Cryptographic URLs

The main disadvantage of standard HMAC presigned URLs is that once generated, they will remain active until the specified expiration date/time has elapsed. Therefore, if a system administrator inadvertently generates a 24-hour signed link for someone who should not have access to it, there is no way for the underlying object storage system to revoke that particular URL prior to the time limit being reached..

To provide immediate revocation capabilities without sacrificing edge performance, modern media architectures implement token versioning:

Database Record: Asset Version Pointer
       │
       ▼
HMAC Payload: /a/{assetId}?v={version}&exp={timestamp}
       │
       ▼
Edge Cache Verification: Compare 'v' with Fast In-Memory Key-Value Store
       │
  ┌────┴────┐
  ▼         ▼
Matches   Mismatched (Revoked)
  │         │
200 OK    403 Forbidden

An administrator's action of clicking "Revoke Link" within the dashboard causes the platform to increment the internal asset version integer. The edge worker compares the version parameter included in the signed token to a fast key-value store. In the event that there is a discrepancy between the two versions, the edge worker immediately terminates the request and returns an HTTP 403 Forbidden response.

Another approach involves maintaining an ephemeral revocation nonce list. The edge checks incoming request signatures against a bloom filter of canceled tokens stored in memory.

Statistical Risk Analysis: The Cost of Misconfigured Links

The Verizon Data Breach Investigations Report documents that misconfigured cloud assets and unauthenticated links represent over 21% of initial access vectors in modern enterprise web security incidents.

Organizations have a basic problem with the use of unlisted URLs as a form of authorization. In business settings, links can be distributed through various methods such as shared calendar appointments, project boards and even chat transcript exports. Many times over 65 percent of confidential documents distributed via unlisted links will continue to exist long after the project has been completed. and each of the browser requirements against current versions of both types of browsers.)

Implementing automated expiration policies ensures that dormant links deactivate automatically, shrinking the attack surface across your digital infrastructure.

Enterprise Link Governance Matrix

To maintain data compliance under regulations such as GDPR, HIPAA, and SOC 2, organizations must establish clear rules governing when employees may generate public versus private links.

Use this operational matrix to establish baseline permissions across your team:

Securing Unlisted Assets at the Edge

If your platform must provide unlisted public links for ease of use, implement defense-in-depth security controls at the edge network layer:

1. Enforce noindex Robots Directives: Always return X-Robots-Tag: noindex, nofollow, noarchive on unlisted asset routes. This prevents Google, Bing, and search spiders from indexing the URL if it appears in public HTML markup.
2. Implement Rate Limiting: Limit IP addresses to a reasonable threshold (such as sixty requests per minute) to thwart automated brute-force enumeration tools.
3. Strip Referrers on HTML Wrappers: If you provide a preview share page for the asset, serve it with Referrer-Policy: no-referrer to prevent outgoing link clicks from leaking the token to external hosts.
4. Provide One-Click Revocation: Build dashboard controls that allow users to invalidate an unlisted link instantly. When revoked, the edge server invalidates cached copies and rejects subsequent queries with HTTP 404.
5. Enforce Ephemeral Upload Windows: For file collection portals, restrict the time window during which external uploaders can submit payloads to temporary links.

Modern media management requires a balanced approach to access control. Organizations should distinguish between their daily media distribution and secure organizational records. Unlisted public links provide an easy way to share low-risk creative assets. However, if you need to protect the confidentiality of your data, then replace the use of bearer tokens with cryptographically signed URLs or stringent identity verification.