/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "<WebSig>" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 2001, Institute for
* Data Communications Systems, <http://www.nue.et-inf.uni-siegen.de/>.
* The development of this software was partly funded by the European
* Commission in the <WebSig> project in the ISIS Programme.
* For more information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package ant;
import java.io.*;
import sun.misc.HexDumpEncoder;
/**
*
* @author Niko Schweitzer
*/
public class HexDump {
/**
* Method prettyPrintHex
*
*
* @param baToConvert
* @return hexdump string
*/
public static String prettyPrintHex(byte[] baToConvert) {
HexDumpEncoder hde = new HexDumpEncoder();
return hde.encodeBuffer(baToConvert);
}
/**
* Method prettyPrintHex
*
*
* @param sToConvert
* @return hexdump string
*/
public static String prettyPrintHex(String sToConvert) {
return prettyPrintHex(sToConvert.getBytes());
}
/** Field DEBUG */
private static boolean DEBUG = false;
/** Field HEX_DIGITS */
private final static char[] HEX_DIGITS = { '0', '1', '2', '3', '4', '5', '6',
'7', '8', '9', 'A', 'B', 'C', 'D',
'E', 'F' };
/** Field BIT_DIGIT */
private static char[] BIT_DIGIT = { '0', '1' };
/** Field COMPARE_BITS */
private final static byte[] COMPARE_BITS = { (byte) 0x80, (byte) 0x40,
(byte) 0x20, (byte) 0x10,
(byte) 0x08, (byte) 0x04,
(byte) 0x02, (byte) 0x01 };
/** Field BYTE_SEPARATOR */
private static char BYTE_SEPARATOR = ' ';
/** Field WITH_BYTE_SEPARATOR */
private static boolean WITH_BYTE_SEPARATOR = true;
/**
* Sets the Debug attribute of the Convert object
*
* @param dbg The new Debug value
*/
public static void setDebug(boolean dbg) {
DEBUG = dbg;
}
/**
* Sets the WithByteSeparator attribute of the Convert class
*
* @param bs The new WithByteSeparator value
*/
public static void setWithByteSeparator(boolean bs) {
WITH_BYTE_SEPARATOR = bs;
}
/**
* Sets the ByteSeparator attribute of the Convert class
*
* @param bs The new ByteSeparator value
*/
public static void setByteSeparator(char bs) {
BYTE_SEPARATOR = bs;
}
/**
* Sets the BitDigits attribute of the Convert class
*
* @param bd The new BitDigits value
* @exception Exception Description of Exception
*/
public static void setBitDigits(char[] bd) throws Exception {
if (bd.length != 2) {
throw new Exception("wrong number of characters!");
}
BIT_DIGIT = bd;
}
/**
* Method setBitDigits
*
* @param zeroBit
* @param oneBit
*/
public static void setBitDigits(char zeroBit, char oneBit) {
BIT_DIGIT[0] = zeroBit;
BIT_DIGIT[1] = oneBit;
}
/*
* Converts a byte array to hex string
*/
/**
* Description of the Method
*
* @param block Description of Parameter
* @return Description of the Returned Value
*/
public static String byteArrayToBinaryString(byte[] block) {
StringBuffer strBuf = new StringBuffer();
int iLen = block.length;
//---- for all bytes of array
for (int i = 0; i < iLen; i++) {
byte2bin(block[i], strBuf);
//---- if bit i is set ----//
if ((i < iLen - 1) & WITH_BYTE_SEPARATOR) {
strBuf.append(BYTE_SEPARATOR);
}
}
return strBuf.toString();
}
/**
* Method toBinaryString
*
* @param ba
*
*/
public static String toBinaryString(byte[] ba) {
return byteArrayToBinaryString(ba);
}
/**
* Method toBinaryString
*
* @param b
*
*/
public static String toBinaryString(byte b) {
byte[] ba = new byte[1];
ba[0] = b;
return byteArrayToBinaryString(ba);
}
/**
* Method toBinaryString
*
* @param s
*
*/
public static String toBinaryString(short s) {
return toBinaryString(toByteArray(s));
}
/**
* Method toBinaryString
*
* @param i
*
*/
public static String toBinaryString(int i) {
return toBinaryString(toByteArray(i));
}
/**
* Method toBinaryString
*
* @param l
*
*/
public static String toBinaryString(long l) {
return toBinaryString(toByteArray(l));
}
/**
* Method toByteArray
*
* @param s
*
*/
public static final byte[] toByteArray(short s) {
byte[] baTemp = new byte[2];
baTemp[1] = (byte) (s);
baTemp[0] = (byte) (s >> 8);
return baTemp;
}
/**
* Method toByteArray
*
* @param i
*
*/
public static final byte[] toByteArray(int i) {
byte[] baTemp = new byte[4];
baTemp[3] = (byte) i;
baTemp[2] = (byte) (i >> 8);
baTemp[1] = (byte) (i >> 16);
baTemp[0] = (byte) (i >> 24);
return baTemp;
}
/**
* Method toByteArray
*
* @param l
*
*/
public static final byte[] toByteArray(long l) {
byte[] baTemp = new byte[8];
baTemp[7] = (byte) l;
baTemp[6] = (byte) (l >> 8);
baTemp[5] = (byte) (l >> 16);
baTemp[4] = (byte) (l >> 24);
baTemp[3] = (byte) (l >> 32);
baTemp[2] = (byte) (l >> 40);
baTemp[1] = (byte) (l >> 48);
baTemp[0] = (byte) (l >> 56);
return baTemp;
}
/**
* Description of the Method
*
* @param block Description of Parameter
* @return Description of the Returned Value
*/
public static String byteArrayToHexString(byte[] block) {
long lTime = System.currentTimeMillis();
StringBuffer buf = new StringBuffer();
int len = block.length;
for (int i = 0; i < len; i++) {
byte2hex(block[i], buf);
if ((i < len - 1) & WITH_BYTE_SEPARATOR) {
buf.append(BYTE_SEPARATOR);
}
}
return buf.toString();
}
/**
* Description of the Method
*
* @param in string to be converted
* @return String in readable hex encoding
*/
public static String stringToHexString(String in) {
byte[] ba = in.getBytes();
return toHexString(ba);
}
/**
* Description of the Method
*
* @param block Description of Parameter
* @param offset Description of Parameter
* @param length Description of Parameter
* @return Description of the Returned Value
*/
public static String byteArrayToHexString(byte[] block, int offset,
int length) {
long lTime = System.currentTimeMillis();
StringBuffer buf = new StringBuffer();
int len = block.length;
length = length + offset;
if ((len < length)) {
length = len;
}
for (int i = 0 + offset; i < length; i++) {
byte2hex(block[i], buf);
if (i < length - 1) {
buf.append(":");
}
}
return buf.toString();
}
/**
* Returns a string of hexadecimal digits from a byte array. Each byte is
* converted to 2 hex symbols.
*
* @param ba Description of Parameter
* @return Description of the Returned Value
*/
public static String toHexString(byte[] ba) {
return toHexString(ba, 0, ba.length);
}
/**
* Method toHexString
*
* @param b
*
*/
public static String toHexString(byte b) {
byte[] ba = new byte[1];
ba[0] = b;
return toHexString(ba, 0, ba.length);
}
/**
* Description of the Method
*
* @param s
* @return Description of the Returned Value
*/
public static String toHexString(short s) {
return toHexString(toByteArray(s));
}
/**
* Method toHexString
*
* @param i
*
*/
public static String toHexString(int i) {
return toHexString(toByteArray(i));
}
/**
* Method toHexString
*
* @param l
*
*/
public static String toHexString(long l) {
return toHexString(toByteArray(l));
}
/**
* Method toString
*
* @param ba
*
*/
public static String toString(byte[] ba) {
return new String(ba).toString();
}
/**
* Method toString
*
* @param b
*
*/
public static String toString(byte b) {
byte[] ba = new byte[1];
ba[0] = b;
return new String(ba).toString();
}
/**
* converts String to Hex String. Example: niko ->6E696B6F
*
* @param ba Description of Parameter
* @param offset Description of Parameter
* @param length Description of Parameter
* @return Description of the Returned Value
*/
public static String toHexString(byte[] ba, int offset, int length) {
long lTime = System.currentTimeMillis();
char[] buf;
if (WITH_BYTE_SEPARATOR) {
buf = new char[length * 3];
} else {
buf = new char[length * 2];
}
for (int i = offset, j = 0, k; i < offset + length; ) {
k = ba[i++];
buf[j++] = HEX_DIGITS[(k >>> 4) & 0x0F];
buf[j++] = HEX_DIGITS[k & 0x0F];
if (WITH_BYTE_SEPARATOR) {
buf[j++] = BYTE_SEPARATOR;
}
}
return new String(buf);
}
/**
* Converts readable hex-String to byteArray
*
* @param strA
*
*/
public static byte[] hexStringToByteArray(String strA) {
ByteArrayOutputStream result = new ByteArrayOutputStream();
// alle Hex-Zeichen konvertieren, den Rest Ignorieren
// jedes Zeichen stellt einen 4-Bit Wert dar
byte sum = (byte) 0x00;
boolean nextCharIsUpper = true;
for (int i = 0; i < strA.length(); i++) {
char c = strA.charAt(i);
switch (Character.toUpperCase(c)) {
case '0' :
if (nextCharIsUpper) {
sum = (byte) 0x00;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x00;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '1' :
if (nextCharIsUpper) {
sum = (byte) 0x10;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x01;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '2' :
if (nextCharIsUpper) {
sum = (byte) 0x20;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x02;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '3' :
if (nextCharIsUpper) {
sum = (byte) 0x30;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x03;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '4' :
if (nextCharIsUpper) {
sum = (byte) 0x40;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x04;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '5' :
if (nextCharIsUpper) {
sum = (byte) 0x50;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x05;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '6' :
if (nextCharIsUpper) {
sum = (byte) 0x60;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x06;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '7' :
if (nextCharIsUpper) {
sum = (byte) 0x70;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x07;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '8' :
if (nextCharIsUpper) {
sum = (byte) 0x80;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x08;
result.write(sum);
nextCharIsUpper = true;
}
break;
case '9' :
if (nextCharIsUpper) {
sum = (byte) 0x90;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x09;
result.write(sum);
nextCharIsUpper = true;
}
break;
case 'A' :
if (nextCharIsUpper) {
sum = (byte) 0xA0;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x0A;
result.write(sum);
nextCharIsUpper = true;
}
break;
case 'B' :
if (nextCharIsUpper) {
sum = (byte) 0xB0;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x0B;
result.write(sum);
nextCharIsUpper = true;
}
break;
case 'C' :
if (nextCharIsUpper) {
sum = (byte) 0xC0;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x0C;
result.write(sum);
nextCharIsUpper = true;
}
break;
case 'D' :
if (nextCharIsUpper) {
sum = (byte) 0xD0;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x0D;
result.write(sum);
nextCharIsUpper = true;
}
break;
case 'E' :
if (nextCharIsUpper) {
sum = (byte) 0xE0;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x0E;
result.write(sum);
nextCharIsUpper = true;
}
break;
case 'F' :
if (nextCharIsUpper) {
sum = (byte) 0xF0;
nextCharIsUpper = false;
} else {
sum |= (byte) 0x0F;
result.write(sum);
nextCharIsUpper = true;
}
break;
}
}
if (!nextCharIsUpper) {
throw new RuntimeException("The String did not contain an equal number of hex digits");
}
return result.toByteArray();
}
/*
* Converts a byte to hex digit and writes to the supplied buffer
*/
/**
* Description of the Method
*
* @param b Description of Parameter
* @param buf Description of Parameter
*/
private static void byte2hex(byte b, StringBuffer buf) {
char[] hexChars = { '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A',
'B', 'C', 'D', 'E', 'F' };
int high = ((b & 0xf0) >> 4);
int low = (b & 0x0f);
buf.append(hexChars[high]);
buf.append(hexChars[low]);
}
/**
* Description of the Method
*
* @param b Description of Parameter
* @param buf Description of Parameter
*/
private static void byte2bin(byte b, StringBuffer buf) {
// test every 8 bit
for (int i = 0; i < 8; i++) {
//---test if bit is set
if ((b & COMPARE_BITS[i]) != 0) {
buf.append(BIT_DIGIT[1]);
} else {
buf.append(BIT_DIGIT[0]);
}
}
}
/**
* Returns a string of 8 hexadecimal digits (most significant digit first)
* corresponding to the integer <i>n</i> , which is treated as unsigned.
*
* @param n Description of Parameter
* @return Description of the Returned Value
*/
private static String intToHexString(int n) {
char[] buf = new char[8];
for (int i = 7; i >= 0; i--) {
buf[i] = HEX_DIGITS[n & 0x0F];
n >>>= 4;
}
return new String(buf);
}
/**
* test and demo for the Convert class
*
* @param args none needed
*/
public static void main(String args[]) {
System.out.println("-test and demo of the converter ");
// enable debug outputs
setDebug(false);
String str = new String("Niko");
byte[] ba = str.getBytes();
System.out.println("to convert: " + str);
System.out.println("converted1: " + byteArrayToHexString(ba));
System.out.println("converted1: "
+ byteArrayToHexString(ba, 0, ba.length));
System.out.println("converted3: " + stringToHexString(str));
System.out.println("----Convert integer to hexString...");
int i = -2;
System.out.println("to convert: " + i + " -> " + intToHexString(i));
System.out.println("----Convert byte[] to binary String...");
byte[] baToConvert = { (byte) 0xff, (byte) 0x00, (byte) 0x33, (byte) 0x11,
(byte) 0xff, (byte) 0x5f, (byte) 0x5f, (byte) 0x4f,
(byte) 0x1f, (byte) 0xff };
System.out.println("to convert: " + toHexString(baToConvert) + " -> "
+ byteArrayToBinaryString(baToConvert));
//---- modify line separator
setByteSeparator('-');
System.out.println("to convert: " + toHexString(baToConvert) + " -> "
+ byteArrayToBinaryString(baToConvert));
//---- modify line separator
setByteSeparator('*');
setWithByteSeparator(true);
System.out.println("to convert: " + toHexString(baToConvert) + " -> "
+ byteArrayToBinaryString(baToConvert));
//---- modify bit digits
char[] bd = { 'a', 'b' };
try {
setBitDigits(bd);
} catch (Exception ex) {
ex.printStackTrace();
}
System.out.println("to convert: " + toHexString(baToConvert) + " -> "
+ byteArrayToBinaryString(baToConvert));
//------------------------------------------------//
setBitDigits('0', '1');
System.out.println("---- Convert.toByteArray(int) ");
for (int iToConvert = -10; iToConvert < 10; iToConvert++) {
System.out.println("to convert = " + iToConvert + " = "
+ HexDump.toBinaryString(iToConvert));
byte[] baConvInt = new byte[4];
baConvInt = HexDump.toByteArray(iToConvert);
System.out.println("convertet byteArray = "
+ HexDump.toBinaryString(baConvInt));
}
System.out.println("---- toHexString(int) ");
i = -1;
System.out.println(i + " = 0x" + toHexString(i) + " = "
+ toBinaryString(i));
i++;
System.out.println(i + " = 0x" + toHexString(i) + " = "
+ toBinaryString(i));
//------------------------------------------------//
System.out.println("---- toHexString(long) ");
long l = 100;
System.out.println(l + " = 0x" + toHexString(l) + " = "
+ toBinaryString(l));
java.util.Random rnd = new java.util.Random();
l = rnd.nextLong();
System.out.println(l + " = 0x" + toHexString(l) + " = "
+ toBinaryString(l));
//------------------------------------------------//
System.out.println("---- toHexString(short) ");
short s = 100;
System.out.println(s + " = 0x" + toHexString(s) + " = "
+ toBinaryString(s));
rnd = new java.util.Random();
s = (short) rnd.nextInt();
System.out.println(s + " = 0x" + toHexString(s) + " = "
+ toBinaryString(s));
//---------------------------------------------------------------------------//
// convert dezimal-String to binary
System.out.println("---- read file in Hex-Format ");
String strToConvert = "12345654321";
System.out.println(strToConvert + " = "
+ stringToHexString(strToConvert));
System.out.println("Das ist die Hex-Darstellung des obigen Strings");
byte[] baConverted = new byte[strToConvert.length()];
baConverted = hexStringToByteArray(strToConvert);
System.out.println("ba = " + toHexString(ba));
}
}