CRC32 checksum คำนวณอย่างไร

บางทีฉันอาจจะไม่เห็น แต่ CRC32 ดูเหมือนจะซับซ้อนโดยไม่จำเป็นหรืออธิบายไม่เพียงพอในทุกที่ที่ฉันพบบนเว็บ

ฉันเข้าใจว่ามันเป็นส่วนที่เหลือจากการหารเลขคณิตแบบไม่ถือตามค่าของข้อความหารด้วยพหุนาม (ตัวสร้าง) แต่การนำไปใช้จริงทำให้ฉันหนีไป

ฉันได้อ่าน คำแนะนำที่ไม่เจ็บปวดสำหรับอัลกอริทึมการตรวจจับข้อผิดพลาด CRCและฉันต้องบอกว่ามันไม่เจ็บปวด มันเป็นไปตามทฤษฎีที่ค่อนข้างดี แต่ผู้เขียนไม่เคยเข้าใจง่ายๆว่า "นี่มัน" เขาบอกว่าพารามิเตอร์สำหรับอัลกอริทึม CRC32 มาตรฐานคืออะไร แต่เขาละเลยที่จะอธิบายอย่างชัดเจนว่าคุณจะไปถึงมันอย่างไร

ส่วนที่ทำให้ฉันเข้าใจคือเมื่อเขาพูดว่า "นี่ไง" จากนั้นก็พูดว่า "โอ้ยังไงก็ตามมันสามารถย้อนกลับหรือเริ่มต้นด้วยเงื่อนไขเริ่มต้นที่แตกต่างกันได้" และไม่ได้ให้คำตอบที่ชัดเจนว่าวิธีสุดท้ายคืออะไร ของการคำนวณการตรวจสอบ CRC32 จากการเปลี่ยนแปลงทั้งหมดที่เขาเพิ่งเพิ่มเข้าไป

• มีคำอธิบายที่ง่ายกว่านี้เกี่ยวกับวิธีคำนวณ CRC32 หรือไม่?

ฉันพยายามเขียนโค้ดใน C ว่าตารางถูกสร้างขึ้นอย่างไร:

for (i = 0; i < 256; i++)
{
    temp = i;

    for (j = 0; j < 8; j++)
    {
        if (temp & 1)
        {
            temp >>= 1;
            temp ^= 0xEDB88320;
        }
        else {temp >>= 1;}
    }
    testcrc[i] = temp;
}

แต่ดูเหมือนว่าจะสร้างค่าที่ไม่สอดคล้องกับค่าที่ฉันพบจากที่อื่นบนอินเทอร์เน็ต ฉันทำได้ใช้ค่าที่พบทางออนไลน์ แต่ฉันต้องการเข้าใจว่าค่าเหล่านี้ถูกสร้างขึ้นอย่างไร

ความช่วยเหลือใด ๆ ในการล้างตัวเลขที่สับสนอย่างไม่น่าเชื่อเหล่านี้จะได้รับการชื่นชมมาก

พหุนามสำหรับ CRC32 คือ:

x ³² + x ²⁶ + x ²³ + x ²² + x ¹⁶ + x ¹² + x ¹¹ + x ¹⁰ + x ⁸ + x ⁷ + x ⁵ + x ⁴ + x ² + x + 1

• Wikipedia
• การคำนวณ CRC

หรือในฐานสิบหกและไบนารี:

0x 01 04 C1 1D B7
1 0000 0100 1100 0001 0001 1101 1011 0111

เทอมสูงสุด (x ³² ) มักจะไม่ถูกเขียนอย่างชัดเจนดังนั้นจึงสามารถแทนด้วยเลขฐานสิบหกได้

0x 04 C1 1D B7

อย่าลังเลที่จะนับ 1 และ 0 แต่คุณจะพบว่ามันตรงกับพหุนามที่ไหน 1บิต 0 (หรือบิตแรก) และxเป็นบิต 1 (หรือบิตที่สอง)

ทำไมต้องเป็นพหุนามนี้? เนื่องจากจำเป็นต้องมีพหุนามมาตรฐานที่กำหนดและมาตรฐานถูกกำหนดโดย IEEE 802.3 นอกจากนี้ยังเป็นเรื่องยากมากที่จะค้นหาพหุนามที่ตรวจจับข้อผิดพลาดของบิตต่างๆได้อย่างมีประสิทธิภาพ

คุณสามารถคิดว่า CRC-32 เป็นชุดของ "เลขคณิตไบนารีที่ไม่มีการดำเนินการ" หรือโดยทั่วไปคือ "XOR และการทำงานกะ" สิ่งนี้เรียกในทางเทคนิคว่าเลขคณิตพหุนาม

