The SHA256 function taken from cloudflares bot protection, deobfuscated.

cloudflare-sha256-function.js

window.SHA256 = function (ay, aA, az) {
  ay = (function (aD, aG, aF, aE) {
    aD = aD.replace(/\r\n/g, '\n');
    aE = '';

    for (
      aF = 0;
      aF < aD.length;
      aG = aD.charCodeAt(aF),
        128 > aG
          ? (aE += String.fromCharCode(aG))
          : (127 < aG && 2048 > aG
              ? (aE += String.fromCharCode((aG >> 6) | 192))
              : ((aE += String.fromCharCode((aG >> 12) | 224)),
                (aE += String.fromCharCode(((aG >> 6) & 63) | 128))),
            (aE += String.fromCharCode((aG & 63) | 128))),
        aF++
    ) {}

    return aE;
  })(ay);

  return (function (aD, aF, aE) {
    aE = '';

    for (
      aF = 0;
      aF < 4 * aD.length;
      aE +=
        '0123456789abcdef'.charAt(
          (aD[aF >> 2] >> (8 * (3 - (aF % 4)) + 4)) & 15
        ) +
        '0123456789abcdef'.charAt((aD[aF >> 2] >> (8 * (3 - (aF % 4)))) & 15),
        aF++
    ) {}

    return aE;
  })(
    (function (
      aD,
      aE,
      aY,
      aX,
      aW,
      aV,
      aU,
      aT,
      aS,
      aR,
      aQ,
      aP,
      aO,
      aN,
      aM,
      aL,
      aK,
      aJ,
      aI,
      aH,
      aG,
      aF
    ) {
      aF = [
        1116352408, 1899447441, 3049323471, 3921009573, 961987163, 1508970993,
        2453635748, 2870763221, 3624381080, 310598401, 607225278, 1426881987,
        1925078388, 2162078206, 2614888103, 3248222580, 3835390401, 4022224774,
        264347078, 604807628, 770255983, 1249150122, 1555081692, 1996064986,
        2554220882, 2821834349, 2952996808, 3210313671, 3336571891, 3584528711,
        113926993, 338241895, 666307205, 773529912, 1294757372, 1396182291,
        1695183700, 1986661051, 2177026350, 2456956037, 2730485921, 2820302411,
        3259730800, 3345764771, 3516065817, 3600352804, 4094571909, 275423344,
        430227734, 506948616, 659060556, 883997877, 958139571, 1322822218,
        1537002063, 1747873779, 1955562222, 2024104815, 2227730452, 2361852424,
        2428436474, 2756734187, 3204031479, 3329325298,
      ];
      aG = [
        1779033703, 3144134277, 1013904242, 2773480762, 1359893119, 2600822924,
        528734635, 1541459225,
      ];
      aH = Array(64);
      aD[aE >> 5] |= 128 << (24 - (aE % 32));
      aD[(((aE + 64) >> 9) << 4) + 15] = aE;

      for (aI = 0; aI < aD.length; aI += 16) {
        aK = aG[0];
        aL = aG[1];
        aM = aG[2];
        aN = aG[3];
        aO = aG[4];
        aP = aG[5];
        aQ = aG[6];
        aR = aG[7];

        for (aJ = 0; 64 > aJ; aJ++) {
          aU = aJ;
          if (16 > aJ) aV = aD[aJ + aI];
          else {
            aV = aH[aJ - 2];
            aV = aC(aV, 17) ^ aC(aV, 19) ^ (aV >>> 10);
            aV = aB(aV, aH[aJ - 7]);
            aY = aH[aJ - 15];
            aY = aC(aY, 7) ^ aC(aY, 18) ^ (aY >>> 3);
            aV = aB(aB(aV, aY), aH[aJ - 16]);
          }
          aH[aU] = aV;
          aU = aO;
          aU = aC(aU, 6) ^ aC(aU, 11) ^ aC(aU, 25);
          aU = aB(aB(aB(aB(aR, aU), (aO & aP) ^ (~aO & aQ)), aF[aJ]), aH[aJ]);
          aR = aK;
          aR = aC(aR, 2) ^ aC(aR, 13) ^ aC(aR, 22);
          aV = aB(aR, (aK & aL) ^ (aK & aM) ^ (aL & aM));
          aR = aQ;
          aQ = aP;
          aP = aO;
          aO = aB(aN, aU);
          aN = aM;
          aM = aL;
          aL = aK;
          aK = aB(aU, aV);
        }

        aG[0] = aB(aK, aG[0]);
        aG[1] = aB(aL, aG[1]);
        aG[2] = aB(aM, aG[2]);
        aG[3] = aB(aN, aG[3]);
        aG[4] = aB(aO, aG[4]);
        aG[5] = aB(aP, aG[5]);
        aG[6] = aB(aQ, aG[6]);
        aG[7] = aB(aR, aG[7]);
      }

      return aG;
    })(
      (function (aD, aF, aE) {
        aE = [];

        for (
          aF = 0;
          aF < 8 * aD.length;
          aE[aF >> 5] |= (aD.charCodeAt(aF / 8) & 255) << (24 - (aF % 32)),
            aF += 8
        ) {}

        return aE;
      })(ay),
      8 * ay.length
    )
  );

  function aB(aD, aE, aF) {
    aF = (aD & 65535) + (aE & 65535);
    return (((aD >> 16) + (aE >> 16) + (aF >> 16)) << 16) | (aF & 65535);
  }

  function aC(aD, aE) {
    return (aD >>> aE) | (aD << (32 - aE));
  }
};