Callstack attack

Question

If my contract has a payout function like this

address bossAddress;
address employeeAddress;
uint256 bossSalary;
uint256 employeeSalary;
function payout (){
    if (msg.sender==bossAddress){
            employeeAddress.send(employeeSalary);
            bossAddress.send(bossSalary);
            selfdestruct(bossAddress);
    }
}

Then, if I were a malicious boss, could I have exploited the payout such that only the boss gets paid?

A) If the employeeAddress is a contract, but bossAddress is a regular address, can I exploit the callstack attack so that the transaction fails on employeeAddress.send(employeeSalary), but continues to run bossAddress.send(bossSalary)? I guess what I'm asking is if both send calls reduces the callstack count, or just the send call that involves a contract address.

B) On the other hand, if the employee address is a contract that uses a lot of gas, I probably won't need to do any exploit, since the employeeAddress.send will fail from out of gass, then the boss should get paid both employeeSalary AND bossSalary, thanks to the selfdestruct() call.

C) And as a last point, is there a way to specify gas on the send call? This should prevent most out-of-gass errors in the case employeeAddress is actually a contract.

I just need to verify that my understanding of gas / callstack behavior is correct.

Answer 1

Call depth attack

A. No. If the call depth is at 1024, employeeAddress.send will fail. The depth remains at 1024 and bossAddress.send will also fail. The depth will only decrease to 1023 when payout (or its caller, depending on how payout is invoked) is finished.

B. Yes, that all sounds correct and no need for any call depth manipulation.

C. There is no way to specify gas for Solidity .send() and it forwards zero gas to the recipient. It is the responsibility of recipients of send() to do nothing/little in their fallback function if they want to avoid Out of Gas and receive Ether.

---

Reentrant attack

Solidity's send forwards zero gas so it can't be used for a reentrant attack.

If the contract has at least twice the bossSalary (example: bossSalary and employeeSalary are the same), and the boss is paid first using .call, then a reentrant attack is possible:

function payout (){
    if (msg.sender==bossAddress){
            bossAddress.call.value(bossSalary)();
            employeeAddress.call.value(employeeSalary)();
            selfdestruct(bossAddress);
    }
}

bossAddress could have a fallback function to invoke payout a second time before the employee is paid. Since none of the return values of .call are checked, employeeAddress.call will fail but there's no throw so the boss gets to keep both salaries.

The return value of all .send and .call (and related .callcode, .delegatecall) should be checked and handled carefully.