Incorrect CRC16 value for ACE file

Question

Hi,
I am trying to implement a Java app that will read ACE files. These are files that are compressed using an app such as WinAce.
I have looked at the ACE file structure documentation that says that the first 2 bytes holds the CRC 16-bit for the file header. The header is usually 54-bytes long. The first 2 bytes is the CRC-16. The next two bytes holds the length of important ACE file info. The next single byte up until the end of the header is the section that is read and the CRC is calculated from it. So, for example, if the total header is 55 bytes, the CRC is calculated from bytes 4 to the end 54 (as first byte is 0).
0      2           4             5                    ...                                54
|CRC16 | Length    |     00      |  IMPORTANT ACE FILE INFO (BYTES 4 to 54 USED IN CRC16) |
-------------------------------------------------------------------------------------------However, the CRC calculated by WinAce is "de 06" in hexadecimal and when I calculated the checksum I got "a2 94". I dont know why my checksum is incorrect.
Here is my entire class that calculates the checksum:
package org.ace.internals;
public class CRCDemo
// calculating 16-bit CRC
     * generator polynomial
    private static final int poly = 0x1021; /* x16 + x12 + x5 + 1 generator polynomial */
    /* 0x8408 used in European X.25 */
     * scrambler lookup table for fast computation.
    private static int[] crcTable = new int[256];
    static
        // initialise scrambler table
        for ( int i = 0; i < 256; i++ )
            int fcs = 0;
            int d = i << 8;
            for ( int k = 0; k < 8; k++ )
                if ( ((fcs ^ d) & 0x8000) != 0 )
                    fcs = ( fcs << 1 ) ^ poly;
                else
                    fcs = ( fcs << 1 );
                d <<= 1;
                fcs &= 0xffff;
            crcTable[i] = fcs;
     * Calc CRC with cmp method.
     * @param b byte array to compute CRC on
     * @return 16-bit CRC, signed
    public static short cmpCRC( byte[] b )
        // loop, calculating CRC for each byte of the string
        int work = 0xffff;
        for ( int i = 0; i < b.length; i++ )
            work = ( crcTable[( (work >> 8)) & 0xff] ^ ( work << 8 ) ^ ( b[i] & 0xff ) ) & 0xffff;
        return(short)work;
    public static void main(String[] args)
        //The relevant ACE header section that is used to calculate the CRC16
        byte[] bytes = new byte[]
            (byte)0x00, (byte)0x00, (byte)0x90, (byte)0x2a, (byte)0x2a, (byte)0x41,
            (byte)0x43, (byte)0x45, (byte)0x2a, (byte)0x2a, (byte)0x14, (byte)0x14,
            (byte)0x02, (byte)0x00, (byte)0xac, (byte)0x5a, (byte)0xe1, (byte)0x32,
            (byte)0x2b, (byte)0x0d, (byte)0x3e, (byte)0x23, (byte)0x00, (byte)0x00,
            (byte)0x00, (byte)0x00, (byte)0x16, (byte)0x2a, (byte)0x55, (byte)0x4e,
            (byte)0x52, (byte)0x45, (byte)0x47, (byte)0x49, (byte)0x53, (byte)0x54,
            (byte)0x45, (byte)0x52, (byte)0x45, (byte)0x44, (byte)0x20, (byte)0x56,
            (byte)0x45, (byte)0x52, (byte)0x53, (byte)0x49, (byte)0x4f, (byte)0x4e,
            (byte)0x2a
        CRCDemo crcdemo = new CRCDemo();
        short crc16bit = crcdemo.cmpCRC(bytes);
        System.out.println(Integer.toHexString(crc16bit));
}Any hints and code is much appreciated. Thanks.
Rizwan

Answer 1

