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

# Proteção de Autoria de Código

> Prove que você escreveu o código com atestados criptográficos.

Prove que você escreveu o código. Truthlocks cria atestados criptográficos para código-fonte, APIs, documentação e outros ativos digitais. Proteja sua propriedade intelectual com hashing SHA-256 e prova com carimbo de data/hora — tudo sem que seu código-fonte saia da sua máquina.

## Por que a autoria do código é importante

* **Disputas de IP:** Prove que você escreveu o código antes que outra pessoa o reivindique. A prova criptográfica com carimbo de data/hora é uma evidência admissível.
* **Proteção de código aberto:** Proteja suas contribuições antes de publicar. Se alguém fizer um fork e reivindicar a propriedade, você terá a prova.
* **Trabalho por contrato:** Prove datas de entrega e autoria a clientes com atestados verificáveis independentemente.
* **Verificação de portfólio:** Empregadores ou clientes em potencial podem verificar se seu trabalho reivindicado é genuinamente seu.

## Como funciona

**1. Faça o hash do seu código localmente**

Calcule o SHA-256 do seu arquivo de origem, arquivo de repositório ou qualquer artefato.
O conteúdo do arquivo nunca sai da sua máquina.

**2. Enviar o hash**

Envie o hash, título e metadados para a API Truthlocks. Um atestado é
criado com sua chave de assinatura pessoal.

**3. Ancorar ao registro de transparência**

O atestado é ancorado a um registro somente de adição, compatível com RFC 6962
registro de transparência com um carimbo de data/hora imutável.

**4. Compartilhar a prova**

Obtenha um URL de prova compartilhável, um selo incorporável ou um certificado para download.

## Proteger um Único Arquivo (CLI / API)

Faça o hash de um arquivo de origem e envie a atestação:

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

## Proteger um Repositório Inteiro

Crie um arquivo determinístico do seu repositório e faça o hash dele:

```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]
>
> Use `git archive` em vez de compactar o diretório — ele produz determinísticos
> saída, independentemente dos metadados do sistema de arquivos, tornando o hash reproduzível.

## Exemplos

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

## Integração CI/CD

Automatize a proteção de código em seu pipeline de CI. Proteja cada lançamento:

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

## Adicionar um Selo ao Seu README

Mostre o status de verificação diretamente em seu repositório:

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

O selo mostra dinamicamente o status de verificação e é armazenado em cache para desempenho. Substitua `ATTESTATION_ID` pelo ID retornado do endpoint de cunhagem.

## Verificação

Qualquer pessoa pode verificar independentemente a autoria do seu código:

1. Faça o hash do arquivo original com SHA-256 (mesmo algoritmo usado durante a proteção).
2. Visite a URL da prova ou chame `POST /v1/verify` com o ID da atestação.
3. O sistema confirma que o hash corresponde, verifica a assinatura criptográfica e verifica a âncora do log de transparência.

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

## Propriedades e limites de segurança

Fazer o hash de um arquivo localmente pode evitar o upload de seus bytes de origem, mas não é uma prova de conhecimento zero. Inspecione o cliente escolhido e solicite para confirmar quais metadados ele envia.

Uma atestação pode vincular um hash submetido a uma chave de assinatura e a um ponto de verificação de log. Isso é evidência da submissão registada; não estabelece quem escreveu originalmente o código, autoria exclusiva, propriedade, ou que apenas uma pessoa poderia tê-lo submetido. A verificação depende de chaves confiáveis e da disponibilidade do material de prova.


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