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

# Protección de autoría de código

> Demuestre que escribió el código con atestaciones criptográficas.

Demuestre que escribió el código. Truthlocks crea atestaciones criptográficas para código fuente, API, documentación y otros activos digitales. Proteja su propiedad intelectual con hashing SHA-256 y prueba con marca de tiempo, todo sin que su código fuente salga de su máquina.

## Por qué es importante la autoría del código

* **Disputas de IP:** Demuestre que escribió el código antes de que otra persona lo reclame. La prueba criptográfica con marca de tiempo es evidencia admisible.
* **Protección de código abierto:** Proteja sus contribuciones antes de publicarlas. Si alguien las bifurca y reclama la propiedad, usted tiene la prueba.
* **Trabajo por contrato:** Demuestre las fechas de entrega y la autoría a los clientes con atestaciones verificables de forma independiente.
* **Verificación de portafolio:** Los posibles empleadores o clientes pueden verificar que su trabajo declarado es genuinamente suyo.

## Cómo funciona

**1. Calcular hash de su código localmente**

Calcule el SHA-256 de su archivo fuente, archivo de repositorio o cualquier artefacto.
El contenido del archivo nunca sale de su máquina.

**2. Enviar el hash**

Envíe el hash, el título y los metadatos a la API de Truthlocks. Una atestación es
creado con su clave de firma personal.

**3. Anclaje al registro de transparencia**

La atestación está anclada a un registro de solo anexión, compatible con RFC 6962
registro de transparencia con una marca de tiempo inmutable.

**4. Compartir la prueba**

Obtenga una URL de prueba compartible, una insignia incrustable o un certificado descargable.

## Proteger un solo archivo (CLI / API)

Haga un hash de un archivo fuente y envíe la atestación:

```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 un repositorio completo

Cree un archivo determinista de su repositorio y hágale un hash:

```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]
>
> Utilice `git archive` en lugar de comprimir el directorio; produce resultados deterministas
> salida independientemente de los metadatos del sistema de archivos, lo que hace que el hash sea reproducible.

## Ejemplos

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

## Integración CI/CD

Automatice la protección de código en su pipeline de CI. Proteja cada lanzamiento:

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

## Añadir una Insignia a tu README

Muestre el estado de verificación directamente en su repositorio:

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

La insignia muestra dinámicamente el estado de verificación y se almacena en caché para mejorar el rendimiento. Reemplace `ATTESTATION_ID` con el ID devuelto por el endpoint de acuñación.

## Verificación

Cualquiera puede verificar de forma independiente la autoría de su código:

1. Calcule el hash del archivo original con SHA-256 (el mismo algoritmo utilizado durante la protección).
2. Visite la URL de prueba o llame a `POST /v1/verify` con el ID de atestación.
3. El sistema confirma que el hash coincide, verifica la firma criptográfica y comprueba el anclaje del registro de transparencia.

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

## Propiedades y límites de seguridad

Hacer un hash de un archivo localmente puede evitar la carga de sus bytes de origen, pero no es una prueba de conocimiento cero. Inspeccione el cliente y la solicitud elegidos para confirmar qué metadatos envía.

Una atestación puede vincular un hash enviado a una clave de firma y un punto de control de registro. Eso es evidencia de la presentación registrada; no establece quién escribió originalmente el código, la autoría exclusiva, la propiedad o que solo una persona podría haberlo enviado. La verificación depende de claves confiables y de la disponibilidad del material de prueba.


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