Ten przewodnik jest przeznaczony jako odniesienie dla deweloperów, którzy chcą wdrożyć zweryfikowane kompilacje dla swoich programów na platformie Solana. Omówimy, czym są zweryfikowane kompilacje, jak z nich korzystać, specjalne uwagi oraz najlepsze praktyki, aby zapewnić autentyczność Twojego programu w łańcuchu bloków.

Czym są zweryfikowane kompilacje?

Zweryfikowane kompilacje zapewniają, że wykonywalny program, który wdrażasz w sieci Solana, odpowiada kodowi źródłowemu w Twoim repozytorium. Dzięki temu deweloperzy i użytkownicy mogą mieć pewność, że program działający w łańcuchu bloków dokładnie odpowiada publicznej bazie kodu, co promuje przejrzystość i bezpieczeństwo.

Proces weryfikacji polega na porównaniu skrótu programu w łańcuchu bloków ze skrótem programu lokalnie zbudowanego z kodu źródłowego. To zapewnia brak rozbieżności między obiema wersjami.

Chociaż zweryfikowana kompilacja nie powinna być uważana za bardziej bezpieczną niż niezweryfikowana, umożliwia ona deweloperom samodzielne zweryfikowanie, że kod źródłowy odpowiada temu, co zostało wdrożone w łańcuchu bloków. Korzystając z kodu źródłowego, deweloper może następnie zweryfikować, co kod wykonuje podczas wysyłania transakcji.

Pipeline zweryfikowanych kompilacji został opracowany i jest utrzymywany przez Ellipsis Labs oraz OtterSec. Aby uzyskać więcej szczegółów, zapoznaj się z przewodnikiem w oryginalnym repozytorium zweryfikowanych kompilacji oraz procesem weryfikacji kompilacji bezpośrednio w zestawie narzędzi Anza, gdy tylko będzie tam obsługiwany.

Jak to działa?

Proces weryfikacji polega na porównaniu skrótu programu znajdującego się w łańcuchu bloków z hashem programu zbudowanego lokalnie z kodu źródłowego. Budujesz swój program w kontrolowanym środowisku, używając Solana Verify CLI i Dockera. Zapewnia to, że proces budowy jest deterministyczny i spójny na różnych systemach. Po uzyskaniu pliku wykonywalnego możesz wdrożyć go w sieci Solana. Podczas procesu budowy zostanie utworzony PDA programu verify. Ten PDA zawiera wszystkie dane niezbędne do weryfikacji programu. PDA zawiera adres programu, URL repozytorium git, hash commita oraz argumenty użyte do budowy programu.

Korzystając z danych zawartych w PDA, każdy może lokalnie uruchomić polecenie verify program i sprawdzić, czy program został zbudowany z dostarczonego kodu źródłowego. Następnie każdy może zweryfikować to samodzielnie, całkowicie bez zaufania, lub uruchomić własne verify API zarządzane przez OtterSec, aby zapewnić użytkownikom łatwy punkt dostępu do sprawdzania weryfikacji. Możesz już zobaczyć te wywołania API używane w Solana Explorer i SolanaFM, między innymi.

Dlaczego warto korzystać ze zweryfikowanych buildów?

Korzystanie ze zweryfikowanych buildów zapewnia następujące korzyści:

• Bezpieczeństwo: Gwarancja, że program działający w łańcuchu bloków odpowiada kodowi źródłowemu, co zapobiega złośliwym zmianom.

• Przejrzystość: Umożliwia innym użytkownikom i deweloperom weryfikację, że program w łańcuchu bloków jest godny zaufania, porównując go z publiczną bazą kodu.

• Zaufanie: Zwiększa zaufanie użytkowników, ponieważ zweryfikowane buildy pokazują, że zachowanie programu w łańcuchu bloków jest zgodne z publicznym kodem. Tworząc programy możliwe do weryfikacji, minimalizujesz ryzyko związane z uruchamianiem nieautoryzowanego lub złośliwego kodu. Zapewnia to również zgodność z najlepszymi praktykami i ułatwia badaczom bezpieczeństwa kontakt z Tobą. Ponadto portfele i inne narzędzia mogą łatwiej akceptować transakcje z Twojego programu, o ile jest on zweryfikowany.

