/*
* Copyright (c) 2010-2012 TMate Software Ltd
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; version 2 of the License.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* For information on how to redistribute this software under
* the terms of a license other than GNU General Public License
* contact TMate Software at support@hg4j.com
*/
package org.tmatesoft.hg.internal;
import java.io.IOException;
import java.io.InputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;
import org.tmatesoft.hg.core.Nodeid;
import org.tmatesoft.hg.repo.HgInvalidStateException;
/**
* <pre>
* DigestHelper dh;
* dh.sha1(...).asHexString();
* or
* dh = dh.sha1(...);
* nodeid.equalsTo(dh.asBinary());
* </pre>
*
* @author Artem Tikhomirov
* @author TMate Software Ltd.
*/
public class DigestHelper {
private MessageDigest sha1;
private byte[] digest;
public DigestHelper() {
}
private MessageDigest getSHA1() {
if (sha1 == null) {
try {
sha1 = MessageDigest.getInstance("SHA-1");
} catch (NoSuchAlgorithmException ex) {
// could hardly happen, JDK from Sun always has sha1.
HgInvalidStateException t = new HgInvalidStateException("Need SHA-1 algorithm for nodeid calculation");
t.initCause(ex);
throw t;
}
}
return sha1;
}
public DigestHelper sha1(Nodeid nodeid1, Nodeid nodeid2, byte[] data) {
return sha1(nodeid1.toByteArray(), nodeid2.toByteArray(), data);
}
// sha1_digest(min(p1,p2) ++ max(p1,p2) ++ final_text)
public DigestHelper sha1(byte[] nodeidParent1, byte[] nodeidParent2, byte[] data) {
MessageDigest alg = getSHA1();
if ((nodeidParent1[0] & 0x00FF) < (nodeidParent2[0] & 0x00FF)) {
alg.update(nodeidParent1);
alg.update(nodeidParent2);
} else {
alg.update(nodeidParent2);
alg.update(nodeidParent1);
}
digest = alg.digest(data);
assert digest.length == 20;
return this;
}
public String asHexString() {
if (digest == null) {
throw new IllegalStateException("Shall init with sha1() call first");
}
return toHexString(digest, 0, digest.length);
}
// by reference, be careful not to modify (or #clone() if needed)
public byte[] asBinary() {
if (digest == null) {
throw new IllegalStateException("Shall init with sha1() call first");
}
return digest;
}
// XXX perhaps, digest functions should throw an exception, as it's caller responsibility to deal with eof, etc
public DigestHelper sha1(InputStream is /*ByteBuffer*/) throws IOException {
MessageDigest alg = getSHA1();
byte[] buf = new byte[1024];
int c;
while ((c = is.read(buf)) != -1) {
alg.update(buf, 0, c);
}
digest = alg.digest();
return this;
}
public DigestHelper sha1(CharSequence... seq) {
MessageDigest alg = getSHA1();
for (CharSequence s : seq) {
byte[] b = s.toString().getBytes();
alg.update(b);
}
digest = alg.digest();
return this;
}
public static String toHexString(byte[] data, final int offset, final int count) {
char[] result = new char[count << 1];
final String hexDigits = "0123456789abcdef";
final int end = offset+count;
for (int i = offset, j = 0; i < end; i++) {
result[j++] = hexDigits.charAt((data[i] >>> 4) & 0x0F);
result[j++] = hexDigits.charAt(data[i] & 0x0F);
}
return new String(result);
}
public static boolean ascii2bin(byte[] ascii, int offset, int len, byte[] binary) {
assert len % 2 == 0;
assert binary.length >= len >>> 1;
boolean zeroBytes = true;
for (int i = 0, j = offset; i < len >>> 1; i++) {
int b = ascii[j++] & 0xCF; // -0x30 to get decimal digit out from their char, and to uppercase if a letter
int hiNibble = b > 64 ? b - 55 : b;
b = ascii[j++] & 0xCF;
int lowNibble = b > 64 ? b - 55 : b;
if (hiNibble >= 16 || lowNibble >= 16) {
throw new IllegalArgumentException(String.format("Characters '%c%c' (%1$d and %2$d) at index %d are not valid hex digits", ascii[j-2], ascii[j-1], j-2));
}
b = (((hiNibble << 4) | lowNibble) & 0xFF);
binary[i] = (byte) b;
zeroBytes = zeroBytes && b == 0;
}
return zeroBytes;
}
}