Guía de Instalación: OTS - One-Time-Secret Sharing Platform

Instala y configura OTS con cifrado AES-256 en el navegador. Guía verificada paso a paso para despliegue Docker Compose o nativo con Go v1.22.0.

Última actualización: 28 sep 2026 Versión soportada: v1.22.0 (estable) Licencia: Apache-2.0 Desarrollador: Luzifer Knut Ahlers

¿Qué es OTS?

OTS (One-Time-Secret Sharing Platform) es una plataforma open source desarrollada por Luzifer Knut Ahlers para compartir secretos de forma segura. Los datos se cifran con AES-256 simétrico en el navegador del cliente antes de ser transmitidos al servidor, garantizando que la infraestructura backend nunca pueda acceder al contenido descifrado.

Última versión estable: v1.22.0 (27 sep 2026) | Releases oficiales

La plataforma genera automáticamente una URL única que contiene el ID del secreto y la contraseña de acceso, permitiendo compartir información sensible sin exponerla en tránsito.

Arquitectura y Seguridad

Cifrado: AES-256 simétrico en el navegador (client-side encryption) - los secretos se cifran antes de salir del cliente
Almacenamiento: Memoria RAM o Redis/Valkey para persistencia configurable
Protocolo: HTTP/HTTPS con soporte completo para proxy inverso (nginx, caddy)
Licencia: Apache-2.0 - permite uso comercial y modificación
Lenguaje: Go (Golang) - compilado estáticamente o dinámicamente
Frontend: Vue.js 3 con componentes reactivos optimizados

Prerrequisitos Verificados

Docker Compose (Recomendado para Producción)

docker --version  # v20.10+ recomendado
docker-compose --version  # v2.0+ recomendado

Despliegue Nativo con Go

go version  # v1.21+ recomendado
node --version  # LTS (para construcción dinámica)
make  # para build-local

Instalación Docker Compose (Recomendado)

Paso 1: Crear Directorio de Trabajo

mkdir -p /path/to/ots-deployment
cd /path/to/ots-deployment

Paso 2: Configurar docker-compose.yml

version: '3.8'

services:
  ots-app:
    image: ghcr.io/luzifer/ots:v1.22.0
    restart: always
    environment:
      - REDIS_URL=redis://valkey:6379/0
      - SECRET_EXPIRY="604800"
      - STORAGE_TYPE=redis
    depends_on:
      - valkey
    ports:
      - "3000:3000"
  valkey:
    image: docker.io/valkey/valkey:9.1.2-alpine
    restart: always
    volumes:
      - ./data:/data

Paso 3: Ejecutar Contenedores

docker-compose up -d

Paso 4: Verificar Estado

docker-compose ps
# Debería mostrar todos los contenedores en estado "Up"

Instalación Nativa con Go

Paso 1: Clonar Repositorio Oficial

git clone https://github.com/Luzifer/ots.git
cd ots

Paso 2: Construcción Local Dinámica

make build-local

Paso 3: Construcción Estática para Producción (Recomendado)

CGO_ENABLED=0 make build-local

Nota: Para producción, usar compilación estática con CGO_ENABLED=0 reduce el tamaño del binario y elimina dependencias de librerías C.

Paso 4: Ejecutar Binario

./ots serve --listen 0.0.0.0:3000

Configuración Detallada

Variable	Descripción	Valor por defecto
REDIS_URL	Conexión a Redis/Valkey para persistencia	redis://default:password@host:6379/0
SECRET_EXPIRY	Expiración en segundos (0 = indefinida)	604800 (168h / 1 semana)
STORAGE_TYPE	método de almacenamiento	redis o mem
CUSTOMIZE	Ruta al archivo YAML de personalización	/etc/ots/customize.yaml
LISTEN	Interfaz y puerto de escucha	0.0.0.0:3000

Personalización Avanzada

---
appLogo: 'applogo.png'
overlayFSPath: '/etc/ots/assets'
customize:
  - name: "Custom Theme"
    value: "theme-dark.css"

Opciones disponibles en la Wiki oficial incluyen branding completo, temas CSS y configuración de API.

Consideraciones de Seguridad

1. HTTPS Obligatorio

Configurar proxy inverso (nginx) con Let's Encrypt para cifrado en tránsito.

2. Credenciales API (Opcional)

ots-cli create --instance https://ots.fyi -u myuser:mypass "mi secreto aquí"

3. Secretos de Redis/Valkey

