Are you wondering how to become a blockchain developer? This course helps you learn blockchain development using Hyperledger Fabric.

educativebc.tar.gz

educativeBClaunch

In this course, we will build blockchain concepts from the ground up. We will start with basic cryptography constructs, like hash functions and PKI encryption, to first build a solid base for understanding blockchain and appreciate its value. Then, we will explore the Hyperledger Fabric technology by IBM using hands-on development environment within your browser. This course is a great starting point for engineers looking to develop expertise in blockchain technology with Hyperledger Fabric specialty. In this course, you will deploy your own blockchain network, deploy chaincode on it and create an application that invokes your chaincode running in fabric network. You will also learn to manage fabric user identities in your application using wallets.

Become a Blockchain Developer


A hash value for a data is X is a function:

`HASH(X) = Y`

Such that:
- No other X' can have HASH(X') equal to Y. Its one to one mapping.
- The size of Y is fixed and the size of X can be arbitrary.
- Given Y you can not calculate X. Its a one-way function!






## Hash Functions for Checking Integrity

This means that I can take a huge text file and compute its unique digest using a hash function. If I send that file and its computed hash along with it to a receiver, Bob, Bob can then recompute the hash to ensure that the content of that file were not corrupted in the transmission. When we download a file from the internet, it uses the same hash functions to verify its integrity.

## SHA256 Hash Function
There are multiple standardized hash function implementations that are used, such as SHA256, which we will be using in our course.

You can find libraries that implement SHA256 hash in all technologies, so you never have to write your code for SHA256 implementation.

Here is a small Javascript widget that will calculate sha256 of any data you enter:


body { 
  text-align: center;
}

#content {
  background: #fff;
  border-radius: 4px;
  padding: 20px;
  transition: all 0.2s;
}



#input {
  display: inline-block;
  width: auto;
}

#diagram {
  height: 50px;
  width: auto;
}

#hash {
  display: inline-block;
  width: auto;
  position: relative;
  bottom: 10px;
}


.done {
  color: rgba(0, 0, 0, 0.3);
  text-decoration: line-through;
}




<!doctype html>
<html>

  <head>
    <script src="https://code.jquery.com/jquery-1.8.3.min.js"></script>
    <script src="https://cdnjs.cloudflare.com/ajax/libs/jsencrypt/2.3.1/jsencrypt.js"></script>
    <script type="text/javascript"></script>
  </head>

  <body>
    <div id='content'>
    </div>
  </body>

</html>


"use strict";

function _instanceof(left, right) { if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { return !!right[Symbol.hasInstance](left); } else { return left instanceof right; } }

function _typeof(obj) { if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }

function _classCallCheck(instance, Constructor) { if (!_instanceof(instance, Constructor)) { throw new TypeError("Cannot call a class as a function"); } }

function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }

function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }

function _possibleConstructorReturn(self, call) { if (call && (_typeof(call) === "object" || typeof call === "function")) { return call; } return _assertThisInitialized(self); }

function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }

function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }

function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } subClass.prototype = Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }); if (superClass) _setPrototypeOf(subClass, superClass); }

function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }

var HashFunction =
/*#__PURE__*/
function (_React$Component) {
  _inherits(HashFunction, _React$Component);

  function HashFunction(props) {
    var _this;

    _classCallCheck(this, HashFunction);

    _this = _possibleConstructorReturn(this, _getPrototypeOf(HashFunction).call(this, props));
    _this.state = {
      value: '',
      hash: 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855'
    };
    _this.handleChange = _this.handleChange.bind(_assertThisInitialized(_this));
    _this.handlePaste = _this.handlePaste.bind(_assertThisInitialized(_this));
    _this.handleSubmit = _this.handleSubmit.bind(_assertThisInitialized(_this));
    return _this;
  }

  _createClass(HashFunction, [{
    key: "handleChange",
    value: function handleChange(event) {
      var text = event.target.value.replace(/\s/g, '');
      this.setState({
        value: text,
        hash: sha256(text)
      });
    }
  }, {
    key: "handlePaste",
    value: function handlePaste(event) {
      var text = event.clipboardData.getData('Text').replace(/\s/g, '');
      this.setState({
        hash: sha256(text)
      });
      console.log('value:', text);
    }
  }, {
    key: "handleSubmit",
    value: function handleSubmit(event) {
      alert('A name was submitted: ' + this.state.value);
      event.preventDefault();
    }
  }, {
    key: "render",
    value: function render() {
      return React.createElement("form", {
        onSubmit: this.handleSubmit
      }, React.createElement("textarea", {
        id: "input",
        type: "data",
        rows: "3",
        cols: "15",
        value: this.state.value,
        onChange: this.handleChange,
        onPaste: this.handlePaste
      }), React.createElement("img", {
        id: "diagram",
        src: "https://res.cloudinary.com/dxbm70w1m/image/upload/v1547742901/Blockchain/hash_function_diagram.png"
      }), React.createElement("div", {
        id: "hash"
      }, React.createElement("p", null, this.state.hash.substring(0, this.state.hash.length / 2)), React.createElement("p", null, this.state.hash.substring(this.state.hash.length / 2 + 1, this.state.hash.length))));
    }
  }]);

  return HashFunction;
}(React.Component);

ReactDOM.render(React.createElement(HashFunction, null), document.querySelector("#content"));

