ในเวกเตอร์ทดสอบต่อไปนี้Whirlpool รุ่นดั้งเดิมจะถูกเรียกว่าWhirlpool-0 , Whirlpool รุ่นปรับปรุงครั้งแรกจะถูกเรียกว่าWhirlpool-Tและ Whirlpool เวอร์ชันล่าสุดจะถูกเรียกว่าWhirlpool

• ในการปรับปรุงครั้งแรกในปี 2001 นั้นS-boxถูกเปลี่ยนจากแบบที่สร้างขึ้นแบบสุ่มซึ่งมีคุณสมบัติการเข้ารหัสที่ดี ไปเป็นแบบที่มีคุณสมบัติการเข้ารหัสที่ดีกว่าและง่ายต่อการใช้งานในฮาร์ดแวร์
• ในการแก้ไขครั้งที่สอง (2003) พบ ข้อบกพร่องใน เมทริกซ์การแพร่กระจาย ซึ่งทำให้ความปลอดภัยที่ประเมินไว้ของอัลกอริทึมลดลงต่ำกว่าศักยภาพ ^{[ 4 ]}การเปลี่ยนค่าคงที่ของเมทริกซ์หมุน 8x8 จาก (1, 1, 3, 1, 5, 8, 9, 5) เป็น (1, 1, 4, 1, 8, 5, 2, 9) แก้ปัญหานี้ได้

การดำเนิน การ SubBytesใช้การเรียงสับเปลี่ยนแบบไม่เชิงเส้น (S-box) กับแต่ละไบต์ของสถานะอย่างอิสระ โดย S-box ขนาด 8 บิตนั้นประกอบด้วย S-box ขนาด 4 บิตที่เล็กกว่า 3 อัน

การ ดำเนินการ ShiftColumnsจะเลื่อนไบต์แต่ละตัวในแต่ละคอลัมน์ของสถานะแบบวนรอบ คอลัมน์jจะมีการเลื่อนไบต์ลงมาjตำแหน่ง

การ ดำเนินการ MixBytesInRowsคือการคูณแต่ละแถวด้วยเมทริกซ์ 8×8 ทาง ขวา โดยเลือกเมทริกซ์ให้มีจำนวนสาขา (คุณสมบัติสำคัญเมื่อพิจารณาความต้านทานต่อการวิเคราะห์การเข้ารหัสแบบดิฟเฟอเรนเชียล ) เท่ากับ 9 ซึ่งเป็นค่าสูงสุด${\displaystyle GF({2^{8}})}$

การ ดำเนินการ AddRoundKeyใช้การดำเนินการXOR ระดับบิต เพื่อเพิ่มคีย์ที่คำนวณโดยตารางกำหนดคีย์ไปยังสถานะปัจจุบัน ตารางกำหนดคีย์นั้นเหมือนกับการเข้ารหัสทุกประการ ยกเว้นฟังก์ชัน AddRoundKey ถูกแทนที่ด้วย ฟังก์ชัน AddRoundConstantที่เพิ่มค่าคงที่ที่กำหนดไว้ล่วงหน้าในแต่ละรอบ

ข้อความที่จะทำการแฮชจะถูกเติมข้อมูล ก่อน เพื่อให้แน่ใจว่าความยาวของข้อความนั้นเป็นจำนวนเท่าของขนาดบล็อก (512 บิต) โดยใช้ วิธี การเติมข้อมูล มาตรฐาน ที่กำหนดไว้ใน มาตรฐาน ISO/IEC 10118-1 (ซึ่งเป็นวิธีการเดียวกับที่ใช้สำหรับmd5 , sha-2และอื่นๆ):${\displaystyle M}$

1. เพิ่มบิต '1' เข้าไป;
2. เพิ่มบิต '0' มากเท่าที่จำเป็นเพื่อให้ความยาวเป็นจำนวนเท่าของ 256 ( );${\displaystyle 512-256}$
3. เพิ่มความยาวเดิมของข้อความในหน่วยบิตโดยใช้รูปแบบบิ๊กเอนเดียน 256 บิต

จากนั้น ข้อความที่เติมข้อมูลแล้วจะถูกแบ่งออกเป็นบล็อกขนาด512 บิต${\displaystyle t}$${\displaystyle m_{i}}$${\displaystyle 1\leq i\leq t}$

