1 2 Previous Next 17 Replies Latest reply: May 1, 2006 12:04 AM by 843853 RSS

    CRC32C checksum in Java

    843853
      I'm having a hard time finding a java implementation of CRC32C checksum.
      There are some C versions from linux that I have found and attempted to convert to Java, but with no success yet. Anyone know of some existing code or be willing to at my code to help me figure out what I'm doing wrong?

      Thanks,
      Eric
        • 1. Re: CRC32C checksum in Java
          843853
          Take a look at the java.util.zip package, especially the CRC32 class.
          • 2. Re: CRC32C checksum in Java
            843853
            It's something like:
            import java.util.zip.CRC32;
            
            class Foo {
                public static void main(String[] args) {
                    CRC32 crc32 = new CRC32();
                    crc32.update(/*some byte array to calculate checksum for*/):
                    long crc32value = crc32.getValue();
                    System.out.println(crc32value);
                }
            }
            Enjoy!
            • 3. Re: CRC32C checksum in Java
              843853
              It's something like:
              import
              java.util.zip.CRC32;
              
              class Foo {
              public static void main(String[] args) {
              CRC32 crc32 = new CRC32();
              crc32.update(/*some byte array to calculate
              checksum for*/):
              long crc32value = crc32.getValue();
              System.out.println(crc32value);
              }
              code]Enjoy!
              Unfortunately, I'm looking for CRC32C not just CRC32. But thanks for the suggestion

              Eric
              • 4. Re: CRC32C checksum in Java
                843853
                Oops, sorry didn't notice the trailing 'c'. The posts I made were regarding the CRC32 checksum. CRC32C is very similar, you could take a look at the implementation of the java.util.zip.CRC32 and use it to write your own CRC32C implementation. Post specific questions here if you run into trouble.
                Good luck!
                • 5. Re: CRC32C checksum in Java
                  843853
                  Oops, sorry didn't notice the trailing 'c'. The posts
                  I made were regarding the CRC32 checksum. CRC32C is
                  very similar, you could take a look at the
                  implementation of the java.util.zip.CRC32 and use it
                  to write your own CRC32C implementation. Post
                  specific questions here if you run into trouble.
                  Good luck!
                  Well, sorry again, that won't work since the implementation is compiled as native code. Well, you could still post what you've got so far and I (or someone else) can try to help you.
                  • 6. Re: CRC32C checksum in Java
                    843853
                    Here is the code that I have. It uses this table method since that is
                    supposed to perform better. This is base on c code at the following
                    link, (which is in the linux kernel):

                    http://www.ussg.iu.edu/hypermail/linux/kernel/0404.3/0864.html

                    Thanks,
                    Eric

                         static final long crc_c[] = {
                         0x00000000L, 0xF26B8303L, 0xE13B70F7L, 0x1350F3F4L,
                         0xC79A971FL, 0x35F1141CL, 0x26A1E7E8L, 0xD4CA64EBL,
                         0x8AD958CFL, 0x78B2DBCCL, 0x6BE22838L, 0x9989AB3BL,
                         0x4D43CFD0L, 0xBF284CD3L, 0xAC78BF27L, 0x5E133C24L,
                         0x105EC76FL, 0xE235446CL, 0xF165B798L, 0x030E349BL,
                         0xD7C45070L, 0x25AFD373L, 0x36FF2087L, 0xC494A384L,
                         0x9A879FA0L, 0x68EC1CA3L, 0x7BBCEF57L, 0x89D76C54L,
                         0x5D1D08BFL, 0xAF768BBCL, 0xBC267848L, 0x4E4DFB4BL,
                         0x20BD8EDEL, 0xD2D60DDDL, 0xC186FE29L, 0x33ED7D2AL,
                         0xE72719C1L, 0x154C9AC2L, 0x061C6936L, 0xF477EA35L,
                         0xAA64D611L, 0x580F5512L, 0x4B5FA6E6L, 0xB93425E5L,
                         0x6DFE410EL, 0x9F95C20DL, 0x8CC531F9L, 0x7EAEB2FAL,
                         0x30E349B1L, 0xC288CAB2L, 0xD1D83946L, 0x23B3BA45L,
                         0xF779DEAEL, 0x05125DADL, 0x1642AE59L, 0xE4292D5AL,
                         0xBA3A117EL, 0x4851927DL, 0x5B016189L, 0xA96AE28AL,
                         0x7DA08661L, 0x8FCB0562L, 0x9C9BF696L, 0x6EF07595L,
                         0x417B1DBCL, 0xB3109EBFL, 0xA0406D4BL, 0x522BEE48L,
                         0x86E18AA3L, 0x748A09A0L, 0x67DAFA54L, 0x95B17957L,
                         0xCBA24573L, 0x39C9C670L, 0x2A993584L, 0xD8F2B687L,
                         0x0C38D26CL, 0xFE53516FL, 0xED03A29BL, 0x1F682198L,
                         0x5125DAD3L, 0xA34E59D0L, 0xB01EAA24L, 0x42752927L,
                         0x96BF4DCCL, 0x64D4CECFL, 0x77843D3BL, 0x85EFBE38L,
                         0xDBFC821CL, 0x2997011FL, 0x3AC7F2EBL, 0xC8AC71E8L,
                         0x1C661503L, 0xEE0D9600L, 0xFD5D65F4L, 0x0F36E6F7L,
                         0x61C69362L, 0x93AD1061L, 0x80FDE395L, 0x72966096L,
                         0xA65C047DL, 0x5437877EL, 0x4767748AL, 0xB50CF789L,
                         0xEB1FCBADL, 0x197448AEL, 0x0A24BB5AL, 0xF84F3859L,
                         0x2C855CB2L, 0xDEEEDFB1L, 0xCDBE2C45L, 0x3FD5AF46L,
                         0x7198540DL, 0x83F3D70EL, 0x90A324FAL, 0x62C8A7F9L,
                         0xB602C312L, 0x44694011L, 0x5739B3E5L, 0xA55230E6L,
                         0xFB410CC2L, 0x092A8FC1L, 0x1A7A7C35L, 0xE811FF36L,
                         0x3CDB9BDDL, 0xCEB018DEL, 0xDDE0EB2AL, 0x2F8B6829L,
                         0x82F63B78L, 0x709DB87BL, 0x63CD4B8FL, 0x91A6C88CL,
                         0x456CAC67L, 0xB7072F64L, 0xA457DC90L, 0x563C5F93L,
                         0x082F63B7L, 0xFA44E0B4L, 0xE9141340L, 0x1B7F9043L,
                         0xCFB5F4A8L, 0x3DDE77ABL, 0x2E8E845FL, 0xDCE5075CL,
                         0x92A8FC17L, 0x60C37F14L, 0x73938CE0L, 0x81F80FE3L,
                         0x55326B08L, 0xA759E80BL, 0xB4091BFFL, 0x466298FCL,
                         0x1871A4D8L, 0xEA1A27DBL, 0xF94AD42FL, 0x0B21572CL,
                         0xDFEB33C7L, 0x2D80B0C4L, 0x3ED04330L, 0xCCBBC033L,
                         0xA24BB5A6L, 0x502036A5L, 0x4370C551L, 0xB11B4652L,
                         0x65D122B9L, 0x97BAA1BAL, 0x84EA524EL, 0x7681D14DL,
                         0x2892ED69L, 0xDAF96E6AL, 0xC9A99D9EL, 0x3BC21E9DL,
                         0xEF087A76L, 0x1D63F975L, 0x0E330A81L, 0xFC588982L,
                         0xB21572C9L, 0x407EF1CAL, 0x532E023EL, 0xA145813DL,
                         0x758FE5D6L, 0x87E466D5L, 0x94B49521L, 0x66DF1622L,
                         0x38CC2A06L, 0xCAA7A905L, 0xD9F75AF1L, 0x2B9CD9F2L,
                         0xFF56BD19L, 0x0D3D3E1AL, 0x1E6DCDEEL, 0xEC064EEDL,
                         0xC38D26C4L, 0x31E6A5C7L, 0x22B65633L, 0xD0DDD530L,
                         0x0417B1DBL, 0xF67C32D8L, 0xE52CC12CL, 0x1747422FL,
                         0x49547E0BL, 0xBB3FFD08L, 0xA86F0EFCL, 0x5A048DFFL,
                         0x8ECEE914L, 0x7CA56A17L, 0x6FF599E3L, 0x9D9E1AE0L,
                         0xD3D3E1ABL, 0x21B862A8L, 0x32E8915CL, 0xC083125FL,
                         0x144976B4L, 0xE622F5B7L, 0xF5720643L, 0x07198540L,
                         0x590AB964L, 0xAB613A67L, 0xB831C993L, 0x4A5A4A90L,
                         0x9E902E7BL, 0x6CFBAD78L, 0x7FAB5E8CL, 0x8DC0DD8FL,
                         0xE330A81AL, 0x115B2B19L, 0x020BD8EDL, 0xF0605BEEL,
                         0x24AA3F05L, 0xD6C1BC06L, 0xC5914FF2L, 0x37FACCF1L,
                         0x69E9F0D5L, 0x9B8273D6L, 0x88D28022L, 0x7AB90321L,
                         0xAE7367CAL, 0x5C18E4C9L, 0x4F48173DL, 0xBD23943EL,
                         0xF36E6F75L, 0x0105EC76L, 0x12551F82L, 0xE03E9C81L,
                         0x34F4F86AL, 0xC69F7B69L, 0xD5CF889DL, 0x27A40B9EL,
                         0x79B737BAL, 0x8BDCB4B9L, 0x988C474DL, 0x6AE7C44EL,
                         0xBE2DA0A5L, 0x4C4623A6L, 0x5F16D052L, 0xAD7D5351L
                    };
                         static long CRC32C(long c, byte d) {
                    //          int crc (c=(c>>8)^crc_c[(c^(d))&0xFF])
                              long tableIndex = (c^((int)d & 0xff)) & 0xff;
                              
                              long cShift8 = (c>>>8) & 0x00ffffff;
                              long tableValue = crc_c[(int)tableIndex];
                              long crc = (cShift8^tableValue);
                              return crc;
                         }
                         public static long calculateCRC32C(byte[] data) {
                              // seed the crc value
                              long crc = -1; //0x00000000ffffffffL;
                              for (byte b : data) {
                                   crc = CRC32C(crc, b);
                              }
                              
                              return crc;
                         }
                    • 7. Re: CRC32C checksum in Java
                      843853
                      That seems ok to me. What is the problem you're having?
                      • 8. Re: CRC32C checksum in Java
                        843853
                        Well, I've got some test data and it seems that I'm getting the wrong results.
                        But then again, maybe the test data is bad? If you know of a good source for
                        test data for CRC32C, that would be great. Here is the test data and the results that I am supposed to get:

                             byte[] rawData = {0x01, (byte)0xC0, 0x00, 0x00,
                                                 0x00, 0x00, 0x00, 0x00,
                                                 0x00, 0x00, 0x00, 0x00,
                                                 0x00, 0x00, 0x00, 0x00,
                                                 0x01, (byte)0xFE, 60, (byte)0xAC,
                                                 0x00, 0x00, 0x00, 0x08,
                                                 0x00, 0x00, 0x00, 0x04,
                                                 0x00, 0x00, 0x00, 0x09,
                                                 0x25, 0x00, 0x00, 0x00,
                                                 0x00, 0x00, 0x00, 0x00,
                                                 0x00, 0x00, 0x00, 0x00,
                                                 0x00, 0x00, 0x00, 0x00
                                                 
                                                 };
                             
                             // this should result in 148AB099

                        I got this test data from a com trace of some hardware that is
                        supposed to automatically generate the CRC32C, but maybe it's
                        wrong? Doesn't seem likely, but you never know

                        Thanks,
                        Eric
                        • 9. Re: CRC32C checksum in Java
                          843853
                          Have you tried running the C version of the crc32c algorithm on the same data and compared to your Java version result?
                          • 10. Re: CRC32C checksum in Java
                            843853
                            > long crc = -1; //0x00000000ffffffffL;
                            You might want to check, but I'm almost certain that the widening conversion will sign-extend 0xffffffff to 0xffffffffffffffff.
                            • 11. Re: CRC32C checksum in Java
                              843853
                              > long crc = -1; //0x00000000ffffffffL;
                              You might want to check,
                              but I'm almost certain that the widening conversion
                              will sign-extend 0xffffffff to 0xffffffffffffffff.
                              It will. To OP, when you want a specific long hex value, write it like so: 0xffffffffL

                              ~Cheers
                              • 12. Re: CRC32C checksum in Java
                                843853
                                Thanks for the suggestion, but it unfortunately did not make a difference.
                                I tried long crc = 0xffffffffL, crc=-1, and crc=0x00000000ffffffffL. All gave the
                                same results.

                                I think I'll try running my test data against the c version of the code and see what the results are. In the meantime any suggestions are welcome.

                                Thanks,
                                Eric
                                • 13. Re: CRC32C checksum in Java
                                  843853
                                  I suspect your test is invalid. Using the 'C' program (heart obtainable from various sources on the web)
                                  /* SCTP kernel reference Implementation
                                   * Copyright (c) 1999-2001 Motorola, Inc.
                                   * Copyright (c) 2001-2003 International Business Machines, Corp.
                                   * 
                                   * This file is part of the SCTP kernel reference Implementation
                                   * 
                                   * SCTP Checksum functions
                                   * 
                                   * The SCTP reference implementation 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; either version 2, or (at your option)
                                   * any later version.
                                   * 
                                   * The SCTP reference implementation 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.
                                   * 
                                   * You should have received a copy of the GNU General Public License
                                   * along with GNU CC; see the file COPYING.  If not, write to
                                   * the Free Software Foundation, 59 Temple Place - Suite 330,
                                   * Boston, MA 02111-1307, USA.  
                                   * 
                                   * Please send any bug reports or fixes you make to the
                                   * email address(es):
                                   *    lksctp developers <lksctp-developers@lists.sourceforge.net>
                                   * 
                                   * Or submit a bug report through the following website:
                                   *    http://www.sf.net/projects/lksctp
                                   *
                                   * Written or modified by: 
                                   *    Dinakaran Joseph 
                                   *    Jon Grimm <jgrimm@us.ibm.com>
                                   *    Sridhar Samudrala <sri@us.ibm.com>
                                   * 
                                   * Any bugs reported given to us we will try to fix... any fixes shared will
                                   * be incorporated into the next SCTP release.
                                   */
                                  
                                  /* The following code has been taken directly from
                                   * draft-ietf-tsvwg-sctpcsum-03.txt
                                   *
                                   * The code has now been modified specifically for SCTP knowledge.
                                   */
                                  
                                  #include <linux/types.h>
                                  #import <stdio.h>
                                  
                                  #define CRC32C_POLY 0x1EDC6F41
                                  #define CRC32C(c,d) (c=(c>>8)^crc_c[(c^(d))&0xFF])
                                  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
                                  /* Copyright 2001, D. Otis.  Use this program, code or tables    */
                                  /* extracted from it, as desired without restriction.            */
                                  /*                                                               */
                                  /* 32 Bit Reflected CRC table generation for SCTP.               */
                                  /* To accommodate serial byte data being shifted out least       */
                                  /* significant bit first, the table's 32 bit words are reflected */
                                  /* which flips both byte and bit MS and LS positions.  The CRC   */
                                  /* is calculated MS bits first from the perspective of the serial*/
                                  /* stream.  The x^32 term is implied and the x^0 term may also   */
                                  /* be shown as +1.  The polynomial code used is 0x1EDC6F41.      */
                                  /* Castagnoli93                                                  */
                                  /* x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+  */
                                  /* x^11+x^10+x^9+x^8+x^6+x^0                                     */
                                  /* Guy Castagnoli Stefan Braeuer and Martin Herrman              */
                                  /* "Optimization of Cyclic Redundancy-Check Codes                */
                                  /* with 24 and 32 Parity Bits",                                  */
                                  /* IEEE Transactions on Communications, Vol.41, No.6, June 1993  */
                                  /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
                                  __u32 crc_c[256] = {
                                       0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
                                       0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
                                       0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
                                       0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
                                       0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
                                       0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
                                       0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
                                       0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
                                       0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
                                       0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
                                       0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
                                       0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
                                       0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
                                       0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
                                       0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
                                       0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
                                       0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
                                       0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
                                       0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
                                       0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
                                       0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
                                       0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
                                       0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
                                       0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
                                       0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
                                       0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
                                       0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
                                       0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
                                       0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
                                       0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
                                       0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
                                       0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
                                       0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
                                       0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
                                       0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
                                       0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
                                       0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
                                       0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
                                       0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
                                       0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
                                       0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
                                       0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
                                       0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
                                       0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
                                       0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
                                       0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
                                       0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
                                       0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
                                       0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
                                       0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
                                       0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
                                       0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
                                       0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
                                       0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
                                       0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
                                       0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
                                       0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
                                       0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
                                       0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
                                       0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
                                       0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
                                       0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
                                       0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
                                       0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
                                  };
                                       
                                  __u32 sctp_update_cksum(__u8 *buffer, __u16 length, __u32 crc32)
                                  {
                                       __u32 i;
                                  
                                       for (i = 0; i < length ; i++)
                                            CRC32C(crc32, buffer);

                                       return crc32;
                                  }

                                  __u8 test_data[48] = {
                                  0x01, 0xC0, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x01, 0xFE, 0x60, 0xAC,
                                  0x00, 0x00, 0x00, 0x08,
                                  0x00, 0x00, 0x00, 0x04,
                                  0x00, 0x00, 0x00, 0x09,
                                  0x25, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  };

                                  int main( int argc, char * argv[] )
                                  {
                                  __u32 crc32c = ~0;

                                  printf("Hello World\n");

                                  crc32c = sctp_update_cksum(test_data, 48, crc32c);
                                  printf("Hello World\n");
                                  printf("0x%x\n", crc32c);
                                  }


                                  which is cut down from a Linux implementaiton I get as result
                                  0x664f75eb
                                  and using the Java program
                                  public class CRC32CDelegate
                                  {   
                                      public int getCRC32()
                                      {
                                          return crc32;
                                      }
                                      
                                      private int crc32 = ~0;
                                          
                                      private void CRC32C(byte d)
                                      {
                                          crc32 = (crc32>>>8)^crc_c[(crc32^d)&0xFF];
                                      }
                                      
                                      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
                                      /* Copyright 2001, D. Otis.  Use this program, code or tables    */
                                      /* extracted from it, as desired without restriction.            */
                                      /*                                                               */
                                      /* 32 Bit Reflected CRC table generation for SCTP.               */
                                      /* To accommodate serial byte data being shifted out least       */
                                      /* significant bit first, the table's 32 bit words are reflected */
                                      /* which flips both byte and bit MS and LS positions.  The CRC   */
                                      /* is calculated MS bits first from the perspective of the serial*/
                                      /* stream.  The x^32 term is implied and the x^0 term may also   */
                                      /* be shown as +1.  The polynomial code used is 0x1EDC6F41.      */
                                      /* Castagnoli93                                                  */
                                      /* x^32+x^28+x^27+x^26+x^25+x^23+x^22+x^20+x^19+x^18+x^14+x^13+  */
                                      /* x^11+x^10+x^9+x^8+x^6+x^0                                     */
                                      /* Guy Castagnoli Stefan Braeuer and Martin Herrman              */
                                      /* "Optimization of Cyclic Redundancy-Check Codes                */
                                      /* with 24 and 32 Parity Bits",                                  */
                                      /* IEEE Transactions on Communications, Vol.41, No.6, June 1993  */
                                      /* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
                                      private static final int crc_c[] = {
                                          0x00000000, 0xF26B8303, 0xE13B70F7, 0x1350F3F4,
                                          0xC79A971F, 0x35F1141C, 0x26A1E7E8, 0xD4CA64EB,
                                          0x8AD958CF, 0x78B2DBCC, 0x6BE22838, 0x9989AB3B,
                                          0x4D43CFD0, 0xBF284CD3, 0xAC78BF27, 0x5E133C24,
                                          0x105EC76F, 0xE235446C, 0xF165B798, 0x030E349B,
                                          0xD7C45070, 0x25AFD373, 0x36FF2087, 0xC494A384,
                                          0x9A879FA0, 0x68EC1CA3, 0x7BBCEF57, 0x89D76C54,
                                          0x5D1D08BF, 0xAF768BBC, 0xBC267848, 0x4E4DFB4B,
                                          0x20BD8EDE, 0xD2D60DDD, 0xC186FE29, 0x33ED7D2A,
                                          0xE72719C1, 0x154C9AC2, 0x061C6936, 0xF477EA35,
                                          0xAA64D611, 0x580F5512, 0x4B5FA6E6, 0xB93425E5,
                                          0x6DFE410E, 0x9F95C20D, 0x8CC531F9, 0x7EAEB2FA,
                                          0x30E349B1, 0xC288CAB2, 0xD1D83946, 0x23B3BA45,
                                          0xF779DEAE, 0x05125DAD, 0x1642AE59, 0xE4292D5A,
                                          0xBA3A117E, 0x4851927D, 0x5B016189, 0xA96AE28A,
                                          0x7DA08661, 0x8FCB0562, 0x9C9BF696, 0x6EF07595,
                                          0x417B1DBC, 0xB3109EBF, 0xA0406D4B, 0x522BEE48,
                                          0x86E18AA3, 0x748A09A0, 0x67DAFA54, 0x95B17957,
                                          0xCBA24573, 0x39C9C670, 0x2A993584, 0xD8F2B687,
                                          0x0C38D26C, 0xFE53516F, 0xED03A29B, 0x1F682198,
                                          0x5125DAD3, 0xA34E59D0, 0xB01EAA24, 0x42752927,
                                          0x96BF4DCC, 0x64D4CECF, 0x77843D3B, 0x85EFBE38,
                                          0xDBFC821C, 0x2997011F, 0x3AC7F2EB, 0xC8AC71E8,
                                          0x1C661503, 0xEE0D9600, 0xFD5D65F4, 0x0F36E6F7,
                                          0x61C69362, 0x93AD1061, 0x80FDE395, 0x72966096,
                                          0xA65C047D, 0x5437877E, 0x4767748A, 0xB50CF789,
                                          0xEB1FCBAD, 0x197448AE, 0x0A24BB5A, 0xF84F3859,
                                          0x2C855CB2, 0xDEEEDFB1, 0xCDBE2C45, 0x3FD5AF46,
                                          0x7198540D, 0x83F3D70E, 0x90A324FA, 0x62C8A7F9,
                                          0xB602C312, 0x44694011, 0x5739B3E5, 0xA55230E6,
                                          0xFB410CC2, 0x092A8FC1, 0x1A7A7C35, 0xE811FF36,
                                          0x3CDB9BDD, 0xCEB018DE, 0xDDE0EB2A, 0x2F8B6829,
                                          0x82F63B78, 0x709DB87B, 0x63CD4B8F, 0x91A6C88C,
                                          0x456CAC67, 0xB7072F64, 0xA457DC90, 0x563C5F93,
                                          0x082F63B7, 0xFA44E0B4, 0xE9141340, 0x1B7F9043,
                                          0xCFB5F4A8, 0x3DDE77AB, 0x2E8E845F, 0xDCE5075C,
                                          0x92A8FC17, 0x60C37F14, 0x73938CE0, 0x81F80FE3,
                                          0x55326B08, 0xA759E80B, 0xB4091BFF, 0x466298FC,
                                          0x1871A4D8, 0xEA1A27DB, 0xF94AD42F, 0x0B21572C,
                                          0xDFEB33C7, 0x2D80B0C4, 0x3ED04330, 0xCCBBC033,
                                          0xA24BB5A6, 0x502036A5, 0x4370C551, 0xB11B4652,
                                          0x65D122B9, 0x97BAA1BA, 0x84EA524E, 0x7681D14D,
                                          0x2892ED69, 0xDAF96E6A, 0xC9A99D9E, 0x3BC21E9D,
                                          0xEF087A76, 0x1D63F975, 0x0E330A81, 0xFC588982,
                                          0xB21572C9, 0x407EF1CA, 0x532E023E, 0xA145813D,
                                          0x758FE5D6, 0x87E466D5, 0x94B49521, 0x66DF1622,
                                          0x38CC2A06, 0xCAA7A905, 0xD9F75AF1, 0x2B9CD9F2,
                                          0xFF56BD19, 0x0D3D3E1A, 0x1E6DCDEE, 0xEC064EED,
                                          0xC38D26C4, 0x31E6A5C7, 0x22B65633, 0xD0DDD530,
                                          0x0417B1DB, 0xF67C32D8, 0xE52CC12C, 0x1747422F,
                                          0x49547E0B, 0xBB3FFD08, 0xA86F0EFC, 0x5A048DFF,
                                          0x8ECEE914, 0x7CA56A17, 0x6FF599E3, 0x9D9E1AE0,
                                          0xD3D3E1AB, 0x21B862A8, 0x32E8915C, 0xC083125F,
                                          0x144976B4, 0xE622F5B7, 0xF5720643, 0x07198540,
                                          0x590AB964, 0xAB613A67, 0xB831C993, 0x4A5A4A90,
                                          0x9E902E7B, 0x6CFBAD78, 0x7FAB5E8C, 0x8DC0DD8F,
                                          0xE330A81A, 0x115B2B19, 0x020BD8ED, 0xF0605BEE,
                                          0x24AA3F05, 0xD6C1BC06, 0xC5914FF2, 0x37FACCF1,
                                          0x69E9F0D5, 0x9B8273D6, 0x88D28022, 0x7AB90321,
                                          0xAE7367CA, 0x5C18E4C9, 0x4F48173D, 0xBD23943E,
                                          0xF36E6F75, 0x0105EC76, 0x12551F82, 0xE03E9C81,
                                          0x34F4F86A, 0xC69F7B69, 0xD5CF889D, 0x27A40B9E,
                                          0x79B737BA, 0x8BDCB4B9, 0x988C474D, 0x6AE7C44E,
                                          0xBE2DA0A5, 0x4C4623A6, 0x5F16D052, 0xAD7D5351,
                                      };
                                      
                                      void update(byte[] buffer, int length)
                                      {
                                          for (int i = 0; i < length ; i++)
                                              CRC32C(buffer);
                                  }

                                  public static void main(String[] args)
                                  {
                                  byte[] rawData = {
                                  0x01, (byte)0xC0, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x01, (byte)0xFE, 0x60, (byte)0xAC,
                                  0x00, 0x00, 0x00, 0x08,
                                  0x00, 0x00, 0x00, 0x04,
                                  0x00, 0x00, 0x00, 0x09,
                                  0x25, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00,
                                  0x00, 0x00, 0x00, 0x00
                                  };

                                  CRC32CDelegate delegate = new CRC32CDelegate();
                                  delegate.update(rawData, rawData.length);
                                  System.out.println(Integer.toHexString(delegate.getCRC32()));
                                  }
                                  }


                                  I get the same result.
                                  • 14. Re: CRC32C checksum in Java
                                    843853
                                    Thanks for trying this out in C also. I also get the same results as you do
                                    for the Java program. One thing that seems strange to me, however, is a second test that I ran. I believe by definition, if you have some test data, such as
                                         byte[] rawData = {
                                         0x01, (byte)0xC0, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x01, (byte)0xFE, 0x60, (byte)0xAC,
                                         0x00, 0x00, 0x00, 0x08,
                                         0x00, 0x00, 0x00, 0x04,
                                         0x00, 0x00, 0x00, 0x09,
                                         0x25, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00

                                    and get the results, in this case 0x664f75eb, that you should be able
                                    to append that result to the original data, run the test again and get a result of 0.

                                    When I run with the updated test data:

                                         byte[] rawData = {
                                         0x01, (byte)0xC0, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x01, (byte)0xFE, 0x60, (byte)0xAC,
                                         0x00, 0x00, 0x00, 0x08,
                                         0x00, 0x00, 0x00, 0x04,
                                         0x00, 0x00, 0x00, 0x09,
                                         0x25, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x00, 0x00, 0x00, 0x00,
                                         0x66, 0x4f, 0x75, (byte)0xeb
                                    };

                                    I don't get 0 as a result. Instead I get 0x239a4dba. Am I misunderstanding
                                    something about how CRC32C works, or is there a problem with the code?

                                    Thanks,
                                    Eric
                                    1 2 Previous Next