Esta guía está destinada a ser una referencia para desarrolladores que desean implementar compilaciones verificadas para sus programas en Solana. Cubriremos qué son las compilaciones verificadas, cómo usarlas, consideraciones especiales y mejores prácticas para garantizar la autenticidad de tu programa en la cadena.

¿Qué son las compilaciones verificadas?

Las compilaciones verificadas aseguran que el programa ejecutable que despliegas en la red de Solana coincide con el código fuente en tu repositorio. Al hacer esto, los desarrolladores y usuarios pueden tener la confianza de que el programa ejecutándose en la cadena corresponde exactamente al código base público, promoviendo la transparencia y seguridad.

El proceso de verificación implica comparar el hash del programa en la cadena con el hash del programa compilado localmente a partir del código fuente. Esto asegura que no haya discrepancias entre las dos versiones.

Aunque una compilación verificada no debe considerarse más segura que una no verificada, la compilación permite a los desarrolladores verificar por sí mismos que el código fuente coincide con lo que está desplegado en la cadena. Usando el código fuente, un desarrollador puede entonces validar qué ejecuta el código al enviar una transacción.

El proceso de compilaciones verificadas fue concebido y es mantenido por Ellipsis Labs y OtterSec. Para más detalles, sigue la guía en el repositorio original de compilaciones verificadas así como el proceso de verificación de compilación directamente en el conjunto de herramientas Anza, una vez que sea compatible.

¿Cómo funciona?

El proceso de verificación se realiza comparando el hash del programa en la cadena con el hash del programa compilado localmente a partir del código fuente. Compilas tu programa en un entorno controlado utilizando Solana Verify CLI y Docker. Esto asegura que el proceso de compilación sea determinista y consistente en diferentes sistemas. Una vez que tienes el ejecutable, puedes desplegarlo en la red Solana. Durante el proceso de compilación se crea una PDA del programa de verificación. Esta PDA contiene todos los datos necesarios para verificar el programa. La PDA contiene la dirección del programa, la URL de git, el hash del commit y los argumentos utilizados para compilar el programa.

Utilizando los datos en la PDA, cualquiera puede ejecutar el comando del programa de verificación localmente y comprobar si el programa fue compilado a partir del código fuente proporcionado. Entonces todos pueden verificar por sí mismos de manera completamente confiable o pueden ejecutar su propia API de verificación mantenida por OtterSec para proporcionar un punto de acceso fácil para que los usuarios comprueben la verificación. Ya puedes ver estas llamadas a la API siendo utilizadas en el Explorador de Solana y SolanaFM, entre otros lugares.

¿Por qué debería usar compilaciones verificadas?

El uso de compilaciones verificadas proporciona los siguientes beneficios:

• Seguridad: Garantiza que el programa que se ejecuta en la cadena coincide con el código fuente, evitando alteraciones maliciosas.

• Transparencia: Permite a otros usuarios y desarrolladores validar que el programa en la cadena es confiable comparándolo con el código base público.

• Confianza: Aumenta la confianza del usuario, ya que las compilaciones verificadas demuestran que el comportamiento de tu programa en la cadena está alineado con tu código público. Al construir programas verificables, minimizas los riesgos asociados con la ejecución de código no autorizado o malicioso. También asegura que cumples con las mejores prácticas y proporcionas a los investigadores de seguridad una forma fácil de contactarte. Además, las carteras y otras herramientas pueden permitir transacciones desde tu programa más fácilmente siempre que esté verificado.

• Descubribilidad: Cuando proporcionas una compilación verificada de tu programa, todos pueden encontrar tu código fuente, documentación, SDK del programa o IDL y también pueden contactarte fácilmente a través de GitHub en caso de que haya algún problema.

¿Cómo creo compilaciones verificadas?

Para crear compilaciones verificadas, deberás seguir estos pasos:

Resumen:

• Confirma tu código en un repositorio público
• Construye una compilación verificada en Docker
• Despliega la compilación verificada
• Verifica el programa desplegado contra la API pública

Si verificas tu programa que no está construido en un contenedor Docker, muy probablemente fallará porque las compilaciones de programas de Solana no son deterministas en diferentes sistemas.

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

cargo install solana-verify

