crc 0.2 → 0.3

data/lib/crc/_byruby.rb

@@ -9,7 +9,7 @@
 # \* \* \* \* \* \* \* \*
 #
 # Ruby implemented CRC generator.
-# It's used slice-by-16 algorithm with byte-order free and byte-alignment free.
+# It's used slice-by-16 algorithm with byte-order free.
 # This is based on the Intel's slice-by-eight algorithm.
 #
 # It's faster than about 50% (CRC-32) and about 30% (CRC-64) of
@@ -26,69 +26,46 @@
 #
 # If defined "RUBY_CRC_NOFAST=3" enviroment variable, switch to reference algorithm.
 #
-module CRC
-  module Utils
-    def bitreflect8(n)
-      n    = n.to_i
-      n    = ((n & 0x55) <<  1) | ((n >>  1) & 0x55)
-      n    = ((n & 0x33) <<  2) | ((n >>  2) & 0x33)
-      return ((n & 0x0f) <<  4) |  (n >>  4) # 0x0f
-    end
-
-    def bitreflect16(n)
-      n    = n.to_i
-      n    = ((n & 0x5555) <<  1) | ((n >>  1) & 0x5555)
-      n    = ((n & 0x3333) <<  2) | ((n >>  2) & 0x3333)
-      n    = ((n & 0x0f0f) <<  4) | ((n >>  4) & 0x0f0f)
-      return ((n & 0x00ff) <<  8) |  (n >>  8) # 0x00ff
-    end
-
-    def bitreflect32(n)
-      n    = n.to_i
-      n    = ((n & 0x55555555) <<  1) | ((n >>  1) & 0x55555555)
-      n    = ((n & 0x33333333) <<  2) | ((n >>  2) & 0x33333333)
-      n    = ((n & 0x0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f)
-      n    = ((n & 0x00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff)
-      return ((n & 0x0000ffff) << 16) |  (n >> 16) # 0x0000ffff
-    end
-
-    def bitreflect64(n)
-      n    = n.to_i
-      n    = ((n & 0x5555555555555555) <<  1) | ((n >>  1) & 0x5555555555555555)
-      n    = ((n & 0x3333333333333333) <<  2) | ((n >>  2) & 0x3333333333333333)
-      n    = ((n & 0x0f0f0f0f0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f0f0f0f0f)
-      n    = ((n & 0x00ff00ff00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff00ff00ff)
-      n    = ((n & 0x0000ffff0000ffff) << 16) | ((n >> 16) & 0x0000ffff0000ffff)
-      return ((n & 0x00000000ffffffff) << 32) |  (n >> 32) # 0x00000000ffffffff
-    end
-
-    def bitreflect128(n)
-      n    = n.to_i
-      n    = ((n & 0x55555555555555555555555555555555) <<  1) | ((n >>  1) & 0x55555555555555555555555555555555)
-      n    = ((n & 0x33333333333333333333333333333333) <<  2) | ((n >>  2) & 0x33333333333333333333333333333333)
-      n    = ((n & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
-      n    = ((n & 0x00ff00ff00ff00ff00ff00ff00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
-      n    = ((n & 0x0000ffff0000ffff0000ffff0000ffff) << 16) | ((n >> 16) & 0x0000ffff0000ffff0000ffff0000ffff)
-      n    = ((n & 0x00000000ffffffff00000000ffffffff) << 32) | ((n >> 32) & 0x00000000ffffffff00000000ffffffff)
-      return ((n & 0x0000000000000000ffffffffffffffff) << 64) |  (n >> 64) # 0x0000000000000000ffffffffffffffff
-    end
-  end
-
-  class Generator < Struct.new(:bitsize, :bitmask, :polynomial, :initial_state, :table, :reflect_input, :reflect_output, :xor_output, :name)
-    BasicStruct = superclass
-
-    def initialize(bitsize, polynomial, initial_state = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil)
+class CRC
+  class << self
+    #
+    # call-seq:
+    #   new(bitsize, polynomial, initial_crc = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil) -> new crc module class (CRC based class)
+    #   new(initial_crc = nil, size = 0) -> new crc generator (CRC instance)
+    #   new(seq, initial_crc = nil, size = 0) -> new crc generator (CRC instance)
+    #
+    def new(bitsize, polynomial, initial_crc = 0, reflect_input = true, reflect_output = true, xor_output = ~0, name = nil)
       bitsize = bitsize.to_i
       if bitsize < 1 || bitsize > 64
         raise ArgumentError, "wrong bitsize (except 1..64, but given #{bitsize})"
       end
+
       bitmask = ~(~0 << bitsize)
       polynomial = bitmask & polynomial
-      initial_state = bitmask & initial_state
+      initial_crc = bitmask & initial_crc
       xor_output = bitmask & xor_output
       name = (name.nil? || ((name = String(name)).empty?)) ? nil : name
-      super(bitsize, bitmask, polynomial, initial_state, nil,
-            !!reflect_input, !!reflect_output, xor_output, name)
+
+      ::Class.new(self) do
+        @bitsize = bitsize
+        @bitmask = bitmask
+        @polynomial = polynomial
+        @initial_crc = initial_crc
+        @table = nil
+        @reflect_input = !!reflect_input
+        @reflect_output = !!reflect_output
+        @xor_output = xor_output
+        @name = name
+
+        # CRC クラスを普通に派生させた場合でも、CRC.new の基底メソッドが呼ばれるための細工
+        define_singleton_method(:new, &Class.instance_method(:new).bind(self))
+
+        singleton_class.class_eval do
+          alias_method :[], :new
+        end
+
+        extend CRC::ModuleClass
+      end
     end
 
     def update_with_reference(seq, state)
@@ -204,14 +181,14 @@ module CRC
 
     def table
       if reflect_input
-        set_table t = CRC.build_reflect_table(bitsize, polynomial, slice: 16)
+        @table = CRC.build_reflect_table(bitsize, polynomial, slice: 16)
       else
-        set_table t = CRC.build_table(bitsize, polynomial, slice: 16)
+        @table = CRC.build_table(bitsize, polynomial, slice: 16)
       end
 
-      define_singleton_method :table, self.class.superclass.instance_method(:table)
+      singleton_class.class_eval "attr_reader :table"
 
-      t
+      @table
     end
 
     case ENV["RUBY_CRC_NOFAST"].to_i
@@ -222,13 +199,60 @@ module CRC
     else
       alias update update_with_reference
     end
+  end
+
+  module ModuleClass
+    attr_reader :bitsize, :bitmask, :polynomial, :initial_crc,
+                :reflect_input, :reflect_output, :xor_output, :name
+
+    alias reflect_input? reflect_input
+    alias reflect_output? reflect_output
+  end
+
+  module Utils
+    def bitreflect8(n)
+      n    = n.to_i
+      n    = ((n & 0x55) <<  1) | ((n >>  1) & 0x55)
+      n    = ((n & 0x33) <<  2) | ((n >>  2) & 0x33)
+      return ((n & 0x0f) <<  4) |  (n >>  4) # 0x0f
+    end
 
-    class BasicStruct
-      alias set_table table=
-      private :set_table
+    def bitreflect16(n)
+      n    = n.to_i
+      n    = ((n & 0x5555) <<  1) | ((n >>  1) & 0x5555)
+      n    = ((n & 0x3333) <<  2) | ((n >>  2) & 0x3333)
+      n    = ((n & 0x0f0f) <<  4) | ((n >>  4) & 0x0f0f)
+      return ((n & 0x00ff) <<  8) |  (n >>  8) # 0x00ff
+    end
 
-      undef :bitsize=, :bitmask=, :polynomial=, :initial_state=, :table=,
-            :reflect_input=, :reflect_output=, :xor_output=, :name=, :[]=
+    def bitreflect32(n)
+      n    = n.to_i
+      n    = ((n & 0x55555555) <<  1) | ((n >>  1) & 0x55555555)
+      n    = ((n & 0x33333333) <<  2) | ((n >>  2) & 0x33333333)
+      n    = ((n & 0x0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f)
+      n    = ((n & 0x00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff)
+      return ((n & 0x0000ffff) << 16) |  (n >> 16) # 0x0000ffff
+    end
+
+    def bitreflect64(n)
+      n    = n.to_i
+      n    = ((n & 0x5555555555555555) <<  1) | ((n >>  1) & 0x5555555555555555)
+      n    = ((n & 0x3333333333333333) <<  2) | ((n >>  2) & 0x3333333333333333)
+      n    = ((n & 0x0f0f0f0f0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f0f0f0f0f)
+      n    = ((n & 0x00ff00ff00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff00ff00ff)
+      n    = ((n & 0x0000ffff0000ffff) << 16) | ((n >> 16) & 0x0000ffff0000ffff)
+      return ((n & 0x00000000ffffffff) << 32) |  (n >> 32) # 0x00000000ffffffff
+    end
+
+    def bitreflect128(n)
+      n    = n.to_i
+      n    = ((n & 0x55555555555555555555555555555555) <<  1) | ((n >>  1) & 0x55555555555555555555555555555555)
+      n    = ((n & 0x33333333333333333333333333333333) <<  2) | ((n >>  2) & 0x33333333333333333333333333333333)
+      n    = ((n & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f) <<  4) | ((n >>  4) & 0x0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f0f)
+      n    = ((n & 0x00ff00ff00ff00ff00ff00ff00ff00ff) <<  8) | ((n >>  8) & 0x00ff00ff00ff00ff00ff00ff00ff00ff)
+      n    = ((n & 0x0000ffff0000ffff0000ffff0000ffff) << 16) | ((n >> 16) & 0x0000ffff0000ffff0000ffff0000ffff)
+      n    = ((n & 0x00000000ffffffff00000000ffffffff) << 32) | ((n >> 32) & 0x00000000ffffffff00000000ffffffff)
+      return ((n & 0x0000000000000000ffffffffffffffff) << 64) |  (n >> 64) # 0x0000000000000000ffffffffffffffff
     end
   end
 end

data/lib/crc/_combine.rb

@@ -33,7 +33,7 @@
 # License:: zlib-style
 #--
 
-module CRC
+class CRC
   module Aux
     def self.gf2_matrix_times(matrix, vector)
       sum = 0
@@ -53,13 +53,13 @@ module CRC
 
       nil
     end
-  end
 
-  class Generator
-    def combine(crc1, crc2, len2)
+    def self.combine(crc1, crc2, len2,
+                     bitsize, polynomial, initial_crc,
+                     reflect_input, reflect_output, xor_output)
       return crc1 unless len2 > 1
 
-      crc1 ^= initial_state
+      crc1 ^= initial_crc
 
       odd = []
       even = []

data/lib/crc/_modules.rb

@@ -12,12 +12,13 @@
 #   * https://github.com/cluelogic/cluelib/blob/master/src/cl_crc.svh
 #   * https://users.ece.cmu.edu/~koopman/crc/hw_data.html
 #   * https://users.ece.cmu.edu/~koopman/roses/dsn04/koopman04_crc_poly_embedded.pdf
+#   * (CRC-64-ISO-3309) http://swissknife.cvs.sourceforge.net/viewvc/swissknife/SWISS/lib/SWISS/CRC64.pm
 #++
 
-module CRC
+class CRC
   LIST = [
     #
-    # bit size,  polynomial,            initial state,
+    # bit size,  polynomial,              initial crc,
     #                refrect input,                xor output,
     #                      reflect output,                       crc("123456789"), names...
     #
@@ -33,10 +34,10 @@ module CRC
     [ 6,               0x19,  true,  true,          0,      0,               0x26, "CRC-6-DARC"],
     [ 6,               0x03,  true,  true,          0,      0,               0x06, "CRC-6-ITU"],
     [ 7,               0x09, false, false,          0,      0,               0x75, "CRC-7", "CRC-7-JESD84-A441"],
-    [ 7,               0x65, false, false,          0,      0,                nil, "CRC-7-MVB"],
+    #[ 7,               0x65, false, false,          0,      0,                nil, "CRC-7-MVB"],
     [ 7,               0x4F,  true,  true,         ~0,      0,               0x53, "CRC-7-ROHC", "CRC-7-RFC 3095"],
     [ 7,               0x45, false, false,          0,      0,               0x61, "CRC-7-UMTS"],
-    [ 8,               0xD5, false, false,          0,      0,                nil, "CRC-8"],
+    #[ 8,               0xD5, false, false,          0,      0,                nil, "CRC-8"],
     [ 8,               0x07, false, false,          0,      0,               0xF4, "CRC-8-CCITT", "CRC-8-SMBus"],
     [ 8,               0x31,  true,  true,          0,      0,               0xA1, "CRC-8-MAXIM", "CRC-8-Dallas/Maxim", "DOW-CRC"],
     [ 8,               0x39,  true,  true,          0,      0,               0x15, "CRC-8-DARC"],
@@ -60,9 +61,9 @@ module CRC
     [14,             0x0805,  true,  true,          0,      0,             0x082D, "CRC-14-DARC"],
     [15,             0x4599, false, false,          0,      0,             0x059E, "CRC-15", "CRC-15-CAN"],
     [15,             0x6815, false, false,          1,      1,             0x2566, "CRC-15-MPT1327"],
-    [16,             0x2F15, false, false,          0,      0,                nil, "Chakravarty"],
-    [16,             0x8005,  true,  true,          0,      0,             0xBB3D, "ARC", "CRC-16", "CRC-IBM", "CRC-16-ARC", "CRC-16-LHA"],
-    [16,             0xA02B, false, false,          0,      0,                nil, "CRC-16-ARINC"],
+    #[16,             0x2F15, false, false,          0,      0,                nil, "Chakravarty"],
+    [16,             0x8005,  true,  true,          0,      0,             0xBB3D, "CRC-16", "ARC", "CRC-IBM", "CRC-16-ARC", "CRC-16-LHA"],
+    #[16,             0xA02B, false, false,          0,      0,                nil, "CRC-16-ARINC"],
     [16,             0x1021, false, false,     0x1D0F,      0,             0xE5CC, "CRC-16-AUG-CCITT", "CRC-16-SPI-FUJITSU"],
     [16,             0xC867, false, false,         ~0,      0,             0x4C06, "CRC-16-CDMA2000"],
     [16,             0x0589, false, false,          1,      1,             0x007E, "CRC-16-DECT-R", "R-CRC-16"],
@@ -81,14 +82,14 @@ module CRC
     [16,             0xA097, false, false,          0,      0,             0x0FB3, "CRC-16-TELEDISK"],
     [16,             0x1021,  true,  true,     0x89EC,      0,             0x26B1, "CRC-16-TMS37157"],
     [16,             0x8005,  true,  true,          0,     ~0,             0xB4C8, "CRC-16-USB"],
-    [16,             0x1021,  true,  true,     0xC6C6,      0,             0xBF05, "CRC-A", "CRC-16-ISO/IEC FCD 14443-3"],
-    [16,             0x1021,  true,  true,          0,      0,             0x2189, "KERMIT", "CRC-16-CCITT", "CRC-16-CCITT-TRUE", "CRC-CCITT"],
-    [16,             0x8005,  true,  true,         ~0,      0,             0x4B37, "MODBUS"],
-    [16,             0x1021,  true,  true,          0,     ~0,             0x906E, "X-25", "CRC-16-IBM-SDLC", "CRC-16-ISO-HDLC", "CRC-B"],
-    [16,             0x1021, false, false,          0,      0,             0x31C3, "XMODEM", "ZMODEM", "CRC-16-ACORN", "CRC-16-LTE"],
-    [17,         0x0001685B, false, false,          0,      0,                nil, "CRC-17-CAN"],
-    [21,         0x00102899, false, false,          0,      0,                nil, "CRC-21-CAN"],
-    [24,         0x005D6DCB, false, false,          0,      0,                nil, "CRC-24"],
+    [16,             0x1021,  true,  true,     0xC6C6,      0,             0xBF05, "CRC-16-A", "CRC-A", "CRC-16-ISO/IEC FCD 14443-3"],
+    [16,             0x1021,  true,  true,          0,      0,             0x2189, "CRC-16-KERMIT", "KERMIT", "CRC-16-CCITT", "CRC-16-CCITT-TRUE", "CRC-CCITT"],
+    [16,             0x8005,  true,  true,         ~0,      0,             0x4B37, "CRC-16-MODBUS", "MODBUS"],
+    [16,             0x1021,  true,  true,          0,     ~0,             0x906E, "CRC-16-X-25", "X-25", "CRC-16-IBM-SDLC", "CRC-16-ISO-HDLC", "CRC-16-CRC-B", "CRC-B"],
+    [16,             0x1021, false, false,          0,      0,             0x31C3, "CRC-16-XMODEM", "XMODEM", "CRC-16-ZMODEM", "ZMODEM", "CRC-16-ACORN", "CRC-16-LTE"],
+    #[17,         0x0001685B, false, false,          0,      0,                nil, "CRC-17-CAN"],
+    #[21,         0x00102899, false, false,          0,      0,                nil, "CRC-21-CAN"],
+    #[24,         0x005D6DCB, false, false,          0,      0,                nil, "CRC-24"],
     [24,         0x00864CFB, false, false,          0,      0,         0x00CDE703, "CRC-24-Radix-64"],
     [24,         0x00864CFB, false, false, 0x00B704CE,      0,         0x0021CF02, "CRC-24-OPENPGP"],
     [24,         0x0000065B,  true,  true, 0x00555555,      0,         0x00C25A56, "CRC-24-BLE"],
@@ -97,25 +98,25 @@ module CRC
     [24,         0x00328B63, false, false,          0,     ~0,         0x00B4F3E6, "CRC-24-INTERLAKEN"],
     [24,         0x00864CFB, false, false,          0,      0,         0x00CDE703, "CRC-24-LTE-A"],
     [24,         0x00800063, false, false,          0,      0,         0x0023EF52, "CRC-24-LTE-B"],
-    [30,         0x2030B9C7, false, false,          0,      0,                nil, "CRC-30"],
+    #[30,         0x2030B9C7, false, false,          0,      0,                nil, "CRC-30"],
     [30,         0x2030B9C7, false, false,          0,     ~0,         0x04C34ABF, "CRC-30-CDMA"],
     [31,         0x04C11DB7, false, false,          0,     ~0,         0x0CE9E46C, "CRC-31-PHILIPS"],
-    [32,         0x04C11DB7,  true,  true,          0,     ~0,         0xCBF43926, "CRC-32", "CRC-32-ADCCP", "PKZIP", "CRC-32-PKZIP"],
+    [32,         0x04C11DB7,  true,  true,          0,     ~0,         0xCBF43926, "CRC-32", "CRC-32-ADCCP", "CRC-32-PKZIP", "PKZIP"],
     [32,         0x04C11DB7, false, false,          0,     ~0,         0xFC891918, "CRC-32-BZIP2", "CRC-32-AAL5", "CRC-32-DECT-B", "B-CRC-32"],
     [32,         0x1EDC6F41,  true,  true,          0,     ~0,         0xE3069283, "CRC-32C", "CRC-32-ISCSI", "CRC-32-CASTAGNOLI", "CRC-32-INTERLAKEN"],
     [32,         0xa833982b,  true,  true,          0,     ~0,         0x87315576, "CRC-32D"],
     [32,         0x04C11DB7, false, false,         ~0,      0,         0x0376E6E7, "CRC-32-MPEG-2"],
     [32,         0x04C11DB7, false, false,         ~0,     ~0,         0x765E7680, "CRC-32-POSIX", "CKSUM"],
-    [32,         0x741B8CD7,  true,  true,          0,     ~0,                nil, "CRC-32K"],
-    [32,         0x32583499,  true,  true,          0,     ~0,                nil, "CRC-32K2"],
+    #[32,         0x741B8CD7,  true,  true,          0,     ~0,                nil, "CRC-32K"],
+    #[32,         0x32583499,  true,  true,          0,     ~0,                nil, "CRC-32K2"],
     [32,         0x814141AB, false, false,          0,      0,         0x3010BF7F, "CRC-32Q"],
-    [32,         0x04C11DB7,  true,  true,         ~0,      0,         0x340BC6D9, "JAMCRC", "CRC-32-JAMCRC"],
-    [32,         0x000000AF, false, false,          0,      0,         0xBD0BE338, "XFER", "CRC-32-XFER"],
+    [32,         0x04C11DB7,  true,  true,         ~0,      0,         0x340BC6D9, "CRC-32-JAMCRC", "JAMCRC"],
+    [32,         0x000000AF, false, false,          0,      0,         0xBD0BE338, "CRC-32-XFER", "XFER"],
     [40,       0x0004820009, false, false,         ~0,     ~0,       0xD4164FC646, "CRC-40-GSM"],
-    [64, 0x42F0E1EBA9EA3693,  true,  true,          0,     ~0, 0x995DC9BBDF1939FA, "CRC-64", "CRC-64-XZ"],
+    [64, 0x42F0E1EBA9EA3693,  true,  true,          0,     ~0, 0x995DC9BBDF1939FA, "CRC-64-XZ", "CRC-64"],
     [64, 0x42F0E1EBA9EA3693, false, false,          0,      0, 0x6C40DF5F0B497347, "CRC-64-ECMA", "CRC-64-ECMA-182"],
     [64, 0x42F0E1EBA9EA3693, false, false,          0,     ~0, 0x62EC59E3F1A4F00A, "CRC-64-WE"],
-    [64, 0x000000000000001B, false, false,          0,      0,                nil, "CRC-64-ISO"],
+    [64, 0x000000000000001B,  true,  true,          0,      0, 0x46A5A9388A5BEFFE, "CRC-64-ISO", "CRC-64-ISO-3309"],
     # [82, 0x308C0111011401440411,  true,  true,          0,      0, 0x9EA83F625023801FD612, "CRC-82/DARC"],
   ]
 end

data/lib/crc/acrc.rb

@@ -0,0 +1,195 @@
+#!ruby
+
+require_relative "../crc"
+
+class CRC
+  module ModuleClass
+    #
+    # call-seq:
+    #   acrc(crc, rest_seq = nil, target_crc = 0) -> byte string as arc-code
+    #
+    # 目的となる crc になるように、指定された crc に続くバイト列を逆算します。
+    #
+    # 出力されるバイト列は、crc のビット数を表現できるバイト数となります。
+    #
+    # 現在のところ、reflect-input/output 限定となっています。
+    #
+    # * crc32("123456789????") の結果が 0 となるような、???? の部分を逆算する
+    #
+    #     seq = "123456789"
+    #     seq << CRC::CRC32.acrc(seq)
+    #     p CRC::CRC32[seq] # => #<CRC::CRC32:00000000>
+    #
+    # * crc32("123456789????ABCDEFG") の結果が 0 となるような、???? の部分を逆算する
+    #
+    #     seq1 = "123456789"
+    #     seq2 = "ABCDEFG"
+    #     seq = seq1 + CRC::CRC32.acrc(seq1, seq2) + seq2
+    #     p CRC::CRC32[seq] # => #<CRC::CRC32:00000000>
+    #
+    # * crc32("123456789????ABCDEFG") の結果が 0x12345678 となるような、???? の部分を逆算する
+    #
+    #     seq1 = "123456789"
+    #     seq2 = "ABCDEFG"
+    #     target_crc = 0x12345678
+    #     seq = seq1 + CRC::CRC32.acrc(seq1, seq2, target_crc) + seq2
+    #     p CRC::CRC32[seq] # => #<CRC::CRC32:12345678>
+    #
+    def acrc(crc, rest_seq = nil, target_crc = 0)
+      raise NotImplementedError, "crc polynomial is not odd" unless polynomial.odd?
+      raise NotImplementedError, "crc module is not reflect input and output" unless reflect_input? && reflect_output?
+
+      bitsize = self.bitsize
+      poly = CRC.bitreflect(polynomial, bitsize)
+      target_crc = target_crc.to_i
+      target_crc ^= xor_output
+
+      if rest_seq
+        rest_seq.bytesize.downto(1) do |i|
+          target_crc = Aux.acrc_loop_reflect(target_crc, rest_seq.getbyte(i - 1), poly, bitsize, 0xff, 8)
+        end
+      end
+
+      bytes = (bitsize + 7) / 8
+      bits = bytes * 8
+
+      case crc
+      when Numeric
+        state = bitmask & crc ^ xor_output
+      when CRC
+        raise "different crc module (given %p(%p), expect %p)" % [crc, crc.class, self] unless variant?(crc)
+        state = crc.state
+      else
+        state = new(crc).state
+      end
+
+      if bits > bitsize
+        # ビット数が 8 の境界にない場合、その隙間分を埋める。
+        # 現在の実装では、最終結果のバイト列における最終バイト値の
+        # 上位ビットが 0 であるようにしている。
+        pad = bits - bitsize
+        target_crc = Aux.acrc_loop_reflect(target_crc, 0, poly, bitsize, 0xff, pad)
+      end
+
+      target_crc = Aux.acrc_loop_reflect(target_crc, state, poly, bitsize, bitmask, bitsize)
+
+      bytes.times.reduce("") { |a, *| a << (target_crc & 0xff).chr(Encoding::BINARY); target_crc >>= 8; a }
+    end
+  end
+
+  module Aux
+    def self.acrc_loop_reflect(target_crc, state, poly, crcbits, bitmask, bits)
+      head = bits - 1
+      bitmask1 = bitmask >> 1
+      crchead = crcbits - 1
+
+      #puts "target_crc=0b%016b, state=0b%016b, reversed-polynomial=0b%016b" % [target_crc, state, poly]
+      bits.times do |i|
+        if target_crc[crchead] == 0
+          target_crc <<= 1
+        else
+          target_crc ^= poly
+          target_crc <<= 1
+          target_crc |= 0x01
+        end
+
+        target_crc ^= state[head]
+        #puts "    0_%016b ^ %d" % [target_crc, state[head]]
+        state = (state & bitmask1) << 1
+      end
+      #puts "target_crc=0b%016b" % target_crc
+
+      target_crc
+    end
+  end
+end
+
+if $0 == __FILE__
+  seq = "abcdefghijklmnopqrstuvwxyz"
+  seq2 = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+  code = CRC::X_25.acrc(seq, seq2)
+  puts "base-crc=[%p, %p], arc'd-crc=%p, arc-code=%s" % [CRC::X_25[seq], CRC::X_25[seq2], CRC::X_25[seq + code + seq2], code.unpack("H*")[0]]
+  code = CRC::CRC32.acrc(seq, seq2)
+  puts "base-crc=[%p, %p], arc'd-crc=%p, arc-code=%s" % [CRC::CRC32[seq], CRC::CRC32[seq2], CRC::CRC32[seq + code + seq2], code.unpack("H*")[0]]
+  code = CRC::CRC32C.acrc(seq, seq2)
+  puts "base-crc=[%p, %p], arc'd-crc=%p, arc-code=%s" % [CRC::CRC32C[seq], CRC::CRC32C[seq2], CRC::CRC32C[seq + code + seq2], code.unpack("H*")[0]]
+
+  MyCRC = crcmod = CRC.new(32, rand(1<<32) | 1, rand(1<<32) | 1, true, true, rand(1<<32) | 1)
+  20.times do |i|
+    s = (10+rand(20)).times.reduce("") { |a, *| a << rand(256).chr(Encoding::BINARY) }
+    t = (10+rand(20)).times.reduce("") { |a, *| a << rand(256).chr(Encoding::BINARY) }
+    crc = crcmod.new(s)
+    puts "crc=[%p, %p], arc'd-crc=%p, target=%08X, seq=%s" %
+      [crc, crcmod[t], crcmod.new(s + crcmod.acrc(crc.crc, t, i * 9929) + t), i * 9929, s.unpack("H*")[0]]
+  end
+end
+
+__END__
+
+目的となる CRC 値を逆算して、特定のバイト列を得る機能です。
+
+ただの思いつきで、crc すると結果が 0 になるバイト列を計算できないかなと遊んでみた結果、
+それなりの形となってしまいました。
+
+以下は acrc メソッドとして実装した、その仕組みとなります。
+
+
+X-25{CRC-16-0x1021 ref-in/out xor=0xffff} を用いた場合
+
+("abcdefghijklmnopqrstuvwxyz" + ??) を CRC して結果を 0 にしたい (?? は2バイト)。
+
+この時の ?? を求める。
+
+先に "abcdefghijklmnopqrstuvwxyz" までの CRC を求めておく => 0x0d43
+
+(ここまでの内部状態は 0xf2bc) ?? <STOP> (この段階で内部状態が 0xffff であること)
+
+内部状態の最上位ビットから順に送って、目的となる内部状態が 0xffff から 0xf2bc になるような値を逆算する
+
+
+code = 0 # 最終的に求めたい CRC
+state = 0b1111001010111100 # 現在の CRC 生成器の内部状態
+reversed_polynomial = 0b1000010000001000
+
+    1. 最終的に求めたい CRC と xor_output する
+            1111111111111111
+
+    2. この時、code の最上位ビットが1なので、poly (reversed) で xor する
+       最上位ビットが0ならば何もしない
+            0111101111110111
+
+    3. 左にずらす
+            1111011111101110
+
+    4. (2) において poly-reversed で xor したため、最下位ビットを1にする
+       (2) を行わなかった場合は何もしない
+            1111011111101111
+
+    5. 目的となる内部状態の最上位ビットと作業内部状態の最下位ビットを xor した時に 1 となるように調整する
+       (2) を行わなかった場合は 0 を維持するように処置する
+            1111011111101110
+
+    6. 1 ビット目の処理が完了。(2) に戻って必要なだけ繰り返す
+
+    1111011111101110 <= 1   ## 最上位から2ビット目を入力
+    1110011111001100 <= 1   ## 最上位から3ビット目を入力
+    1100011110001000 <= 1   ## 以下同様に……
+    1000011100000000 <= 0
+    0000011000010001 <= 0
+    0000110000100010 <= 1
+    0001100001000101 <= 0
+    0011000010001010 <= 1
+    0110000100010101 <= 0
+    1100001000101010 <= 1
+    1000110001000100 <= 1
+    0001000010011000 <= 1
+    0010000100110001 <= 1
+    0100001001100011 <= 0
+    1000010011000110 <= 0
+    0000000110011101        ## 繰り返して得られた結果
+                               この結果を元にして、バイト順を入れ替える
+                               (CRC として求める場合に、下位から入力されるため)
+
+    10011101:00000001 >>>> [0x9d, 0x01] が返る
+
+[EOF]