• Odkrywalność: Gdy udostępniasz zweryfikowaną wersję swojego programu, każdy może znaleźć Twój kod źródłowy, dokumentację, SDK programu lub IDL, a także łatwo skontaktować się z Tobą przez GitHub w przypadku problemów.

Jak tworzyć zweryfikowane wersje?

Aby stworzyć zweryfikowane wersje, musisz wykonać następujące kroki:

Podsumowanie:

• Zatwierdź swój kod w publicznym repozytorium
• Zbuduj zweryfikowaną wersję w Dockerze
• Wdróż zweryfikowaną wersję
• Zweryfikuj wdrożony program względem publicznego API

Jeśli zweryfikujesz swój program, który nie został zbudowany w kontenerze Dockera, najprawdopodobniej weryfikacja się nie powiedzie, ponieważ kompilacje programów Solana nie są deterministyczne na różnych systemach.

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>

Jak zweryfikować program kontrolowany przez Multisig, taki jak Squads

Aby zdalna weryfikacja działała, musisz zapisać dane weryfikacyjne w PDA podpisanym przez autorytet programu. Jeśli Twój program jest kontrolowany przez multisig, możesz wyeksportować tę transakcję zapisu PDA i przesłać ją za pomocą Squads Protocol lub innego rozwiązania multisig według własnego wyboru.

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

Weryfikacja z obrazu docker

Możesz również zweryfikować swój program względem obrazu docker, uruchamiając następujące polecenie:

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

To polecenie ładuje obraz zapisany pod adresem ellipsislabs/hello_world_verifiable_build:latest i weryfikuje, czy hash ścieżki wykonywalnej w kontenerze jest taki sam jak hash programu on-chain przekazanego do polecenia. Ponieważ build został już przesłany do obrazu, nie ma potrzeby pełnej rekompilacji pliku wykonywalnego, co mogłoby zająć dużo czasu.

Dockerfile, który tworzy obraz ellipsislabs/hello_world_verifiable_build:latest, znajduje się w repozytorium ellipsis labs /examples/hello_world.

Poniżej znajduje się oczekiwany wynik:

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 ✅

Przykładowa zweryfikowana kompilacja

Oto przykład weryfikacji przykładowego programu o ID FWEYpBAf9WsemQiNbAewhyESfR38GBBHLrCaU3MpEKWv przy użyciu kodu źródłowego z tego repozytorium:

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

Domyślnie polecenie verify-from-repo pobiera ostatni commit z głównej gałęzi. Możesz także określić konkretny commit, jeśli chcesz dalej pracować nad repozytorium, używając parametru commit-hash: --commit-hash 5b82b86f02afbde330dff3e1847bed2d42069f4e

Na koniec możesz również bezpośrednio zweryfikować program za pomocą API 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

Polecenie --remote wysyła żądanie kompilacji do API OtterSec, co uruchamia zdalną kompilację twojego programu. Po zakończeniu kompilacji system weryfikuje, czy hash programu w łańcuchu bloków odpowiada hashowi wygenerowanego artefaktu kompilacji z twojego repozytorium.

Popularne programy, które już zostały zweryfikowane

Phoenix

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

Końcowy wynik:

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

Zwróć uwagę, że musieliśmy określić library-name, ponieważ repozytorium Squads zawiera wiele programów. Używamy flagi --bpf, ponieważ squads_mpl był wcześniej zweryfikowany z Anchor.

Końcowy wynik:

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

Końcowy wynik:

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

Końcowy wynik:

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

Najczęściej zadawane pytania

Moja weryfikacja kończy się niepowodzeniem. Co powinienem zrobić?

Sprawdź te typowe problemy:

• Nieprawidłowy podpisujący: Potwierdź, że Twój podpisujący jest uprawnieniem do aktualizacji programu, uruchamiając solana program show YourProgramId
• Brak PDA on-chain: Uruchom solana-verify verify-from-repo -um i wybierz TAK po wyświetleniu pytania. Bez przesłania PDA, API nie może pobrać Twoich metadanych weryfikacji.
• Niezgodność danych PDA: Zaktualizuj swój PDA, jeśli ponownie wdrożyłeś swój program. Dane PDA muszą być zgodne z wdrożonym programem.
• Nieprawidłowy hash commit: Utwórz swój PDA używając dokładnego hash commit, który wdrożyłeś
• Różnice w środowisku budowania: Użyj Dockera z solana-verify podczas tworzenia swojego PDA