Whirlpool ทำซ้ำรูป แบบการแฮช Miyaguchi-Preneelบนบล็อกเหล่านี้^{[ส่วนที่ 3.11 และ 3.12] [ 1 ]} :

${\displaystyle {\begin{aligned}&{\begin{aligned}\eta _{i}&=\mu \left(m_{i}\right),\\H_{0}&=\mu \left(IV\right),\\H_{i}&=W\left[H_{i-1}\right]\left(\eta _{i}\right)\oplus H_{i-1}\oplus \eta _{i},\ 1\leq i\leq t\\\end{aligned}}\\&{\text{Whirlpool}}\left(M\right)\equiv \mu ^{-1}\left(H_{t}\right)\end{aligned}}}$

ที่ไหน:

• ${\displaystyle \mu$ :\{0,1\}^{512}\to {\mathcal {M}}_{8\times 8}} คือฟังก์ชันแปลงสตริงเป็นเมทริกซ์
• ${\displaystyle \mu ^{-1}:{\mathcal {M}}_{8\times 8}\to \{0,1\}^{512}}$คือ ฟังก์ชันแปลง เมทริกซ์เป็นสตริง ;
• ${\displaystyle IV}$คือเวกเตอร์เริ่มต้นซึ่งเป็นสตริงของบิต 0 จำนวน 512 บิต;
• ${\displaystyle W}$คือฟังก์ชันการเข้ารหัสแบบ Whirlpool

ฟังก์ชันการเข้ารหัสบล็อกภายใน^{[ส่วนที่ 3.9] [ 1 ]}ทำงานและส่งคืนเมทริกซ์ 8x8 :${\displaystyle W\left[{\mathcal {M}}_{8\times 8}\right]:{\mathcal {M}}_{8\times 8}\to {\mathcal {M}}_{8\times 8}}$

${\displaystyle {\begin{aligned}W\left[K\right]=\left({\underset {1}{\overset {r=R}{\bigcirc }}}\rho \left[K_{r}\right]\right)\circ \sigma \left[K_{0}\right]\end{aligned}}}$

ที่ไหน:

• ${\displaystyle R}$คือจำนวนรอบ (มาตรฐานที่ Whirlpool ใช้)${\displaystyle R=10}$
• ${\displaystyle K_{n}}$เป็น คีย์ลำดับ ที่ nของตารางคีย์;${\displaystyle K}$
• ${\displaystyle \rho }$คือฟังก์ชันการปัดเศษ

ตารางคีย์จะขยายคีย์เป็นลำดับของคีย์^{[ส่วนที่ 3.8] [ 1 ]} :${\displaystyle K\in {\mathcal {M}}_{8\times 8}}$${\displaystyle K_{r}\in {\mathcal {M}}_{8\times 8},\ 0\leq r\leq R}$

${\displaystyle {\begin{aligned}K_{0}&=K,\\K_{r}&=\rho \left[c^{r}\right]\left(K_{r-1}\right),\ 1\leq r\leq R\\\end{aligned}}}$

ที่ไหน:

• ${\displaystyle c^{r}\in {\mathcal {M}}_{8\times 8}}$คือเมทริกซ์คงที่รอบที่r

ค่าคงที่รอบสำหรับ รอบ ที่ r , , คือเมทริกซ์ , ซึ่งกำหนดไว้ดังนี้:${\displaystyle r>0}$${\displaystyle c^{r}\in {\mathcal {M}}_{8\times 8}}$

${\displaystyle {\begin{aligned}c_{0,j}^{r}&=S\left[8\left(r-1\right)+j\right],&0\leq j<8\\c_{i,j}^{r}&=0,&1\leq i<8,0\leq j<8\\\end{aligned}}}$

ที่ไหน:

• ${\displaystyle S\in {\mathcal {M}}_{16\times 16}}$คือกล่อง S

ฟังก์ชันรอบ^{[ส่วนที่ 3.7] [ 1 ]}ถูกกำหนดดังนี้:${\displaystyle \rho \left[{\mathcal {M}}_{8\times 8}\right]:{\mathcal {M}}_{8\times 8}\to {\mathcal {M}}_{8\times 8}}$

${\displaystyle {\begin{aligned}\rho \left[k\right]&=\sigma \left[k\right]\circ \theta \circ \pi \circ \gamma \\&_{\left(=\ AK\ \circ \ MR\ \circ \ SC\ \circ \ SB\right)}\\\end{aligned}}}$

ที่ไหน:

• ${\displaystyle \gamma }$คือชั้นที่ไม่เป็นเชิงเส้น
• ${\displaystyle \pi }$คือการเรียงสับเปลี่ยน แบบวนรอบ ;
• ${\displaystyle \theta }$คือชั้นการแพร่กระจาย;
• ${\displaystyle \sigma }$เป็นการเพิ่มเติมที่สำคัญ

โดยทั่วไป S-Box จะแสดงเป็นตารางค้นหา โดยที่ ไบต์อินพุตแต่ละ ไบต์จะถูกแมปไปยัง ไบต์เอาต์พุตที่สอดคล้องกันสามารถคำนวณได้โดยใช้เทคนิคการสร้างแผนที่การแพร่กระจายที่เหมาะสมที่สุด^{[ส่วนที่ 2.4] [ 1 ]}แต่ต่อไปนี้เป็นการ แสดง ในรูปแบบเมทริกซ์ :${\displaystyle S\in {\mathcal {M}}_{16\times 16}}$${\displaystyle {\begin{aligned}&S={\begin{pmatrix}18_{(16)}&23_{(16)}&c6_{(16)}&e8_{(16)}&87_{(16)}&b8_{(16)}&01_{(16)}&4f_{(16)}&36_{(16)}&a6_{(16)}&d2_{(16)}&f5_{(16)}&79_{(16)}&6f_{(16)}&91_{(16)}&52_{(16)}\\60_{(16)}&bc_{(16)}&9b_{(16)}&8e_{(16)}&a3_{(16)}&0c_{(16)}&7b_{(16)}&35_{(16)}&1d_{(16)}&e0_{(16)}&d7_{(16)}&c2_{(16)}&2e_{(16)}&4b_{(16)}&fe_{(16)}&57_{(16)}\\15_{(16)}&77_{(16)}&37_{(16)}&e5_{(16)}&9f_{(16)}&f0_{(16)}&4a_{(16)}&da_{(16)}&58_{(16)}&c9_{(16)}&29_{(16)}&0a_{(16)}&b1_{(16)}&a0_{(16)}&6b_{(16)}&85_{(16)}\\bd_{(16)}&5d_{(16)}&10_{(16)}&f4_{(16)}&cb_{(16)}&3e_{(16)}&05_{(16)}&67_{(16)}&e4_{(16)}&27_{(16)}&41_{(16)}&8b_{(16)}&a7_{(16)}&7d_{(16)}&95_{(16)}&d8_{(16)}\\fb_{(16)}&ee_{(16)}&7c_{(16)}&66_{(16)}&dd_{(16)}&17_{(16)}&47_{(16)}&9e_{(16)}&ca_{(16)}&2d_{(16)}&bf_{(16)}&07_{(16)}&ad_{(16)}&5a_{(16)}&83_{(16)}&33_{(16)}\\63_{(16)}&02_{(16)}&aa_{(16)}&71_{(16)}&c8_{(16)}&19_{(16)}&49_{(16)}&d9_{(16)}&f2_{(16)}&e3_{(16)}&5b_{(16)}&88_{(16)}&9a_{(16)}&26_{(16)}&32_{(16)}&b0_{(16)}\\e9_{(16)}&0f_{(16)}&d5_{(16)}&80_{(16)}&be_{(16)}&cd_{(16)}&34_{(16)}&48_{(16)}&ff_{(16)}&7a_{(16)}&90_{(16)}&5f_{(16)}&20_{(16)}&68_{(16)}&1a_{(16)}&ae_{(16)}\\b4_{(16)}&54_{(16)}&93_{(16)}&22_{(16)}&64_{(16)}&f1_{(16)}&73_{(16)}&12_{(16)}&40_{(16)}&08_{(16)}&c3_{(16)}&ec_{(16)}&db_{(16)}&a1_{(16)}&8d_{(16)}&3d_{(16)}\\97_{(16)}&00_{(16)}&cf_{(16)}&2b_{(16)}&76_{(16)}&82_{(16)}&d6_{(16)}&1b_{(16)}&b5_{(16)}&af_{(16)}&6a_{(16)}&50_{(16)}&45_{(16)}&f3_{(16)}&30_{(16)}&ef_{(16)}\\3f_{(16)}&55_{(16)}&a2_{(16)}&ea_{(16)}&65_{(16)}&ba_{(16)}&2f_{(16)}&c0_{(16)}&de_{(16)}&1c_{(16)}&fd_{(16)}&4d_{(16)}&92_{(16)}&75_{(16)}&06_{(16)}&8a_{(16)}\\b2_{(16)}&e6_{(16)}&0e_{(16)}&1f_{(16)}&62_{(16)}&d4_{(16)}&a8_{(16)}&96_{(16)}&f9_{(16)}&c5_{(16)}&25_{(16)}&59_{(16)}&84_{(16)}&72_{(16)}&39_{(16)}&4c_{(16)}\\5e_{(16)}&78_{(16)}&38_{(16)}&8c_{(16)}&d1_{(16)}&a5_{(16)}&e2_{(16)}&61_{(16)}&b3_{(16)}&21_{(16)}&9c_{(16)}&1e_{(16)}&43_{(16)}&c7_{(16)}&fc_{(16)}&04_{(16)}\\51_{(16)}&99_{(16)}&6d_{(16)}&0d_{(16)}&fa_{(16)}&df_{(16)}&7e_{(16)}&24_{(16)}&3b_{(16)}&ab_{(16)}&ce_{(16)}&11_{(16)}&8f_{(16)}&4e_{(16)}&b7_{(16)}&eb_{(16)}\\3c_{(16)}&81_{(16)}&94_{(16)}&f7_{(16)}&b9_{(16)}&13_{(16)}&2c_{(16)}&d3_{(16)}&e7_{(16)}&6e_{(16)}&c4_{(16)}&03_{(16)}&56_{(16)}&44_{(16)}&7f_{(16)}&a9_{(16)}\\2a_{(16)}&bb_{(16)}&c1_{(16)}&53_{(16)}&dc_{(16)}&0b_{(16)}&9d_{(16)}&6c_{(16)}&31_{(16)}&74_{(16)}&f6_{(16)}&46_{(16)}&ac_{(16)}&89_{(16)}&14_{(16)}&e1_{(16)}\\16_{(16)}&3a_{(16)}&69_{(16)}&09_{(16)}&70_{(16)}&b6_{(16)}&d0_{(16)}&ed_{(16)}&cc_{(16)}&42_{(16)}&98_{(16)}&a4_{(16)}&28_{(16)}&5c_{(16)}&f8_{(16)}&86_{(16)}\\\end{pmatrix}}\\\end{aligned}}}$

