הצגת המקור של הדף "Twofish"

{{צופן בלוקים
|תמונה=
|תכנון=ברוס שנייר
|פרסום=2000
|מבוסס על=[[Blowfish]], [[SQUARE]]
|גרסאות מתקדמות=[[Threefish]]
|אורך מפתח=128/192/256 סיביות
|אורך בלוק=128 סיביות
|מבנה=[[רשת פייסטל]] מאוזנת
|מספר סבבים=16
|קריפטואנליזה=
}}
'''Twofish''' הוא [[צופן בלוקים]] [[צופן סימטרי|סימטרי]] שפותח ב-1998 בחברת [[Counterpane Labs]] על ידי צוות [[קריפטוגרפיה|קריפטוגרפים]] בראשות [[ברוס שנייר]], על מנת לשמש כמועמד ל[[AES|תקן ההצפנה המתקדם]]. דורג שלישי בחמשת המועמדים המובילים והפסיד ל[[AES#צופן ריינדל|ריינדל]]. האלגוריתם פועל על בלוקים בגודל 128 סיביות וטווח מפתח מ-128 עד 256 סיביות והוא ממוטב למעבדי 32 סיביות. בעת התחרות לתקן הוכרז על ידי [[NIST]] כמו לגבי יתר המועמדים המובילים שלא התגלו בו חולשות ולא ידוע על התקפה יעילה נגדו. הצופן נחשב כממשיכו של [[Blowfish]] וגם הוא חופשי לשימוש ואינו מוגן ב[[זכויות יוצרים]] או [[פטנט]]. הוא בנוי בסגנון [[רשת פייסטל]] בשישה-עשר סבבים וכולל;
*פונקציה [[פונקציה חד-חד-ערכית ועל|חד-חד-ערכית ועל]] המיוצגת על ידי ארבע תיבות החלפה (S-box) לא [[פונקציה ליניארית|ליניאריות]] תלויות מפתח, בגודל 8x8 סיביות.
*הכפלה ב[[מטריצה|מטריצת]] [[MDS]] קיצור של maximum distance separable, שהיא פונקציה ליניארית קבועה 4x4 מעל [[שדה סופי]] <math>F_{2^8}</math> וצמצום ב[[פולינום פרימיטיבי]] קבוע.
*התמרת פסבדו-[[שער אדמר|אדמר]] PHT. פונקציית ערבוב הפועלת על זוגות משתנים בני 32 סיביות כדלהלן; בהינתן <math>a,b</math> הפלט הוא <math>a'=(a+b) \mbox{ mod }2^{32}</math> ו-<math>b'=(a+2b) \mbox{ mod }2^{32}</math>.
*[[הזזה מעגלית]] בסיביות (bitwise rotation), כלומר לאחר כל הזזה סיבית הגלישה הנפלטת מצד אחד מוחזרת מהצד השני.
*[[הלבנה (קריפטוגרפיה)|הלבנה]] שהיא [[XOR]] עם 128 סיביות מהמפתח לפני הסבב הראשון ואחרי הסבב האחרון.
*תהליך הרחבת מפתח המתואר להלן.

יישום ממוטב של האלגוריתם במחשב 32 סיביות צורך כ-18 [[אות שעון|מחזורי שעון]] ל[[בית (מחשב)|בית]] או 1820 מחזורי שעון במעבד 8 סיביות. Twofish ניתן ליישום בחומרה בעלות של 14,000 [[שער לוגי|שערים]]. תהליך הרחבת המפתח וכן סבב ההצפנה מתחשב במגוון אפשרויות כדי לאפשר איזון בין ביצועים לביטחון בהתאם לצורך. ההתקפה הטובה ביותר הידועה כנגד האלגוריתם היא [[התקפת גלוי נבחר]] עם <math>2^{22.5}</math> טקסטים ו-<math>2^{51}</math> ניסיונות בחמשה סבבים בלבד. עם מפתח בגודל 128 סיביות יישום בתוכנה של Twofish איטי מעט בהשוואה לריינדל ואילו עם מפתח 256 סיביות קיים יתרון קל ל-Twofish.

==שיקולי פיתוח==
[[אלגוריתם]] Twofish פותח במיוחד לפי דרישות תקן ההצפנה של [[המכון הלאומי לתקנים וטכנולוגיה]] של [[ארצות הברית]]:
*אורך הבלוק נקבע ל-128 סיביות.
*אורכי מפתח נקבעו ל-128, 192 או 256 סיביות.
*יעילות הן בחומרה והן בתוכנה.
*גמישות; יישום במגוון אפשרויות על פלטפורמות שונות ועם אורכי מפתח שונים וכן התאמה לשימוש כ[[צופן זרם]], [[פונקציית גיבוב]] או [[קוד אימות מסרים]].
*מבנה פשוט המסייע ביישום ובניתוח האלגוריתם.
*מהירות הצפנה של כ-500 מחזורי שעון בגרסה הממוטבת.
*פעולות [[אלגברה|אלגבריות]] פשוטות שאינן מערימות קשיים ביישום בתוכנה או בחומרה.
*ביטחון; ההתקפה הטובה ביותר האפשרית כנגד האלגוריתם במלוא הסבבים תהיה ב[[סיבוכיות]] של לא פחות מ-<math>2^{80}</math>.

==תיאור האלגוריתם==
[[קובץ:TwofishScheme.png|שמאל|ממוזער|450px|תרשים אלגוריתם Twofish. הסמל <math>\oplus</math> מייצג XOR והסמל <math>\boxplus </math> מייצג חיבור מודולו <math>2^{32}</math>. הפונקציה ROL מייצגת הזזה מעגלית שמאלה בסיביות לפי המציין התחתי ואילו ROR מייצג הזזה מעגלית ימינה]]
'''קלט''': 128 סיביות טקסט קריא המיוצגים על ידי 16 בתים <math>p_0,p_1,...,p_{15}</math>, מפתח <math>M</math> בגודל 128, 192 או 256 סיביות.

'''פלט''': 16 בתי צופן <math>c_0, c_1, ..., c_{15}</math>.

1. הקלט מפוצל לארבע [[מילה (מחשב)|מילים]], <math>P_0,P_1,P_2,P_3</math> של 32 סיביות כל אחת לפי [[סדר בתים]] קטן (little-endian) כלומר הספרה הפחות משמעותית מוצבת בבית הראשון שבכתובת הזיכרון. הנוסחה היא:
:<math>\textstyle P_i=\sum_{j=0}^3 p_{(4i+j)}\cdot 2^{8_j}, \ \ \ \ \ i=0,...,3</math>

(הערה: במעבד עם סדר בתים קטן (כמו ב[[ארכיטקטורת x86]]), בשפות [[C (שפת תכנות)|C]] ו-[[C++]]{{D}} אין צורך בפעולת חישוב כלשהי בהמרה זו ובהמרה האחרונה בסעיף 6, כיוון שניתן להתייחס ל[[מצביע]] הקלט כאל כמצביע ל[[טיפוס נתונים#שלמים|שלם-32]] במקום לבתים או להשתמש במבנה [[טיפוס נתונים#טיפוס מאוחד (Union)|Union]], כך שסיביות הקלט והפלט נותרות במקומן).

2. שלב הלבנה; מבצעים XOR עם 4 מילות מהמפתח המורחב <math>K</math> (הכנת המפתח בהמשך):

:<math>R_{0,i}=P_i \oplus K_i, \ \ \ \ \ i=0,...,3</math>

3. בכל סבב מ-16 הסבבים, שתי המילים הראשונות <math>R_0,R_1</math> משמשות כקלט לפונקציה <math>F</math> (להלן) שמקבלת כפרמטר גם את מספר הסבב, המילה השלישית <math>R_2</math> מחוברת ב-XOR עם התוצאה הראשונה של <math>F</math> ולאחר מכן מסובבת בהזזה מעגלית סיבית אחת ימינה. המילה הרביעית <math>R_3</math> מסובבת בהזזה מעגלית שמאלה סיבית אחת ואז מחוברת ב-XOR עם התוצאה השנייה של <math>F</math>. לאחר מכן שני החצאים מחליפים מקומות וחוזר חלילה. באופן פורמלי עבור <math>r=0</math> עד <math>15</math> מבצעים:
<div class="mw-content-ltr">
3.1 <math>(F_{r,0},F_{r,1})=F(R_{r,0},R_{r,1},r)</math>

3.2 <math>R_{r+1,0}=\mbox{ROR}_1(R_{r,2} \oplus F_{r,0})</math>

3.3 <math>R_{r+1,1}=\mbox{ROL}_1(R_{r,3}) \oplus F_{r,1}</math>

3.4 <math>R_{r+1,2}=R_{r,0}</math>

3.5 <math>R_{r+1,3}=R_{r,1}</math>

</div>כאן ROR מייצג Rotate Right שהיא פונקציית הזזה מעגלית לימין במספר סיביות לפי המציין התחתי ו-ROL מייצג Rotate Left.

4. מבצעים החלפה נוספת בין שני חצאי הקלט (למעשה מבטלים את ההחלפה מהסבב האחרון)

5. מבצעים הלבנה נוספת עם ארבע מילות מפתח מורחב נוספות.
<math>C_i=R_{16,(i+2) \mbox{ mod }4} \oplus K_{i+4}, \ \ \ \ i=0,...,3</math>

6. התוצאה מומרת בחזרה ל-16 בתים לפי אותו סדר בתים:
<math>c_i=\left \lfloor \frac{C_{ \left \lfloor i/4 \right \rfloor}}{2^{8(i \mbox{ mod }4)}} \right \rfloor \mbox{ mod }2^8, \ \ \ \ i=0,...,15</math>

===פונקציה F===
הפונקציה <math>F</math> מקבלת שלושה פרמטרים: שתי מילים <math>R_0,R_1</math> ומספר הסבב <math>r</math> שמהווה אינדקס לערך המתאים במפתח המורחב. <math>R_0</math> משמש [[קלט]] לפונקציית <math>g</math> שמתוארת להלן המחזירה את <math>T_0</math>. ו-<math>R_1</math> מסובב בהזזה מעגלית 8 סיביות שמאלה ואז משמש גם הוא קלט לפונקציה <math>g</math> שמחזירה את <math>T_1</math>. התוצאות משולבות יחד באמצעות פונקציית PHT בה מוסיפים שתי מילים מתאימות מהמפתח המורחב לפי <math>r</math>, הפלט הוא הזוג <math>(F_0,F_1)</math> ובניסוח פורמלי:
<div class="mw-content-ltr">
:<math>T_0=g(R_0)</math>

:<math>T_1=g(\mbox{ROL}_8(R_1))</math>

:<math>F_0=(T_0+T_1+K_{2r+8}) \mbox{ mod } 2^{32}</math>

:<math>F_1=(T_0+2T_1+K_{2r+9}) \mbox{ mod } 2^{32}</math>
</div>

===פונקציה g===
הפונקציה <math>g</math> מקבלת כפרמטר מילה אחת <math>X</math> בגודל 32 סיביות, מפצלת אותה לארבעה בתים, כל אחד מהם משמש אינדקס לתיבת ההחלפה המתאימה שמחזירה בית אחר. מייצגים את התוצאות כווקטור באורך 4 מעל השדה <math>F_{2^8}</math> ומכפילים במטריצת MDS בגודל 4x4 (ראו תרשים). התוצאה מומרת בחזרה למילה אחת:
<div style="clear: left; float: left;" border="1">
<math>\mbox{MDS}=\begin{pmatrix} \mbox{01 EF 5B 5B} \\ \mbox{5B EF EF 01} \\ \mbox{EF 5B 01 EF} \\ \mbox{EF 01 EF 5B} \end{pmatrix}</math>
</div>

:<math>x_i=\lfloor X/2^{8i}\rfloor \mbox{ mod }2^8\ \ \ \ \ i=0,...,3</math>

:<math>y_i=s_i[x_i]\ \ \ \ \ i=0,...,3</math>

:<math>\begin{pmatrix} z_0 \\ z_1 \\ z_2 \\ z_3 \end{pmatrix}=\begin{pmatrix} \cdot & \cdots & \cdot \\ \vdots & \mbox{MDS} & \vdots \\ \cdot & \cdots & \cdot \end{pmatrix} \cdot \begin{pmatrix} y_0 \\ y_1 \\ y_2 \\ y_3 \end{pmatrix}</math>

כאשר <math>s_i</math> היא תיבת החלפה ו-<math>Z</math> הוא התוצאה של <math>g</math>. לצורך המרה בין אלמנטים בשדה <math>F_{2^8}</math> לבין בתי הקלט משתמשים בפולינום הפרימיטיבי <math>v(x)=x^8+x^6+x^5+x^3+1</math> ממעלה 8. האלמנט <math>a= \textstyle \sum_{i=0}^7 a_ix^i</math> כאשר מקדמיו בינאריים, מתאים לבית <math>\textstyle \sum_{i=0}^7 a_i2^i</math>. זהו מיפוי טבעי במובן שפעולות חיבור הן בעצם XOR בלבד.

לצורך יעילות ביישום הן בתוכנה והן בחומרה מיישמים את הכפל במטריצה באמצעות סדרת פעולות XOR ו-Shift תוך שימוש בטכניקה שנקראת [[LFSR]], כדלהלן:
<div class="mw-content-ltr">
:<math>z_0=y_0\ \ \oplus \ \ (y_1\ \ \oplus \ \ \mbox{L1} (y_1)\ \ \oplus \ \ \mbox{L2} (y_1))\ \ \oplus \ \ ((y_2\ \ \oplus \ \ \mbox{L2} (y_2))\ \ \oplus \ \ ((y_3 \ \ \oplus \ \ \mbox{L2} (y_3))</math>
:<math>z_1=(y_0\ \ \oplus \ \ \mbox{L2} (y_0))\ \ \oplus \ \ (y_1\ \ \oplus \ \ \mbox{L1} (y_1)\ \ \oplus \ \ \mbox{L2} (y_1))\ \ \oplus \ \ (y_2\ \ \oplus \ \ \mbox{L1} (y_2) \ \ \oplus \ \ \mbox{L2} (y_2))\ \ \oplus \ \ y_3</math>
:<math>z_2=(y_0 \ \ \oplus \ \ \mbox{L1} (y_0)\ \ \oplus \ \ \mbox{L2} (y_0))\ \ \oplus \ \ ((y_1 \ \ \oplus \ \ \mbox{L2} (y_1))\ \ \oplus \ \ y_2 \ \ \oplus \ \ (y_3 \ \ \oplus \ \ \mbox{L1} (y_3)\ \ \oplus \ \ \mbox{L2} (y_3))</math>
:<math>z_3=(y_0 \ \ \oplus \ \ \mbox{L1} (y_0)\ \ \oplus \ \ \mbox{L2} (y_1))\ \ \oplus \ \ y_1\ \ \oplus \ \ (y_2\ \ \oplus \ \ \mbox{L1} (y_2)\ \ \oplus \ \ \mbox{L2} (y_2)) \ \ \oplus \ \ ((y_3 \ \ \oplus \ \ \mbox{L2} (y_3))</math>
</div>
והפונקציות L1, L2 הן אוגרי זיזה (LFSR) הראשון מבוסס על הסיבית הראשונה והשני על הסיביות הראשונה והשנייה והן מוגדרות כך:
<div class="mw-content-ltr">
:<math>\mbox{L1}(x) = (x \gg 1)\ \ \oplus \ \ (x \ \ \mbox{AND} \ \ \mbox{0x01} \ \ ? \ \ \mbox{0xB4} \ \ : \ \ 0)</math>
:<math>\mbox{L2}(x) = (x \gg 2)\ \ \oplus \ \ (x \ \ \mbox{AND} \ \ \mbox{0x02} \ \ ? \ \ \mbox{0xB4} \ \ : \ \ 0)\ \ \oplus \ \ (x \ \ \mbox{AND} \ \ \mbox{0x01} \ \ ? \ \ \mbox{0x5A} \ \ : \ \ 0)</math>

</div> (הסימן <math>\gg</math> מייצג הזזה לימין והסימן AND שנקרא [[וגם (לוגיקה)|וגם]] בודק האם הסיבית המתאימה דולקת, 0x02 היא סיבית LSB השנייה). התוצאה היא המרה של ערכי <math>z_i</math> למילה בגודל 32 סיביות בסדר בתים קטן לפי הנוסחה <math>\textstyle Z=\sum_{i=0}^3 z_i \cdot 2^{8i}</math> (במעבד עם סדר בתים קטן, התוצאה מתקבלת במבנה הרצוי ואין צורך בהמרה כלשהי).

==הרחבת מפתח==
המפתח המורחב מכיל מערך של 40 מילים <math>K_0,...,K_{39}</math> וארבע תיבות החלפה מהפונקציה <math>g</math>. המפתח כאמור יכול להיות <math>N=128</math>, <math>N=192</math> או <math>N=256</math> סיביות. לצורך הכנת המפתח המורחב יהי <math>k=N/64</math>, מכינים מהמפתח מערך <math>M</math> בגודל <math>8k</math> בתים <math>m_0,...,m_{8k-1}</math> (מרפדים באפסים אם נדרש), ממירים ל-<math>2k</math> מילים בגודל 32 סיביות לפי סדר בתים little-endian. ואז ממירים את <math>M</math> לשני וקטורים (זוגי ואי זוגי) כלומר <math>M_e=(M_0,M_2,...,M_{2k-2})</math> וכן <math>M_o=(M_1,M_3,...,M_{2k-1})</math>. וקטור נוסף בגודל <math>k</math> מיוצר מהמפתח בקבוצות של 8 סיביות, אותם מפרשים כווקטור מעל <math>F_{2^8}</math> ומכפילים במטריצה 4x8 של קוד RS ([[ריד-סולומון]]) כמתואר בתרשים להלן. פעולת הכפל במטריצה נראית כך:

<div style="clear: left; float: left;" border="1">
<math>\text{RS}=\begin{pmatrix} \text{01 A4 55 87 5A 58 DB 9E} \\ \text{A4 56 82 F3 1E C6 68 E5} \\ \text{02 A1 FC C1 47 AE 3D 19} \\ \text{A4 55 87 5A 58 DB 9E 03} \end{pmatrix}</math>
</div>

:<math>\begin{pmatrix} s_{i,0} \\ s_{i,1} \\ s_{i,2} \\ s_{i,3} \end{pmatrix}=\begin{pmatrix} \cdot & \cdots & \cdot \\ \vdots & \mbox{RS} & \vdots \\ \cdot & \cdots & \cdot \end{pmatrix} \cdot \begin{pmatrix} m_{8i} \\ m_{8i+1} \\ m_{8i+2} \\ m_{8i+3} \\ m_{8i+4} \\ m_{8i+5} \\ m_{8i+6} \\ m_{8i+7} \end{pmatrix}</math>

ואז מחשבים עבור <math>i=0,...,k-1</math> בסדר הפוך <math>S = (S_{k-1},S_{k-2},...,S_0)</math>:

:<math>S_i=\sum_{j=0}^3 s_{i,j}\cdot 2^{8j}</math>

להכפלה במטריצה בשיטת [[ריד-סולומון]], משתמשים בפולינום פרימיטיבי <math>w(x)=x^8+x^6+x^3+x^2+1</math>.

שלושת הווקטורים <math>M_e,M_o,S</math> הם הבסיס לתהליך הרחבת המפתח.

===פונקציה h===
הפונקציה המשמשת להרחבת המפתח מקבלת פרמטר <math>X</math> בגודל 32 סיביות ורשימה <math>L=(L_0,...,L_{k-1})</math> של מילות 32 סיביות באורך <math>k</math> ומפיקה מילה אחת. הפונקציה פועלת באופן איטרטיבי <math>k</math> שלבים, בכל שלב 4 בתים עוברים בתיבות החלפה קבועות ומחוברים ב-XOR עם בתים מהרשימה <math>L</math> ולסיום מועברים שוב בתיבות ההחלפה ומוכפלים במטריצת MDS. כדלהלן:
תחילה מפצלים לבתים כאשר <math>i=0,...,k-1</math> ו-<math>j=0,...,3</math>:

:<math>l_{u,j}=\left \lfloor L_i/2^{8j} \right \rfloor \mbox{ mod }2^8</math>

:<math>x_j=\left \lfloor X/2^{8j} \right \rfloor \mbox{ mod }2^8</math>

בשלב החלפה ו-XOR תחילה מציבים <math>y_{k,j}=x_j</math> כאשר <math> j=0,...,3</math> ואז מחשבים לפי ערך <math>k</math>:

:{| class="wikitable"
|-
! <math>k = 4</math> !! <math>k \ge 3</math>!! In all cases
|-
| <math>y_{3,0} = q_1[y_{4,0}] \oplus l_{3,0}</math> || <math>y_{2,0} = q_1[y_{3,0}] \oplus l_{2,0}</math> || <math>y_0 = q_1[q_0[q_0[y_{2,0}] \oplus l_{1,0}] \oplus l_{0,0}]</math>
|-
| <math>y_{3,1} = q_0[y_{4,1}] \oplus l_{3,1}</math> || <math>y_{2,1} = q_1[y_{3,1}] \oplus l_{2,1}</math> || <math>y_1 = q_0[q_0[q_1[y_{2,1}] \oplus l_{1,1}] \oplus l_{0,1}]</math>
|-
| <math>y_{3,2} = q_0[y_{4,2}] \oplus l_{3,2}</math> || <math>y_{2,2} = q_0[y_{3,2}] \oplus l_{2,2}</math> || <math>y_2 = q_1[q_1[q_0[y_{2,2}] \oplus l_{1,2}] \oplus l_{0,2}]</math>
|-
| <math>y_{3,3} = q_1[y_{4,3}] \oplus l_{3,3}</math> || <math>y_{2,3} = q_0[y_{3,3}] \oplus l_{2,3}</math> || <math>y_3 = q_0[q_1[q_1[y_{2,3}] \oplus l_{1,3}] \oplus l_{0,3}]</math>
|}

כאשר <math>q_0, q_1</math> הן תמורות קבועות של ערכים בגודל 8 סיביות המוגדרות להלן.
הווקטור <math>y_i</math> מוכפל במטריצת MDS כמו בפונקציה <math>g</math> לעיל:

:<math>\begin{pmatrix} z_0 \\ z_1 \\ z_2 \\ z_3 \end{pmatrix}=\begin{pmatrix} \cdot & \cdots & \cdot \\ \vdots & \mbox{MDS} & \vdots \\ \cdot & \cdots & \cdot \end{pmatrix} \cdot \begin{pmatrix} y_0 \\ y_1 \\ y_2 \\ y_3 \end{pmatrix}</math>

:<math>Z=\sum_{i=0}^3 z_i \cdot 2^{8i}</math>

===תיבות החלפה S-box===
כאמור תיבות ההחלפה תלויות במפתח, ליתר דיוק בווקטור <math>S</math> שהוכן מהמפתח לעיל. דהיינו ארבע התיבות מחושבות מתוך <math>x_i,y_i</math> עבור <math>i=0,...,3</math> בפונקציה <math>h</math> כאשר הרשימה <math>L</math> היא <math>S</math> בתמציתיות: <math>g(X)=h(X,S)</math>.

===המפתח המורחב K===
עם השלמת הגדרת הפונקציה <math>h</math>, אפשר להשלים את תהליך הרחבת המפתח כדלהלן:
<div class="mw-content-ltr">
:<math> \rho=2^{24}+2^{16}+2^8+1</math>

:<math> A_i=h(2i\rho,M_e)</math>

:<math> B_i=\mbox{ROL}(h((2i+1)\rho,M_o),8)</math>

:<math> K_{2i}=(A_i+B_i)\mbox{ mod }2^{32}</math>

:<math> K_{2i+1}=\mbox{ROL}((A_i+2B_i)\mbox{ mod }2^{32},9)</math>
</div>
הקבוע <math>\rho</math> משמש כאן להכפלת בתים, התכונה שלו היא שהמילה <math>i\rho </math> מורכבת מארבעה בתים שווים בערכם ל-<math>i</math>. שימו לב שנעשה שימוש בהזזה מעגלית, בווקטורים <math>M_e,M_o</math> ובפונקציית PHT. התמורות הקבועות <math>q_0</math> ו-<math>q_1</math> מחושבות מתוך 4 תמורות שונות, עבור קלט <math>x</math> מחשבים את הפלט <math>y</math> על ידי:
<div class="mw-content-ltr">
:<math> a_0,b_0=\left \lfloor x/16 \right \rfloor, x\mbox{ mod }16</math>

:<math> a_1=a_0 \oplus b_0</math>

:<math> b_1=a_0 \oplus \mbox{ROR}_4(b_0,1) \oplus 8a_0 \mbox{ mod }16</math>

:<math> a_2,b_2=t_0[a_1],t_1[b_1]</math>

:<math> a_3=a_2 \oplus b_2</math>

:<math>b_3=a_2\oplus \mbox{ROR}_4(b_2,1) \oplus 8a_2 \mbox{ mod }16</math>

:<math>a_4,b_4=t_2[a_3],t_3[b_3]</math>

:<math>y=16b_4+a_4</math>
</div>
תחילה מפצלים את הבית לשני ניבלים, שעוברים שלב ערבוב עם [[פונקציה חד-חד-ערכית]] ועל, כל ניבל עובר בנוסף בתיבת החלפה של 4 סיביות קבועה משלו ואז מאחדים את הניבלים. תיבות ההחלפה 4-סיביות הן:

{| class="wikitable"
|-
! <math>q_0</math> !! <math>q_1</math>
|-
| <math>t_0 = [ \mbox{817D6F320B59ECA4} ]</math> || <math>t_0 = [ \mbox{28BDF76E31940AC5} ] </math>
|-
| <math>t_1 = [ \mbox{ECB81235F4A6709D} ]</math> || <math>t_1 = [ \mbox{1E2B4C376DA5F908} ] </math>
|-
| <math>t_2 = [ \mbox{BA5E6D90C8F32471} ]</math> || <math>t_2 = [ \mbox{4C75169A0ED82B3F} ] </math>
|-
| <math>t_3 = [ \mbox{D7F4126E9B3085CA} ]</math> || <math>t_3 = [ \mbox{B951C3DE647F208A} ] </math>
|}

===פענוח===
צופן Twofish משתמש בתהליך הכנה מעט שונה עבור פענוח. השוני הוא בסדר ההפוך של המפתח המורחב <math>K</math>. בגרסאות הממוטבות ביישום האלגוריתם בפועל, נמנעים בדרך כלל מפעולות אריתמטיות מסובכות, אותם מחליפים בטבלאות החלפה פשוטות בהם הערכים קודדו מראש בהתאם. ובמקרה של יישום בחומרה מוגבלת כמו [[כרטיס חכם]], מפרקים פעולות לפקודות בסיסיות ביותר כמו Shift ו-XOR, לעיתים על חשבון יעילות.

==ראו גם==
* [[AES]]
* [[Threefish]]

==קישורים חיצוניים==
* [[ברוס שנייר]], [https://www.schneier.com/twofish.html Twofish], Schneier on Security

{{קריפטוגרפיה}}

[[קטגוריה:צפני בלוקים]]