MD4 basic transformation. Transforms context based on 512 bits from input block starting from the offset'th byte. @param block input sub-array. @param offset starting position of sub-array.
(byte[] block, int offset)
| 199 | * @param offset starting position of sub-array. |
| 200 | */ |
| 201 | private void transform(byte[] block, int offset) { |
| 202 | |
| 203 | // encodes 64 bytes from input block into an array of 16 32-bit |
| 204 | // entities. Use A as a temp var. |
| 205 | for (int i = 0; i < 16; i++) |
| 206 | X[i] = |
| 207 | (block[offset++] & 0xFF) | (block[offset++] & 0xFF) |
| 208 | << 8 | (block[offset++] & 0xFF) |
| 209 | << 16 | (block[offset++] & 0xFF) |
| 210 | << 24; |
| 211 | |
| 212 | int A = context[0]; |
| 213 | int B = context[1]; |
| 214 | int C = context[2]; |
| 215 | int D = context[3]; |
| 216 | |
| 217 | A = FF(A, B, C, D, X[0], 3); |
| 218 | D = FF(D, A, B, C, X[1], 7); |
| 219 | C = FF(C, D, A, B, X[2], 11); |
| 220 | B = FF(B, C, D, A, X[3], 19); |
| 221 | A = FF(A, B, C, D, X[4], 3); |
| 222 | D = FF(D, A, B, C, X[5], 7); |
| 223 | C = FF(C, D, A, B, X[6], 11); |
| 224 | B = FF(B, C, D, A, X[7], 19); |
| 225 | A = FF(A, B, C, D, X[8], 3); |
| 226 | D = FF(D, A, B, C, X[9], 7); |
| 227 | C = FF(C, D, A, B, X[10], 11); |
| 228 | B = FF(B, C, D, A, X[11], 19); |
| 229 | A = FF(A, B, C, D, X[12], 3); |
| 230 | D = FF(D, A, B, C, X[13], 7); |
| 231 | C = FF(C, D, A, B, X[14], 11); |
| 232 | B = FF(B, C, D, A, X[15], 19); |
| 233 | |
| 234 | A = GG(A, B, C, D, X[0], 3); |
| 235 | D = GG(D, A, B, C, X[4], 5); |
| 236 | C = GG(C, D, A, B, X[8], 9); |
| 237 | B = GG(B, C, D, A, X[12], 13); |
| 238 | A = GG(A, B, C, D, X[1], 3); |
| 239 | D = GG(D, A, B, C, X[5], 5); |
| 240 | C = GG(C, D, A, B, X[9], 9); |
| 241 | B = GG(B, C, D, A, X[13], 13); |
| 242 | A = GG(A, B, C, D, X[2], 3); |
| 243 | D = GG(D, A, B, C, X[6], 5); |
| 244 | C = GG(C, D, A, B, X[10], 9); |
| 245 | B = GG(B, C, D, A, X[14], 13); |
| 246 | A = GG(A, B, C, D, X[3], 3); |
| 247 | D = GG(D, A, B, C, X[7], 5); |
| 248 | C = GG(C, D, A, B, X[11], 9); |
| 249 | B = GG(B, C, D, A, X[15], 13); |
| 250 | |
| 251 | A = HH(A, B, C, D, X[0], 3); |
| 252 | D = HH(D, A, B, C, X[8], 9); |
| 253 | C = HH(C, D, A, B, X[4], 11); |
| 254 | B = HH(B, C, D, A, X[12], 15); |
| 255 | A = HH(A, B, C, D, X[2], 3); |
| 256 | D = HH(D, A, B, C, X[10], 9); |
| 257 | C = HH(C, D, A, B, X[6], 11); |
| 258 | B = HH(B, C, D, A, X[14], 15); |
no test coverage detected