Blockchain is certainly not the latest buzzword any longer, it moved well forward on the Gartner Hype Cycle, passed the peak of inflated expectations and I am sure we will find it in the trough of disillusionment in the soon to be updated 2018 version. It is picked up by various industries looking for use-cases and applications. Unfortunately we are looking at Blockchain fatigue already, as there is much hype but little visible implementations outside the cryptocurrency space. I prefer projects that implement blockchain as the right tool for a particular problem over the “let’s see which business case we can throw blockchain at” approach.
In the aviation (airport) space I believe Blockchain has its appliance, but as previously stated I wont attempt to build an AODB with Blockchain as “database” for milestones just for the sake of integrating this technology. For some scenarios you certainly need immutability of data, but we can implement this with the means of other immutable data storage. It is also no point implementing a blockchain into a corporate network infrastructure with few nodes under the control of one entity, this does not fulfill the promise of distributed ledger and trust. A few use-cases that I see, usually involving multiple business parties:
- Baggage tracking from end-to-end (goes well with IATA 753 effective since June 1st)
- Service and contract management, billing (eg. groundhandler-airline)
- Aircraft spare parts management (here the track of provenance have a huge impact)
Trying to understand blockchain can be overwhelming, ranging from Satoshi Nakamoto’s original whitepaper to a endless number of books, talks, websites.
One approach to understand the technology is to break it down into smaller pieces that are implementing proven existing technology or algorithms and understand how they come together eventually forming the much more complex blockchain.
I wont attempt to explain blockchain here, this is redundant, plenty of knowledgeable people have written books and articles you can refer to, but split it into some basic easy digestible portions, some coding included. Before attempting to code against real blockchain implementations, like Ethereum or Hyperledger, I will implement the most basic and simple blockchain first.
1. Hash
The most essential element of blockchain is a hash, a digital signature. A hash is a one way encryption, once something is hashed there is no way to reverse the process and reveal the original text (decrypt it). Using the SHA (Secure Hash Algorithm), the most popular algorithm with its variants of 256, 384 and 512 bit, defined by NIST, we can convert a text (data) of any length to a 256 bit representation (for SHA256) which is represented by a 64 byte hex string. There is a number of libraries implementing the algorithm, below is the Apache DigestUtils version.
private void testSHA(){
String sha256hex = DigestUtils.sha256Hex("Jim Smith");
System.out.println("\n1 SHA256: " + sha256hex);
String sha256hex2 = DigestUtils.sha256Hex("jim smith");
System.out.println("\n2 SHA256: " + sha256hex2);
String sha256hex3 = DigestUtils.sha256Hex("jim smith and the lazy brown fox");
System.out.println("\n3 SHA256: " + sha256hex3);
String sha384hex = DigestUtils.sha384Hex("Jim Smith");
System.out.println("\n4 SHA384: " + sha384hex);
String sha512hex = DigestUtils.sha512Hex("Jim Smith");
System.out.println("\n5 SHA512: " + sha512hex);
}
resulting in
1 SHA256: 65742910cc03889474f1ee2c8f321a105603d0ae2f91070ffd95b35f8da88261
2 SHA256: bfae13266154ec3c4de5c09cf14358305e44f48d2156953723ebbb184a724499
3 SHA256: e5a4a1b8bd88eb7cf8bff9ee5dd235f87ef996262d4d0213c1387f6141ab9574
4 SHA384: c6e76ad773905c1eedb6a0bd9c0b1602a56928d1ce95d70190cd908797466b948dd342aa69dd0343251afece2e48bfc2
5 SHA512: f813c3d9deb66d4999f6839acc60eb6e2fff6a84266c02e0d4b183f5e56d9674c70b0b136f9e1388673cefbc9278f583e3a4c9803ef0c49f9af28aca60dae5ac
Important to notice:
– Change of one character in the original text produces a complete new hash.
– Independent from the length of the original text the hash has the same length.
2. Chained blocks
As the wording implies, there are blocks of information that are linked together. Sounds like a linked list, where every list entry is pointing to the next information. The chained blocks are linked differently, every block points to the hashed previous block.
For illustration I choose a typical baggage journey (simplified).
A bag passes different key touchpoints and changes its custody a few times between the various parties during the handling. Every time there is a new milestone event we record it, eg. bag scanned by groundhandler at the chute at what time, and include the hash of the previous milestone. This way the lifecycle from bag drop at departure to bag delivery at destination is recorded in an immutable way and cannot be changed afterwards.
Pitfall: The bag journey is recorded in an immutable way, but the blockchain cannot verify or confirm the milestone actually happened. This falls into the responsibility of the overall design and service orchestration.
Let’s build a very simple application implementing the above blockchain for baggage handling.
A java class BagTransaction representing the bag attributes inclusive timestamp and the custody transfer.
package blockchaindemo;
import java.time.Instant;
import org.apache.commons.codec.digest.DigestUtils;
public class BagTransaction {
private String bagTag;
private String timeStamp;
private String pnr;
private String transferFrom;
private String transferTo;
private long blockID;
private String blockHash;
private String previousBlockHash;
public BagTransaction(String bagTag, String pnr, String transferFrom, String transferTo, long blockID,
String previousBlockHash) {
super();
this.bagTag = bagTag;
this.timeStamp = Instant.now().toString();
this.pnr = pnr;
this.transferFrom = transferFrom;
this.transferTo = transferTo;
this.blockID = blockID;
this.previousBlockHash = previousBlockHash;
this.blockHash = createCurrentHash();
}
public String getHash() {
return this.blockHash;
}
@Override
public String toString() {
return "BagTransaction [bagTag=" + bagTag + ", timeStamp=" + timeStamp + ", pnr=" + pnr + ", transferFrom="
+ transferFrom + ", transferTo=" + transferTo + ", blockID=" + blockID + ", blockHash=" + blockHash
+ ", previousBlockHash=" + previousBlockHash + "]";
}
private String createCurrentHash() {
String returnHash = "";
returnHash = DigestUtils.sha256Hex(
this.bagTag + this.timeStamp + this.pnr + this.transferFrom + this.transferTo + this.previousBlockHash);
return returnHash;
}
}
Take note of the hashing method that includes all fields inclusive of the previous hash.
A java class BagDemoApp using the transaction class.
package blockchaindemo;
import java.util.Random;
public class BagDemoApp {
public static void main(String[] args) {
BagDemoApp demoApp = new BagDemoApp();
demoApp.demo1();
}
public void demo1() {
String myBagTag = randomBagTagID();
String myPNR = randomPNR();
String currentBagBlockHash = "";
// Print Bag Tag (Genesis Block)
BagTransaction bagTransaction1 = new BagTransaction(myBagTag, myPNR, Entity.NIL.name(), Entity.PAX.name(), 1,
"0");
currentBagBlockHash = bagTransaction1.getHash();
// Bag Drop
BagTransaction bagTransaction2 = new BagTransaction(myBagTag, myPNR, Entity.PAX.name(), Entity.AIRP.name(), 2,
currentBagBlockHash);
currentBagBlockHash = bagTransaction2.getHash();
// Bag SEC Scan
BagTransaction bagTransaction3 = new BagTransaction(myBagTag, myPNR, Entity.AIRP.name(), Entity.SEC.name(), 3,
currentBagBlockHash);
currentBagBlockHash = bagTransaction3.getHash();
// Display Transactions
System.out.println(bagTransaction1);
System.out.println(bagTransaction2);
System.out.println(bagTransaction3);
}
// HELPER METHODS --------------------------------------------
public String randomPNR() {
final String alphabet = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ";
final int N = alphabet.length();
Random r = new Random();
StringBuffer tempPNR = new StringBuffer();
for (int i = 0; i < 6; i++) {
char nxtChar = alphabet.charAt(r.nextInt(N));
while ((i == 0) && (Character.isDigit(nxtChar)))
nxtChar = alphabet.charAt(r.nextInt(N));
tempPNR.append(nxtChar);
}
return tempPNR.toString();
}
public String randomBagTagID() {
String tempBagTag = "";
long range = 9999999999L;
Random r = new Random();
long number = (long) (r.nextDouble() * range);
tempBagTag = String.format("%010d", number);
return tempBagTag;
}
public enum Entity {
PAX {
@Override
public String toString() {
return "Passenger";
}
},
GH {
@Override
public String toString() {
return "Groundhandler";
}
},
AIRL {
@Override
public String toString() {
return "Airline";
}
},
AIRP {
@Override
public String toString() {
return "Airport";
}
},
SEC {
@Override
public String toString() {
return "Security";
}
},
NIL {
@Override
public String toString() {
return "nil";
}
}
}
}
Executing the application
BagTransaction [bagTag=1691462171, timeStamp=2018-08-12T08:02:25.745Z, pnr=ICSEAH, transferFrom=NIL, transferTo=PAX, blockID=1, blockHash=3ff736f7158d224db6e2e8ba25f3d50321903cd911646576f442a60f8c5872ed, previousBlockHash=0]
BagTransaction [bagTag=1691462171, timeStamp=2018-08-12T08:02:25.808Z, pnr=ICSEAH, transferFrom=PAX, transferTo=AIRP, blockID=2, blockHash=88dd4a2be3bc90ebce71635bedd6bcb63b326044e4bd49634a859a86458de243, previousBlockHash=3ff736f7158d224db6e2e8ba25f3d50321903cd911646576f442a60f8c5872ed]
BagTransaction [bagTag=1691462171, timeStamp=2018-08-12T08:02:25.808Z, pnr=ICSEAH, transferFrom=AIRP, transferTo=SEC, blockID=3, blockHash=ea7767ddb2dd7c2bfed4d3a038b9249e43df15a0396ff71da717783db9fee3c4, previousBlockHash=88dd4a2be3bc90ebce71635bedd6bcb63b326044e4bd49634a859a86458de243]
Please note, this is the most simple implementation of a blockchain for illustration purpose, it still misses a lot of features to pass to production, eg. mining, proof-of-work, etc.
In a second part might spin this a bit further. Stay tuned.
Disclaimer: This discussion, datamodel and sourcecode or application is for study purpose solely. It does not reflect or replicate any existing commercial product.
The JavaDude Weblog 