bashChain.bash

#!/bin/bash
# BashChain v0.1a : BASH Blockchain PoC : https://github.com/elemantalcode/bash-scripts

# Set some basic blockchain variables
difficulty=1 # Set the difficulty of "mining". Set to < 3 for testing and > 20 to burn CPU cycles
genesis_time="2017-01-01 00:00:00" # Set the Genesis block time
genesis_data="Genesis Block" # Set the Genesis block data
chain_count=6 # Amount of blocks to generate

# Standard variables
nonce=0 # Always start with 0 nonce
blockchain=() # Declare our blockchain array variable
chain_increment=1 # Start increment from 1 because Genesis = 0

function genBlock() { # Generate a block
 block_index="$1" # Block index number
 block_previous="$2" # Previous block
 block_timestamp="$3" # Timestamp for the block
 block_data="$4" # Data to preserve in block

 [[ "$2" == "genesis" ]] && block_previous=$'\0' # If Genesis, set to explicit NULL
 [[ "$3" == "now" ]] && block_timestamp="${now}" # Use current timestamp unless otherwise told

 # Send off to calculate the hash
 newblock=$( getHash "${block_index}" "${block_previous}" "${block_timestamp}" "${block_data}" "${nonce}" )
 echo "${newblock}" # Return the new block
}

function getHash() { # Calculate the HASH (we use SHA256)
 hash_index="$1" # Hash index number
 hash_previous="$2" # Previous hash
 hash_timestamp="$3" # Timestamp for the hash
 hash_data="$4" # Data to preserve as part of hash
 hash_nonce="$5" # NONCEnse :P

 # Use existing Linux tools and strip out unwanted output
 hash_256=$( echo "${hash_index}${hash_previous}${hash_timestamp}${hash_data}${hash_nonce}" | sha256sum | awk '{print $1}' )
 echo "${hash_256}" # Return the new hash
}

function getGenesis() { # In the beginning... Genesis 1:1
 genesis_time="$1" # Timestamp for the Genesis block
 genesis_data="$2" # Data to use as part of the Genesis block

 # Generate the Genesis block in the same way that we mine other blocks, with different values though
 genesis=$( genBlock "0" "genesis" "${genesis_time}" "${genesis_data}" "${nonce}" )
 echo "${genesis}" # Return the Genesis block
}

function mineBlock() {
 # This is terrible, I know, but shows extremely basic "proof of work" concept
 # For the love of green apples and all that is holy, do NOT use in production... no, seriously!
 mine_index="$1" # Index for the newly mined block
 mine_previous="$2" # Previously mined block
 mine_data="$3" # Data to insert into mined block
 now=$( date '+%Y-%m-%d %H:%M:%S' ) # Current timestamp

 # So we generate a bunch of 0s to test against - the higher the difficulty, the more 0s
 a=$( printf -v row "%${difficulty}s"; echo ${row// /0} )
 b="" # Set an empty variable to test against

 while [ "$a" != "$b" ] # So, while we haven't found the amount of 0s we want...
 do
 # Yup, "mine" a block
 mine_block=$( genBlock "$mine_index" "${mine_previous}" "${now}" "${mine_data}" "${nonce}" )
 b=${mine_block:0:$difficulty} # Check for prefixed 0s and match against difficulty
 #echo "Trying HASH: $mine_block"
 (( nonce++ )) # Increment nonce and try again
 done
 echo "${mine_block}" # Return with our new shiny "mined" block
}

# Generate Genesis block
genesis=$( getGenesis "${genesis_time}" "${genesis_data}" )
# Add the block into the chain, as index 0. We use an array here; Could be a file, sql, whatever
blockchain[0]="IDX:0,TIME:${genesis_time},HASH:${genesis},DATA:${genesis_data}"

while [ $chain_increment -lt $chain_count ] # Keep generating blocks and adding to chain until we reach
do # the requested limit
 # Grab the previous block in the chain, and strip out the HASH
 previous_block=$( echo "${blockchain[-1]}" | cut -d',' -f3 | cut -d':' -f2 )
 block_data="Block ${chain_increment}" # Create "random" data for the blocks
 now=$( date '+%Y-%m-%d %H:%M:%S' ) # Current timestamp
 # Go forth and multiply (and add to your lineage... or at the very least, our blockchain array)
 newblock=$( mineBlock "${chain_increment}" "${previous_block}" "${block_data}" )
 blockchain[$chain_increment]="IDX:${chain_increment},TIME:${now},HASH:${newblock},DATA:${block_data}"
 (( chain_increment++ )) # Keep counting until we reach the requested block limit
done

OIFS="$IFS" # This is a naf cheat to avoid split lines on spaces
IFS="
"

for block in "${blockchain[@]}" # Loop through every array entry (the blocks in the chain)
do
 echo "${block}" # .....aaaaand display them ;)
done

# Reset IFS
IFS="$OIFS"