Usar credenciales seguras y ACLs modernos (Redis v6+).

4. Expiración Automática

Configurar SECRET_EXPIRY para limitar ventana de acceso.

5. CORS en Proxy Inverso

Añadir headers CORS adecuados en nginx/caddy.

Backup y Persistencia

Montar Volumen en Redis/Valkey

volumes:
  - ./data:/data

Snapshot Manual de Persistencia

# Crear backup completo del volumen de datos
tar -czf backup-ots-$(date +%Y%m%d).tar.gz ./data/

# Ejemplo con fecha específica
tar -czf backup-ots-20260928.tar.gz ./data/

Comprobación Posterior

Paso 1: Verificar que el Servicio está Corriendo

docker-compose ps
# Debería mostrar todos los contenedores en estado "Up"

Paso 2: Acceder a la Interfaz Web

Abre tu navegador y navega a:

http://localhost:3000
https://ots.fyi (si usas proxy inverso con HTTPS)

Paso 3: Crear un Secreto de Prueba

ots-cli create --instance http://localhost:3000 "Secreto de prueba verificado"

Paso 4: Verificar Logs

docker-compose logs -f ots-app
# Debería mostrar mensajes de inicio sin errores

Actualización y Rollback

Actualizar a Nueva Versión

# Editar docker-compose.yml con nueva versión
sed -i 's/ghcr.io\/luzifer\/ots:v1.22.0/ghcr.io\/luzifer\/ots:v1.23.0/' docker-compose.yml

# Reiniciar contenedores
docker-compose up -d

# Verificar estado
docker-compose ps

Rollback a Versión Anterior

# Editar docker-compose.yml con versión anterior
sed -i 's/ghcr.io\/luzifer\/ots:v1.23.0/ghcr.io\/luzifer\/ots:v1.22.0/' docker-compose.yml

# Reiniciar contenedores
docker-compose up -d

Backup antes de Actualizar (Obligatorio)

# Crear snapshot del volumen de datos
tar -czf backup-ots-pre-update-$(date +%Y%m%d).tar.gz ./data/

OTS-CLI Oficial

Comandos Disponibles

Crear Secreto con Autenticación

ots-cli create --instance https://ots.fyi -u myuser:mypass "mi secreto aquí"

Listar Secretos Activos

ots-cli list --instance https://ots.fyi

Eliminar Secreto por ID

ots-cli delete --instance https://ots.fyi --id secret-id-123

Descargar Binarios Oficiales

Descarga binarios oficiales en Releases GitHub.

Errores Habituales

Error	Causa Probable	Solución Verificada
`Connection refused`	Puerto 3000 no expuesto	Verificar `ports: - "3000:3000"` en docker-compose.yml
`Redis connection failed`	REDIS_URL incorrecto	Usar formato: `redis://default:password@host:6379/0`
`Secrets expiring too fast`	SECRET_EXPIRY muy bajo	Aumentar a `604800` (1 semana) o usar 0 para indefinido
`HTTPS warnings in browser`	Falta certificado SSL	Configurar proxy inverso con Let's Encrypt
`CORS errors`	Headers CORS incorrectos	Añadir headers CORS en nginx/caddy
`Build failed: CGO error`	Go compilación dinámica sin librerías C	Usar `CGO_ENABLED=0 make build-local` para producción

Preguntas Frecuentes (FAQ)

¿Puede el servidor leer los secretos?

No. El cifrado AES-256 ocurre en el navegador antes del envío. El servidor solo almacena datos cifrados y nunca puede descifrarlos sin la contraseña de acceso.

¿Qué es mejor: Redis o memoria?

Redis/Valkey permite persistencia de datos entre reinicios y múltiples instancias. Memoria es más simple pero pierde todos los datos al reiniciar el servicio.

¿Cómo expirar secretos automáticamente?

Configurar SECRET_EXPIRY en segundos (ej: 604800 = 1 semana) o usar Redis TTL para control granular por secreto.

¿Es seguro compartir secretos públicos?

No recomendado. Los secretos deben compartirse solo con destinatarios específicos que conozcan la contraseña de acceso generada.

¿Cómo personalizar el branding?

Usar el archivo customize.yaml con opciones de logo, temas CSS y configuración de API disponibles en la Wiki oficial.

¿Puedo usar OTS sin Redis?

Sí, usando STORAGE_TYPE=mem, pero perderás persistencia entre reinicios. Solo recomendado para desarrollo o pruebas.