cargo install solana-verify --version $VERSION

cargo install solana-verify --git https://github.com/Ellipsis-Labs/solana-verifiable-build --rev 13a1db2

[workspace]
members = ["program/programs/*"]
resolver = "2"

[profile.release]
overflow-checks = true
lto = "fat"
codegen-units = 1

[profile.release.build-override]
opt-level = 3
incremental = false
codegen-units = 1

[package]
name = "waffle"
version = "0.1.0"
edition = "2021"

[lib]
name = "waffle"
crate-type = ["cdylib", "lib"]

[dependencies]
solana-program = "2.1.0"

solana-verify build

solana-verify build --library-name $PROGRAM_LIB_NAME

solana-verify get-executable-hash target/deploy/$PROGRAM_LIB_NAME.so

solana program deploy -u $NETWORK_URL target/deploy/$PROGRAM_LIB_NAME.so --program-id $PROGRAM_ID --with-compute-unit-price 50000 --max-sign-attempts 100 --use-rpc

solana-verify get-program-hash -u $NETWORK_URL $PROGRAM_ID

solana-verify verify-from-repo -u $NETWORK_URL --program-id $PROGRAM_ID https://github.com/$REPO_PATH --commit-hash $COMMIT_HASH --library-name $PROGRAM_LIB_NAME --mount-path $MOUNT_PATH

solana-verify verify-from-repo --remote -um --program-id PhoeNiXZ8ByJGLkxNfZRnkUfjvmuYqLR89jjFHGqdXY https://github.com/Ellipsis-Labs/phoenix-v1

solana-verify remote submit-job --program-id <program-id> --uploader <address>

solana-verify remote get-job-status --job-id <job-id>

Cómo verificar tu programa cuando está controlado por una multifirma como Squads

Para que la verificación remota funcione, necesitas escribir los datos de verificación en un PDA firmado por la autoridad del programa. Si tu programa está controlado por una multifirma, puedes exportar esta transacción de escritura PDA y enviarla a través de Squads Protocol u otra solución de multifirma de tu elección.

solana-verify build

solana config set --url "PayedMainnetRPCAddress" // the public endpoint will be rate limited too much
solana program deploy target/deploy/verify_squads.so

solana-verify verify-from-repo https://github.com/solana-developers/verify-squads --program-id 6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD

solana-verify export-pda-tx https://github.com/solana-developers/verify-squads --program-id 6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD --uploader <your program authority> --encoding base58 --compute-unit-price 0

P6vBfcPaaXb8fZoT3NBAYEcdtEj7tubA1k2gBxmFKZ3UWF5YyrmDMFTvLKALCJoUuRsPAjMckudYruCu3eeWQtuDrFbEMLxLFutnKXac974fnkMivcwUdY66VLjbxQT6ATmcy7F4hBtz1G4P1h6iBJLhb8WtrtgY3i4qq45MUEb7RjuMEfUFXKrNgPdGxkz5xvMHq3dxKRcpmEK5k2DkeW6SUQYBVe19Ga3B9GyhTX8k3CMt9JCEah13WyRnQd8GjoK6sTEvGJym6xDNvmd8yiJYSNcaYwEJsjHEUf4Yh6kAC7ki2KRvVAr3NVe1gjqK9McrwSQjtUatvydTG8Zovcr7PPUEMf3yPMgKXjZLB2QpkH63yTTYdNAnWFuv9E6b6nYRqye5XcNi436yKw5U14fXh65yK34bgYLi9328UT1huJELsJU9BRGnGUmb6GWp6c2WL5BhnzgNTSnt9TXFfEgUMzhvKzpVBxLP44hwqqBdyUhHFysCF37531PnmiESq8x1xou23xJ6FcQbc199754MkqQd7tX9CUznGzAEqHGkzn3VBoJnojsKtgYmiTYbdRsT1CU18MbYEE7WvGAvXyxxbpNzbAcc94HrnM6cqRGmwhEBroPfFghTdmzg9D

solana-verify remote submit-job --program-id 6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD
--uploader <your program authority>

solana-verify build
solana program write-buffer target/deploy/verify_squads.so --with-compute-unit-price 50000 --max-sign-attempts 50