Mój lokalny hash kompilacji nie pasuje do hash on-chain. Dlaczego?

Zazwyczaj oznacza to:

• Używasz różnych wersji toolchain Rust/Solana
• Twoje zależności zostały zaktualizowane pomiędzy kompilacjami
• Nie kompilowałeś w kontenerze Docker
• Pobrałeś niewłaściwy commit

Rozwiąż to, kompilując za pomocą solana-verify build w Dockerze, używając dokładnego commit, który wdrożyłeś.

Jak długo potrwa moja weryfikacja?

Spodziewaj się następujących ram czasowych w zależności od rozmiaru programu:

• Proste programy: 1-5 minut
• Złożone programy: 5-15 minut
• Bardzo duże programy: Do 30 minut

Śledź postęp, używając endpointu statusu zadania.

Mój program jest niezmienny (brak uprawnień do aktualizacji). Jak mogę go zweryfikować?

Jeśli Twój program nie ma uprawnień do aktualizacji lub został uczyniony niezmiennym, zanim mogłeś utworzyć PDA, mamy dla tej sytuacji adres na białej liście. Skontaktuj się z nami pod adresem contact@osec.io, a pomożemy Ci zweryfikować Twój program.

Czym jest PDA i dlaczego ma znaczenie?

Twoje PDA (Program Derived Account) umożliwia weryfikację bez zaufania:

• Przechowywanie On-Chain: Przechowuj metadane weryfikacji (URL repozytorium, hash commita, parametry budowania) on-chain w PDA należącym do programu Otter Verify (verifycLy8mB96wd9wqq3WDXQwM4oU6r42Th37Db9fC)
• Kryptograficzne Powiązanie: Twoje PDA jest wyprowadzone z adresu Twojego programu, tworząc niezmienne powiązanie z danymi weryfikacji
• Zdecentralizowane Zaufanie: Każdy może odczytać Twoje PDA i niezależnie zweryfikować Twój program

Dlaczego muszę utworzyć PDA przed użyciem API?

API działa tylko z on-chain PDA, ponieważ:

• Bez Zaufania: API odrzuca arbitralne dane - używa tylko tego, co Twój upgrade authority zapisał on-chain
• Prostsze: Po prostu podaj signer + program_id; API pobiera wszystko inne z Twojego PDA
• Odporne na Manipulacje: Twoje PDA tworzy niezmienny zapis, który każdy może zweryfikować niezależnie
• Dowód Własności: Twój signer musi być upgrade authority, kryptograficznie potwierdzając, że kontrolujesz program

Jak często powinienem weryfikować swój program?

Weryfikuj swój program:

• Po każdym wdrożeniu lub aktualizacji
• Gdy aktualizujesz swoje repozytorium źródłowe
• Nie martw się o ponowną weryfikację w innych przypadkach - API automatycznie ponownie weryfikuje wszystkie programy co 24 godziny

Co się dzieje, gdy aktualizuję swój program?

Wykonaj te kroki po aktualizacji:

1. API wykrywa Twoją aktualizację i usuwa weryfikację Twojego programu.
2. Zaktualizuj swoje PDA nowymi metadanymi weryfikacji:

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

3. Prześlij nowe żądanie weryfikacji używając swojego upgrade authority
4. API zweryfikuje Twoją nową wersję względem zaktualizowanego PDA

Ważne: Zawsze aktualizuj swoje PDA używając upgrade authority z nowym hash commita dla zaktualizowanego programu.

Czy mogę zaufać wynikom weryfikacji?

Tak – system jest zaprojektowany tak, aby był niezależny i możliwy do samodzielnej weryfikacji:

Co czyni go godnym zaufania:

• PDA On-Chain: Twoje metadane weryfikacji są przechowywane w blockchainie, nie są kontrolowane przez żaden centralny organ
• Dowód uprawnień do aktualizacji: Tylko organ uprawniony do aktualizacji Twojego programu może utworzyć/zaktualizować PDA
• Niezależna weryfikacja: Każdy może zweryfikować, odczytując Twoje PDA i uruchamiając solana-verify lokalnie
• Ciągła ponowna weryfikacja: API automatycznie ponownie weryfikuje wszystkie programy co 24 godziny