var sha256 = function sha256(ascii) {
  function rightRotate(value, amount) {
    return value >>> amount | value << 32 - amount;
  }

  ;
  var mathPow = Math.pow;
  var maxWord = mathPow(2, 32);
  var lengthProperty = 'length';
  var i, j; // Used as a counter across the whole file

  var result = '';
  var words = [];
  var asciiBitLength = ascii[lengthProperty] * 8; //* caching results is optional - remove/add slash from front of this line to toggle
  // Initial hash value: first 32 bits of the fractional parts of the square roots of the first 8 primes
  // (we actually calculate the first 64, but extra values are just ignored)

  var hash = sha256.h = sha256.h || []; // Round constants: first 32 bits of the fractional parts of the cube roots of the first 64 primes

  var k = sha256.k = sha256.k || [];
  var primeCounter = k[lengthProperty];
  /*/
  var hash = [], k = [];
  var primeCounter = 0;
  //*/

  var isComposite = {};

  for (var candidate = 2; primeCounter < 64; candidate++) {
    if (!isComposite[candidate]) {
      for (i = 0; i < 313; i += candidate) {
        isComposite[i] = candidate;
      }

      hash[primeCounter] = mathPow(candidate, .5) * maxWord | 0;
      k[primeCounter++] = mathPow(candidate, 1 / 3) * maxWord | 0;
    }
  }

  ascii += '\x80'; // Append ?' bit (plus zero padding)

  while (ascii[lengthProperty] % 64 - 56) {
    ascii += '\x00';
  } // More zero padding


  for (i = 0; i < ascii[lengthProperty]; i++) {
    j = ascii.charCodeAt(i);
    if (j >> 8) return; // ASCII check: only accept characters in range 0-255

    words[i >> 2] |= j << (3 - i) % 4 * 8;
  }

  words[words[lengthProperty]] = asciiBitLength / maxWord | 0;
  words[words[lengthProperty]] = asciiBitLength; // process each chunk

  for (j = 0; j < words[lengthProperty];) {
    var w = words.slice(j, j += 16); // The message is expanded into 64 words as part of the iteration

    var oldHash = hash; // This is now the undefinedworking hash", often labelled as variables a...g
    // (we have to truncate as well, otherwise extra entries at the end accumulate

    hash = hash.slice(0, 8);

    for (i = 0; i < 64; i++) {
      var i2 = i + j; // Expand the message into 64 words
      // Used below if 

      var w15 = w[i - 15],
          w2 = w[i - 2]; // Iterate

      var a = hash[0],
          e = hash[4];
      var temp1 = hash[7] + (rightRotate(e, 6) ^ rightRotate(e, 11) ^ rightRotate(e, 25)) // S1
      + (e & hash[5] ^ ~e & hash[6]) // ch
      + k[i] // Expand the message schedule if needed
      + (w[i] = i < 16 ? w[i] : w[i - 16] + (rightRotate(w15, 7) ^ rightRotate(w15, 18) ^ w15 >>> 3) // s0
      + w[i - 7] + (rightRotate(w2, 17) ^ rightRotate(w2, 19) ^ w2 >>> 10) // s1
      | 0); // This is only used once, so *could* be moved below, but it only saves 4 bytes and makes things unreadble

      var temp2 = (rightRotate(a, 2) ^ rightRotate(a, 13) ^ rightRotate(a, 22)) + ( // S0
      a & hash[1] ^ a & hash[2] ^ hash[1] & hash[2]); // maj

      hash = [temp1 + temp2 | 0].concat(hash); // We don't bother trimming off the extra ones, they're harmless as long as we're truncating when we do the slice()

      hash[4] = hash[4] + temp1 | 0;
    }

    for (i = 0; i < 8; i++) {
      hash[i] = hash[i] + oldHash[i] | 0;
    }
  }

  for (i = 0; i < 8; i++) {
    for (j = 3; j + 1; j--) {
      var b = hash[i] >> j * 8 & 255;
      result += (b < 16 ? 0 : '') + b.toString(16);
    }
  }

  return result;
};

codemirror

babel

Each hash function has a corresponding inverse function

The input of a hash function has to be of a fixed length

Hash functions only work for integer inputs

Which of the following statements is maybe true?

<p>Which of the following statements is maybe true?</p>


SHA 256 produces a 256 bit (32 byte) hash value. How many possible hash values are there?

<p>SHA 256 produces a 256 bit (32 byte) hash value. How many possible hash values are there?</p>


Input cannot be determined from hash value

Assume the following hash function,
`HASH(x) = sum(to_ascii(x)) %1024`
Which of the following properties does this hash function **lack**?

<p>Assume the following hash function,
<code>HASH(x) = sum(to_ascii(x)) %1024</code>
Which of the following properties does this hash function <strong>lack</strong>?</p>


Test Yourself

<p>Test Yourself</p>


In the next lesson, we will discuss what Public key cryptography is.


# Hash Functions for Checking Integrity

This means that I can take a huge text file and compute its unique digest using a hash function. If I send that file and its computed hash along with it to a receiver, Bob, Bob can then recompute the hash to ensure that the content of that file were not corrupted in the transmission. When we download a file from the internet, it uses the same hash functions to verify its integrity.

# SHA256 Hash Function
There are multiple standardized hash function implementations that are used, such as SHA256, which we will be using in our course.

You can find libraries that implement SHA256 hash in all technologies, so you never have to write your code for SHA256 implementation.

Here is a small Javascript widget that will calculate sha256 of any data you enter:


A hash function maps data of arbitrary length to a unique fixed length string, called digest.

Introduction - Understanding Blockchain

The technology pre-reqs for understanding blockchain

Blockchain data storage

Understanding the value of blockchain (Bitcoin example)

Hyperledger Fabric - Concepts

STEP 1: Deploy first Fabric Network

STEP 2: Write and deploy Chaincode

STEP 3: Create a Client Application

Hash Functions

Hash Functions for Checking Integrity #

SHA256 Hash Function #