[Ethereum] Weighted Random Number Array generation in solidity

The organizer can cheat the system by attempting many different addresses, which, when added to your formula Key number + address1 + address2 ... + addressN % 255 as the last address and getting the hash of the block, make this address the winner.

You can think about it this way:

• If your system is secure, there is no way to cheat the system.
• If there is no way to cheat the system, the organizer also cannot cheat the system.
• If there is no way for organizer to cheat the system, then knowing the key number doesn't give you any way to cheat the system. (Otherwise the organizer would cheat the system because he knows the key number)
• If knowing the key number doesn't give you any way to cheat the system, the system is as secure with the key number as without the key number.
• You can get rid of the key number. The formula Key number + address1 + address2 ... + addressN % 255 is as secure as this one address1 + address2 ... + addressN % 255.
• However, the above formula without the key number is insecure as it's subject to the same attack I described in the beginning. Right before the time when the winner is decided someone can atempt a bunch of addresses and find one that makes him the winner.
• This means that the formula with the key number is insecure also.

As a result we came to a contradiction - we made the assumption that our system is secure in the beginning and at the end concluded that it's insecure. Thus our assumption is not correct.

What you should do instead is split the lottery into 2 phases:

1. When buying a ticket participants must include with the transaction:

   • hash of some random number.
   • cost of the ticket.
   • some fairly large deposit.

2. When all tickets are sold (or after some expiration) everyone who bought a ticket in the 1st phase must reveal the secret number.

   • When you reveal your secret number you get your deposit back.
   • After everyone revealed their secret number, those secret numbers together are used as source of randomness to determine the winner, e.g. concat them and hash.
   • If anyone didn't reveal their secret number (or after some expiration), the lottery is cancelled: everyone who revealed their secret numbers can withdraw the price they paid for tickets. Everyone who didn't reveal the secret number loses their deposit and the cost of ticket.
   • The deposit provides the incentive to reveal the secret number. The reason why lottery must be cancelled if anyone didn't reveal their secret number is there is a way to cheat the system by not exposing the secret number if it's favorable for the attacker.

In a similar way RANDAO is implemented. Check out the section Additional Rules and Incentives for other things you need to make sure to prevent the possibility of cheating.

In particular, the deposit size summed with the ticket price has to be not lesser than the maximum reward (normally, total amount in the lottery). Any deposit smaller than this will give an opportunity for cheating as explained by lungj here

You can use an incrementing nonce each time a number is generated. This would have a large effect on the hash output.

Random 0-100 Example:

contract Random {
    uint nonce;


    function random() internal returns (uint) {
    uint random = uint(keccak256(now, msg.sender, nonce)) % 100;
    nonce++;
    return random;
    }

    function getRandom() external view returns (uint) {
        return random();
    }
}