• ไพรเมอร์ CRC บทที่ 5

เพื่อให้เข้าใจได้ดีขึ้นให้นึกถึงการคูณนี้:

(x^3 + x^2 + x^0)(x^3 + x^1 + x^0)
= (x^6 + x^4 + x^3
 + x^5 + x^3 + x^2
 + x^3 + x^1 + x^0)
= x^6 + x^5 + x^4 + 3*x^3 + x^2 + x^1 + x^0

ถ้าเราถือว่า x เป็นฐาน 2 เราจะได้:

x^7 + x^3 + x^2 + x^1 + x^0

• ไพรเมอร์ CRC Chp.5

ทำไม? เนื่องจาก 3x ^ 3 คือ 11x ^ 11 (แต่เราต้องการเพียง 1 หรือ 0 หลักก่อนเท่านั้น) เราจึงดำเนินการต่อ:

=1x^110 + 1x^101 + 1x^100          + 11x^11 + 1x^10 + 1x^1 + x^0
=1x^110 + 1x^101 + 1x^100 + 1x^100 + 1x^11 + 1x^10 + 1x^1 + x^0
=1x^110 + 1x^101 + 1x^101          + 1x^11 + 1x^10 + 1x^1 + x^0
=1x^110 + 1x^110                   + 1x^11 + 1x^10 + 1x^1 + x^0
=1x^111                            + 1x^11 + 1x^10 + 1x^1 + x^0

แต่นักคณิตศาสตร์เปลี่ยนกฎเพื่อให้เป็น mod 2 ดังนั้นโดยพื้นฐานแล้ว binary polynomial mod 2 ใด ๆ ก็เป็นเพียงการเพิ่มโดยไม่ต้องพกหรือ XOR สมการเดิมของเราจึงมีลักษณะดังนี้:

=( 1x^110 + 1x^101 + 1x^100 + 11x^11 + 1x^10 + 1x^1 + x^0 ) MOD 2
=( 1x^110 + 1x^101 + 1x^100 +  1x^11 + 1x^10 + 1x^1 + x^0 )
= x^6 + x^5 + x^4 + 3*x^3 + x^2 + x^1 + x^0 (or that original number we had)

ฉันรู้ว่านี่เป็นการก้าวกระโดดของความเชื่อ แต่นี่เกินความสามารถของฉันในฐานะโปรแกรมเมอร์สายงาน หากคุณเป็นนักเรียน CS หรือวิศวกรระดับฮาร์ดคอร์ฉันขอท้าให้ทำลายสิ่งนี้ ทุกคนจะได้รับประโยชน์จากการวิเคราะห์นี้

ดังนั้นเพื่อหาตัวอย่างเต็ม:

   Original message                : 1101011011
   Polynomial of (W)idth 4         :      10011
   Message after appending W zeros : 11010110110000

ตอนนี้เราแบ่งข้อความเสริมด้วยโพลีโดยใช้เลขคณิต CRC นี่คือการหารเดียวกันกับก่อนหน้านี้:

            1100001010 = Quotient (nobody cares about the quotient)
       _______________
10011 ) 11010110110000 = Augmented message (1101011011 + 0000)
=Poly   10011,,.,,....
        -----,,.,,....
         10011,.,,....
         10011,.,,....
         -----,.,,....
          00001.,,....
          00000.,,....
          -----.,,....
           00010,,....
           00000,,....
           -----,,....
            00101,....
            00000,....
            -----,....
             01011....
             00000....
             -----....
              10110...
              10011...
              -----...
               01010..
               00000..
               -----..
                10100.
                10011.
                -----.
                 01110
                 00000
                 -----
                  1110 = Remainder = THE CHECKSUM!!!!

การหารจะให้ผลหารซึ่งเราทิ้งไปและส่วนที่เหลือซึ่งเป็นเช็คซัมที่คำนวณได้ สิ่งนี้จะสิ้นสุดการคำนวณ โดยปกติแล้วการตรวจสอบจะถูกผนวกเข้ากับข้อความและผลลัพธ์ที่ส่ง ในกรณีนี้ระบบส่งกำลัง: 11010110111110

• ไพรเมอร์ CRC บทที่ 7

ใช้เฉพาะตัวเลข 32 บิตเป็นตัวหารและใช้สตรีมทั้งหมดเป็นเงินปันผล โยนผลหารออกและเก็บส่วนที่เหลือไว้ ลากส่วนที่เหลือที่ท้ายข้อความของคุณและคุณมี CRC32

