Secure File Transfer & Sharing: Zero-Trust Architecture with Fragment Keys and Nonces

ZeroNote's file transfer system implements a revolutionary zero-trust architecture where every file transmission is secured with unique fragment keys and individual nonces. In this comprehensive guide, we'll explore how our system ensures that your files remain completely private and accessible only to intended recipients.

🛡️ The Challenge of Secure File Sharing

Traditional file sharing services store your files on their servers, often in plaintext or with weak encryption. Even when files are encrypted, the service provider typically holds the keys, meaning they can access your content. ZeroNote takes a fundamentally different approach: zero-trust architecture where even we cannot access your files.

🔑 Fragment Key Architecture

The foundation of ZeroNote's secure file transfer is our fragment key system. Unlike traditional encryption that uses a single key, we split file access into multiple cryptographic fragments, each serving a specific purpose in the security chain.

Fragment Key Generation

// ZeroNote Fragment Key System
class FileFragmentManager {
    constructor() {
        this.fragmentSize = 32; // 256-bit fragments
        this.minFragments = 3;  // Minimum security fragments
        this.maxFragments = 7;  // Maximum for performance
    }

    async generateFragmentSet(fileId, recipientPublicKey) {
        const fragments = {
            accessFragment: await this.generateSecureRandom(this.fragmentSize),
            contentFragment: await this.generateSecureRandom(this.fragmentSize),
            validationFragment: await this.generateSecureRandom(this.fragmentSize),
            temporalFragment: this.generateTimeBasedFragment(),
            recipientFragment: await this.deriveRecipientFragment(recipientPublicKey)
        };

        // Combine fragments using XOR with entropy mixing
        const masterKey = await this.combineFragments(fragments);
        
        // Store fragments separately with different access patterns
        await this.storeFragmentSecurely(fileId, fragments);
        
        return {
            masterKey,
            fragmentIds: Object.keys(fragments),
            expirationTime: Date.now() + (15 * 60 * 1000) // 15 minutes
        };
    }

    async combineFragments(fragments) {
        const combined = new Uint8Array(this.fragmentSize);
        const fragmentValues = Object.values(fragments);
        
        // XOR all fragments with entropy mixing
        for (let i = 0; i < this.fragmentSize; i++) {
            let byte = 0;
            fragmentValues.forEach((fragment, index) => {
                byte ^= fragment[i] ^ (index * 17); // Entropy mixing
            });
            combined[i] = byte;
        }
        
        // Final PBKDF2 derivation for additional security
        return await crypto.subtle.deriveKey(
            { name: "PBKDF2", salt: combined.slice(0, 16), iterations: 100000, hash: "SHA-256" },
            await crypto.subtle.importKey("raw", combined, "PBKDF2", false, ["deriveKey"]),
            { name: "AES-GCM", length: 256 },
            false,
            ["encrypt", "decrypt"]
        );
    }
}
        

🎲 Individual Nonce System

Every file within a ZeroNote transfer receives its own unique nonce, ensuring that even if multiple files are shared together, each has independent cryptographic protection.

Nonce Generation and Management

class NonceManager {
    constructor() {
        this.nonceSize = 12; // 96-bit nonces for AES-GCM
        this.usedNonces = new Set(); // Prevent reuse
    }

    async generateFileNonce(fileId, fragmentKey) {
        let nonce;
        let attempts = 0;
        const maxAttempts = 100;

        do {
            // Generate cryptographically secure random nonce
            nonce = crypto.getRandomValues(new Uint8Array(this.nonceSize));
            
            // Add file-specific entropy
            const fileEntropy = await this.hashString(fileId);
            for (let i = 0; i < this.nonceSize; i++) {
                nonce[i] ^= fileEntropy[i % fileEntropy.length];
            }
            
            attempts++;
        } while (this.usedNonces.has(this.arrayToHex(nonce)) && attempts < maxAttempts);

        if (attempts >= maxAttempts) {
            throw new Error('Unable to generate unique nonce');
        }

        // Store nonce with expiration
        const nonceId = this.arrayToHex(nonce);
        this.usedNonces.add(nonceId);
        
        // Auto-cleanup after 15 minutes
        setTimeout(() => {
            this.usedNonces.delete(nonceId);
        }, 15 * 60 * 1000);

        return {
            nonce,
            nonceId,
            fragmentBinding: await this.bindNonceToFragment(nonce, fragmentKey)
        };
    }