Zrozum te ograniczenia:

• Weryfikacja potwierdza, że kod źródłowy odpowiada wdrożeniu – NIE potwierdza, że Twój kod jest bezpieczny
• Zawsze przeglądaj kod przed interakcją z programami
• Zweryfikowany ≠ poddany audytowi lub bezpieczny
• Sprawdź repozytorium i commit w PDA, aby upewnić się, że pochodzi z zaufanego źródła

Jak mogę samodzielnie zweryfikować program?

Zweryfikuj dowolny program samodzielnie, odczytując jego PDA w blockchainie i uruchamiając weryfikację lokalnie:

Krok 1: Odczytaj PDA w blockchainie

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

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

Krok 2: Zweryfikuj lokalnie

# 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

To dowodzi:

1. Metadane PDA są autentyczne (przechowywane w blockchainie)
2. Kod źródłowy w repozytorium PDA odpowiada wdrożonemu programowi
3. Nie musisz ufać API – zweryfikuj wszystko samodzielnie w blockchainie

Czy ktoś inny może zweryfikować mój program bez pozwolenia?

Tak, dlatego wymagamy, aby osobą podpisującą był organ uprawniony do aktualizacji. Weryfikację uznajemy za ważną tylko wtedy, gdy osoba podpisująca jest organem uprawnionym do aktualizacji.

Czego potrzebuję do tworzenia weryfikowalnych kompilacji?

Zainstaluj te narzędzia:

• Docker (do deterministycznych kompilacji)
• Cargo (menedżer pakietów Rust)
• Solana Verify CLI: cargo install solana-verify
• Publiczne repozytorium Git z Twoim kodem źródłowym

Czy mogę weryfikować prywatne repozytoria?

Nie - weryfikacja wymaga publicznego kodu źródłowego:

• Twoje PDA przechowuje publiczny adres URL repozytorium, do którego każdy ma dostęp
• Weryfikacja bezpośrednia zależy od publicznego dostępu do kodu
• Użytkownicy muszą przeczytać Twój kod źródłowy, aby zrozumieć, co robi Twój program
• Cały cel polega na umożliwieniu użytkownikom niezależnej weryfikacji zgodności źródła z wdrożeniem

Prywatne repozytoria psują podstawowy model zaufania systemu weryfikacji.

Jak zweryfikować program kontrolowany przez Squads Multisig?

Wykonaj następujące kroki dla programów kontrolowanych przez 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...

Krytyczne: Zawsze weryfikuj lokalnie (krok 2), aby potwierdzić, że hash kompilacji się zgadza przed wyeksportowaniem transakcji PDA.

Podsumowanie

Używanie zweryfikowanych kompilacji na Solanie zapewnia integralność i wiarygodność Twoich programów w sieci oraz umożliwia programistom bezpośrednie znalezienie Twoich SDK z poziomu Solana Explorer. Wykorzystując narzędzia takie jak Solana Verify CLI i Docker, możesz utrzymywać weryfikowalne i bezpieczne kompilacje zgodne z Twoim kodem źródłowym. Zawsze podejmuj niezbędne środki ostrożności, aby używać spójnych środowisk i rozważ rozwiązania zarządzania dla bezpiecznych aktualizacji i wdrożeń.

Bezpieczeństwo + Zastrzeżenie

Chociaż zweryfikowane kompilacje są potężnym narzędziem zapewniającym integralność Twoich programów Solana, nie są one całkowicie bezpośrednie w domyślnej konfiguracji. Obrazy dockera są budowane i hostowane przez Solana Foundation.

Pamiętaj, że budujesz swój projekt w pobranym obrazie dockera i że cała Twoja konfiguracja jest kopiowana do tego obrazu dockera w celu kompilacji, w tym potencjalnie wrażliwe informacje.

Jeśli chcesz mieć całkowicie bezpośrednią konfigurację, możesz sam zbudować obrazy dockera i hostować je na własnej infrastrukturze. W ten sposób możesz mieć pewność, że obrazy dockera nie zostały zmodyfikowane. Skrypty do tworzenia własnych obrazów dockera znajdziesz w repozytorium Verified builds, możesz je sforkować i uruchomić akcje github samodzielnie lub zweryfikować ich poprawność.

