How data is secured on ethereum network?

Question

Blockchain is distributed decentralized database and same data is present on every node on network so now anybody on the network can see my data, so how it is secured over blockchain network?

Answer 1

Ethereum is developed as a platform which facilitates peer-to-peer contracts and applications. Ethereum is a public blockchain. Meaning all the participants have access to the data on the ethereum blockchain which includes the balance of a particular address, the transactions that the address has performed. Your transactions are secure in that no one can change your transactions after the fact.

When you deploy a smart contract, you can add the code for reference after it is verified. This decentralizes trust at the cost of privacy. However as long as one cannot link your ethereum address to the physical you, your transactions are in an essence private.

Basically, you should use the blockchain platform that is suitable for your business use case. There are private permissioned blockchains that provide privacy to some extent.

Answer 2

To make your data private and not accessible to anyone else - it should be encrypted, but that is not a goal of the blockchain (ethereum network), so it's up to you to do that

Answer 3

In ethereum, they keep patricia merkle tree in the database (see: https://github.com/ethereum/wiki/wiki/Patricia-Tree), so that we can verify the data is correct (in the merlkle tree).

Also the message broadcasted to each peer was unencrypted, you can see in their wiki (https://github.com/ethereum/devp2p).

Take send transaction as example (https://github.com/ethereum/go-ethereum/blob/master/eth/peer.go#L196), in source code (https://github.com/ethereum/go-ethereum/blob/master/p2p/message.go#L90):

// SendTransactions sends transactions to the peer and includes the hashes
// in its transaction hash set for future reference.
func (p *peer) SendTransactions(txs types.Transactions) error {
    for _, tx := range txs {
        p.knownTxs.Add(tx.Hash())
    }
    return p2p.Send(p.rw, TxMsg, txs)
}

// Send writes an RLP-encoded message with the given code.
// data should encode as an RLP list.
func Send(w MsgWriter, msgcode uint64, data interface{}) error {
    size, r, err := rlp.EncodeToReader(data)
    if err != nil {
        return err
    }
    return w.WriteMsg(Msg{Code: msgcode, Size: uint32(size), Payload: r})
}

They just send rlp encoded message.