Content-Addressable Access Token

The problem

Verifying permissions in complex systems is difficult because it is hard to ensure that the data being accessed hasn't been tampered with or moved.

What it does

It creates a digital key that checks if a piece of information is still in its original, correct location by verifying its unique digital fingerprint.

Why it matters

It ensures that access is only granted if the data remains exactly as it was intended to be.

Validation

It was run in the sandbox and it failed. run output shows an error/traceback — the artifact does NOT run clean.

$ python3 content_addressable_access.py
Traceback (most recent call last):
  File "/work/content_addressable_access.py", line 45, in <module>
    root = ContentAddressableNode('root_content')
           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
  File "/work/content_addressable_access.py", line 8, in __init__
    self.hash = self.compute_hash()
                ^^^^^^^^^^^^^^^^^^^
  File "/work/content_addressable_access.py", line 18, in compute_hash
    return hashlib.sha256(content_hash + children_hashes).hexdigest()
                          ~~~~~~~~~~~~~^~~~~~~~~~~~~~~~~
TypeError: can't concat str to bytes

No screenshot — there is nothing working to show. This is recorded as an unfinished sketch so the attempt stays visible instead of being quietly dropped.

The code

All of it — 60 lines, one file, standard library only.

import hashlib
import json

class ContentAddressableNode:
    def __init__(self, content=''):
        self.content = content
        self.children = {}
        self.hash = self.compute_hash()
        self.permissions = {
            'read': ['*'],  # Default permissions
            'write': ['admin']
        }

    def compute_hash(self):
        """Compute SHA-256 hash of node content and children"""
        children_hashes = ''.join(sorted(self.children.values()))
        content_hash = hashlib.sha256(self.content.encode()).digest()
        return hashlib.sha256(content_hash + children_hashes).hexdigest()

    def add_child(self, path, node):
        """Add child node at specified path"""
        self.children[path] = node.hash

    def validate_path(self, path_list):
        """Recursively validate path integrity"""
        current_hash = self.hash
        for part in path_list[:-1]:
            if part not in self.children:
                return False
            child_node = self.children[part]  # This would normally be a lookup in a DB
            if child_node != current_hash:
                return False
            current_hash = child_node
        return current_hash == path_list[-1]

    def check_access(self, token, required_permission, path):
        """Verify access based on token and path"""
        if not self.validate_path(path):
            return False
        return token in self.permissions.get(required_permission, [])

# Example usage
if __name__ == '__main__':
    # Create sample content tree
    root = ContentAddressableNode('root_content')
    
    user_node = ContentAddressableNode('user_data')
    root.add_child('users', user_node)
    
    document_node = ContentAddressableNode('document_content')
    user_node.add_child('docs', document_node)
    
    # Simulate access check
    token = 'admin'
    path = ['users', 'docs']  # Path to validate
    
    if root.check_access(token, 'read', path):
        print(f'Access granted for {token} to path {path}')
    else:
        print(f'Access denied for {token} to path {path}')