Formale Überprüfung von Tezos Smart Contracts
2 Antworten
- Stimmen
-
- 2019-01-31
Wenn wir damiteinverstanden sind,dass der Zweck der Analysen sowohl als Eigenschaftenbeweisen und den Benutzern vonintelligenten Verträgen helfen,sie zu verstehen,würdeich sagen:
- .
- Werte: Studieren,welche Wertejedes Element des Speicherplatzesin der Zukunft dauern kann.
- Effekte: studieren,welche Effektein der Zukunft auftreten können: Normalerweise können Transfers auftreten und auf welche Bedingungen.
- Eigentümer: Wer kanneine Änderung an welchem Teil des Speicherplatzes auslösen können.
If we agree that the purpose of analyses is to both prove properties and help users of smart contracts to understand them, I would say:
- Values: studying what values each element of the storage can take in the future.
- Effects: studying what effects can occur in the future: typically what transfers can occur and on what conditions.
- Ownership: who can trigger a change on what part of the storage.
-
Eine ziemlich lange Version dieser Antwort: https://link.medium.com/ru9ImrdepuA rather long version of this answer: https://link.medium.com/ru9idRDePU
- 2
- 2019-03-06
- FFF
-
- 2019-01-31
Dasist alsoeine riesige Frage,undich denke,esgibt viele Leute qualifizierter alsich,aberich werdeeine anfängliche Anleitung anbieten.
In Software-Stiftungen,ein Buch über CoQ,sprechen sie übereine implizierte Sprachenamens Imp. IMP hateine Syntax wie:
Z ::=x ;; Y ::=1 ;; Während ~ (z=0)tun Y ::=y * z ;; Z ::=Z - 1 ENDE
das sollteetwas leicht als Auftrag undetwaseinfaches Schleifen verstanden werden.
::=
ist zum Auftrag,eine While-Schleife,bis Z 0ist. In Python wäre dies:deffoo (x): z=x. y=1. Während z!=0: y=y * z Z -=1
Wir können danneinige der zugrunde liegenden Logikfür die Symbole definieren. Zum Beispiel
FIXPOINT AEVAL (A: AEXP): NAT:= passen Sie Amit ein | Anumn ⇒n | APLUS A1 A2 ⇒ (AEVAL A1) + (AEVAL A2) | Aminus A1 A2 ⇒ (AEVAL A1) - (AEVAL A2) | Amuliert A1 A2 ⇒ (AEVAL A1) * (AEVAL A2) Ende.
Dies definiert arithmetische Operationen.
Sie könnten auch reservierte Wörter analysieren,wie:
Induktive COM: Typ:= | Cskip | Cbreak (* & lt; --- Neu *) | Cass (X: String) (A: AEXP) | CSEQ (C1 C2: com) | CIF (B: BEXP) (C1 C2: com) | CWer (B: BEXP) (C: com).
Dann könnten Sie das Programmmit diesen definierten Typenin CoQ zuordnen,wie:
CSEQ (Cass Z x) (Csq (cass y (s o)) (CWer (BNOT (BNOT Z o)) (CSEQ (CASS y (Amut y z)) (Cass z (aminus z (s o)))))))
Wir können danneinige Beweise über diein dieser Sprache vorgenommenen Funktionen oder Anweisungenmit formaler Logik vornehmen. Hieristein Beispiel,dasbeweist,dass,wenn Znicht 4ist,xistnicht 2:
Beispiel ceval_example1: leer_st=[ X ::=2 ;; Test x ≤ 1 Dann y ::=3 Sonst z ::=4 Fische ] ⇒ (Z! - & GT; 4; X! - & GT; 2). Beweis. (* Wirmüssen den Zwischenstaat liefern *) Wenden Siee_seqmit (x! - > 2) an. - (* Befehlsbefehl *) Wenden Siee_ass an. Reflexivität. - (* Wenn Befehl *) Wenden Siee_iffalse an. Reflexivität. Wenden Siee_ass an. Reflexivität. Qed.
Inzwischen hoffeich,dass der Antrag aufeinen intelligenten Vertragetwas offensichtlichist. Wenn Sie den Smart-Vertragin CoQ abstrakten könnten,können Sie CoQ verwenden,umeinige Komponenten Ihres Smart-Vertrags streng zubeweisen. Esbesteht auch das Potenzial,den Bedingungeneinesintelligenten Vertragsin CoQ zu übersiedeln undihn von Michelson zu kompilieren,aber dasistnureine Möglichkeit,undich habe keine Beweisefür den Baugesehen.
ref: https://softwarefoundations.cis.upenn.edu/lf- aktuell/iMP.HTML
So this is a huge question and I think there are many people more qualified than me, but I'll offer some initial guidance.
In Software Foundations, a book on Coq, they talk about an implied language called Imp. Imp has a syntax like:
Z ::= X;; Y ::= 1;; WHILE ~(Z = 0) DO Y ::= Y * Z;; Z ::= Z - 1 END
Which should be somewhat easily understood as assignment and some simple looping.
::=
is for assignment, a while loop until z is 0. In python this would be:def foo(x): z = x y = 1 while z != 0: y = y * z z -= 1
We can then define some of the underlying logic for the symbols. For example,
Fixpoint aeval (a : aexp) : nat := match a with | ANum n ⇒ n | APlus a1 a2 ⇒ (aeval a1) + (aeval a2) | AMinus a1 a2 ⇒ (aeval a1) - (aeval a2) | AMult a1 a2 ⇒ (aeval a1) * (aeval a2) end.
This will define arithmetic operations.
You could also parse out reserved words, like:
Inductive com : Type := | CSkip | CBreak (* <--- NEW *) | CAss (x : string) (a : aexp) | CSeq (c1 c2 : com) | CIf (b : bexp) (c1 c2 : com) | CWhile (b : bexp) (c : com).
Then you could map the program to these defined types in Coq, like:
CSeq (CAss Z X) (CSeq (CAss Y (S O)) (CWhile (BNot (BEq Z O)) (CSeq (CAss Y (AMult Y Z)) (CAss Z (AMinus Z (S O))))))
We can then make some proofs about the functions or statements made in this language using formal logic. Here is an example proving that if z is not 4, then x is not 2:
Example ceval_example1: empty_st =[ X ::= 2;; TEST X ≤ 1 THEN Y ::= 3 ELSE Z ::= 4 FI ]⇒ (Z !-> 4 ; X !-> 2). Proof. (* We must supply the intermediate state *) apply E_Seq with (X !-> 2). - (* assignment command *) apply E_Ass. reflexivity. - (* if command *) apply E_IfFalse. reflexivity. apply E_Ass. reflexivity. Qed.
By now I hope the application to a smart contract is somewhat apparent. If you could abstract the smart contract into Coq, you could use Coq to prove some components of your smart contract rigorously. There is also potential to outline conditions of a smart contract in Coq and compile it to Michelson, but that's just a possibility and I haven't seen any evidence of its construction.
ref: https://softwarefoundations.cis.upenn.edu/lf-current/Imp.html
-
Vielen Dankfür die ausführliche Antwort.Es scheint,dass Siemireine Strategieerklären,wie *,umintelligente Verträgefür dieformale Analyse zuerstellen,hiermit COQ.Ich denke,meine Frage war stärker darauf konzentriert,auf welche Art von Ergebnissen/Garantien an der Kreuzung dessen,was durch statische Analyseerreichbarist und auseinem Blockchain-Anwendungs-Perspektiven wünschenswertist.Thanks for the detailed answer. It seems you are explaining to me a strategy of *how* to make smart contracts amenable to formal analysis, here by using Coq. I guess my question was more focused on what sorts of results/guarantees are at the intersection of of what is achieveable by static analysis and desireable from a blockchain application perspective.
- 0
- 2019-01-31
- Ezy
-
Wenn das die Frageist,könnten Sieeinfacheinen Füllerbauen.Verträge haben sehr starre Eingänge,daher wäreesnicht zu schwer,eine Vielzahl von Eingängen auszuprobieren und die Antworten anzuzeigen.https://en.wikipedia.org/wiki/fuzzing.if that's the question, you could just build a fuzzer. Contracts have very rigid inputs so it wouldn't be too hard to try a wide variety of inputs and see the responses given. https://en.wikipedia.org/wiki/Fuzzing
- 0
- 2019-02-01
- Rob
-
@Rob Ich habe das Gefühl,dassintelligente Verträgein einer übergreifenden Welt lebenmüssen,so dasseinfache Debugging-Tools solche Fuzzer sind,diemöglicherweisenicht ausreichen.@Rob I feel that smart contracts must live in an adversarial world so simple debugging tools such are fuzzers might not be enough.
- 1
- 2019-02-02
- FFF
-
Sie könntenimmermehrtun,aberin Betracht ziehen,dass die sehr strengen Einschränkungen an den Eingängenfür den Fuzz-Test auseiner Vielzahl von Gegnerverträgen wahrscheinlicheine große Anzahlmöglicher Szenarien abdecken.Ich denke,ein Honeypot-Szenario wiein der Solidität wäre leichter zutesten und schwieriger zumerken,da alleexternen Anrufenach dem Abschluss des Vertrags stattfinden.you could ALWAYS do more, but considering the very strict constraints on inputs fuzz testing from a variety of adversarial contracts would probably cover a large number of possible scenarios. I think a honeypot scenario like in solidity would be easier to test for and harder to orchestrate since all external calls happen after the contract's completion.
- 0
- 2019-02-02
- Rob
Was sind die Analysen von Tezos-Smart-Verträgen,die DAPPS-Autoren ammeisten zugute kommen?
Umnur klar zu sein,durch "Analyse"meine meine "statische Programmanalyse".Siehe zum Beispiel hier .
Grundsätzlich wäre die Idee,dass vor dem Begeheneinesintelligenten Vertrags an die Ketteeine statische Analyseentweder auf dem High-Niveau-Quellcode oder alternativ direkt das Kompilierungszielin Michelson durchführen würde,um verschiedene Laufzeiteigenschaften des Programms zubewerten.