Vérification formelle des contrats intelligents Tezos
2 réponses
- votes
-
- 2019-01-31
Sinous convenons que lebut des analysesest deprouver despropriétéset d'aider les utilisateurs de contratsintelligents à les comprendre,je dirais:
- Valeurs: Étudier quelles valeurs chaque élément du stockagepeutprendre à l'avenir.
- Effets: Étudier quelseffetspeuvent survenir à l'avenir: lestransfertspeuventgénéralement seproduireet sur quelles conditions.
- Propriété: quipeut déclencher unemodification de lapartie du stockage.
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.
-
Une version assez longue de cette réponse: https://link.medium.com/ru9idrdepuA rather long version of this answer: https://link.medium.com/ru9idRDePU
- 2
- 2019-03-06
- FFF
-
- 2019-01-31
C'est donc une énorme questionet jepense qu'il y abeaucoup depersonnesplus qualifiées quemoi,maisje vais offrir quelques conseilsinitiaux.
Dans lesfondations logicielles,un livre sur le COQ,ilsparlent d'une langueimplicite appelée Imp. IMP a une syntaxe comme:
z ::=x ;;; Y ::=1 ;; ~ ~ (Z=0)faire Y ::=y * z ;; Z ::=z - 1 FINIR
qui devrait être quelquepeu comprise comme une affectationet uneboucle simple.
::=
estpour une affectation,uneboucletandis quejusqu'à zest 0. à Python,ce serait:deffoo (x): z=x y=1 tandis que z!=0: y=y * z z -=1
Nouspouvonsensuite définir unepartie de la logique sous-jacentepour les symboles. Parexemple,
FixPoint AEVAL (A: AEXP): NAT:== correspondre à | Anumn ⇒n | APLUS A1 A2 ⇒ (AEVAL A1) + (AEVAL A2) | Aminus A1 A2 ⇒ (AEVAL A1) - (AEVAL A2) | AMUT A1 A2 ⇒ (AEVAL A1) * (AEVAL A2) finir.
Cela définira les opérations arithmétiques.
Vouspouvez également analyser lesmots réservés,comme:
Inductive COM: Type:= | Cskip | Cbreft (* & lt; ---nouveau *) | Cass (x: String) (A: AEXP) | CSEQ (C1 C2: COM) | CIF (B: BEXP) (C1 C2: COM) | CWhile (B: BEXP) (C: COM).
Ensuite,vouspouvezmapper leprogramme sur cestypes définisen Coq,comme:
CSEQ (CASS Z X) (CSEQ (CASS Y (S O)) (CWHILE (BNOT (BEQ Z O)) (CSEQ (CASS Y (AMUT Y Z)) (CASS Z (Aminus Z (S O))))))
Nouspouvonsensuitefaire despreuves sur lesfonctions ou les déclarationsfaites dans cette langue à l'aide de la logiqueformelle. Voici unexemple quiprouve que si zn'estpas 4,alors xn'estpas 2:
exemple ceval_example1: vide_st=[ X ::=2 ;; Test x ≤ 1 Alors y ::=3 Sinon z ::=4 FI ] ⇒ (z! - > 4; x! - > 2). Preuve. (* Nous devonsfournir l'étatintermédiaire *) Appliqueze_seq avec (x! - > 2). - (* Commande d'affectation *) Appliquere_ass. réflexivité. - (* Si commande *) Appliquere_iffalse. réflexivité. Appliquere_ass. réflexivité. QED.
D'icimaintenant,j'espère que la demande à un contratintelligentest quelquepeu apparente. Si vouspouviez abstraire le contratintelligenten Coq,vouspouvez utiliser Coqpourprouver des composants de votre contratintelligent rigoureusement. Ilest égalementpossible de définir des conditions d'un contratintelligenten Coqet de la compiler à Michelson,mais c'est unepossibilitéet jen'ai vu aucunepreuve de sa construction.
ref: https://softwarefoundations.cis.upenn.edu/lf- actuel/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
-
Mercipour la réponse détaillée.Il semble que vousm'expliquez une stratégie de * Comment *faire des contratsintelligentspouvant être utiliséspour une analyseformelle,icien utilisant Coq.Je suppose quema question étaitplus axée sur letype de résultats/garanties à l'intersection de ce quiest réalisablepar analyse statiqueet souhaitable d'unpoint de vue de l'application deblockchain.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
-
Si c'est la question,vouspouvez simplement construire unpoussière.Les contrats ont desintrantstrès rigides,ilne serait doncpastrop difficile d'essayer unegrande variété d'intrantset de voir les réponses données.https://fr.wikipedia.org/wiki/fuzzingif 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 Jepense que les contratsintelligents doivent vivre dans unmonde contradictoire si simple des outils de débogagetels que lespoussespourraientne pas suffire.@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
-
Vouspouveztoujoursfaireplus,mais comptetenu des contraintestrès strictes sur lesintrantsfuzz Lestests de divers contrats contradictoires couvriraientprobablement ungrandnombre de scénariospossibles.Jepense qu'un scénario de chèvre-glot comme dans la solidité seraitplusfacile àtesteret plus difficile à orchestrerpuisquetous les appelsexternes seproduisent après lafin de l'achèvement du contrat.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
Quelles sont les analyses des contratsintelligents Tezospouvantprofiter aux écrivains de Dapps leplus?
justepour être clair,par "analyse"ici,je veux dire "analyse deprogramme statique".Voirparexemple ici .
Fondamentalement,l'idée serait qu'avant de commettre un contratintelligent à la chaîne,oneffectuerait une analyse statique sur le code source de hautniveau,soit directement à la cible de compilation dans Michelson afin d'évaluer diversespropriétés d'exécution duprogramme.