ต่อไปนี้เป็นตัวอย่างการใช้งาน อัลก อริทึม Whirlpool มาตรฐาน :

S := 0x18, 0x23, 0xc6, 0xe8, 0x87, 0xb8, 0x01, 0x4f, 0x36, 0xa6, 0xd2, 0xf5, 0x79, 0x6f, 0x91, 0x52, \ 0x60, 0xbc, 0x9b, 0x8e, 0xa3, 0x0c, 0x7b, 0x35, 0x1d, 0xe0, 0xd7, 0xc2, 0x2e, 0x4b, 0xfe, 0x57, \ 0x15, 0x77, 0x37, 0xe5, 0x9f, 0xf0, 0x4a, 0xda, 0x58, 0xc9, 0x29, 0x0a, 0xb1, 0xa0, 0x6b, 0x85, \ 0xbd, 0x5d, 0x10, 0xf4, 0xcb, 0x3e, 0x05, 0x67, 0xe4, 0x27, 0x41, 0x8b, 0xa7, 0x7d, 0x95, 0xd8, \ 0xfb, 0xee, 0x7c, 0x66, 0xdd, 0x17, 0x47, 0x9e, 0xca, 0x2d, 0xbf, 0x07, 0xad, 0x5a, 0x83, 0x33, \ 0x63, 0x02, 0xaa, 0x71, 0xc8, 0x19, 0x49, 0xd9, 0xf2, 0xe3, 0x5b, 0x88, 0x9a, 0x26, 0x32, 0xb0, \ 0xe9, 0x0f, 0xd5, 0x80, 0xbe, 0xcd, 0x34, 0x48, 0xff, 0x7a, 0x90, 0x5f, 0x20, 0x68, 0x1a, 0xae, \ 0xb4, 0x54, 0x93, 0x22, 0x64, 0xf1, 0x73, 0x12, 0x40, 0x08, 0xc3, 0xec, 0xdb, 0xa1, 0x8d, 0x3d, \ 0x97, 0x00, 0xcf, 0x2b, 0x76, 0x82, 0xd6, 0x1b, 0xb5, 0xaf, 0x6a, 0x50, 0x45, 0xf3, 0x30, 0xef, \ 0x3f, 0x55, 0xa2, 0xea, 0x65, 0xba, 0x2f, 0xc0, 0xde, 0x1c, 0xfd, 0x4d, 0x92, 0x75, 0x06, 0x8a, \ 0xb2, 0xe6, 0x0e, 0x1f, 0x62, 0xd4, 0xa8, 0x96, 0xf9, 0xc5, 0x25, 0x59, 0x84, 0x72, 0x39, 0x4c, \ 0x5e, 0x78, 0x38, 0x8c, 0xd1, 0xa5, 0xe2, 0x61, 0xb3, 0x21, 0x9c, 0x1e, 0x43, 0xc7, 0xfc, 0x04, \ 0x51, 0x99, 0x6d, 0x0d, 0xfa, 0xdf, 0x7e, 0x24, 0x3b, 0xab, 0xce, 0x11, 0x8f, 0x4e, 0xb7, 0xeb, \ 0x3c, 0x81, 0x94, 0xf7, 0xb9, 0x13, 0x2c, 0xd3, 0xe7, 0x6e, 0xc4, 0x03, 0x56, 0x44, 0x7f, 0xa9, \ 0x2a, 0xbb, 0xc1, 0x53, 0xdc, 0x0b, 0x9d, 0x6c, 0x31, 0x74, 0xf6, 0x46, 0xac, 0x89, 0x14, 0xe1, \ 0x16, 0x3a, 0x69, 0x09, 0x70, 0xb6, 0xd0, 0xed, 0xcc, 0x42, 0x98, 0xa4, 0x28, 0x5c, 0xf8, 0x86 C := 0x01, 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, 0x09, \ 0x09, 0x01, 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, \ 0x02, 0x09, 0x01, 0x01, 0x04, 0x01, 0x08, 0x05, \ 0x05, 0x02, 0x09, 0x01, 0x01, 0x04, 0x01, 0x08, \ 0x08, 0x05, 0x02, 0x09, 0x01, 0x01, 0x04, 0x01, \ 0x01, 0x08, 0x05, 0x02, 0x09, 0x01, 0x01, 0x04, \ 0x04, 0x01, 0x08, 0x05, 0x02, 0x09, 0x01, 0x01, \ 0x01, 0x04, 0x01, 0x08, 0x05, 0x02, 0x09, 0x01 # เมทริกซ์ที่สร้างจากเวกเตอร์เริ่มต้น IM := 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0, \ 0, 0, 0, 0, 0, 0, 0, 0 R := 10 func getConstantRoundMatrix(r) cr := IM สำหรับ j ตั้งแต่ 0 ถึง 7 cr[j] := S[8 * (r - 1) + j] สิ้นสุดสำหรับ ส่งคืน cr เอ็นด์ฟันค์ func whirlpoolRound(matrix, key) # ใช้การแปลงแบบไม่เชิงเส้น γ สำหรับ i ตั้งแต่ 0 ถึง 7 สำหรับ j ตั้งแต่ 0 ถึง 7 matrix[i * 8 + j] = S[matrix[i * 8 + j]] สิ้นสุดสำหรับ สิ้นสุดสำหรับ # ใช้การเรียงสับเปลี่ยนแบบวนรอบ π tmp := เมทริกซ์ สำหรับ i ตั้งแต่ 0 ถึง 7 สำหรับ j ตั้งแต่ 0 ถึง 7 # '+ 8' เพื่อป้องกันดัชนีติดลบ matrix[i * 8 + j] = tmp[((i - j + 8) % 8) * 8 + j] สิ้นสุดสำหรับ สิ้นสุดสำหรับ matrix := tmp # ใช้การแพร่เชิงเส้น θ เมทริกซ์ := ผลคูณดอท (เมทริกซ์, C) # ใช้การเพิ่มคีย์ σ[key] เมทริกซ์ := เมทริกซ์ xor คีย์ เมทริกซ์ผลตอบแทน เอ็นด์ฟันค์ ฟังก์ชัน whirlpool(M) m, t := pad(M) # ส่งคืนค่า (paddedMessageDividedInChunks, amountOfChunks) H := IM สำหรับ i ตั้งแต่ 0 ถึง t W := m[t] Kr := H W := W xor H สำหรับ r ตั้งแต่ 1 ถึง R cr := getConstantRoundMatrix(r) Kr := whirlpoolRound(Kr, cr) W := whirlpoolRound(W, Kr) สิ้นสุดสำหรับ H := H xor W H := H xor m[t] สิ้นสุดสำหรับ คืนค่าเมทริกซ์เป็นเลขฐานสิบหก (H) เอ็นด์ฟันค์