Hi,
not sure if WinACE uses the same CRC algorithm and CRC seeds as WinZip.
But here's a utility class I've been using a long while, which generates the exact CRC values as Winzip.
regards,
Owen
import java.io.FileNotFoundException;
import java.io.FileInputStream;
import java.io.BufferedInputStream;
import java.io.InputStream;
public class CRC32
    protected static long []CRCTable;
    /* Initial Polynomial values may be choosen at random, in a 32-bit CRC algorithm
     * anything from 0 to 4294967295     ( ( 2 ^ 32 ) - 1 ).
     * However EDB88320 is the exact value used by PKZIP and ARJ, so we generate
     * identical checksums to them.  A nice touch to make testing easier.
    protected final static long CRC32_POLYNOMIAL = 0xEDB88320L;
    protected final static long INITIAL_CRC32    = 0xFFFFFFFFL;
    static
        CRCTable = new long[256];
        int i, j;
        long crc;
        for (i = 0; i <= 255; i++)
            crc = i;
            for (j = 8; j > 0; j--)
              if ( ( crc & 1 ) != 0 )
                  crc = ( crc >> 1 ) ^ CRC32_POLYNOMIAL;
              else
                  crc >>= 1;
            CRCTable[ i ] = crc;
    public static long getInitialCRC ( )
        return ( INITIAL_CRC32 );
    public static long calcFileCRC32 ( String filename ) throws Exception
        FileInputStream inputStream = new FileInputStream ( filename );
        CRC32InputStream checksumInputStream = new CRC32InputStream ( inputStream );
        long crc32 = calcFileCRC32 ( checksumInputStream );  // inputStream );
        // long crc32 = calcFileCRC32 ( inputStream );
        long checksum = checksumInputStream.getChecksum();
        System.out.println ("CRC32InputStream : " + Long.toHexString ( checksum ) );
        if ( inputStream != null )
             inputStream.close();
        return ( crc32 );
    public static long calcFileCRC32 ( InputStream inStream ) throws Exception
        long lCrc = INITIAL_CRC32;
        int iCount = 0;
        byte []buffer = new byte [ 4096 ];
        BufferedInputStream myFastReader = new BufferedInputStream ( inStream );
        while ( ( iCount = myFastReader.read ( buffer ) ) > 0 )
            // lCrc = calculateBufferCRC (buffer, iCount, lCrc);
            lCrc = calculateBufferCRC (buffer, 0, iCount, lCrc);
       lCrc ^= INITIAL_CRC32;
       return ( lCrc );
    public static long calcCRC32 ( String aStr )
        long lCrc = 0;
        if ( aStr != null )
            byte [] strBytes = aStr.getBytes(); // Warning : encoding scheme dependant
            if ( strBytes != null )
                lCrc = calculateBufferCRC ( strBytes, strBytes.length, 0xFFFFFFFFL );
        return ( lCrc );
    public static long updateCRC ( byte b, long lCrc )
        long temp1 = ( lCrc >> 8 ) & 0x00FFFFFFl;
        long temp2 = CRCTable [ ( (int) lCrc ^ b ) & 0xFF ];
        return ( temp1 ^ temp2 );
    public static long calculateBufferCRC ( byte []pcBuffer, int iCount, long lCrc )
        if ( iCount <= 0 )
             return ( lCrc );
        int pcIndex = 0;
        long temp1, temp2;
        while (iCount-- != 0)
            temp1 = ( lCrc >> 8 ) & 0x00FFFFFFl;
            temp2 = CRCTable [ ( (int) lCrc ^ pcBuffer[pcIndex++] ) & 0xFF ];
            lCrc = temp1 ^ temp2;
      return ( lCrc );
    public static long calculateBufferCRC ( byte []pcBuffer, int offset, int iCount, long lCrc )
        if ( iCount <= 0 )
             return ( lCrc );
        int pcIndex = offset;
        long temp1, temp2;
        while (iCount-- != 0)
            temp1 = ( lCrc >> 8 ) & 0x00FFFFFFl;
            temp2 = CRCTable [ ( (int) lCrc ^ pcBuffer[pcIndex++] ) & 0xFF ];
            lCrc = temp1 ^ temp2;
      return ( lCrc );
    public static void main ( String args[] )
        long crc;
        if ( args.length > 0 )
            for ( int i=0; i<args.length; i++ )
                try
                    // crc = calcCRC32 ( args[i] );
                    crc = calcFileCRC32 ( args[i] );
                    System.out.println ( i + " : " + crc + " ( " + Long.toHexString(crc) + " ) : " + args[i] );
                catch ( Exception e )
                    e.printStackTrace();
}