153 lines
4.5 KiB
Java
153 lines
4.5 KiB
Java
import java.util.Arrays;
|
|
import java.util.List;
|
|
|
|
public final class MD4Task {
|
|
|
|
public static void main(String[] aArgs) {
|
|
String text = "Rosetta Code";
|
|
|
|
MD4 md4 = new MD4();
|
|
byte[] result = md4.engineDigest(text);
|
|
|
|
StringBuilder stringBuilder = new StringBuilder();
|
|
for ( byte bb : result ) {
|
|
stringBuilder.append(String.format("%02x", bb));
|
|
}
|
|
System.out.println(stringBuilder.toString());
|
|
}
|
|
|
|
}
|
|
|
|
final class MD4 {
|
|
|
|
public MD4() {
|
|
engineReset();
|
|
}
|
|
|
|
public byte[] engineDigest(String aText) {
|
|
engineUpdate(aText.getBytes(), 0, aText.length());
|
|
|
|
final int bufferIndex = (int) ( count % BLOCK_LENGTH );
|
|
final int paddingLength = ( bufferIndex < 56 ) ? 56 - bufferIndex : 120 - bufferIndex;
|
|
|
|
byte[] tail = new byte[paddingLength + 8];
|
|
tail[0] = (byte) 0x80;
|
|
|
|
for ( int i = 0; i < 8; i++ ) {
|
|
tail[paddingLength + i] = (byte) ( ( count * 8 ) >>> ( 8 * i ) );
|
|
}
|
|
|
|
engineUpdate(tail, 0, tail.length);
|
|
|
|
byte[] result = new byte[16];
|
|
for ( int i = 0; i < 4; i++ ) {
|
|
for ( int j = 0; j < 4; j++ ) {
|
|
result[i * 4 + j] = (byte) ( context[i] >>> ( 8 * j ) );
|
|
}
|
|
}
|
|
|
|
engineReset();
|
|
return result;
|
|
}
|
|
|
|
private void engineUpdate(byte[] aMessageBytes, int aOffset, int aMessageLength) {
|
|
if ( aOffset < 0 || aMessageLength < 0 || (long) aOffset + aMessageLength > (long) aMessageBytes.length ) {
|
|
throw new ArrayIndexOutOfBoundsException("Incorrect arguments for method engineUpdate");
|
|
}
|
|
|
|
int bufferIndex = (int) ( count % BLOCK_LENGTH );
|
|
count += aMessageLength;
|
|
final int partialLength = BLOCK_LENGTH - bufferIndex;
|
|
int i = 0;
|
|
|
|
if ( aMessageLength >= partialLength ) {
|
|
System.arraycopy(aMessageBytes, aOffset, buffer, bufferIndex, partialLength);
|
|
transform(buffer, 0);
|
|
i = partialLength;
|
|
while ( i + BLOCK_LENGTH - 1 < aMessageLength ) {
|
|
transform(aMessageBytes, aOffset + i);
|
|
i += BLOCK_LENGTH;
|
|
}
|
|
bufferIndex = 0;
|
|
}
|
|
|
|
if ( i < aMessageLength ) {
|
|
System.arraycopy(aMessageBytes, aOffset + i, buffer, bufferIndex, aMessageLength - i);
|
|
}
|
|
}
|
|
|
|
private void transform (byte[] aBuffer, int aOffset) {
|
|
for ( int i = 0; i < 16; i++ ) {
|
|
extra[i] = ( ( aBuffer[aOffset++] & 0xff ) ) |
|
|
( ( aBuffer[aOffset++] & 0xff ) << 8 ) |
|
|
( ( aBuffer[aOffset++] & 0xff ) << 16 ) |
|
|
( ( aBuffer[aOffset++] & 0xff ) << 24 );
|
|
}
|
|
|
|
int a = context[0];
|
|
int b = context[1];
|
|
int c = context[2];
|
|
int d = context[3];
|
|
|
|
for ( int i : List.of( 0, 4, 8, 12 ) ) {
|
|
a = ff(a, b, c, d, extra[i + 0], 3);
|
|
d = ff(d, a, b, c, extra[i + 1], 7);
|
|
c = ff(c, d, a, b, extra[i + 2], 11);
|
|
b = ff(b, c, d, a, extra[i + 3], 19);
|
|
}
|
|
|
|
for ( int i : List.of( 0, 1, 2, 3 ) ) {
|
|
a = gg(a, b, c, d, extra[i + 0], 3);
|
|
d = gg(d, a, b, c, extra[i + 4], 5);
|
|
c = gg(c, d, a, b, extra[i + 8], 9);
|
|
b = gg(b, c, d, a, extra[i + 12], 13);
|
|
}
|
|
|
|
for ( int i : List.of( 0, 2, 1, 3 ) ) {
|
|
a = hh(a, b, c, d, extra[i + 0], 3);
|
|
d = hh(d, a, b, c, extra[i + 8], 9);
|
|
c = hh(c, d, a, b, extra[i + 4], 11);
|
|
b = hh(b, c, d, a, extra[i + 12], 15);
|
|
}
|
|
|
|
context[0] += a;
|
|
context[1] += b;
|
|
context[2] += c;
|
|
context[3] += d;
|
|
}
|
|
|
|
private void engineReset() {
|
|
count = 0;
|
|
context[0] = 0x67452301;
|
|
context[1] = 0xefcdab89;
|
|
context[2] = 0x98badcfe;
|
|
context[3] = 0x10325476;
|
|
Arrays.fill(extra, 0);
|
|
Arrays.fill(buffer, (byte) 0);
|
|
}
|
|
|
|
private static int rotate(int t, int s) {
|
|
return t << s | t >>> ( 32 - s );
|
|
}
|
|
|
|
private static int ff(int a, int b, int c, int d, int x, int s) {
|
|
return rotate(a + ( ( b & c ) | ( ~b & d ) ) + x, s);
|
|
}
|
|
|
|
private static int gg(int a, int b, int c, int d, int x, int s) {
|
|
return rotate(a + ( ( b & ( c | d ) ) | ( c & d ) ) + x + 0x5A827999, s);
|
|
}
|
|
|
|
private static int hh(int a, int b, int c, int d, int x, int s) {
|
|
return rotate(a + ( b ^ c ^ d ) + x + 0x6ED9EBA1, s);
|
|
}
|
|
|
|
private static final int BLOCK_LENGTH = 64;
|
|
|
|
private long count;
|
|
private int[] context = new int[4];
|
|
private int[] extra = new int[16];
|
|
private byte[] buffer = new byte[BLOCK_LENGTH];
|
|
|
|
}
|