สำหรับการแพร่แบบเชิงเส้นจำเป็นต้องใช้การคูณเมทริกซ์สามารถใช้เลขคณิตของฟิลด์กาโลอิส ในการเขียน อัลกอริทึมการคูณ นี้ได้ :${\displaystyle \theta }$

func dotProduct(A, B) tmp: เมทริกซ์ สำหรับ i ตั้งแต่ 0 ถึง 7 สำหรับ j ตั้งแต่ 0 ถึง 7 tmp[i * 8 + j] := 0 สำหรับ k ตั้งแต่ 0 ถึง 7 # การคูณฟิลด์กาโลอิส (2^8) a := A[i * 8 + k]; b := B[k * 8 + j]; ผลิตภัณฑ์ := 0; ในขณะที่ b > 0 ถ้า b และ 1 == 1 ผลิตภัณฑ์ := ผลิตภัณฑ์ xor a จบเงื่อนไข ถ้า a & 0x80 != 0 a := (a << 1) xor 0x11d # x^8 + x^4 + x^3 + x^2 + 1 อื่น a := a << 1 จบเงื่อนไข b := b >> 1 จบในขณะที่ tmp[i * 8 + j] := tmp[i * 8 + j] xor product สิ้นสุดสำหรับ สิ้นสุดสำหรับ สิ้นสุดสำหรับ ส่งคืน tmp เอ็นด์ฟันค์