    async bindNonceToFragment(nonce, fragmentKey) {
        // Cryptographically bind nonce to fragment key
        const binding = await crypto.subtle.digest('SHA-256', 
            new Uint8Array([...nonce, ...new Uint8Array(await crypto.subtle.exportKey('raw', fragmentKey))])
        );
        return new Uint8Array(binding);
    }
}
        

🚫 Zero-Trust Access Control

ZeroNote's zero-trust model ensures that files can only be accessed by validated owners or recipients. The system continuously verifies identity and authorization at every access attempt.

Access Validation Flow

class ZeroTrustAccessValidator {
    async validateFileAccess(request) {
        const validation = {
            timestamp: Date.now(),
            stages: []
        };

        try {
            // Stage 1: Token Validation
            const tokenValid = await this.validateAccessToken(request.token);
            validation.stages.push({ stage: 'token', valid: tokenValid });
            if (!tokenValid) throw new Error('Invalid access token');

            // Stage 2: Fragment Key Reconstruction
            const fragments = await this.retrieveUserFragments(request.userId, request.fileId);
            const reconstructed = await this.reconstructFragmentKey(fragments);
            validation.stages.push({ stage: 'fragments', valid: !!reconstructed });

            // Stage 3: Cryptographic Proof of Ownership
            const ownershipProof = await this.verifyOwnership(
                request.signature, 
                request.fileId, 
                request.userId
            );
            validation.stages.push({ stage: 'ownership', valid: ownershipProof });

            // Stage 4: Temporal Validity
            const timeValid = await this.validateTimeConstraints(request.fileId);
            validation.stages.push({ stage: 'temporal', valid: timeValid });

            // Stage 5: Access Pattern Analysis
            const behaviorValid = await this.analyzeBehaviorPattern(request);
            validation.stages.push({ stage: 'behavior', valid: behaviorValid });

            // All stages must pass
            const allValid = validation.stages.every(stage => stage.valid);
            
            if (allValid) {
                return {
                    granted: true,
                    accessKey: reconstructed,
                    expiration: Date.now() + (15 * 60 * 1000),
                    validation
                };
            }

            throw new Error('Access validation failed');

        } catch (error) {
            await this.logSecurityEvent('ACCESS_DENIED', {
                userId: request.userId,
                fileId: request.fileId,
                reason: error.message,
                validation
            });
            
            return { granted: false, reason: error.message };
        }
    }

    async verifyOwnership(signature, fileId, userId) {
        // Verify cryptographic signature proving file ownership
        const message = `${fileId}:${userId}:${Date.now()}`;
        const userPublicKey = await this.getUserPublicKey(userId);
        
        return await crypto.subtle.verify(
            "ECDSA",
            userPublicKey,
            signature,
            new TextEncoder().encode(message)
        );
    }
}
        

🔄 Proxy-Based Secure Delivery

Files are never directly accessible through web URLs. Instead, ZeroNote uses a sophisticated proxy system that validates every request and streams content through encrypted channels.

Secure Proxy Implementation

⏰ Auto-Expiration and Cleanup

ZeroNote implements multiple layers of automatic cleanup to ensure that shared files don't persist longer than necessary, providing perfect forward secrecy.

Cleanup Mechanisms

• Time-based: Automatic deletion after 15 minutes
• Event-based: Cleanup on successful view/download
• Session-based: Cleanup when browser tab closes
• Error-based: Cleanup on access violations
• System-based: Periodic cleanup of orphaned files

class AutoCleanupManager {
    constructor() {
        this.cleanupTasks = new Map();
        this.cleanupReasons = {
            TIMEOUT: 'timeout',
            SUCCESS: 'successful_access',
            ERROR: 'access_error',
            MANUAL: 'manual_cleanup',
            SYSTEM: 'system_cleanup'
        };
    }

    scheduleFileCleanup(fileId, maxLifetime = 15 * 60 * 1000) {
        // Cancel any existing cleanup for this file
        this.cancelCleanup(fileId);
        
        // Schedule new cleanup
        const timeoutId = setTimeout(async () => {
            await this.executeCleanup(fileId, this.cleanupReasons.TIMEOUT);
        }, maxLifetime);
        
        this.cleanupTasks.set(fileId, {
            timeoutId,
            scheduledAt: Date.now(),
            maxLifetime,
            reason: 'scheduled'
        });
        
        console.log(`Cleanup scheduled for file ${fileId} in ${maxLifetime}ms`);
    }