solana program set-buffer-authority Fu3k79g53ZozAj47uq1tXrFy4QbQYh7y745DDsxjtyLR --new-buffer-authority 3JG6ULvZVCrkKtSSskKNJGe8RNZGFe8Ruev9KUhxzK5K

solana-verify export-pda-tx https://github.com/solana-developers/verify-squads --program-id 6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD --uploader 3JG6ULvZVCrkKtSSskKNJGe8RNZGFe8Ruev9KUhxzK5K

solana-verify remote submit-job --program-id 6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD --uploader 3JG6ULvZVCrkKtSSskKNJGe8RNZGFe8Ruev9KUhxzK5K

Verification request sent with request id: b63339d2-163e-49ac-b55d-3454c1c2b5b3
Verification in progress... ⏳ [00:18:02] ✅ Process completed. (Done in 18
minutes) Program 6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD has been verified.
✅ The provided GitHub build matches the on-chain hash. On Chain Hash:
96f8c3d9400258f7759408d1f6f8435b4a24d9b52f5a0340d97907e567cb8773 Executable
Hash: 96f8c3d9400258f7759408d1f6f8435b4a24d9b52f5a0340d97907e567cb8773 Repo URL:
https://github.com/Woody4618/verify-squads/tree/0fb0a2e30c15c51732c0ad5e837975a6f7bbc7ed
Check the verification status at:
https://verify.osec.io/status/6XBGfP17P3KQAKoJb2s5M5fR4aFTXzPeuC1af2GYkvhD Job
url: https://verify.osec.io/job/b63339d2-163e-49ac-b55d-3454c1c2b5b3

Verificar desde imagen docker

También puedes verificar tu programa contra una imagen docker ejecutando el siguiente comando:

solana-verify verify-from-image -e
examples/hello_world/target/deploy/hello_world.so -i
ellipsislabs/hello_world_verifiable_build:latest -p
2ZrriTQSVekoj414Ynysd48jyn4AX6ZF4TTJRqHfbJfn

Este comando carga la imagen almacenada en ellipsislabs/hello_world_verifiable_build:latest, y verifica que el hash del path ejecutable en el contenedor sea el mismo que el hash del programa en cadena proporcionado al comando. Debido a que la compilación ya fue subida a una imagen, no es necesaria una recompilación completa del ejecutable, lo cual puede tomar mucho tiempo.

El Dockerfile que crea la imagen ellipsislabs/hello_world_verifiable_build:latest se puede encontrar en el repositorio de ellipsis labs /examples/hello_world.

A continuación se muestra la salida esperada:

Verifying image: "ellipsislabs/hello_world_verifiable_build:latest", on network
"https://api.mainnet.solana.com" against program ID
2ZrriTQSVekoj414Ynysd48jyn4AX6ZF4TTJRqHfbJfn Executable path in container:
"examples/hello_world/target/deploy/hello_world.so"

Executable hash:
08d91368d349c2b56c712422f6d274a1e8f1946ff2ecd1dc3efc3ebace52a760 Program hash:
08d91368d349c2b56c712422f6d274a1e8f1946ff2ecd1dc3efc3ebace52a760 Executable
matches on-chain program data ✅

Ejemplo de compilación verificada

Aquí hay un ejemplo de verificación de un programa de ejemplo con el ID FWEYpBAf9WsemQiNbAewhyESfR38GBBHLrCaU3MpEKWv usando el código fuente de este repositorio:

solana-verify verify-from-repo https://github.com/solana-developers/verified-program --url YOUR-RPC-URL --program-id FWEYpBAf9WsemQiNbAewhyESfR38GBBHLrCaU3MpEKWv --mount-path waffle --library-name waffle --commit-hash 5b82b86f02afbde330dff3e1847bed2d42069f4e

Por defecto, el comando verify-from-repo toma el último commit de la rama principal. También puedes definir un commit específico en caso de que quieras continuar trabajando en el repositorio usando el parámetro commit-hash: --commit-hash 5b82b86f02afbde330dff3e1847bed2d42069f4e

Finalmente, también puedes verificar directamente el programa contra la API de OtterSec:

solana-verify verify-from-repo https://github.com/solana-developers/verified-program --url YOUR-RPC-URL --remote --program-id FWEYpBAf9WsemQiNbAewhyESfR38GBBHLrCaU3MpEKWv --mount-path waffle --library-name waffle --commit-hash 5b82b86f02afbde330dff3e1847bed2d42069f4e

El comando --remote envía una solicitud de compilación a la API de OtterSec, que desencadena una compilación remota de tu programa. Una vez que la compilación está completa, el sistema verifica que el hash en cadena de tu programa coincida con el hash del artefacto de compilación generado desde tu repositorio.

Programas populares que ya están verificados

Phoenix

solana-verify verify-from-repo -um --program-id PhoeNiXZ8ByJGLkxNfZRnkUfjvmuYqLR89jjFHGqdXY https://github.com/Ellipsis-Labs/phoenix-v1

Resultado final:

Executable Program Hash from repo: 6877a5b732b3494b828a324ec846d526d962223959534dbaf4209e0da3b2d6a9
On-chain Program Hash: 6877a5b732b3494b828a324ec846d526d962223959534dbaf4209e0da3b2d6a9
Program hash matches ✅

Squads V3

solana-verify verify-from-repo https://github.com/Squads-Protocol/squads-mpl --commit-hash c95b7673d616c377a349ca424261872dfcf8b19d --program-id SMPLecH534NA9acpos4G6x7uf3LWbCAwZQE9e8ZekMu -um --library-name squads_mpl --bpf

Nota que necesitamos especificar el library-name porque el repositorio de Squads incluye múltiples programas. Usamos la bandera --bpf porque squads_mpl fue verificado previamente con Anchor.

Resultado final:

Executable Program Hash from repo: 72da599d9ee14b2a03a23ccfa6f06d53eea4a00825ad2191929cbd78fb69205c
On-chain Program Hash: 72da599d9ee14b2a03a23ccfa6f06d53eea4a00825ad2191929cbd78fb69205c
Program hash matches ✅

Drift V2

solana-verify verify-from-repo -um --program-id dRiftyHA39MWEi3m9aunc5MzRF1JYuBsbn6VPcn33UH https://github.com/drift-labs/protocol-v2 --commit-hash 110d3ff4f8ba07c178d69f9bfc7b30194fac56d6 --library-name drift

Resultado final:

Executable Program Hash from repo: e31d58edeabc3c30bf6f2aa60bfaa5e492b41ec203e9006404b463e5adee5828
On-chain Program Hash: e31d58edeabc3c30bf6f2aa60bfaa5e492b41ec203e9006404b463e5adee5828
Program hash matches ✅

Marginfi V2

solana-verify verify-from-repo -um --program-id MFv2hWf31Z9kbCa1snEPYctwafyhdvnV7FZnsebVacA https://github.com/mrgnlabs/marginfi-v2 --commit-hash d33e649e415c354cc2a1e3c49131725552d69ba0 --library-name marginfi -- --features mainnet-beta

Resultado final:

Executable Program Hash from repo: 890d68f48f96991016222b1fcbc2cc81b8ef2dcbf280c44fe378c523c108fad5
On-chain Program Hash: 890d68f48f96991016222b1fcbc2cc81b8ef2dcbf280c44fe378c523c108fad5
Program hash matches ✅

Preguntas frecuentes

Mi verificación está fallando. ¿Qué debo hacer?

Verifica estos problemas comunes:

• Firmante incorrecto: Confirma que tu firmante es la autoridad de actualización del programa ejecutando solana program show YourProgramId
• Sin PDA en cadena: Ejecuta solana-verify verify-from-repo -um y selecciona SÍ cuando se te solicite. Sin cargar el PDA, la API no puede recuperar tus metadatos de verificación.
• Discrepancia de datos del PDA: Actualiza tu PDA si has vuelto a desplegar tu programa. Los datos de tu PDA deben coincidir con tu programa desplegado.
• Hash de commit incorrecto: Crea tu PDA usando el hash de commit exacto que desplegaste
• Diferencias en el entorno de compilación: Usa Docker con solana-verify al crear tu PDA

El hash de mi compilación local no coincide con el hash en cadena. ¿Por qué?

Esto generalmente significa:

• Estás usando versiones diferentes de las herramientas de Rust/Solana
• Tus dependencias se actualizaron entre compilaciones
• No compilaste en un contenedor Docker
• Hiciste checkout del commit equivocado

