Twofish

Twofish הוא צופן בלוקים סימטרי שפותח ב-1998 בחברת Counterpane Labs על ידי צוות קריפטוגרפים בראשות ברוס שנייר, על מנת לשמש כמועמד לתקן ההצפנה המתקדם. דורג שלישי בחמשת המועמדים המובילים והפסיד לריינדל. האלגוריתם פועל על בלוקים בגודל 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>.

==תיאור האלגוריתם==
תרשים אלגוריתם 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++ אין צורך בפעולת חישוב כלשהי בהמרה זו ובהמרה האחרונה בסעיף 6, כיוון שניתן להתייחס למצביע הקלט כאל כמצביע לשלם-32 במקום לבתים או להשתמש במבנה 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

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