I am reading through the solidity docs and came across this comment in the code.
Can some one please explain how this is a security risk? Is it talking about calling a new contract using delegate which re-enters recursively ? I suppose i still fail to understand the security implications.
function bid() payable {
// No arguments are necessary, all
// information is already part of
// the transaction. The keyword payable
// is required for the function to
// be able to receive Ether.
// Revert the call if the bidding
// period is over.
require(now <= (auctionStart + biddingTime));
// If the bid is not higher, send the
// money back.
require(msg.value > highestBid);
if (highestBidder != 0) {
// Sending back the money by simply using
// highestBidder.send(highestBid) is a security risk
// because it can be prevented by the caller by e.g.
// raising the call stack to 1023. It is always safer
// to let the recipients withdraw their money themselves.
pendingReturns[highestBidder] += highestBid;
}
highestBidder = msg.sender;
highestBid = msg.value;
HighestBidIncreased(msg.sender, msg.value);
}
In the below function, it talks about setting a storage variable to 0 , in case the function is called again, I fail to understand how is this again a security issue. Is this something similar to multithreading in C++ environment (for lack of a better comparison i could think of).
function withdraw() returns (bool) {
var amount = pendingReturns[msg.sender];
if (amount > 0) {
// It is important to set this to zero because the recipient
// can call this function again as part of the receiving call
// before `send` returns.
pendingReturns[msg.sender] = 0;
if (!msg.sender.send(amount)) {
// No need to call throw here, just reset the amount owing
pendingReturns[msg.sender] = amount;
return false;
}
}
return true;
}
Since each call is more or less a transaction, shouldn't there be no problems with them being re-entrant?
Thanks!