Comparison of byte arrays

I try to compare 2 byte arrays.

Byte array 1 is an array with the last 3 bytes of a sha1 hash:

  private static byte[] sha1SsidGetBytes(byte[] sha1)
  {
    return new byte[] {sha1[17], sha1[18], sha1[19]};
  }

Byte array 2 is an array that I fill with 3 bytes coming from an hexadecimal string:

  private static byte[] ssidGetBytes(String ssid)
  {
    BigInteger ssidBigInt = new 开发者_运维知识库BigInteger(ssid, 16);

    return ssidBigInt.toByteArray();
  }

How is it possible that this comparison:

  if (Arrays.equals(ssidBytes, sha1SsidGetBytes(snSha1)))
  {
  }

works most of the times but sometimes not. Byte Order?

e.g. for "6451E6" (hex string) it works fine, for "ABED74" it does not...

The problem is pretty obvious if you try this:

BigInteger b1 = new BigInteger("6451E6", 16);
BigInteger b2 = new BigInteger("ABED74", 16);

System.out.println(b1.toByteArray().length);
System.out.println(b2.toByteArray().length);

Specifically, ABED74 creates a BigInteger whose byte array is 4 bytes long--so of course it's not going to be equal to any three byte array.

The straightforward fix is to change the return statement in ssidGetBytes from

return ssidBigInt.toByteArray();

to

byte[] ba = ssidBigInt.toByteArray();
return new byte[] { ba[ba.length - 3], ba[ba.length - 2], ba[ba.length - 1] };

Your approach of parsing a hex string via BigInteger is flawed, basically. For example, new BigInteger("ABED74").toByteArray() returns an array of 4 bytes, not three. While you could hack around this, you're fundamentally not trying to do anything involving BigInteger values... you're just trying to parse hex.

I suggest you use the Apache Codec library to do the parsing:

byte[] array = (byte[]) new Hex().decode(text);

(The API for Apache Codec leaves something to be desired, but it does work.)

From the javadoc's (emphasis mine):

http://download.oracle.com/javase/1.5.0/docs/api/java/math/BigInteger.html#toByteArray%28%29

Returns a byte array containing the two's-complement representation of this BigInteger. The byte array will be in big-endian byte-order: the most significant byte is in the zeroth element. The array will contain the minimum number of bytes required to represent this BigInteger, including at least one sign bit, which is (ceil((this.bitLength() + 1)/8)). (This representation is compatible with the (byte[]) constructor.)

There is a lot of computations going on inside the ByteInteger(String,radix) constructor that you are using, which does not guarantee the constructed BigInteger will produce a byte array (via its toByteArray() method) comparable to the result of a String's getBytes() encoding.

The output of toByteArray() is intended to be used (mostly) as input to the (byte[]) constructor of BigInteger. It makes no guarantee for uses other than those.

Look at it like this: the output of toByteArray() is the byte representation of the BigInteger object and everything in it including internal attributes like magnitude. Those attributes do not exist in the input String, but are computed during construction of the BitInteger object.

That will be incompatible to the byte representation of the input String which only carries the initial numeric value with which to create a BigInteger.