Soluciona esto compilando con solana-verify build en Docker usando el commit exacto que desplegaste.

¿Cuánto tiempo tomará mi verificación?

Espera estos plazos según el tamaño de tu programa:

• Programas simples: 1-5 minutos
• Programas complejos: 5-15 minutos
• Programas muy grandes: Hasta 30 minutos

Rastrea tu progreso usando el endpoint de estado del trabajo.

Mi programa es inmutable (sin autoridad de actualización). ¿Cómo puedo verificarlo?

Si tu programa no tiene autoridad de actualización o se volvió inmutable antes de que pudieras crear un PDA, tenemos una dirección en lista blanca para esta situación. Contáctanos en contact@osec.io y te ayudaremos a verificar tu programa.

¿Qué es el PDA y por qué importa?

Tu PDA (Program Derived Account) permite la verificación sin necesidad de confianza:

• Almacenamiento On-Chain: Almacena tus metadatos de verificación (URL del repositorio, hash del commit, parámetros de compilación) on-chain en un PDA propiedad del programa Otter Verify (verifycLy8mB96wd9wqq3WDXQwM4oU6r42Th37Db9fC)
• Enlace Criptográfico: Tu PDA se deriva de la dirección de tu programa, creando un enlace inmutable a tus datos de verificación
• Confianza Descentralizada: Cualquiera puede leer tu PDA y verificar tu programa de forma independiente

¿Por qué debo crear el PDA antes de usar la API?

La API solo funciona con PDAs on-chain porque:

• Sin Necesidad de Confianza: La API rechaza datos arbitrarios - solo utiliza lo que tu autoridad de actualización almacenó on-chain
• Más Simple: Solo proporciona firmante + program_id; la API obtiene todo lo demás de tu PDA
• A Prueba de Manipulación: Tu PDA crea un registro inmutable que cualquiera puede verificar de forma independiente
• Prueba de Propiedad: Tu firmante debe ser la autoridad de actualización, demostrando criptográficamente que controlas el programa

¿Con qué frecuencia debo verificar mi programa?

Verifica tu programa:

• Después de cada implementación o actualización
• Cuando actualices tu repositorio fuente
• No te preocupes por volver a verificar de otra manera - la API reverifica automáticamente todos los programas cada 24 horas

¿Qué sucede cuando actualizo mi programa?

Sigue estos pasos después de actualizar:

1. La API detecta tu actualización y anula la verificación de tu programa.
2. Actualiza tu PDA con los nuevos metadatos de verificación:

solana-verify verify-from-repo -um \
  --program-id YourProgramId... \
  https://github.com/your-org/your-program

3. Envía una nueva solicitud de verificación usando tu autoridad de actualización
4. La API verificará tu nueva versión comparándola con el PDA actualizado

Importante: Actualiza siempre tu PDA usando tu autoridad de actualización con el nuevo hash del commit para el programa actualizado.

¿Puedo confiar en los resultados de verificación?

Sí - el sistema está diseñado para ser sin confianza y verificable de forma independiente:

Lo que lo hace confiable:

• PDA On-Chain: Los metadatos de tu verificación residen en la cadena, no están controlados por ninguna autoridad central
• Prueba de autoridad de actualización: Solo la autoridad de actualización de tu programa puede crear/actualizar el PDA
• Verificación independiente: Cualquiera puede verificar leyendo tu PDA y ejecutando solana-verify localmente
• Re-verificación continua: La API re-verifica automáticamente todos los programas cada 24 horas

Comprende estas limitaciones:

• La verificación confirma que el código fuente coincide con el despliegue - NO que tu código sea seguro
• Siempre revisa el código antes de interactuar con programas
• Verificado ≠ auditado, o seguro
• Revisa el repositorio y el commit en el PDA para confirmar que proviene de una fuente confiable

¿Cómo puedo verificar un programa de forma independiente?

Verifica cualquier programa tú mismo leyendo su PDA on-chain y ejecutando la verificación localmente:

Paso 1: Leer el PDA On-Chain

# Install solana-verify if you haven't
cargo install solana-verify

# Get the PDA data
solana-verify list-program-pdas --program-id YourProgramId...

