Privacy Policy

1. Data Collection Protocols & Server Log Ingestion

When you navigate our website, our web servers collect standard, non-personally identifiable information. This processing is necessary to support our network infrastructure, diagnose routing faults, prevent malicious activity, and manage overall platform security. The primary mechanism of this collection is the automated server log file, generated in real time by our HTTP server daemons (Apache and Nginx).

Server Log Data Schema

Our infrastructure relies on the standard Combined Log Format (CLF) for recording inbound web requests. This format ensures that we capture only the technical metadata required to negotiate HTTP/HTTPS requests, verify payload sizes, and analyze regional traffic levels. Below is the specification schema representing each entry written to our access logs:

Each parameter within this schema corresponds to a specific variable evaluated during the server connection lifecycle:

• %h (Remote Host / IP Address): The network identifier of the client initiating the request. Under our privacy-by-design architecture, this value is never stored in its raw format. It is immediately intercepted and anonymized.
• %l (Remote Logname): The RFC 1413 identity of the client. This field is typically empty (represented by a hyphen) in modern web traffic.
• %u (Remote User): The username authenticated by HTTP basic authentication. Because we do not support user logins or authentication on this informational platform, this field is universally populated as a hyphen.
• %t (Time of Request): The synchronized time stamp of the request, formatted as [day/month/year:hour:minute:second zone]. This helps us correlate security alerts with traffic spikes.
• %r (First Line of Request): The HTTP method (GET, POST, etc.), the request URI (e.g., /index.php), and the HTTP protocol version (e.g., HTTP/1.1 or HTTP/2).
• %>s (Final Status Code): The three-digit status code returned by the server to the client (e.g., 200 OK, 404 Not Found, or 500 Internal Server Error).
• %b (Bytes Sent): The total size of the HTTP response payload returned to the client, excluding HTTP headers. This allows us to track CDN efficiency and bandwidth consumption.
• %{Referer}i: The contents of the Referer header, detailing the URL of the page from which the client navigated to the current resource.
• %{User-Agent}i: The user-agent header string, which identifies the browser engine, operating system, layout rendering library, and client hardware platform. This is used strictly for responsive web page optimization.

Raw String Parsing Pipelines

To extract analytical value from these access logs while adhering to our privacy commitments, the raw text logs undergo structured ingestion pipelines. The pipeline isolates, parses, anonymizes, and loads the data into a secure, volatile analytical environment. This workflow is typified by custom log parsers (e.g., built using fluentd, Logstash, or lightweight Python scripts). The following Python snippet demonstrates the raw string parsing pipeline, illustrating how a standard log line is parsed using regular expressions to extract structured, privacy-compliant fields:

# Example Log Parsing and Ingestion Pipeline
import re
import ipaddress

# Regex for parsing the Combined Log Format schema
LOG_PATTERN = re.compile(
    r'^(?P<ip>\S+) (?P<ident>\S+) (?P<auth>\S+) \[(?P<time>[^\]]+)\] '
    r'"(?P<method>\S+) (?P<path>\S+) (?P<proto>[^"]+)" '
    r'(?P<status>\d+) (?P<bytes>\S+) '
    r'"(?P<referer>[^"]*)" "(?P<user_agent>[^"]*)"'
)

def parse_log_line(raw_line):
    match = LOG_PATTERN.match(raw_line)
    if not match:
        return None
    
    data = match.groupdict()
    # Apply IP Masking Algorithm Immediately
    data['ip'] = mask_ip_address(data['ip'])
    
    # Cast variables to native types
    data['status'] = int(data['status'])
    data['bytes'] = 0 if data['bytes'] == '-' else int(data['bytes'])
    
    return data

IP Masking & Anonymization Algorithms

Because raw IP addresses are classified as personal data under global privacy frameworks (such as GDPR), we enforce strict, real-time IP anonymization within our log parsing pipelines before the log records are committed to persistent database storage. This means that a user's original, identifying IP is only held in volatile RAM for the duration of the network handshake and log-splitting execution.

Our masking protocols differ based on the address version:

• IPv4 Anonymization (Zeroing the Last Octet): For IPv4 addresses, which consist of 32 bits divided into four 8-bit octets, we strip the final octet. This is accomplished using a bitwise AND mask or simple string division. In code, the algorithm takes the IP address, parses it as a network object, and applies a network mask of 24 bits (matching class C routing blocks).
  For example, the IPv4 address 198.51.100.127 is mapped to 198.51.100.0. Bitwise, this is calculated as:
  anonymized_ipv4 = raw_ipv4 & 0xFFFFFF00 This removes the specific host identifier, preserving only the local network group. It allows us to determine the user's general geographic region (such as city or country) without identifying their individual residential gateway or terminal.
