Mike Gerwitz

Activist for User Freedom

aboutsummaryrefslogtreecommitdiffstats
path: root/src
diff options
context:
space:
mode:
authorMike Gerwitz <mike.gerwitz@rtspecialty.com>2018-05-29 11:16:59 -0400
committerMike Gerwitz <mike.gerwitz@rtspecialty.com>2018-05-29 11:16:59 -0400
commiteef3eb85eabca531424d217068a4a919b12d5681 (patch)
treee5a1b0c354f1c8d4fb872a018b50fce960eeacfa /src
parent3f7e1fc9b8728081604df41a7401b782ae4f8eba (diff)
downloadtame-eef3eb85eabca531424d217068a4a919b12d5681.tar.gz
tame-eef3eb85eabca531424d217068a4a919b12d5681.tar.bz2
tame-eef3eb85eabca531424d217068a4a919b12d5681.zip
map: Uppercase and hash transformers
This includes a SHA256 implementation which is _not_ intended for secure cryptographic operations; see src/js/sha256.js header for more information. * src/current/compiler/js.xsl (compiler:static): Echo src/js/sha256.js. [map_method_uppercase, map_method_hash]: New functions. * src/current/link.xsl: Include dslc-base.xsl. * src/js/sha256.js: New file.
Diffstat (limited to 'src')
-rw-r--r--src/current/compiler/js.xsl45
-rw-r--r--src/current/link.xsl4
-rw-r--r--src/js/sha256.js112
3 files changed, 159 insertions, 2 deletions
diff --git a/src/current/compiler/js.xsl b/src/current/compiler/js.xsl
index 78afb0c..cfc5ccf 100644
--- a/src/current/compiler/js.xsl
+++ b/src/current/compiler/js.xsl
@@ -2,7 +2,7 @@
<!--
Compiles rater XML into JavaScript
- Copyright (C) 2016, 2017 R-T Specialty, LLC.
+ Copyright (C) 2016, 2017, 2018 R-T Specialty, LLC.
This file is part of TAME.
@@ -1954,8 +1954,51 @@
return ret;
}
+
+
+ /**
+ * Map each string in INPUT to uppercase
+ *
+ * @param {Array|string} input string
+ *
+ * @return {Array<number>|number} mapped value
+ */
+ function map_method_uppercase( input )
+ {
+ if ( Array.isArray( input ) )
+ {
+ return input.map( map_method_uppercase );
+ }
+
+ return input.toUpperCase();
+ }
+
+
+ /**
+ * Map each string in INPUT to an integer
+ *
+ * An integer is constructed by taking the four higher-order bytes from
+ * the SHA256 hash of the input (corresponding to eight hexadecimal digits).
+ *
+ * @param {Array|string} input preimage
+ *
+ * @return {Array<number>|number} mapped value
+ */
+ function map_method_hash( input )
+ {
+ if ( Array.isArray( input ) )
+ {
+ return input.map( map_method_hash );
+ }
+
+ const hash = sha256( input ).substr( 0, 8 );
+ return parseInt( hash, 16 );
+ }
]]>
</text>
+
+<sequence select="unparsed-text(
+ concat( $__path-root, '/src/js/sha256.js' ) )" />
</template>
</stylesheet>
diff --git a/src/current/link.xsl b/src/current/link.xsl
index b46cfef..ac880f9 100644
--- a/src/current/link.xsl
+++ b/src/current/link.xsl
@@ -2,7 +2,7 @@
<!--
Entry point for linker
- Copyright (C) 2016 R-T Specialty, LLC.
+ Copyright (C) 2016, 2018 R-T Specialty, LLC.
This file is part of TAME.
@@ -24,6 +24,8 @@
xmlns="http://www.w3.org/1999/xhtml"
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
+<xsl:include href="include/dslc-base.xsl" />
+
<xsl:include href="compiler/linker.xsl" />
</xsl:stylesheet>
diff --git a/src/js/sha256.js b/src/js/sha256.js
new file mode 100644
index 0000000..1502100
--- /dev/null
+++ b/src/js/sha256.js
@@ -0,0 +1,112 @@
+/**
+ * Source: https://raw.githubusercontent.com/geraintluff/sha256/gh-pages/sha256.js
+ * This script is in the public domain.
+ * This comment was added by R-T Specialty.
+ *
+ * N.B.: THIS IMPLEMENTATION IS NOT INTENDED FOR SECURE CRYPTOGRAPHIC
+ * OPERATIONS. It is used as a seemingly faithful implementation of SHA256
+ * not as a cryptographically secure hash, but as, simply, a hash function
+ * with a uniform distribution. This allows truncating to any length while
+ * still maintaining that uniformity, which is important for avoiding
+ * collisions.
+ *
+ * So, repeat: DO NOT USE FOR SENSITIVE CRYPTOGRAPHIC OPERATIONS. This has
+ * not been audited.
+ */
+
+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 '1' 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 "working 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;
+};