|
| 1 | +// META: title=WebCryptoAPI: digest() cSHAKE algorithms |
| 2 | +// META: timeout=long |
| 3 | + |
| 4 | +var subtle = crypto.subtle; // Change to test prefixed implementations |
| 5 | + |
| 6 | +var sourceData = { |
| 7 | + empty: new Uint8Array(0), |
| 8 | + short: new Uint8Array([ |
| 9 | + 21, 110, 234, 124, 193, 76, 86, 203, 148, 219, 3, 10, 74, 157, 149, 255, |
| 10 | + ]), |
| 11 | + medium: new Uint8Array([ |
| 12 | + 182, 200, 249, 223, 100, 140, 208, 136, 183, 15, 56, 231, 65, 151, 177, 140, |
| 13 | + 184, 30, 30, 67, 80, 213, 11, 204, 184, 251, 90, 115, 121, 200, 123, 178, |
| 14 | + 227, 214, 237, 84, 97, 237, 30, 159, 54, 243, 64, 163, 150, 42, 68, 107, |
| 15 | + 129, 91, 121, 75, 75, 212, 58, 68, 3, 80, 32, 119, 178, 37, 108, 200, 7, |
| 16 | + 131, 127, 58, 172, 209, 24, 235, 75, 156, 43, 174, 184, 151, 6, 134, 37, |
| 17 | + 171, 172, 161, 147, |
| 18 | + ]), |
| 19 | +}; |
| 20 | + |
| 21 | +// Test different output lengths for cSHAKE |
| 22 | +var digestLengths = [0, 256, 384, 512]; |
| 23 | + |
| 24 | +var digestedData = { |
| 25 | + cSHAKE128: { |
| 26 | + 0: { |
| 27 | + empty: new Uint8Array([]), |
| 28 | + short: new Uint8Array([]), |
| 29 | + medium: new Uint8Array([]), |
| 30 | + }, |
| 31 | + 256: { |
| 32 | + empty: new Uint8Array([ |
| 33 | + 127, 156, 43, 164, 232, 143, 130, 125, 97, 96, 69, 80, 118, 5, 133, 62, |
| 34 | + 215, 59, 128, 147, 246, 239, 188, 136, 235, 26, 110, 172, 250, 102, 239, |
| 35 | + 38, |
| 36 | + ]), |
| 37 | + short: new Uint8Array([ |
| 38 | + 222, 166, 45, 115, 230, 181, 156, 247, 37, 208, 50, 13, 102, 0, 137, |
| 39 | + 164, 71, 92, 187, 211, 184, 83, 158, 54, 105, 31, 21, 13, 71, 85, 103, |
| 40 | + 148, |
| 41 | + ]), |
| 42 | + medium: new Uint8Array([ |
| 43 | + 177, 172, 213, 58, 3, 231, 106, 34, 30, 82, 234, 87, 142, 4, 47, 104, |
| 44 | + 106, 104, 195, 209, 201, 131, 42, 177, 130, 133, 207, 79, 48, 76, 163, |
| 45 | + 45, |
| 46 | + ]), |
| 47 | + }, |
| 48 | + 384: { |
| 49 | + empty: new Uint8Array([ |
| 50 | + 127, 156, 43, 164, 232, 143, 130, 125, 97, 96, 69, 80, 118, 5, 133, 62, |
| 51 | + 215, 59, 128, 147, 246, 239, 188, 136, 235, 26, 110, 172, 250, 102, 239, |
| 52 | + 38, 60, 177, 238, 169, 136, 0, 75, 147, 16, 60, 251, 10, 238, 253, 42, |
| 53 | + 104, |
| 54 | + ]), |
| 55 | + short: new Uint8Array([ |
| 56 | + 222, 166, 45, 115, 230, 181, 156, 247, 37, 208, 50, 13, 102, 0, 137, |
| 57 | + 164, 71, 92, 187, 211, 184, 83, 158, 54, 105, 31, 21, 13, 71, 85, 103, |
| 58 | + 148, 240, 55, 64, 1, 183, 136, 138, 188, 54, 152, 212, 11, 137, 174, 49, |
| 59 | + 52, |
| 60 | + ]), |
| 61 | + medium: new Uint8Array([ |
| 62 | + 177, 172, 213, 58, 3, 231, 106, 34, 30, 82, 234, 87, 142, 4, 47, 104, |
| 63 | + 106, 104, 195, 209, 201, 131, 42, 177, 130, 133, 207, 79, 48, 76, 163, |
| 64 | + 45, 63, 170, 9, 252, 130, 170, 225, 66, 211, 223, 205, 121, 5, 138, 93, |
| 65 | + 92, |
| 66 | + ]), |
| 67 | + }, |
| 68 | + 512: { |
| 69 | + empty: new Uint8Array([ |
| 70 | + 127, 156, 43, 164, 232, 143, 130, 125, 97, 96, 69, 80, 118, 5, 133, 62, |
| 71 | + 215, 59, 128, 147, 246, 239, 188, 136, 235, 26, 110, 172, 250, 102, 239, |
| 72 | + 38, 60, 177, 238, 169, 136, 0, 75, 147, 16, 60, 251, 10, 238, 253, 42, |
| 73 | + 104, 110, 1, 250, 74, 88, 232, 163, 99, 156, 168, 161, 227, 249, 174, |
| 74 | + 87, 226, |
| 75 | + ]), |
| 76 | + short: new Uint8Array([ |
| 77 | + 222, 166, 45, 115, 230, 181, 156, 247, 37, 208, 50, 13, 102, 0, 137, |
| 78 | + 164, 71, 92, 187, 211, 184, 83, 158, 54, 105, 31, 21, 13, 71, 85, 103, |
| 79 | + 148, 240, 55, 64, 1, 183, 136, 138, 188, 54, 152, 212, 11, 137, 174, 49, |
| 80 | + 52, 233, 51, 245, 26, 132, 202, 127, 218, 136, 12, 59, 253, 217, 220, |
| 81 | + 58, 94, |
| 82 | + ]), |
| 83 | + medium: new Uint8Array([ |
| 84 | + 177, 172, 213, 58, 3, 231, 106, 34, 30, 82, 234, 87, 142, 4, 47, 104, |
| 85 | + 106, 104, 195, 209, 201, 131, 42, 177, 130, 133, 207, 79, 48, 76, 163, |
| 86 | + 45, 63, 170, 9, 252, 130, 170, 225, 66, 211, 223, 205, 121, 5, 138, 93, |
| 87 | + 92, 60, 17, 189, 45, 17, 195, 248, 169, 51, 31, 98, 172, 221, 186, 225, |
| 88 | + 93, |
| 89 | + ]), |
| 90 | + }, |
| 91 | + }, |
| 92 | + cSHAKE256: { |
| 93 | + 0: { |
| 94 | + empty: new Uint8Array([]), |
| 95 | + short: new Uint8Array([]), |
| 96 | + medium: new Uint8Array([]), |
| 97 | + }, |
| 98 | + 256: { |
| 99 | + empty: new Uint8Array([ |
| 100 | + 70, 185, 221, 43, 11, 168, 141, 19, 35, 59, 63, 235, 116, 62, 235, 36, |
| 101 | + 63, 205, 82, 234, 98, 184, 27, 130, 181, 12, 39, 100, 110, 213, 118, 47, |
| 102 | + ]), |
| 103 | + short: new Uint8Array([ |
| 104 | + 23, 56, 17, 63, 90, 187, 62, 229, 50, 14, 225, 138, 162, 102, 195, 97, |
| 105 | + 122, 116, 117, 219, 216, 237, 154, 152, 89, 148, 253, 221, 97, 18, 173, |
| 106 | + 153, |
| 107 | + ]), |
| 108 | + medium: new Uint8Array([ |
| 109 | + 65, 70, 193, 61, 134, 217, 188, 24, 107, 11, 48, 154, 182, 161, 36, 238, |
| 110 | + 12, 116, 186, 38, 184, 198, 13, 204, 123, 62, 213, 5, 150, 154, 168, |
| 111 | + 209, |
| 112 | + ]), |
| 113 | + }, |
| 114 | + 384: { |
| 115 | + empty: new Uint8Array([ |
| 116 | + 70, 185, 221, 43, 11, 168, 141, 19, 35, 59, 63, 235, 116, 62, 235, 36, |
| 117 | + 63, 205, 82, 234, 98, 184, 27, 130, 181, 12, 39, 100, 110, 213, 118, 47, |
| 118 | + 215, 93, 196, 221, 216, 192, 242, 0, 203, 5, 1, 157, 103, 181, 146, 246, |
| 119 | + ]), |
| 120 | + short: new Uint8Array([ |
| 121 | + 23, 56, 17, 63, 90, 187, 62, 229, 50, 14, 225, 138, 162, 102, 195, 97, |
| 122 | + 122, 116, 117, 219, 216, 237, 154, 152, 89, 148, 253, 221, 97, 18, 173, |
| 123 | + 153, 158, 200, 226, 235, 223, 234, 251, 150, 231, 111, 107, 179, 163, |
| 124 | + 173, 186, 67, |
| 125 | + ]), |
| 126 | + medium: new Uint8Array([ |
| 127 | + 65, 70, 193, 61, 134, 217, 188, 24, 107, 11, 48, 154, 182, 161, 36, 238, |
| 128 | + 12, 116, 186, 38, 184, 198, 13, 204, 123, 62, 213, 5, 150, 154, 168, |
| 129 | + 209, 144, 40, 198, 49, 121, 153, 160, 133, 177, 230, 182, 167, 133, 206, |
| 130 | + 79, 246, |
| 131 | + ]), |
| 132 | + }, |
| 133 | + 512: { |
| 134 | + empty: new Uint8Array([ |
| 135 | + 70, 185, 221, 43, 11, 168, 141, 19, 35, 59, 63, 235, 116, 62, 235, 36, |
| 136 | + 63, 205, 82, 234, 98, 184, 27, 130, 181, 12, 39, 100, 110, 213, 118, 47, |
| 137 | + 215, 93, 196, 221, 216, 192, 242, 0, 203, 5, 1, 157, 103, 181, 146, 246, |
| 138 | + 252, 130, 28, 73, 71, 154, 180, 134, 64, 41, 46, 172, 179, 183, 196, |
| 139 | + 190, |
| 140 | + ]), |
| 141 | + short: new Uint8Array([ |
| 142 | + 23, 56, 17, 63, 90, 187, 62, 229, 50, 14, 225, 138, 162, 102, 195, 97, |
| 143 | + 122, 116, 117, 219, 216, 237, 154, 152, 89, 148, 253, 221, 97, 18, 173, |
| 144 | + 153, 158, 200, 226, 235, 223, 234, 251, 150, 231, 111, 107, 179, 163, |
| 145 | + 173, 186, 67, 218, 96, 240, 12, 209, 36, 150, 223, 90, 243, 226, 138, |
| 146 | + 230, 211, 222, 66, |
| 147 | + ]), |
| 148 | + medium: new Uint8Array([ |
| 149 | + 65, 70, 193, 61, 134, 217, 188, 24, 107, 11, 48, 154, 182, 161, 36, 238, |
| 150 | + 12, 116, 186, 38, 184, 198, 13, 204, 123, 62, 213, 5, 150, 154, 168, |
| 151 | + 209, 144, 40, 198, 49, 121, 153, 160, 133, 177, 230, 182, 167, 133, 206, |
| 152 | + 79, 246, 50, 174, 178, 116, 147, 34, 126, 68, 35, 47, 183, 179, 149, 33, |
| 153 | + 65, 123, |
| 154 | + ]), |
| 155 | + }, |
| 156 | + }, |
| 157 | +}; |
| 158 | + |
| 159 | +// Test cSHAKE digest algorithms with variable output lengths |
| 160 | +Object.keys(digestedData).forEach(function (alg) { |
| 161 | + digestLengths.forEach(function (length) { |
| 162 | + Object.keys(sourceData).forEach(function (size) { |
| 163 | + promise_test(function (test) { |
| 164 | + return crypto.subtle |
| 165 | + .digest({ name: alg, length: length }, sourceData[size]) |
| 166 | + .then(function (result) { |
| 167 | + assert_true( |
| 168 | + equalBuffers(result, digestedData[alg][length][size]), |
| 169 | + 'digest matches expected' |
| 170 | + ); |
| 171 | + }); |
| 172 | + }, alg + ' with ' + length + ' bit output and ' + size + ' source data'); |
| 173 | + |
| 174 | + promise_test(function (test) { |
| 175 | + var buffer = new Uint8Array(sourceData[size]); |
| 176 | + return crypto.subtle |
| 177 | + .digest({ name: alg, length: length }, buffer) |
| 178 | + .then(function (result) { |
| 179 | + // Alter the buffer after calling digest |
| 180 | + if (buffer.length > 0) { |
| 181 | + buffer[0] = ~buffer[0]; |
| 182 | + } |
| 183 | + assert_true( |
| 184 | + equalBuffers(result, digestedData[alg][length][size]), |
| 185 | + 'digest matches expected' |
| 186 | + ); |
| 187 | + }); |
| 188 | + }, alg + |
| 189 | + ' with ' + |
| 190 | + length + |
| 191 | + ' bit output and ' + |
| 192 | + size + |
| 193 | + ' source data and altered buffer after call'); |
| 194 | + }); |
| 195 | + }); |
| 196 | +}); |
| 197 | + |
| 198 | +function equalBuffers(a, b) { |
| 199 | + if (a.byteLength !== b.byteLength) { |
| 200 | + return false; |
| 201 | + } |
| 202 | + var aBytes = new Uint8Array(a); |
| 203 | + var bBytes = new Uint8Array(b); |
| 204 | + for (var i = 0; i < a.byteLength; i++) { |
| 205 | + if (aBytes[i] !== bBytes[i]) { |
| 206 | + return false; |
| 207 | + } |
| 208 | + } |
| 209 | + return true; |
| 210 | +} |
0 commit comments