• IPv6 Anonymization (Block Masking / Subnet Truncation): IPv6 addresses are 128 bits in length, structured as eight 16-bit blocks (expressed in hexadecimal). Identifying individual clients within an IPv6 network typically relies on the last 64 bits of the address (known as the Interface Identifier, often derived from a device's physical MAC address). To ensure complete anonymity, we apply a /48 or /64 subnet block mask, zeroing out all blocks after the first three or four groups.
  For example, the IPv6 address 2001:0db8:85a3:0000:0000:8a2e:0370:7334 is truncated and masked to 2001:0db8:85a3:0000::.
  This is handled by our pipeline through standard networking libraries:
  masked_ipv6 = str(ipaddress.IPv6Network(raw_ipv6 + '/64', strict=False).network_address) This removes all hardware-specific identifiers, protecting the visitor's device identity while retaining the routing prefix required for general geographical validation.

By stripping this resolution, we ensure that even in the event of an administrative breach of our log servers, the data contained therein cannot be used to trace web activity back to a specific individual or single household router.

2. Device Permissions and Data Minimization

Modern web applications frequently leverage Web APIs to query device state, locate hardware profiles, and request direct access to host capabilities. Unlike mobile applications that run compiled binary payloads natively on operating systems, our site operates as a standard, hypermedia-driven resource running entirely within your browser's sandboxed runtime environment. We do not interface with native device managers or attempt to bypass standard sandboxing protocols.

To ensure transparency, we document our interface parameters and browser permissions policy below:

• No Background Services or Workers: We do not register persistent background processes, such as Service Workers, background sync hooks, or push notification daemons, which could wake your browser or query state while our tab is closed.
• No Hardware API Access: Our client-side scripts do not request bindings for sensory hardware APIs. This includes the Geolocation API, WebUSB API, Web Bluetooth API, WebMIDI API, or the MediaDevices interface (microphone, camera, and screen sharing).
• Browser Storage Isolation: Any data written to client-side storage (such as session cookies or local keys) is restricted strictly to our domain using standard origin-bound isolation rules enforced by the browser. It cannot be accessed by other websites.
• Secure Voluntary Form Submissions: When you use our contact form to submit files or bug reports, the browser sends the payload via an encrypted POST request directly to our secure mail queue. We enforce strict MIME-type checking, file-size limits, and quarantine parsing on all uploads to block malicious code execution. Once your submission has been reviewed, it is permanently deleted from our temporary storage queues.

3. Cookie Infrastructure & User Consent Mechanisms

Our site utilizes client-side storage objects, commonly referred to as cookies or web storage, to maintain basic interface preferences and gather analytical data. These storage mechanisms are subject to your explicit consent, which is captured and updated through our interactive cookie compliance banner.

Our site uses two main categories of cookies:

Cookie Consent State Persistence & Web Storage

To persist your preferences across browsing sessions without requiring a database record, we use the browser's localStorage API. Unlike traditional cookies, which are automatically sent to the server with every HTTP request and increase header overhead, localStorage remains strictly on the client side.

When you select your preferences in our consent interface, we write a structured JSON string to a specific storage key:

{
  "version": 1,
  "timestamp": 1782012080000,
  "consent": {
    "necessary": true,
    "analytics": false
  }
}

Session Token Lifetimes & Transmitted Cookie Attributes

Any cookies generated by our platform during your session are written with security flags to prevent client-side script interception (cross-site scripting or XSS attacks) and connection sniffing. We apply the following parameters to session cookies:

• HttpOnly Flag: Prevents client-side scripts from reading the cookie value via the document.cookie interface, shielding the session data from XSS-based theft.
• Secure Flag: Guarantees that the cookie is only transmitted over encrypted connections (HTTPS), protecting it from man-in-the-middle sniffing on public Wi-Fi networks.
• SameSite=Strict Attribute: Mitigates Cross-Site Request Forgery (CSRF) vulnerabilities by instructing the browser never to include the cookie in requests originating from external domains.
• Explicit Max-Age / Expires Parameters: Short-lived analytical tracking cookies are explicitly configured with an expiration window matching the duration of your current browser session, while consent-state configurations persist for a maximum of 365 days before automatically expiring and requiring renewal.

Client-Side Validation & Execution Pipelines

Our frontend scripts perform strict client-side validation of the consent state before initializing any third-party script integrations (such as CDNs or typography loaders). The validation pipeline intercepts execution requests and checks the current state:

// Client-Side Consent Validation and Loader Script
(function() {
    const STORAGE_KEY = 'site_cookie_consent_settings';
    
    function checkConsentAndLoad() {
        const consentData = localStorage.getItem(STORAGE_KEY);
        if (!consentData) {
            showConsentBanner();
            return;
        }
        
        try {
            const parsed = JSON.parse(consentData);
            // Verify structure and integrity
            if (parsed.version === 1 && parsed.consent && parsed.consent.analytics) {
                // Initialize non-essential analytical packages
                loadAnalyticsSuite();
            } else {
                console.log("Analytics cookies disabled by user consent configuration.");
            }
        } catch (e) {
            console.error("Invalid consent configuration data. Resetting storage...");
            localStorage.removeItem(STORAGE_KEY);
            showConsentBanner();
        }
    }
    
    function loadAnalyticsSuite() {
        const script = document.createElement('script');
        script.src = 'https://www.google-analytics.com/analytics.js';
        script.async = true;
        document.head.appendChild(script);
    }
    
    window.addEventListener('DOMContentLoaded', checkConsentAndLoad);
})();

By separating non-essential analytical executions into verified callback wrappers, we guarantee that no analytical tracking scripts are executed, and no analytical cookies are written, until after the user has explicitly clicked the accept button in our cookie configuration dialog.

4. Third-Party Integrations and CDN Processing

To ensure rapid page load speeds, high availability, and low network latency across different geographical regions, our site utilizes global Content Delivery Networks (CDNs) to cache and serve static resources (including CSS stylesheets, JavaScript files, images, and fonts).

These integrations are audited and managed under the following security and data processing guidelines:

• Font Delivery Networks (Google Fonts): We request typography assets directly from Google's content servers. To deliver the appropriate font configuration (woff2, woff, etc.), Google's servers must process your IP address and user-agent string. According to Google's privacy documentation, these typographic requests are kept isolated from personal profiles used for advertising and search tracking.
• Subresource Integrity (SRI) Hashes: For all static assets loaded from third-party networks, we employ Subresource Integrity (SRI) attributes. These attributes contain a cryptographic SHA-384 or SHA-512 hash of the file's content. When the browser downloads the script or stylesheet, it validates the file's hash against the hash declared in our source code. If a CDN node is compromised and the script is altered in transit, the browser immediately blocks execution of the corrupted file, safeguarding your device.
• Asset Local Offloading: Wherever feasible, we offload static scripts and icons from remote CDNs and serve them locally from our own origin server. This reduces the number of third-party network connections required to display our page, limiting external data sharing.

5. Regulatory Compliance & Data Subject Rights (GDPR & CCPA)

We process information in compliance with international privacy frameworks, specifically the European Union's General Data Protection Regulation (GDPR) and the California Consumer Privacy Act (CCPA). While our site functions as an informational resource and avoids storing identifying user accounts, we maintain standard operational procedures to honor your legal rights regarding data access, rectification, portability, and deletion.

Data Subject Access Request (DSAR) Intake Protocols

When a user submits a Subject Access Request (SAR) or an erasure request under CCPA/GDPR, we follow a strict multi-step validation protocol to prevent identity spoofing or unauthorized data disclosure:

1. Intake and Identity Verification: Because we do not store logins, our primary identifier for a visitor is the email address used to contact us. When an access request is submitted, we initiate a cryptographic challenge (such as a dual-factor confirmation link sent to the requestor's verified address) to confirm ownership of the communication channel.
2. System-Wide Data Crawling: Once verification is complete, our compliance team queries our localized mailing queues and temporary server logs using the verified email handle and any provided masked IP identifiers.
3. Review and Redaction: We review the compiled records to ensure that delivering the data does not compromise the privacy rights of other individuals or expose confidential server structures.
4. Secure Dispatch: The verified data package is delivered to the requestor in a structured, machine-readable format within the statutory 30-day compliance window.

Data Portability Formats (JSON & CSV Export Schemas)

Under the right to data portability, data packages are exported in standard formats. The export folder contains both structured JSON and flat CSV representations of all matching logs. The following JSON structure illustrates the schema used for data portability exports:

{
  "export_metadata": {
    "generated_at": "2026-05-22T14:21:28Z",
    "data_controller": "Worldbox Modding Community",
    "request_identifier": "dsar_90812347"
  },
  "subject_records": {
    "email_submissions": [
      {
        "submission_timestamp": "2026-04-10T12:30:15Z",
        "subject_line": "Bug Report: Asset Load Error",
        "originating_ip_masked": "198.51.100.0",
        "message_body_checksum": "sha256:e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855"
      }
    ],
    "consent_preferences": [
      {
        "preference_key": "site_cookie_consent_settings",
        "last_updated": "2026-04-10T12:28:44Z",
        "consented_analytics": false
      }
    ]
  }
}

Database Sanitization & Deletion Queries

When a user requests complete deletion ("Right to be Forgotten"), we run automated database sanitization scripts to ensure that personal identifiers are scrubbed from all secondary tables, temporary caches, and backup queues. We employ two distinct deletion modes depending on the storage engine:

• Hard Deletion (Immediate Removal): Standard application logs and temporary file uploads are permanently deleted from disk. This is executed using secure overwrite commands:
  rm -f -- /var/www/uploads/temp_user_files/user_submission_90812347.*
• Anonymization and Sanitization (Soft Purging): For analytical logs where database integrity is required for cumulative traffic metrics (e.g. counting total page views), we sanitize personal identifiers (emails, IP addresses) by replacing them with high-entropy cryptographic salts or null fields. The SQL query below shows our database sanitization protocol:

-- SQL Database Sanitization Script for GDPR Compliance
BEGIN TRANSACTION;

-- Anonymize contact log records by zeroing identifiable strings
UPDATE user_contact_submissions
SET 
    sender_email = SHA2(CONCAT(sender_email, 'CRYPTOGRAPHIC_SALT_VALUE_2026'), 256),
    sender_ip = '0.0.0.0',
    raw_message_text = '[REDACTED FOR GDPR COMPLIANCE]',
    sanitization_timestamp = NOW()
WHERE 
    sender_email = 'user@example.com';

-- Cascading update to clear session mappings in tracking tables
UPDATE session_analytics
SET 
    client_ip_address = '0.0.0.0',
    device_fingerprint = NULL
WHERE 
    associated_email = 'user@example.com';

COMMIT;

Running these updates ensures that while the counts and general metadata of past visits are preserved to keep overall traffic metrics accurate, the metrics can never be linked to an identifiable person.

COPPA Compliance

We process all content in compliance with the Children's Online Privacy Protection Act (COPPA). Our site is designed as an informational resource for a general audience. We do not intentionally target, collect, or store data from children under the age of 13. If you believe a child under 13 has submitted personal information, please notify us, and we will initiate database sanitization protocols immediately.

6. Data Security, Network Transmission, and Cipher Suites

We protect all data processed across our network by maintaining strict security baselines. Our network transmission configurations are optimized to prevent eavesdropping, replay attacks, and downgrade vulnerabilities.

SSL/TLS Handshake Negotiations & Cipher Suites

All network traffic between your web browser and our servers is encrypted using Transport Layer Security (TLS/HTTPS). We have deprecated support for outdated, insecure protocols (SSL 3.0, TLS 1.0, and TLS 1.1) to defend against protocol downgrade attacks (such as POODLE or BEAST).

Our web servers negotiate connections using TLS 1.2 and TLS 1.3 exclusively. The preferred cipher suites are selected based on their security profiles, resisting modern cryptanalytic techniques. The negotiated connections are prioritized in the following order:

Perfect Forward Secrecy (PFS)

We mandate Ephemeral Diffie-Hellman key exchanges (specifically ECDHE over curves like X25519 or secp256r1) for all TLS connections. This configuration provides Perfect Forward Secrecy (PFS).

PFS ensures that a unique, session-specific cryptographic key is generated dynamically for each inbound connection and is immediately discarded when the session terminates. Because the session keys are never stored, even if an adversary records all encrypted traffic and later obtains the server's master private key, they cannot decrypt the recorded past sessions. This isolates each connection and prevents retroactive decryption attacks.

HTTP Strict Transport Security (HSTS) & Security Headers

To enforce secure transmission channels, our server responses deliver headers instructing modern browsers to restrict connection options:

• HTTP Strict Transport Security (HSTS): We publish an HSTS header that forces browsers to automatically upgrade all HTTP requests to HTTPS, bypassing potential man-in-the-middle redirects.
  Strict-Transport-Security: max-age=63072000; includeSubDomains; preload
  This instructs browsers to store the HTTPS-only rule for 2 years (63,072,000 seconds), apply it to all subdomains, and register our domain on the browser vendor preload list.
• Content Security Policy (CSP): We enforce a strict CSP that limits the sources from which scripts, styles, images, and fonts can be loaded:
  Content-Security-Policy: default-src 'self'; script-src 'self' https://www.google-analytics.com; style-src 'self' 'unsafe-inline' https://fonts.googleapis.com; font-src 'self' https://fonts.gstatic.com; img-src 'self' data:; frame-ancestors 'none';
  This prevents cross-site scripting (XSS), script injection, and clickjacking attacks.
• X-Content-Type-Options: Prevent browser MIME-type sniffing:
  X-Content-Type-Options: nosniff
• X-Frame-Options: Restricts page rendering inside frames:
  X-Frame-Options: DENY

Data Retention Limits

Server logs are automatically purged on a 30-day rolling cycle. Local email inquiries and attachments submitted via the contact form are retained for no more than 60 days following the resolution of the query, after which they are deleted from our secure mail spools. Backup volumes are encrypted at rest using AES-256-XTS and are subject to automatic rotation and purging.

If you have questions about this policy or wish to submit a data erasure request, please contact our privacy compliance officer at support@worldboxapk.net.