Paso 2: Verificar localmente

# Verify using the repository and commit & other arguments from the PDA
solana-verify verify-from-repo \
  --program-id YourProgramId... \
  https://github.com/your-org/your-program
  --commit-hash <commit-hash>
  ... (other arguments from the PDA)
# Confirm the hash output matches the on-chain program hash

Esto demuestra:

1. Los metadatos del PDA son auténticos (almacenados en la cadena)
2. El código fuente en el repositorio del PDA coincide con el programa desplegado
3. No necesitas confiar en la API - verifica todo tú mismo en la cadena

¿Puede alguien más verificar mi programa sin permiso?

Sí, esa es la razón por la que requerimos que el firmante sea la autoridad de actualización. Solo consideramos que la verificación es válida si el firmante es la autoridad de actualización.

¿Qué necesito para crear builds verificables?

Instala estas herramientas:

• Docker (para builds determinísticos)
• Cargo (gestor de paquetes de Rust)
• CLI de Solana Verify: cargo install solana-verify
• Un repositorio Git público con tu código fuente

¿Puedo verificar repositorios privados?

No - la verificación requiere código fuente público:

• Tu PDA almacena una URL de repositorio público a la que cualquiera puede acceder
• La verificación sin confianza depende del acceso público al código
• Los usuarios necesitan leer tu código fuente para entender qué hace tu programa
• El propósito completo es permitir que los usuarios verifiquen de forma independiente que el código fuente coincide con el despliegue

Los repositorios privados rompen el modelo de confianza fundamental del sistema de verificación.

¿Cómo verifico un programa controlado por Squads Multisig?

Sigue estos pasos para programas controlados por multisig:

# 1. Build and deploy normally
solana-verify build
solana program deploy <your-program.so> --program-id YourProgramId...

# 2. Verify locally first - confirm the hash matches
solana-verify verify-from-repo -um \
  --program-id YourProgramId... \
  https://github.com/your-org/your-program

# 3. Export the PDA creation transaction
solana-verify export-pda-tx \
  --program-id YourProgramId... \
  https://github.com/your-org/your-program

# 4. Execute the PDA transaction through your Squads Multisig interface

# 5. After multisig execution, trigger remote verification
solana-verify remote submit-job \
  --program-id YourProgramId... \
  --uploader YourMultisigAddress...

Crítico: Siempre verifica localmente (paso 2) para confirmar que el hash de compilación coincide antes de exportar la transacción PDA.

Conclusión

Usar compilaciones verificadas en Solana asegura la integridad y confiabilidad de tus programas en la red y permite a los desarrolladores encontrar tus SDKs directamente desde un Solana Explorer. Al aprovechar herramientas como Solana Verify CLI y Docker, puedes mantener compilaciones verificables y seguras que se alinean con tu código fuente. Toma siempre las precauciones necesarias para usar entornos consistentes, y considera soluciones de gobernanza para actualizaciones y despliegues seguros.

Seguridad + Descargo de responsabilidad

Aunque las compilaciones verificadas son una herramienta poderosa para asegurar la integridad de tus programas Solana, no es completamente sin confianza en la configuración predeterminada. Las imágenes de docker son construidas y alojadas por la Solana Foundation.

Ten en cuenta que estás compilando tu proyecto en una imagen docker descargada y que toda tu configuración se copia en esa imagen docker para compilar, incluyendo información potencialmente sensible.

Si deseas tener una configuración completamente sin confianza, puedes construir las imágenes docker tú mismo y alojarlas en tu propia infraestructura. De esta forma puedes asegurarte de que las imágenes docker no hayan sido manipuladas. Puedes encontrar los scripts para crear tus propias imágenes docker en el repositorio de Verified builds y puedes bifurcarlo y ejecutar las acciones de github tú mismo o validar que sean correctas.

Además, para la verificación remota estás confiando en la API de OtterSec y en el Solana Explorer hasta cierto punto.

La API o Solana Explorer podrían potencialmente mostrar información incorrecta si se ven comprometidos.

Si deseas tener una configuración completamente sin confianza, puedes ejecutar la API de Verificación tú mismo o ejecutar la verificación del programa localmente utilizando el comando verify-from-repo usando los datos de verificación on-chain que están guardados en un PDA que se deriva de la autoridad de despliegue del programa y del programa de verificación.

