> ## Documentation Index
> Fetch the complete documentation index at: https://docs.truthlocks.com/llms.txt
> Use this file to discover all available pages before exploring further.

# Schutz der Code-Urheberschaft

> Beweisen Sie mit kryptografischen Attestierungen, dass Sie den Code geschrieben haben.

Beweisen Sie, dass Sie den Code geschrieben haben. Truthlocks erstellt kryptografische Attestierungen für Quellcode, APIs, Dokumentation und andere digitale Assets. Schützen Sie Ihr geistiges Eigentum mit SHA-256-Hashing und zeitgestempeltem Nachweis – alles, ohne dass Ihr Quellcode jemals Ihr Gerät verlässt.

## Warum Code-Autorenschaft wichtig ist

* **IP-Streitigkeiten:** Beweisen Sie, dass Sie den Code geschrieben haben, bevor jemand anderes ihn beansprucht. Zeitgestempelte kryptografische Beweise sind zulässige Beweismittel.
* **Open-Source-Schutz:** Schützen Sie Ihre Beiträge vor der Veröffentlichung. Wenn jemand forkt und Eigentum beansprucht, haben Sie einen Beweis.
* **Auftragsarbeiten:** Beweisen Sie Liefertermine und Urheberschaft gegenüber Kunden mit unabhängig überprüfbaren Attestierungen.
* **Portfolio-Verifizierung:** Potenzielle Arbeitgeber oder Kunden können überprüfen, ob Ihre beanspruchte Arbeit tatsächlich Ihnen gehört.

## Funktionsweise

**1. Ihren Code lokal hashen**

Berechnen Sie den SHA-256 Ihrer Quelldatei, Ihres Repository-Archivs oder eines beliebigen Artefakts.
Der Dateiinhalt verlässt niemals Ihren Rechner.

**2. Hash einreichen**

Senden Sie den Hash, den Titel und die Metadaten an die Truthlocks API. Eine Attestierung ist
mit Ihrem persönlichen Signaturschlüssel erstellt.

**3. Anker zum Transparenzprotokoll**

Die Attestierung ist an ein nur anhängbares, RFC 6962-kompatibles
Transparenzprotokoll mit einem unveränderlichen Zeitstempel.

**4. Den Nachweis teilen**

Erhalten Sie eine teilbare Proof-URL, ein einbettbares Badge oder ein herunterladbares Zertifikat.

## Eine einzelne Datei schützen (CLI / API)

Eine Quelldatei hashen und die Bestätigung übermitteln:

```bash theme={null}
# Hash a file locally (macOS/Linux)
HASH=$(sha256sum main.go | awk '{print $1}')

# Submit to Truthlocks API
curl -X POST https://api.truthlocks.com/v1/consumer/mint \
  -H "Authorization: Bearer $TOKEN" \
  -H "Content-Type: application/json" \
  -d '{
    "content_hash": "'$HASH'",
    "title": "main.go — Core Engine v2.1",
    "description": "Primary application entry point and engine logic",
    "file_name": "main.go",
    "content_type": "code",
    "category": "source_code",
    "visibility": "public"
  }'
```

## Ein gesamtes Repository schützen

Erstellen Sie ein deterministisches Archiv Ihres Repos und hashen Sie es:

```bash theme={null}
# Create a deterministic git archive
git archive --format=tar HEAD | sha256sum | awk '{print $1}'

# Or hash a specific commit
git archive --format=tar <commit-sha> | sha256sum | awk '{print $1}'
```

> [!TIP]
>
> Verwenden Sie `git archive` anstelle des Zippens des Verzeichnisses – es erzeugt deterministische
> Ausgabe unabhängig von Dateisystem-Metadaten, wodurch der Hash reproduzierbar wird.

## Beispiele

```javascript Node.js theme={null}
import { createHash } from 'crypto';
import { readFileSync } from 'fs';

// Hash a source file
const content = readFileSync('src/index.ts');
const hash = createHash('sha256').update(content).digest('hex');

// Submit to Truthlocks
const response = await fetch('https://api.truthlocks.com/v1/consumer/mint', {
method: 'POST',
headers: {
'Authorization': 'Bearer ' + token,
'Content-Type': 'application/json',
},
body: JSON.stringify({
content_hash: hash,
title: 'src/index.ts — API Server',
description: 'Main API server entry point',
content_type: 'code',
category: 'source_code',
}),
});

const { attestation_id, content_hash, protected_at, verify_url } = await response.json();
console.log('Proof URL:', verify_url);
console.log('Hash:', content_hash, 'Protected at:', protected_at);

```