Ponadto w przypadku zdalnej weryfikacji w pewnym stopniu ufasz API OtterSec oraz Solana Explorer.

API lub Solana Explorer mogą potencjalnie wyświetlać nieprawidłowe informacje, jeśli zostaną naruszone.

Jeśli chcesz mieć całkowicie beztrustawą konfigurację, możesz samodzielnie uruchomić Verify API lub przeprowadzić weryfikację programu lokalnie za pomocą polecenia verify-from-repo, wykorzystując dane weryfikacyjne w łańcuchu zapisane w PDA, które jest wyprowadzone z organu wdrażającego program i programu weryfikacyjnego.

Program weryfikacyjny został wdrożony przez zespół OtterSec i nie jest jeszcze zamrożony, więc może być w dowolnym momencie zaktualizowany.

Solana Foundation, OtterSec oraz zespół Ellipsis Labs nie ponoszą odpowiedzialności za jakiekolwiek straty lub szkody, które mogą wystąpić w wyniku korzystania z potoku zweryfikowanych kompilacji.

Security.txt dla programów Solana

Oprócz zweryfikowanych kompilacji możesz również dodać plik security.txt do swojego programu. W przyszłości, po implementacji, security.txt będzie zawierać klucz publiczny weryfikatora w celu łatwego dostępu do danych weryfikacyjnych przechowywanych w PDA weryfikacyjnym. PDA zawierający wszystkie informacje potrzebne do zbudowania i zweryfikowania programu jest wyprowadzany z adresu programu i klucza publicznego weryfikatora. Domyślnie jest to ten sam klucz publiczny, który zbudował i wdrożył program. Ale może to być również inny klucz publiczny, który można określić w security.txt.

Funkcja security.txt pozwala deweloperom osadzać informacje kontaktowe i bezpieczeństwa bezpośrednio w ich inteligentnych kontraktach Solana. Zainspirowane securitytxt.org, to podejście zapewnia standaryzowany sposób, dzięki któremu badacze bezpieczeństwa mogą skontaktować się z opiekunami projektu, nawet jeśli znają tylko adres kontraktu.

Po co używać security.txt?

W przypadku wielu projektów, szczególnie mniejszych lub prywatnych, identyfikacja deweloperów na podstawie samego adresu kontraktu może być trudna i czasochłonna. Osadzenie pliku security.txt w programie zapewnia, że badacze bezpieczeństwa mogą łatwo skontaktować się z odpowiednimi osobami, potencjalnie zapobiegając exploitom i zapewniając terminowe zgłaszanie błędów.

Jak zaimplementować security.txt

Aby dodać security.txt do swojego programu Solana, wykonaj następujące kroki:

Dodaj zależność solana-security-txt do swojego pliku Cargo.toml:

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

Użyj makra security_txt! w swoim kontrakcie, aby zdefiniować informacje o bezpieczeństwie. Możesz dołączyć dane kontaktowe, adresy URL projektu, a nawet politykę bezpieczeństwa. Oto przykład:

#[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!"
}

Po osadzeniu informacji security.txt w programie można je łatwo odpytać za pomocą narzędzi takich jak Solana Explorer, zapewniając dostępność danych kontaktowych i informacji o bezpieczeństwie dla każdego, kto chce zgłosić potencjalne problemy.

Najlepsze praktyki

• Używaj linków: W przypadku informacji, które mogą się zmieniać (np. dane kontaktowe), zaleca się linkowanie do strony internetowej zamiast kodowania ich na stałe w kontrakcie. Pozwala to uniknąć częstych aktualizacji programu.

• Weryfikacja: Przed wdrożeniem zweryfikuj format i zawartość za pomocą narzędzia query-security-txt, które może walidować zarówno programy onchain, jak i lokalne pliki binarne:

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

Osadzając informacje kontaktowe dotyczące bezpieczeństwa bezpośrednio w swoim kontrakcie, ułatwiasz badaczom dotarcie do Ciebie, wspierając lepsze bezpieczeństwo i komunikację w ekosystemie Solana.

To jest przykład tego, jak security.txt wygląda w Solana Explorer

Projekt security.txt jest utrzymywany przez Neodyme Labs

Możesz sprawdzić status weryfikacji i przeglądać zweryfikowane programy na verify.osec.io.