El programa de verificación está desplegado por el equipo de OtterSec y aún no está congelado, por lo que puede actualizarse en cualquier momento.

La Fundación Solana, OtterSec y el equipo de Ellipsis Labs no son responsables por ninguna pérdida o daño que pueda ocurrir por el uso del pipeline de compilaciones verificadas.

Security.txt para programas de Solana

Además de las compilaciones verificadas, también puedes añadir un archivo security.txt a tu programa. En el futuro, una vez implementado, el security.txt contendrá la clave pública del verificador para un fácil acceso a los datos de verificación almacenados en el PDA de verificación. El PDA que contiene toda la información necesaria para compilar y verificar un programa se deriva de la dirección del programa y del pubkey del verificador. Por defecto, este es el mismo pubkey que compiló y desplegó el programa. Pero también puede ser otro pubkey que se puede especificar en el security.txt.

La función security.txt permite a los desarrolladores incorporar información de contacto y seguridad directamente dentro de sus contratos inteligentes de Solana. Inspirado en securitytxt.org, este enfoque proporciona una forma estandarizada para que los investigadores de seguridad se pongan en contacto con los mantenedores del proyecto, incluso si solo conocen la dirección del contrato.

¿Por qué usar security.txt?

Para muchos proyectos, especialmente los más pequeños o privados, identificar a los desarrolladores únicamente desde la dirección del contrato puede ser difícil y consumir mucho tiempo. Incorporar un archivo security.txt dentro del programa garantiza que los investigadores de seguridad puedan contactar fácilmente a las personas correctas, previniendo potencialmente exploits y asegurando reportes de errores oportunos.

Cómo implementar security.txt

Para agregar un security.txt a tu programa de Solana, sigue estos pasos:

Agrega la dependencia solana-security-txt a tu Cargo.toml:

[dependencies]
solana-security-txt = "1.1.1"

Usa la macro security_txt! en tu contrato para definir tu información de seguridad. Puedes incluir datos de contacto, URLs del proyecto e incluso una política de seguridad. Aquí hay un ejemplo:

#[cfg(not(feature = "no-entrypoint"))]
use {default_env::default_env, solana_security_txt::security_txt};

#[cfg(not(feature = "no-entrypoint"))]
security_txt! {
    name: "MyProject",
    project_url: "https://myproject.com",
    contacts: "email:security@myproject.com,discord:security#1234",
    policy: "https://myproject.com/security-policy",

    // Optional Fields
    preferred_languages: "en,de",
    source_code: "https://github.com/solana-developers/solana-game-preset",
    source_revision: "5vJwnLeyjV8uNJSp1zn7VLW8GwiQbcsQbGaVSwRmkE4r",
    source_release: "",
    encryption: "",
    auditors: "Verifier pubkey: 5vJwnLeyjV8uNJSp1zn7VLW8GwiQbcsQbGaVSwRmkE4r",
    acknowledgements: "Thank you to our bug bounty hunters!"
}

Una vez que la información de security.txt esté incorporada en tu programa, puede consultarse fácilmente a través de herramientas como el Explorador de Solana, garantizando que tus detalles de contacto y seguridad estén disponibles para cualquiera que busque reportar posibles problemas.

Mejores prácticas

• Usa Enlaces: Para información que probablemente cambie (p. ej., datos de contacto), se recomienda enlazar a una página web en lugar de codificarla directamente en el contrato. Esto evita la necesidad de actualizaciones frecuentes del programa.

• Verificación: Antes de desplegar, verifica el formato y contenido usando la herramienta query-security-txt, que puede validar tanto programas onchain como binarios locales:

query-security-txt target/bpfel-unknown-unknown/release/my_contract.so

Al incorporar la información de contacto de seguridad directamente en tu contrato, facilitas que los investigadores te contacten, fomentando una mejor seguridad y comunicación dentro del ecosistema de Solana.

Este es un ejemplo de cómo se ve security.txt en el Explorador de Solana

El proyecto security.txt es mantenido por Neodyme Labs

Puedes verificar el estado de verificación y explorar programas verificados en verify.osec.io.