Hi 游客

更多精彩,请登录!

比特池塘 区块链技术 正文

Solidity合约安全考量

有个胖子他姓杨
130 0 0
尽管在通常情况下编写一个按照预期运行的软件很简单,
# |* `' [9 B) ~  x( f+ X但想要确保没有人能够以出乎意料的方式使用它就困难多了。
; S3 x# z6 }$ T. G) v: l% y8 ~1 C% j/ T在 Solidity 中,这一点尤为重要,因为智能合约可以用来处理通证,甚至有可能是更有价值的东西。
. g# g5 i$ N: {& i$ y除此之外,智能合约的每一次执行都是公开的,而且源代码也通常是容易获得的。
" ^, i3 {: a( m4 a" s0 [当然,你总是需要考虑有多大的风险:
4 l. b0 t! L& y/ j  g9 X0 j你可以将智能合约与公开的(当然也对恶意用户开放)、甚至是开源的网络服务相比较。) w9 r! I8 A- Q/ H  b* v( ^# M
如果你只是在某个网络服务上存储你的购物清单,则可能不必太在意,
+ T8 h. ~( B% y0 Q8 a, T但如果你使用那个网络服务管理你的银行帐户,# M* K, p& z2 L/ o
那就需要特别当心了。, V* `) h: S: ^. V- E. l
本节将列出一些陷阱和一般性的安全建议,但这绝对不全面。. ?* n# F, X& }5 `- e. J. Q
另外,请时刻注意的是即使你的智能合约代码没有 bug,
4 U; b% v. E: }% d但编译器或者平台本身可能存在 bug。. X) K5 h& u' G; J+ ~! T2 J! ]8 s) Y
一个已知的编译器安全相关的 bug 列表可以在 :ref:已知bug列表 找到,; B7 C5 m9 I  X  v1 _+ x
这个列表也可以用程序读取。
4 S' ~; O) B$ A& m请注意其中有一个涵盖了 Solidity 编译器的代码生成器的 bug 悬赏项目。9 L, ?. \) |( ~6 Z  ~6 a- a5 `
我们的文档是开源的,请一如既往地帮助我们扩展这一节的内容(何况其中一些例子并不会造成损失)!' Q* k$ n: b4 N" I3 U# d
3 A! s: z# o, x0 t6 p
陷阱
( Z. T+ Q* p5 w% ?' p: O/ F9 t0 L) t
0 C+ m3 o% k9 \+ m私有信息和随机性
+ @1 j* j1 v# E. |+ D" a在智能合约中你所用的一切都是公开可见的,即便是局部变量和被标记成 private 的状态变量也是如此。
" D+ j; X- b/ N5 ^如果不想让矿工作弊的话,在智能合约中使用随机数会很棘手1 U% ]' J$ b$ l; L7 h* T0 V
(译者注:在智能合约中使用随机数很难保证节点不作弊,
+ ^# _, w- |& A( T2 C6 V1 D这是因为智能合约中的随机数一般要依赖计算节点的本地时间得到,8 S4 C% f: K% n
而本地时间是可以被恶意节点伪造的,因此这种方法并不安全。
0 V+ c- L" @/ o" d: S9 }' @通行的做法是采用 |off_chain| 的第三方服务,比如 Oraclize 来获取随机数)。" O/ \0 [; s$ O8 B. G
重入
2 c2 t/ {/ r" V# Q任何从合约 A 到合约 B 的交互以及任何从合约 A 到合约 B 的 |ether| 的转移,都会将控制权交给合约 B。. Z& }5 C4 {# f+ O1 @* D$ k' B
这使得合约 B 能够在交互结束前回调 A 中的代码。
5 E+ [! b% R9 S举个例子,下面的代码中有一个 bug(这只是一个代码段,不是完整的合约):
: Z2 U+ s$ {7 _::
) x' v$ a6 A- C) r* {7 Ipragma solidity ^0.4.0;- ?% N8 }* B6 k: F, m
// 不要使用这个合约,其中包含一个 bug。
" f) V( S: @: M( Lcontract Fund {
! F0 S6 j5 T# B% P; G    /// 合约中 |ether| 分成的映射。
! s# Q$ d. ]( f2 L5 |    mapping(address => uint) shares;" G9 u9 s. p% n7 I, h. m! x! _
    /// 提取你的分成。; `+ b- y/ e' o( b
    function withdraw() public {
9 X6 H/ C' v1 o" x0 A. M        if (msg.sender.send(shares[msg.sender]))
1 n* t/ p* U; I- l2 v2 J! C$ m- U            shares[msg.sender] = 0;) F0 E+ Y6 w, p
    }: A6 y( x+ G; Q+ `$ ^  J
}
  c* k7 W+ p/ p3 D+ l6 W这里的问题不是很严重,因为有限的 gas 也作为 send 的一部分,但仍然暴露了一个缺陷:! O! H  J" P* a0 q0 E
|ether| 的传输过程中总是可以包含代码执行,所以接收者可以是一个回调进入 withdraw 的合约。
0 O7 G# N! B, u. X8 L2 K, k, p这就会使其多次得到退款,从而将合约中的全部 |ether| 提取。) Z9 J) s/ L' x7 Y  m, T
特别地,下面的合约将允许一个攻击者多次得到退款,因为它使用了 call ,默认发送所有剩余的 gas。, A. ~$ K  q  X5 i6 }3 K& {
::& ]6 ^  W# a" p' G" m7 I
pragma solidity ^0.4.0;8 E/ P5 m2 b4 u& X/ Y* O
// 不要使用这个合约,其中包含一个 bug。
) a/ A( p  X! j/ g# @8 ncontract Fund {
" y; u1 J( K6 q; G2 Y    /// 合约中 |ether| 分成的映射。+ Q: Y2 k! `2 |1 ]
    mapping(address => uint) shares;2 _, @) j- d/ [* E3 J# X# Q" o" M
    /// 提取你的分成。- N* e3 v* `5 e: ~! j# R9 \
    function withdraw() public {
7 `- T* P# d. C  a        if (msg.sender.call.value(shares[msg.sender])())
& q/ e) N% W: x4 S            shares[msg.sender] = 0;
, g, ?$ D5 L# d+ U& p6 F    }
% N! G/ {0 Q9 L7 x, P' F  u}: X: }% c2 M' x
为了避免重入,你可以使用下面撰写的“检查-生效-交互”(Checks-Effects-Interactions)模式:2 d1 ^9 h/ i- n: f
::6 j6 [4 r( V) G% U1 m: G$ j
pragma solidity ^0.4.11;9 S" N; m7 H: @( M1 [3 `4 n
contract Fund {
2 w6 W  Y1 B* e: M+ [1 @+ g1 M    /// 合约中 |ether| 分成的映射。, B7 T/ l  ]3 U% b, e0 H% g
    mapping(address => uint) shares;
! D  {% x7 a5 J5 p, E6 S  S+ t    /// 提取你的分成。
% T7 F! `- y# _6 e( Y! p- _    function withdraw() public {4 S, T9 t; G: p( D) \* v
        var share = shares[msg.sender];9 _* C* x5 y! l* Y! q! b1 d$ v# u
        shares[msg.sender] = 0;( W7 s( O, D( N6 Z5 H- z
        msg.sender.transfer(share);
9 _9 \; N9 J+ ^# x$ X5 U: ]* K    }
& |/ d- L9 _: \0 ^5 k2 c}
7 f& \0 n! u8 l' }& c请注意重入不仅是 |ether| 传输的其中一个影响,还包括任何对另一个合约的函数调用。
* H" T- m  i; C( t! x' B! q: Z7 @更进一步说,你也不得不考虑多合约的情况。
/ F% [" {5 W  R一个被调用的合约可以修改你所依赖的另一个合约的状态。+ \0 {/ j2 P  u( u6 h
gas 限制和循环
& P9 |8 N1 {$ p# A7 w6 w必须谨慎使用没有固定迭代次数的循环,例如依赖于 |storage| 值的循环:
$ _$ s# D3 }7 l) h; o. x4 Z8 v1 D由于区块 gas 有限,交易只能消耗一定数量的 gas。
( j1 a* |/ U) p. }0 I无论是明确指出的还是正常运行过程中的,循环中的数次迭代操作所消耗的 gas 都有可能超出区块的 gas 限制,从而导致整个合约在某个时刻骤然停止。
2 L( N% U0 l7 l# c0 `6 S4 ?0 H这可能不适用于只被用来从区块链中读取数据的 view 函数。
- H1 L* V+ a& t& k# [- l. ~尽管如此,这些函数仍然可能会被其它合约当作 |on_chain| 操作的一部分来调用,并使那些操作骤然停止。
2 }9 a* U' V; ^/ O6 E/ O# c# B请在合约代码的说明文档中明确说明这些情况。
8 ?  k$ v) L% T/ r# m9 N9 m发送和接收 |ether|
8 l$ A% c0 u! A4 G3 j1 e- u3 a2 r+ l- f$ ^5 G- B' o
目前无论是合约还是“外部账户”都不能阻止有人给它们发送 |ether|。
/ q1 ~0 S  o/ c- u- u* w合约可以对一个正常的转账做出反应并拒绝它,但还有些方法可以不通过创建消息来发送 |ether|。
' ?1 a) K' |* n% s0 C其中一种方法就是单纯地向合约地址“挖矿”,另一种方法就是使用 selfdestruct(x) 。
) M9 J  |* ]3 R* a6 K6 ^: Q  g+ N' S5 [$ O- S% M9 L) p% A
如果一个合约收到了 |ether| (且没有函数被调用),就会执行 fallback 函数。" K/ v) m" I( {+ V1 I0 s3 E/ m
如果没有 fallback 函数,那么 |ether| 会被拒收(同时会抛出异常)。
, ^+ i/ d/ i, `6 @4 n/ S在 fallback 函数执行过程中,合约只能依靠此时可用的“gas 津贴”(2300 gas)来执行。
7 ^' D  P2 L! ]) q* u$ k这笔津贴并不足以用来完成任何方式的 |storage| 访问。* p5 }$ W# T8 u7 I0 L2 Q6 I
为了确保你的合约可以通过这种方式收到 |ether|,请你核对 fallback 函数所需的 gas 数量
$ U' f4 |: @. ^1 \) C) k(在 Remix 的“详细”章节会举例说明)。3 W3 I* F; s% a' U' v- S

! L. f$ {3 @# n" I# U. x有一种方法可以通过使用 addr.call.value(x)() 向接收合约发送更多的 gas。
2 c# W. R! x1 |# |1 \- Z这本质上跟 addr.transfer(x) 是一样的,
9 P6 D9 c( v$ H0 M% S# q只不过前者发送所有剩余的 gas,并且使得接收者有能力执行更加昂贵的操作# v! S+ `: [& F! n" Z% W
(它只会返回一个错误代码,而且也不会自动传播这个错误)。
8 Y) y9 z3 p3 R/ \这可能包括回调发送合约或者你想不到的其它状态改变的情况。. S+ l" B+ R8 ~+ ?6 @
因此这种方法无论是给诚实用户还是恶意行为者都提供了极大的灵活性。, ~. K9 f3 z8 }3 g. j: B6 M. a

% ~! d. Z3 q* D( I# e如果你想要使用 address.transfer 发送 |ether| ,你需要注意以下几个细节:
% t5 }1 h, O# U; P0 c. i如果接收者是一个合约,它会执行自己的 fallback 函数,从而可以回调发送 |ether| 的合约。如果调用的深度超过 1024,发送 |ether| 也会失败。由于调用者对调用深度有完全的控制权,他们可以强制使这次发送失败;
3 L2 X% n" I( ~$ Y: ~0 e$ T请考虑这种可能性,或者使用 send 并且确保每次都核对它的返回值。! a# |: e: i2 n# \5 e
更好的方法是使用一种接收者可以取回 |ether| 的方式编写你的合约。
发送 |ether| 也可能因为接收方合约的执行所需的 gas 多于分配的 gas 数量而失败
  m+ [. r+ n9 b+ T(确切地说,是使用了 require , assert, revert , throw 或者因为这个操作过于昂贵) - “gas 不够用了”。/ {3 q& ^) C6 o/ D# S! G4 V! m& q0 t
如果你使用 transfer 或者 send 的同时带有返回值检查,这就为接收者提供了在发送合约中阻断进程的方法。5 V3 ?, H! J8 q* d4 N  t9 M
再次说明,最佳实践是使用 :ref:“取回”模式而不是“发送”模式。8 j9 ?( }* [$ V! v0 x
8 M3 e9 J6 u. E# Q) a

6 o8 L9 M) f9 r5 m( y调用栈深度
+ t" G1 ~! A; [- D; |外部函数调用随时会失败,因为它们超过了调用栈的上限 1024。
# y; R) m# f8 X/ w% ~" t4 V在这种情况下,Solidity 会抛出一个异常。+ g$ S, u+ y9 W5 ~
恶意行为者也许能够在与你的合约交互之前强制将调用栈设置成一个比较高的值。) v$ L5 s$ p- [( d% L
请注意,使用 .send() 时如果超出调用栈 并不会 抛出异常,而是会返回 false。. K' X: W  l, O8 q4 w+ v( D
低级的函数比如 .call(),.callcode() 和 .delegatecall() 也都是这样的。1 T& H% T+ x& U
tx.origin
; Q  P6 e, a! X永远不要使用 tx.origin 做身份认证。假设你有一个如下的钱包合约:
9 g; {: Z& U9 w0 s; h0 }::+ l' F5 g/ f3 [8 B; A
pragma solidity ^0.4.11;
2 c3 j! C+ G7 M& m0 V/ A* c// 不要使用这个合约,其中包含一个 bug。+ L8 Y- [9 s1 H6 I+ }$ [" z
contract TxUserWallet {8 k$ y( U! Z2 L; V
    address owner;! `7 Y0 w/ r1 Z9 @6 G' C
    function TxUserWallet() public {
- m, [& `4 x2 f& R9 G% C        owner = msg.sender;& J  h  q) h: U/ Z1 |
    }. f% z( j( Q) O+ [* V. k
    function transferTo(address dest, uint amount) public {5 J* X) s$ H% u6 q% I( Q* W
        require(tx.origin == owner);. i  R9 g5 U- }4 M
        dest.transfer(amount);. r9 x9 v2 r3 N1 l2 z5 `! V
    }  q5 \, P9 E7 a; ~
}
$ p" ]  W& l2 i现在有人欺骗你,将 |ether| 发送到了这个恶意钱包的地址:
9 U4 g$ z6 ?$ P$ K2 W) f4 i' e( u::+ \% t5 R/ _! Y" [3 G
pragma solidity ^0.4.11;3 d  b# b1 H+ G$ E
interface TxUserWallet {: a3 H' h' w! ~/ P0 h# h
    function transferTo(address dest, uint amount) public;
$ Z& U( L" ]: L}
0 n, S4 A* f; \& B, [contract TxAttackWallet {% H5 \) Y4 W. M: O! k$ ?' W
    address owner;, d* m; T" t) v5 O7 Z  {( C
    function TxAttackWallet() public {
& b# v1 C; b/ W. @# O1 f        owner = msg.sender;
& X. ]4 N$ G5 ^7 R    }
3 \# S/ L+ g3 k# m    function() public {6 E3 C) t3 k4 d6 B+ v
        TxUserWallet(msg.sender).transferTo(owner, msg.sender.balance);/ r7 P0 u- m6 r: O6 T" g6 l' u/ a
    }% H1 P: L5 j; [4 b
}
8 K" ~7 Z& h% d. \; b# d如果你的钱包通过核查 msg.sender 来验证发送方身份,你就会得到恶意钱包的地址,而不是所有者的地址。
( x# s; F1 J! r/ x' }$ m但是通过核查 tx.origin ,得到的就会是启动交易的原始地址,它仍然会是所有者的地址。
% V- R; o( @8 D' o, X8 `恶意钱包会立即将你的资金抽出。
7 [& q! ~- F( j- ~6 j7 f# p' B细枝末节
1 N( l7 [2 x8 }4 y5 s4 E  m8 X& c在 for (var i = 0; i  中, i 的类型会变为 uint8 ,
+ [; h# ~- n& r9 t因为这是保存 0 值所需的最小类型。如果数组超过 255 个元素,则循环不会终止。
不占用完整 32 字节的类型可能包含“脏高位”。这在当你访问 msg.data 的时候尤为重要 —— 它带来了延展性风险:
" t+ j% s7 W: E你既可以用原始字节 0xff000001 也可以用 0x00000001 作为参数来调用函数 f(uint8 x) 以构造交易。
. `8 J, I8 F" z2 I1 u这两个参数都会被正常提供给合约,并且 x 的值看起来都像是数字 1,. S4 z% T3 s0 C2 W+ Z
但 msg.data 会不一样,所以如果你无论怎么使用 keccak256(msg.data),你都会得到不同的结果。! H0 I3 `4 y6 S: a1 S/ R! K
. @7 M. Q3 O0 t7 K
推荐做法$ [: x! t$ d$ j

2 x& v0 ]8 Y) X" [; r# m! G认真对待警告2 R5 y1 X" ]# }) Y  b& N
如果编译器警告了你什么事,你最好修改一下,即使你不认为这个特定的警告不会产生安全隐患,因为那也有可能埋藏着其他的问题。) v  z2 g  S+ `4 c9 T
我们给出的任何编译器警告,都可以通过轻微的修改来去掉。
. p1 T" O" K  m$ ~$ W$ ]3 F- y8 r同时也请尽早添加 pragma experimental "v0.5.0"; 来允许 0.5.0 版本的安全特性。* ]" B5 Y$ F$ |0 a: s
注意在这种情况下,experimental 并不意味着任何有风险的安全特性,9 A3 K, v4 T  b9 ]- Y  U; w
它只是可以允许一些在当前版本还不支持的 Solidity 特性,来提供向后的兼容。( {' x: L- G! w$ Z8 O7 T
限定 |ether| 的数量/ O" I" J' b$ x) w
限定 |storage| 在一个智能合约中 |ether| (或者其它通证)的数量。. M% I1 E+ ~' ?( W
如果你的源代码、编译器或者平台出现了 bug,可能会导致这些资产丢失。! T% A/ v  W1 r, p4 p
如果你想控制你的损失,就要限定 |ether| 的数量。
$ X& B, z( Q  b2 O* Q  v5 p7 c" B8 T保持合约简练且模块化
5 M2 Y+ E# j: k保持你的合约短小精炼且易于理解。
$ [$ n0 Z% x$ s# @: X找出无关于其它合约或库的功能。
! P8 V, s0 H- Z$ A) H1 v有关源码质量可以采用的一般建议:
. j4 b8 x* \6 D8 \' I1 W6 ^限制局部变量的数量以及函数的长度等等。( I6 z7 ]1 i! n  g
将实现的函数文档化,这样别人看到代码的时候就可以理解你的意图,并判断代码是否按照正确的意图实现。
, x: [- k* o  ~6 A# y使用“检查-生效-交互”(Checks-Effects-Interactions)模式
" w3 H5 [  P( q* W大多数函数会首先做一些检查工作(例如谁调用了函数,参数是否在取值范围之内,它们是否发送了足够的 |ether| ,用户是否具有通证等等)。6 x$ E. |$ H' N) ^
这些检查工作应该首先被完成。8 a0 _( N& N% r6 i
第二步,如果所有检查都通过了,应该接着进行会影响当前合约状态变量的那些处理。6 [* H  d: |/ N7 ^$ F, Y, ?. B2 {0 A
与其它合约的交互应该是任何函数的最后一步。
9 Z" z; j! F) }$ q9 e早期合约延迟了一些效果的产生,为了等待外部函数调用以非错误状态返回。' ^7 A) B' _/ g5 X: v
由于上文所述的重入问题,这通常会导致严重的后果。
# L0 P- ^! X8 Q请注意,对已知合约的调用反过来也可能导致对未知合约的调用,所以最好是一直保持使用这个模式编写代码。
5 \" \' Q4 P0 `! a2 R, j+ F包含故障-安全(Fail-Safe)模式% s3 l4 E5 ]/ f
尽管将系统完全去中心化可以省去许多中间环节,但包含某种故障-安全模式仍然是好的做法,尤其是对于新的代码来说:
8 n9 ?! ?; o/ I# y你可以在你的智能合约中增加一个函数实现某种程度上的自检查,比如“ |ether| 是否会泄露?”,
+ a- X9 m* ?9 j( Z! Z“通证的总和是否与合约的余额相等?”等等。
( N4 i/ C9 S# q6 Q+ Z3 Z& P7 I  H请记住,你不能使用太多的 gas,所以可能需要通过 |off_chain| 计算来辅助。& e2 {7 {- t* t0 t0 d. k) S
如果自检查没有通过,合约就会自动切换到某种“故障安全”模式,- ?3 b/ v1 Y8 T
例如,关闭大部分功能,将控制权交给某个固定的可信第三方,或者将合约转换成一个简单的“退回我的钱”合约。
2 L8 R; ]8 h8 w7 \
% l+ g- Z. R% t形式化验证& f! y% v0 g& u3 o/ {- Q
0 v- K4 Y. b3 E) j0 }, p3 W
使用形式化验证可以执行自动化的数学证明,保证源代码符合特定的正式规范。- ?8 Q4 ]2 D' p8 F+ g
规范仍然是正式的(就像源代码一样),但通常要简单得多。
! R$ M/ H& l! s: I% s, J- \6 a请注意形式化验证本身只能帮助你理解你做的(规范)和你怎么做(实际的实现)的之间的差别。
9 C8 h" X5 w/ H0 r" Z, S你仍然需要检查这个规范是否是想要的,而且没有漏掉由它产生的任何非计划内的效果。
标签: Solidity
BitMere.com 比特池塘系信息发布平台,比特池塘仅提供信息存储空间服务。
声明:该文观点仅代表作者本人,本文不代表比特池塘立场,且不构成建议,请谨慎对待。
您需要登录后才可以回帖 登录 | 立即注册

本版积分规则

成为第一个吐槽的人

有个胖子他姓杨 初中生
  • 粉丝

    0

  • 关注

    0

  • 主题

    10