รีวิวผู้ชายโดยเฉลี่ย:

         QUOTIENT
        ----------
DIVISOR ) DIVIDEND
                 = REMAINDER

1. ใช้ 32 บิตแรก
2. กะบิต
3. ถ้า 32 บิตน้อยกว่า DIVISOR ไปที่ขั้นตอนที่ 2
4. XOR 32 บิตโดย DIVISOR ไปที่ขั้นตอนที่ 2

(โปรดทราบว่าสตรีมจะต้องแบ่งได้ 32 บิตหรือควรมีการบุนวมตัวอย่างเช่นสตรีม ANSI 8 บิตจะต้องมีการบุนวมนอกจากนี้ในตอนท้ายของสตรีมการแบ่งจะหยุดลงด้วย)

สำหรับ IEEE802.3, CRC-32 คิดว่าข้อความทั้งหมดเป็นสตรีมบิตอนุกรมต่อท้าย 32 ศูนย์ที่ท้ายข้อความ จากนั้นคุณต้องย้อนกลับบิตของทุกไบต์ของข้อความและทำ 1 เติมเต็ม 32 บิตแรก ตอนนี้หารด้วยพหุนาม CRC-32, 0x104C11DB7 สุดท้ายคุณต้อง 1 เติมเต็มส่วนที่เหลือ 32 บิตของการหารนี้บิตย้อนกลับแต่ละ 4 ไบต์ของส่วนที่เหลือ ซึ่งจะกลายเป็น CRC 32 บิตที่ต่อท้ายข้อความ

เหตุผลสำหรับขั้นตอนแปลก ๆ นี้คือการใช้งานอีเทอร์เน็ตครั้งแรกจะทำให้ข้อความเป็นอนุกรมทีละไบต์และส่งบิตที่มีนัยสำคัญน้อยที่สุดของทุกไบต์ก่อน จากนั้นสตรีมบิตอนุกรมจะผ่านการคำนวณทะเบียนกะ CRC-32 แบบอนุกรมซึ่งได้รับการเติมเต็มและส่งออกทางสายหลังจากที่ข้อความเสร็จสมบูรณ์ เหตุผลในการเติมเต็ม 32 บิตแรกของข้อความเพื่อที่คุณจะไม่ได้รับ CRC เป็นศูนย์ทั้งหมดแม้ว่าข้อความจะเป็นเลขศูนย์ทั้งหมดก็ตาม

CRC ค่อนข้างง่าย คุณนำพหุนามที่แสดงเป็นบิตและข้อมูลและแบ่งพหุนามลงในข้อมูล (หรือคุณแทนข้อมูลเป็นพหุนามและทำสิ่งเดียวกัน) ส่วนที่เหลือซึ่งอยู่ระหว่าง 0 และพหุนามคือ CRC รหัสของคุณยากที่จะเข้าใจส่วนหนึ่งเป็นเพราะยังไม่สมบูรณ์: ไม่ได้ประกาศ temp และ testcrc ดังนั้นจึงไม่ชัดเจนว่ามีการจัดทำดัชนีอะไรและข้อมูลกำลังทำงานผ่านอัลกอริทึมเท่าใด

วิธีทำความเข้าใจ CRCs คือการพยายามคำนวณบางส่วนโดยใช้ข้อมูลสั้น ๆ (16 บิตหรือมากกว่านั้น) ด้วยพหุนามสั้น ๆ - 4 บิต หากคุณฝึกฝนวิธีนี้คุณจะเข้าใจอย่างแท้จริงว่าคุณจะเขียนโค้ดได้อย่างไร

หากคุณทำบ่อยๆ CRC จะคำนวณในซอฟต์แวร์ได้ค่อนข้างช้า การคำนวณฮาร์ดแวร์มีประสิทธิภาพมากกว่าและต้องใช้เพียงไม่กี่ประตู

นอกเหนือจากการตรวจสอบความซ้ำซ้อนของวงจรวิกิพีเดียและการคำนวณบทความCRCแล้วฉันยังพบบทความชื่อReversing CRC - Theory and Practice ^*เพื่อเป็นข้อมูลอ้างอิงที่ดี

โดยพื้นฐานแล้วมีสามวิธีในการคำนวณ CRC: วิธีพีชคณิตวิธีเชิงบิตและแนวทางที่ขับเคลื่อนด้วยตาราง ในการย้อนกลับ CRC - ทฤษฎีและการปฏิบัติ ^*อัลกอริทึม / วิธีการทั้งสามนี้อธิบายในทางทฤษฎีพร้อมกับในภาคผนวกโดยการใช้งาน CRC32 ในภาษาโปรแกรม C

