> ## 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.

# Protection de la paternité du code

> Prouvez que vous avez écrit le code avec des attestations cryptographiques.

Prouvez que vous avez écrit le code. Truthlocks crée des attestations cryptographiques pour le code source, les API, la documentation et d'autres actifs numériques. Protégez votre propriété intellectuelle avec le hachage SHA-256 et une preuve horodatée — le tout sans que votre code source ne quitte jamais votre machine.

## Pourquoi l'attribution du code est importante

* **Litiges de propriété intellectuelle :** Prouvez que vous avez écrit le code avant que quelqu'un d'autre ne le revendique. La preuve cryptographique horodatée est une preuve admissible.
* **Protection open source:** Protégez vos contributions avant de les publier. Si quelqu'un les fork et en revendique la propriété, vous avez la preuve.
* **Travail contractuel :** Prouvez les dates de livraison et la paternité aux clients avec des attestations vérifiables indépendamment.
* **Vérification de portfolio:** Les employeurs ou clients potentiels peuvent vérifier que votre travail revendiqué est bien le vôtre.

## Comment ça marche

**1. Hacher votre code localement**

Calculez le SHA-256 de votre fichier source, de l'archive de votre dépôt ou de tout artefact.
Le contenu du fichier ne quitte jamais votre machine.

**2. Soumettre le hachage**

Envoyez le hachage, le titre et les métadonnées à l'API Truthlocks. Une attestation est
créé avec votre clé de signature personnelle.

**3. Ancrage au journal de transparence**

L'attestation est ancrée à un journal d'ajout uniquement, compatible RFC 6962
journal de transparence avec un horodatage immuable.

**4. Partager la preuve**

Obtenez une URL de preuve partageable, un badge intégrable ou un certificat téléchargeable.

## Protéger un seul fichier (CLI / API)

Hacher un fichier source et soumettre l'attestation :

```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"
  }'
```

## Protéger un référentiel entier

Créez une archive déterministe de votre dépôt et hachez-la :

```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]
>
> Utilisez `git archive` au lieu de compresser le répertoire — cela produit des résultats déterministes
> sortie quel que soit les métadonnées du système de fichiers, rendant le hachage reproductible.

## Exemples

```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']}")
```

## Intégration CI/CD

Automatisez la protection du code dans votre pipeline CI. Protégez chaque version :

```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"
      }'
```

## Ajouter un badge à votre README

Afficher le statut de vérification directement dans votre dépôt :

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

Le badge affiche dynamiquement l'état de vérification et est mis en cache pour des raisons de performance. Remplacez `ATTESTATION_ID` par l'ID renvoyé par le point de terminaison de frappe.

## Vérification

Tout le monde peut vérifier indépendamment la paternité de votre code :

1. Hachez le fichier original avec SHA-256 (même algorithme utilisé lors de la protection).
2. Visitez l'URL de preuve ou appelez `POST /v1/verify` avec l'ID d'attestation.
3. Le système confirme que le hachage correspond, vérifie la signature cryptographique et vérifie l'ancre du journal de transparence.

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

## Propriétés et limites de sécurité

Le hachage d'un fichier localement peut éviter de télécharger ses octets sources, mais ce n'est pas une preuve à divulgation nulle de connaissance. Inspectez le client choisi et la requête pour confirmer les métadonnées qu'il envoie.

Une attestation peut lier un hachage soumis à une clé de signature et à un point de contrôle de journal. C'est une preuve de la soumission enregistrée ; cela n'établit pas qui a initialement écrit le code, la paternité exclusive, la propriété, ou qu'une seule personne aurait pu le soumettre. La vérification dépend des clés de confiance et de la disponibilité du matériel de preuve.


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