What does a blockchain do? We introduce it through an example of online shopping. When a person shops online with a credit card, the card is linked to a bank or some financial institution. The purpose of the bank is to mediate between customers and businesses.
Imagine a customer buys a product in January. In March the company makes a claim that they never received their money. The customer has a receipt, but the company claims the receipt is counterfeit. What is the customer's defense? The customer can go to the bank, which is a third party, and find the record of the funds that were given to the company.
A blockchain is a secure way to store the data without the need for a bank or other financial institution. The unbiased third party is a network of computers that store the blockchain. When the customer makes the purchase, a block with the purchase data is created. This block is added to the blockchain in such a way that if anyone tampers with the block, then the chain breaks.
One kind of blockchain is described below. Python code for a blockchain is included at the end of the lesson.
Each block in the chain consists of the following:
The code is generated by a hash function. For this description will call the function hash().
If we plug "dog" into the hash function, hash(dog) will return something that looks like a bunch of gibberish: cd6357efdd966de8c0cb2f876cc89ec74ce35f0968e11743987084bd42fb8944. If we slightly change the word to hog, hash(hog) returns a completely different bunch of gibberish: 96e436883f4940841fc9f1f7e935bada3859d2ffb0e5455952438d844f8e9c26. However, the code is not random. Every time we plug in dog, hash(dog) returns the same value. The point is that if I tell you a code, say 77af778b51abd4a3c51c5ddd97204a9c3ae614ebccb75a606c3b6865aed6744e, you have no idea what word I put in to the hash function (in this case cat).
If you want to see the codes that will be generated, see this SHA-256 hash calculator.
Now consider a block. For this example, the block has index 6, data "Add $4 to Bob's account", timestamp 02/03/2018 03:26:53, and the code for the previous block 3d73d23ad9067e7601112c72436d1615c27814b00b01072d2282bf46b57b740a. To get the code for this block, put all the information into the hash function: hash(6Add $4 to Bob's account02/03/2018 03:26:533d73d23ad9067e7601112c72436d1615c27814b00b01072d2282bf46b57b740a). The hash function will return a code for this block: bf83416153d05658c42722760305522cc688df47b32c284c6473b8adac088d6c.
If Bob tries to change the data in the block to "Add $5 to Bob's account" then we get a new code, hash(6Add $5 to Bob's account02/03/2018 03:26:533d73d23ad9067e7601112c72436d1615c27814b00b01072d2282bf46b57b740a) returns e0e5630b8fe69795d30b1f72da319c319c9f70d130b2a9ec82776a797396f242. This code is completely unpredictable. However, if Bob is changing this block then he can change the code to e0e5630b8fe69795d30b1f72da319c319c9f70d130b2a9ec82776a797396f242. But the next block in the blockchain also stores the code for this block. Now the codes don't match which means the blockchain is broken.
Bob would need to update the previous code in the next block to match the code in the block he changed. However, by changing the previous code in the next block, he also needs to compute the new hash code for the next block. This creates a chain reaction such that Bob needs to update every block in the chain that was added after his block.
It would be difficult for someone to manipulate a block and change all of the codes faster than blocks are being added with no one noticing. However, there are two reasons this is nearly impossible.
First, an extra condition is imposed on the codes allowed. For example, the only acceptable codes start with 5 zeros. This is what the nonce is for. The nonce is a number \(n\) that when appended to the string will cause the code to begin with 5 zeros. When a new block is added to the chain, all of the computers that store the chain can search for a nonce value. However, if Bob tries to manipulate a block, he will need to also find new nonce values for every block after the block he changes. This will take a very long time and it is unlikely he will ever catch up to the most current block.
Second, since copies of the blockchain are stored on multiple computers, Bob will need to update all of the computers storing the blockchain to his new version. This could be done if Bob convinces the majority of the computers to accept his changes, but it is unlikely that he will be able to distribute his changes to a majority of the computers. Again, this would have to happen with no one noticing that Bob was manipulating the data.
The data in a blockchain is secure because if anyone tried to change it the change could not propagate far without being detected. This is a development with amazing potential because it removes the need for third parties to guarantee security.
This code gives an example of a blockchain class in Python.
import datetime
import hashlib
class Block:
def __init__(self,index, timestamp, data, previousHash = ""):
self.index = index
self.timestamp = timestamp
self.data = data
self.previousHash = previousHash
self.nonce = 0
def calcHash(self):
tryHash = hashlib.sha256(str(self.index) + str(self.timestamp) + str(self.data) + str(self.previousHash) + str(self.nonce)).hexdigest()
while tryHash[:5] != "00000":
self.nonce += 1
tryHash = hashlib.sha256(str(self.index) + str(self.timestamp) + str(self.data) + str(self.previousHash) + str(self.nonce)).hexdigest()
return tryHash
class Blockchain:
def __init__(self):
self.chain = [Block(0,datetime.datetime.now(),"Genesis block")]
self.chain[0].hash = self.chain[0].calcHash()
def lastBlock(self):
return self.chain[len(self.chain)-1]
def addBlock(self, newBlock):
newBlock.previousHash = self.lastBlock().hash
newBlock.hash = newBlock.calcHash()
self.chain.append(newBlock)
def isValid(self):
for i in range(1, len(self.chain)):
currentBlock = self.chain[i]
previousBlock = self.chain[i-1]
if (currentBlock.hash != currentBlock.calcHash()):
return False
if (currentBlock.previousHash != previousBlock.calcHash()):
return False
return True
bChain = Blockchain() bChain.addBlock(Block(1, datetime.datetime.now(), "Account 5: $3 -> $5"))