```go Go theme={null}
package main

import (
    "crypto/sha256"
    "encoding/hex"
    "fmt"
    "os"
)

func hashFile(path string) (string, error) {
    data, err := os.ReadFile(path)
    if err != nil {
        return "", err
    }
    h := sha256.Sum256(data)
    return hex.EncodeToString(h[:]), nil
}

func main() {
    hash, err := hashFile("main.go")
    if err != nil {
        panic(err)
    }
    fmt.Printf("SHA-256: %s\n", hash)
    // Submit hash to POST /v1/consumer/mint
}
```

```python Python theme={null}
import hashlib
import requests

def hash_file(path: str) -> str:
    with open(path, "rb") as f:
        return hashlib.sha256(f.read()).hexdigest()

file_hash = hash_file("app.py")

response = requests.post(
    "https://api.truthlocks.com/v1/consumer/mint",
    headers={
        "Authorization": f"Bearer {token}",
        "Content-Type": "application/json",
    },
    json={
        "content_hash": file_hash,
        "title": "app.py — Flask Application",
        "content_type": "code",
        "category": "source_code",
    },
)

data = response.json()
print(f"Proof: {data['verify_url']}")
print(f"Hash: {data['content_hash']}  Protected at: {data['protected_at']}")
```

## CI/CD-Integration

Automatisieren Sie den Codeschutz in Ihrer CI-Pipeline. Schützen Sie jede Veröffentlichung:

```yaml GitHub Actions theme={null}
- name: Protect release artifact
  run: |
    HASH=$(sha256sum dist/app.tar.gz | awk '{print $1}')
    curl -X POST https://api.truthlocks.com/v1/consumer/mint \
      -H "Authorization: Bearer $TRUTHLOCKS_TOKEN" \
      -H "Content-Type: application/json" \
      -d '{
        "content_hash": "'$HASH'",
        "title": "Release build",
        "description": "Production release artifact",
        "content_type": "code",
        "category": "release"
      }'
```

## Fügen Sie Ihrem README ein Badge hinzu

Verifizierungsstatus direkt in Ihrem Repository anzeigen:

```md Markdown theme={null}
[![Protected by Truthlocks](https://verify.truthlocks.com/badge/ATTESTATION_ID)](https://verify.truthlocks.com/proof/ATTESTATION_ID)
```

Das Abzeichen zeigt dynamisch den Verifizierungsstatus an und wird zur Leistungsoptimierung zwischengespeichert. Ersetzen Sie `ATTESTATION_ID` durch die vom Mint-Endpunkt zurückgegebene ID.

## Verifizierung

Jeder kann Ihre Code-Urheberschaft unabhängig überprüfen:

1. Hashen Sie die Originaldatei mit SHA-256 (derselbe Algorithmus, der während des Schutzes verwendet wurde).
2. Besuchen Sie die Proof-URL oder rufen Sie `POST /v1/verify` mit der Attestierungs-ID auf.
3. Das System bestätigt die Übereinstimmung des Hashs, verifiziert die kryptografische Signatur und überprüft den Transparenzlog-Anker.

```bash theme={null}
# Verify an attestation
curl -X POST https://api.truthlocks.com/v1/verify \
  -H "Content-Type: application/json" \
  -d '{"attestation_id": "b2c3d4e5-..."}'
```

## Sicherheitseigenschaften und -grenzen

Das lokale Hashen einer Datei kann das Hochladen ihrer Quellbytes vermeiden, ist aber kein Zero-Knowledge-Beweis. Überprüfen Sie den ausgewählten Client und die Anfrage, um zu bestätigen, welche Metadaten er sendet.

Eine Bestätigung kann einen übermittelten Hash an einen Signierschlüssel und einen Protokoll-Checkpoint binden. Das ist ein Nachweis der aufgezeichneten Übermittlung; es stellt nicht fest, wer den Code ursprünglich geschrieben hat, die ausschließliche Urheberschaft, das Eigentum oder dass nur eine Person ihn hätte übermitteln können. Die Verifizierung hängt von vertrauenswürdigen Schlüsseln und dem Vorhandensein des Beweismaterials ab.


This documentation is built and hosted on [Mintlify](https://mintlify.com), a developer documentation platform.