^{* ลิงก์ PDF
ย้อนกลับ CRC - ทฤษฎีและการปฏิบัติ
HU Berlin Public Report
SAR-PR-2006-05
พฤษภาคม 2549
Authors:
Martin Stigge, Henryk Plötz, Wolf Müller, Jens-Peter Redlich}

ฉันใช้เวลาสักพักในการพยายามหาคำตอบสำหรับคำถามนี้และในที่สุดฉันก็ได้เผยแพร่บทช่วยสอนเกี่ยวกับ CRC-32 ในวันนี้: บทช่วยสอนแฮช CRC-32 - ชุมชน AutoHotkey

ในตัวอย่างนี้ฉันสาธิตวิธีคำนวณแฮช CRC-32 สำหรับสตริง ASCII 'abc':

calculate the CRC-32 hash for the ASCII string 'abc':

inputs:
dividend: binary for 'abc': 0b011000010110001001100011 = 0x616263
polynomial: 0b100000100110000010001110110110111 = 0x104C11DB7

011000010110001001100011
reverse bits in each byte:
100001100100011011000110
append 32 0 bits:
10000110010001101100011000000000000000000000000000000000
XOR the first 4 bytes with 0xFFFFFFFF:
01111001101110010011100111111111000000000000000000000000

'CRC division':
01111001101110010011100111111111000000000000000000000000
 100000100110000010001110110110111
 ---------------------------------
  111000100010010111111010010010110
  100000100110000010001110110110111
  ---------------------------------
   110000001000101011101001001000010
   100000100110000010001110110110111
   ---------------------------------
    100001011101010011001111111101010
    100000100110000010001110110110111
    ---------------------------------
         111101101000100000100101110100000
         100000100110000010001110110110111
         ---------------------------------
          111010011101000101010110000101110
          100000100110000010001110110110111
          ---------------------------------
           110101110110001110110001100110010
           100000100110000010001110110110111
           ---------------------------------
            101010100000011001111110100001010
            100000100110000010001110110110111
            ---------------------------------
              101000011001101111000001011110100
              100000100110000010001110110110111
              ---------------------------------
                100011111110110100111110100001100
                100000100110000010001110110110111
                ---------------------------------
                    110110001101101100000101110110000
                    100000100110000010001110110110111
                    ---------------------------------
                     101101010111011100010110000001110
                     100000100110000010001110110110111
                     ---------------------------------
                       110111000101111001100011011100100
                       100000100110000010001110110110111
                       ---------------------------------
                        10111100011111011101101101010011

remainder: 0b10111100011111011101101101010011 = 0xBC7DDB53
XOR the remainder with 0xFFFFFFFF:
0b01000011100000100010010010101100 = 0x438224AC
reverse bits:
0b00110101001001000100000111000010 = 0x352441C2

thus the CRC-32 hash for the ASCII string 'abc' is 0x352441C2

จากนั้นจะมี Rosetta Code ซึ่งแสดง crc32 ที่ใช้งานในภาษาคอมพิวเตอร์หลายสิบภาษา https://rosettacode.org/wiki/CRC-32และมีลิงก์ไปยังคำอธิบายและการใช้งานมากมาย

เพื่อลด crc32 ในการแจ้งเตือนคุณต้อง:

1. สลับบิตในแต่ละไบต์
2. xor สี่ไบต์แรกที่มี 0xFF (เพื่อหลีกเลี่ยงข้อผิดพลาดใน 0s นำหน้า)
3. เพิ่มช่องว่างในตอนท้าย (นี่คือการทำให้ 4 ไบต์สุดท้ายมีส่วนร่วมในแฮช)
4. คำนวณการแจ้งเตือน
5. ย้อนกลับบิตอีกครั้ง
6. x หรือผลลัพธ์อีกครั้ง

ในรหัสนี้คือ:

func CRC32 (file []byte) uint32 {
    for i , v := range(file) {
        file[i] = bits.Reverse8(v)
    }
    for i := 0; i < 4; i++ {
        file[i] ^= 0xFF
    }

    // Add padding
    file = append(file, []byte{0, 0, 0, 0}...)
    newReminder := bits.Reverse32(reminderIEEE(file))

    return newReminder ^ 0xFFFFFFFF
}

โดยที่เตือนความจำ IEEE คือการแจ้งเตือนที่แท้จริงใน GF (2) [x]