    async executeCleanup(fileId, reason) {
        try {
            // Remove from cleanup schedule
            this.cancelCleanup(fileId);
            
            // Securely delete file fragments
            await this.deleteFileFragments(fileId);
            
            // Clear fragment keys from memory
            await this.clearFragmentKeys(fileId);
            
            // Remove access tokens
            await this.revokeAccessTokens(fileId);
            
            // Clear nonces from used set
            await this.clearNonces(fileId);
            
            // Log cleanup event
            await this.auditLogger.logCleanup(fileId, reason);
            
            console.log(`File ${fileId} cleaned up successfully. Reason: ${reason}`);
            
        } catch (error) {
            console.error(`Cleanup failed for file ${fileId}:`, error);
            // Schedule retry
            setTimeout(() => {
                this.executeCleanup(fileId, this.cleanupReasons.SYSTEM);
            }, 5000);
        }
    }

    async deleteFileFragments(fileId) {
        // Securely overwrite file data before deletion
        const filePath = await this.getSecureFilePath(fileId);
        if (await this.fileExists(filePath)) {
            // Multiple-pass secure deletion
            await this.secureOverwrite(filePath, 3);
            await this.deleteFile(filePath);
        }
        
        // Delete metadata
        await this.deleteFileMetadata(fileId);
    }
}
        

🏗️ Webroot Isolation Architecture

One of ZeroNote's most important security features is storing all files outside the web-accessible directory structure. This prevents direct URL access and adds an additional layer of security.

/var/www/zeronote/                 # Web root
├── public/                        # Public assets only
├── templates/                     # View templates
└── src/                          # Application code

/var/secure/zeronote/             # Outside webroot
├── encrypted-files/              # Encrypted file storage
│   ├── fragments/               # Fragment key storage
│   ├── metadata/               # File metadata
│   └── temp/                   # Temporary processing
└── audit-logs/                  # Security audit logs
            

Secure Path Resolution

🔒 Real-World Security Implementation

Let's walk through a complete file sharing scenario to see how all these security layers work together:

Complete File Sharing Flow

1. File Upload: User uploads file with client-side encryption
2. Fragment Generation: System creates unique fragment keys
3. Nonce Assignment: Each file gets individual nonce
4. Secure Storage: File stored outside webroot with fragments
5. Access Token Creation: Temporary token generated for recipient
6. Proxy Delivery: File accessed only through validated proxy
7. Auto-Cleanup: All traces removed after access or timeout

🚀 Performance Optimizations

Despite the multiple security layers, ZeroNote maintains excellent performance through:

• Streaming Decryption: Files processed in chunks to minimize memory usage
• Fragment Caching: Validated fragments cached temporarily
• Parallel Processing: Multiple security validations run concurrently
• Efficient Cleanup: Background cleanup doesn't impact user experience

📚 Integration Examples

Here's how to integrate with ZeroNote's secure file sharing API:

// Client-side integration example
class ZeroNoteFileShare {
    async shareFile(file, recipientEmail, options = {}) {
        try {
            // Step 1: Client-side encryption
            const encryptedFile = await this.encryptFile(file);
            
            // Step 2: Upload to ZeroNote
            const uploadResponse = await fetch('/api/files/upload', {
                method: 'POST',
                body: encryptedFile.buffer,
                headers: {
                    'X-Recipient-Email': recipientEmail,
                    'X-File-Name': file.name,
                    'X-Expiry-Minutes': options.expiryMinutes || 15
                }
            });
            
            const { fileId, shareToken } = await uploadResponse.json();
            
            // Step 3: Generate secure share link
            const shareLink = this.generateShareLink(fileId, shareToken);
            
            return {
                success: true,
                shareLink,
                fileId,
                expiresAt: new Date(Date.now() + (options.expiryMinutes || 15) * 60000)
            };
            
        } catch (error) {
            return {
                success: false,
                error: error.message
            };
        }
    }
    
    async downloadFile(shareToken) {
        const response = await fetch(`/api/files/download/${shareToken}`);
        
        if (!response.ok) {
            throw new Error('File access denied or expired');
        }
        
        // Decrypt received file
        const encryptedData = await response.arrayBuffer();
        const transmissionKey = response.headers.get('X-Transmission-Key');
        const transmissionNonce = response.headers.get('X-Transmission-Nonce');
        
        return await this.decryptTransmission(encryptedData, transmissionKey, transmissionNonce);
    }
}
        

🔍 Security Audit & Compliance

ZeroNote's file transfer system has been designed to meet the highest security standards:

• SOC 2 Type II: Comprehensive security controls audit
• GDPR Compliance: Privacy by design implementation
• HIPAA Ready: Healthcare data protection standards
• Zero-Trust Architecture: NIST 800-207 compliance
• Continuous Monitoring: Real-time security event detection