ต่อไปนี้คือตัวอย่างการใช้งาน การเติมข้อมูลขนาด 512 บิต (ขนาด 64 บิต แบบบิ๊กเอนเดียน ) :

ฟันแพด(M) original_length := len(M) # ในหน่วยไบต์ # 512 บิต (ความยาวทั้งหมด) - 256 บิต (ความยาวตามขนาด) - 1 บิต (บิตสำหรับเติมช่องว่าง) 64 ไบต์ - 32 ไบต์ - 1 ไบต์ = 31 ไบต์ padding := (31 - original_length) % 64 padding := (padding + 64) % 64 # หลีกเลี่ยงการใช้ padding ติดลบ ความยาวทั้งหมด := ความยาวเดิม + 1 + ส่วนเติมเต็ม + 32 # ในหน่วยไบต์ เติมช่องว่าง: ไบต์[ความยาวทั้งหมด] # คัดลอกข้อความต้นฉบับ สำหรับ i ตั้งแต่ 0 ถึง original_length - 1 padded[i] := M[i] สิ้นสุดสำหรับ padded[original_length] := 0x80 # เพิ่มบิต '1' หนึ่งบิต แล้วตามด้วยบิต '0' เจ็ดบิต สำหรับ i ตั้งแต่ original_length + 1 ถึง original_length + padding padded[i] := 0x00 # เพิ่มบิต '0' จำนวน 8 บิต สิ้นสุดสำหรับ สำหรับ i ตั้งแต่ 0 ถึง 31 padded[total_length - 32 + i] := (original_length * 8) >> (8 * (31 - i)) & 0xff สิ้นสุดสำหรับ chunk_amount := total_length / 64 หาร := ไบต์[จำนวนชิ้นส่วน][64] สำหรับ i ตั้งแต่ 0 ถึง chunk_amount - 1 สำหรับ j ตั้งแต่ 0 ถึง 63 divided[i][j] := padded[i * 64 + j] สิ้นสุดสำหรับ สิ้นสุดสำหรับ ส่งคืนแบบแบ่งส่วน, จำนวนชิ้นส่วน เอ็นด์ฟันค์

และนี่คือตัวอย่างของ การแปลง เมทริกซ์เป็นสตริง :

func matrixToHexString(matrix) HEX := "0123456789abcdef" ผลลัพธ์: ไบต์[128] สำหรับ i ตั้งแต่ 0 ถึง 63 ไบต์ := เมทริกซ์[i] ผลลัพธ์[i * 2] := HEX[byte >> 4] result[i * 2 + 1] := HEX[byte & 0xf] สิ้นสุดสำหรับ ส่งคืนผลลัพธ์ เอ็นด์ฟันค์