FEAL

בקריפטוגרפיה, FEAL (ראשי תיבות של Fast data Encipherment ALgorithm, בעברית: אלגוריתם הצפנת נתונים מהיר) כולל משפחה של צפני בלוקים במבנה פייסטל שהראשון שבהם הוצע כאלטרנטיבה לצופן DES והוא מהיר ממנו בתוכנה. הגרסה הראשונה פותחה ב-1987 על ידי אקירו שימיזו ושוי מיאגוטשי מתאגיד הטלגרף והטלפון של יפן (NTT). ב-1994 התקבל הצופן לתקן בין-לאומי ISO/IEC9979 וב-1999 נבחר לתקן ATM וכן נכלל בתקן יפני לכרטיסים חכמים ב-1998. בשל קריפטואנליזה שמעידה על חולשות הצופן אינו בשימוש כיום. NTT ממליצים להשתמש בצופן מדור חדש כמו קמליה.

קיימות מספר גרסאות של FEAL כולן במבנה פייסטל עם אותה פונקציית סבב פנימית אך עם מספר סבבים שונה או עם מפתח גדול יותר. הצופן מקבל בלוק קלט באורך 64 סיביות ומחזיר בלוק מוצפן באורך 64 סיביות. הגרסה הראשונה שכיום נקראת FEAL-4 משתמשת במפתח הצפנה באורך 64 סיביות וכוללת ארבעה סבבים של הפונקציה הפנימית. FEAL-8 מכיל שמונה סבבים עם אותו מפתח ואילו FEAL-NX מכילה מספר דינאמי של סבבים בהתאם לצורך כך ש-<math>N\ge 8</math>. (המספר המומלץ הוא <math>N=32</math>) ואילו "X" מתייחס לאופציה של מפתח באורך 128 סיביות שנוספה בגרסה המאוחרת יותר.

==ביטחון==
מאז שפורסם הפך FEAL ליעד מועדף מצד קריפטונאליסטים מרחבי העולם ופורסמו מחקרים רבים אודות החולשות שלו. כיום ידוע שהצופן אינו בטוח לשימוש כי הוא פגיע במיוחד למספר התקפות קריפטוגרפיות מעשיות ביניהן קריפטואנליזה דיפרנציאלית וקריפטואנליזה ליניארית. למעשה הצופן שימש כ"קטליזטור" במהלך פיתוח התקפות קריפטוגרפיות אילו. הקריפטואנליזה הדיפרנציאלית הומצאה בשביל לפצח את FEAL ובתוך כך התגלתה ככלי יעיל לניתוח צפנים אחרים. כל גרסאות צופן FEAL אינן מומלצות כיום לשימוש כלל והעניין בהן הוא אקדמי בלבד.

בתחילה התגלו בעיות בגרסה הראשונה של הצופן על ידי דן בואר ושון מרפי שגילו התקפות קריפוטאנליטיות הדורשות כמות מועטה של טקסטים גלויים נבחרים כדי לפצח את הצופן בקלות. ההתקפות שלהם מכילות אלמנטים דומים להתקפה הדיפרנציאלית שהתגלתה מאוחר יותר. ב-1998 ניסו מפתחי הצופן לפתור את הבעיה על ידי העלאת מספר הסבבים וכך נוצר FEAL-8 הכולל שמונה סבבים במקום ארבעה.

ב-1991 פרסמו אלי ביהם ועדי שמיר את ההתקפה הדיפרנציאלית שלהם על FEAL-8. אחריהם פורסמו עוד כמה התקפות מסוג זה שמצליחות לפצח את הצופן עם כמות יחסית קטנה של טקסטים גלויים נבחרים. בתגובה פותח FEAL-NX אך הסתבר שההתקפה הדיפרנציאלית של שמיר וביהם הייתה ישימה גם נגד הגרסה הזו שהיא החזקה ביותר שפותחה, ההתקפה שלהם יעילה מכוח גס כל עוד <math>N\le 31</math>.

ב-1991 גילו טארדי וגילברט התקפה חדשה נגד גרסאות צופן FEAL שמסוגלת לפצח אותו בסיבוכיות טובה מכוח גס. למשל FEAL-8 ניתן בשיטה זו לשבירה עם <math>2^{15}</math> טקסטים גלויים נבחרים. מאוחר יותר פרסם מיצורו מצואי את ההתקפה הליניארית שמבוססת על רעיון זה המסוגלת לשבור את צופן FEAL-4 בתוך כחמש דקות עם שישה טקסטים גלויים ידועים. ב-1994 פורסמה התקפה ליניארית נגד FEAL-8 עם <math>2^{12}</math> טקסטים גלויים נבחרים. למעשה בעקבות התקפות אילו נסתם הגולל על FEAL והוא אינו בשימוש כיום כלל. NTT ממליצים להשתמש בקמליה במקומו.

חשיבות הצופן וההתקפות המתוארות היא בעיקר בלקח שאפשר להפיק מהם. זהו הצופן הראשון שפותח על ידי NTT ושימש יסוד ובסיס להתפתחות צפני בלוקים מודרניים חזקים יותר ועמידים יותר נגד קריפטואנליזה דיפרנציאלית וליניארית כמו E2 שהיה מהמועמדים לתקן AES ולא הגיע לגמר וקמליה שנחשב לצופן מודרני חזק.

==פירוט מהלכי הצופן==
תיאור סכמתי של צופן FEAL
להלן תיאור צופן FEAL-NX כאשר <math>N\ge 32</math>. הוא מקבל מפתח באורך 64 או 128 סיביות לפי בחירת המשתמש ופועל על בלוק גלוי באורך 8 בתים. באופן כללי האלגוריתם מבצע שלושה מהלכים:
# קדם עיבוד שנקרא גם הלבנה.
# פונקציה איטרטיבית
# חישוב מסיים

בשלב ההכנה הנקרא קדם-עיבוד, בלוק הטקסט הגלוי <math>P</math> מחולק לשני חצאים <math>(R_0,L_0)</math> באורך 32 סיביות כל אחד. תחילה מבצעים:
:<math>(L_0,R_0)\leftarrow(L_0,R_0)\oplus(K_{N},K_{N+1},K_{N+2},K_{N+3})</math>
כלומר מחברים ב-XOR עם ארבעה תת-מפתחות מתאימים. כל תת-מפתח באורך 16 סיביות לכן כל מחצית מהבלוק מחוברת עם שני תת-מפתחות ואז
:<math>(L_0,R_0)\leftarrow(L_0,R_0)\oplus(\phi,L_0)</math>
כאשר הסימן <math>\phi</math> מייצג בלוק המכיל 32 אפסים, הסימן <math>\oplus</math> הוא XOR ו-<math>K_i</math> מייצג את תת-המפתחות מתהליך ההכנה המתואר להלן. המשמעות של המהלך הוא שהמחצית הימנית היא תוצאה של XOR עם המחצית השמאלית. לפעולת XOR עם אפסים אין השפעה לכן המחצית השמאלית נותרת ללא שינוי.

בשלב האיטרציה, הקלט <math>(L_0,R_0)</math> משלב ההכנה עובר עיבוד עם הפונקציה <math>f</math> בסך הכול <math>N</math> פעמים:
:<math>R_r\leftarrow L_{r-1}\oplus f(R_{r-1},K_{r-1})</math>
:<math>L_r=R_{r-1}</math>

כאשר <math>1 \le r\le N</math>. הפונקציה <math>f</math> מתוארת להלן והפלט הוא התוצאה מהסבב האחרון <math>(L_N,R_N)</math>.

בשלב הסיום, מחליפים בין החצאים של הפלט האחרון <math>(R_N,L_N)\leftarrow(L_N,R_N)</math> ואז מחשבים את:
:<math>(R_N,L_N)\leftarrow (R_N,L_N)\oplus(\phi,R_N)</math>
ולסיום מחברים עם חלקים מתאימים מהמפתח:
:<math>(R_N,L_N)\leftarrow (R_N,L_N)\oplus(K_{N+4},K_{N+5},K_{N+6},K_{N+7})</math>

הטקסט המוצפן הוא <math>C=(R_N,L_N)</math>.

===אלגוריתם הפענוח===
תהליך הפענוח דומה, הקלט <math>(R_N,L_N)</math> מעובד תחילה על ידי:
:<math>(R_N,L_N)\leftarrow (R_N,L_N)\oplus(K_{N+4},K_{N+5},K_{N+6},K_{N+7})</math>
ואז
:<math>(R_N,L_N)\leftarrow (R_N,L_N)\oplus(\phi,R_N)</math>
לאחר מכן מבצעים <math>N</math> פעמים:
:<math>L_{r-1}\leftarrow R_r\oplus f(L_r,K_{r-1})</math>
:<math>R_{r-1}\leftarrow L_r</math>

כדי לקבל את הטקסט המקורי תחילה מבצעים:
:<math>(L_0,R_0)\leftarrow (L_0,R_0)\oplus(\phi,L_0)</math>
לסיום מחשבים את:
:<math>(L_0,R_0)\leftarrow (L_0,R_0)\oplus(K_{N},K_{N+1},K_{N+2},K_{N+3})</math>

שימו לב שמחברים ארבעה תת-מפתחות כי תת-מפתח הוא באורך 16 סיביות ולכן נדרשים ארבעה כדי לחבר עם <math>(L_0,R_0)</math> שהוא באורך 64 סיביות (8 בתים).

===תהליך הכנת המפתח===
<div class="mw-content-ltr" style="clear: left; float: left>
<syntaxhighlight lang="cpp">
#define ROTL(x, n) (byte)(((byte)(x) << (n)) | ((byte)(x) >> (8-(n))))
#define S0(x, y) (byte)(ROTL(((byte)((x) + (y) )), 2))
#define S1(x, y) (byte)(ROTL(((byte)((x) + (y) + 1)), 2))

void FEAL_Fk(byte *a, byte *b)
{
	a[1] ^= a[0], a[2] ^= a[3];
	byte t;
	t = a[2] ^ b[0], a[1] = S1(a[1], t);
	t = a[1] ^ b[1], a[2] = S0(a[2], t);

	t = a[1] ^ b[2], a[0] = S0(a[0], t);
	t = a[2] ^ b[3], a[3] = S1(a[3], t);
}
void FEAL_F(byte *a, byte *b, byte *e)
{
	a[1] = (b[0] ^ b[1] ^ e[0]);
	a[2] = (b[2] ^ b[3] ^ e[1]);

	a[1] = S1(a[1], a[2]);
	a[2] = S0(a[1], a[2]);

	a[0] = S0(b[0], a[1]);
	a[3] = S1(b[3], a[2]);
}
</syntaxhighlight>
<div class="mw-content-rtl">קוד C++{{D}} של הפונקציות הפנימיות <math>f</math> ו-<math>f_k</math></div>
</div>
מהמפתח הסודי המסופק על ידי המשתמש מכינים <math>N+8</math> תת-מפתחות מסומנים <math>K_0,K_1,K_2,...,K_{N+7}</math> כל אחד באורך 16 סיביות (שני בתים), כאשר <math>N</math> מהם משמשים לצורך הפונקציה הפנימית, מפתח אחד לכל סבב ואילו 8 הנוספים משמשים לפעולת ההלבנה (חיבור ב-XOR), ארבעה מהם לפני האיטרציה של הפונקציה הפנימית וארבעה לאחריה. תחילה המפתח מחולק לשני חצאים <math>(K_L,K_R)</math> באורך 64 סיביות כל אחד.

את החצי הימני <math>K_R</math> מחלקים לשני חצאים <math>(K_{R1},K_{R2})</math> ומכינים סדרה של משתנים מקומיים בהתאם למספר הסבבים <math>Q_r</math> בהם מציבים עבור <math>i=0,1,2,...</math>:
:<math>Q_r\leftarrow K_{R1}\oplus K_{R2}</math> כאשר <math>r=3i+1</math>,
:<math>Q_r\leftarrow K_{R1}</math> כאשר <math>r=3i+2</math>,
:<math>Q_r\leftarrow K_{R2}</math> כאשר <math>r=3i+3</math>
<math>r</math> נמוך מ-<math>(N/2)+4</math> ו-<math>N\ge 32</math> כאשר <math>N</math> זוגי.

את החצי השמאלי <math>K_L</math> מחלקים לשני חצאים <math>(A_0,B_0)</math> ומכינים משתנה מקומי ריק <math>D_0</math>. את <math>K_i</math> כאשר <math>i=0</math> עד <math>N+7</math> מכינים עם <math>r=1</math> עד <math>(N/2)+4 </math> כדלהלן:
{| dir="ltr"
|-
|
:<math>D_r=A_{r-1},A_r=B_{r-1}</math>,
:<math>B_r=f_K(\alpha,\beta)=f_K(A_{r-1}(B_{r-1}\oplus D_{r-1})\oplus Q-r))</math>,
:<math>K_{2(r-1)}=(B_{r0},B_{r1})</math>,
:<math>K_{2(r-1)+1}=(B_{r2},B_{r3})</math>
|}
<math>B_r</math> הוא משתנה מקומי המחולק לארבעה בתים <math>B_{r0},B_{r1},B_{r2},B_{r3}</math>.

===פונקציות עזר===
תיאור הפונקציה הפנימית
הפונקציה <math>f</math> מגיעה בשתי גרסאות אחת עבור פונקציית הסבב הפנימית והשנייה עבור הכנת המפתח. הפונקציה <math>f(\alpha,\beta)</math> המשמשת לצורך פונקציית הסבב מקבלת שני פרמטרים הראשון באורך 32 סיביות והשני באורך 16 סיביות, כאשר <math>\alpha</math> מחולק לארבעה בתים: <math>\alpha=(\alpha_0,\alpha_1,\alpha_2,\alpha_3)</math> ו-<math>\beta</math> מחולק לשני בתים <math>\beta=(\beta_0,\beta_1)</math>. פלט הפונקציה כמתואר בתרשים משמאל, הוא <math>f=(f_0,f_1,f_2,f_3)</math> כדלהלן:
{| dir="ltr"
|-
|
:<math>f_1 =\alpha_1 \oplus \beta_0, f_2 =\alpha_2 \oplus \beta_1</math>
:<math>f_1 = f_1 \oplus \alpha_0, f_2 = f_2 \oplus \alpha_3</math>
:<math>f_1 = S_1 (f_1, f_2), f_2 = S_0 (f_2, f_1)</math>
:<math>f_0 = S_0 (\alpha_0, f_1), f_3 = S_1 (\alpha_3, f_2)</math>.
|}
הפונקציה <math>f_K(\alpha,\beta)</math> מקבלת שני פרמטרים באורך 32 סיביות כל אחד וכן תת-מפתח באורך 16 סיביות. הפרמטרים <math>\alpha,\beta</math> מחולקים לבתים כך: <math>\alpha=(\alpha_0,\alpha_1,\alpha_2,\alpha_3)</math> וכן <math>\beta=(\beta_0,\beta_1,\beta_2,\beta_3)</math> ואז הפונקציה מחשבת ומחזירה את ארבעת הערכים <math>(f_{K0},f_{K1},f_{K2},f_{K3})</math>, כדלהלן:
תיאור הפונקציה f בתהליך הכנת המפתח
{| dir="ltr"
|-
|
:<math>f_{K1} = \alpha_1 \oplus \alpha_0</math>
:<math>f_{K2} = \alpha_2 \oplus \alpha_3</math>
:<math>f_{K1} = S_1 (f_{K1}, (f_{K2} \oplus \beta_0))</math>
:<math>f_{K2} = S_0 (f_{K2}, (f_{K1} \oplus \beta_1))</math>
:<math>f_{K0} = S_0 (\alpha_0, (f_{K1} \oplus \beta_2))</math>
:<math>f_{K3} = S_1 (\alpha_3, (f_{K2} \oplus \beta_3))</math>
|}
הפונקציות <math>S_0</math> ו-<math>S_1</math> מוגדרות כדלהלן:
{| dir="ltr"
|-
|
:<math>S_0(X_1, X_2)=\text{ROT2}((X_1 + X_2)\text{ mod }256)</math>
:<math>S_1(X_1, X_2)=\text{ROT2}((X_1 + X_2 + 1)\text{ mod }256)</math>
|}
כאשר <math>X_1</math> ו-<math>X_2</math> הם בתים והפונקציה ROT2 היא הזזה מעגלית לשמאל שתי סיביות, לדוגמה בהינתן <math>X_1=00010011</math> ו-<math>X_2=11110010</math> אז <math>T=(X_1+X_2+1)\text{ mod }256=0000110</math> וכן <math>S_1(X_1,X_2)=00011000</math> בבסיס בינארי.

==קוד לדוגמה==
<syntaxhighlight lang="cpp">
void FEAL_keygen(byte *k, byte *e, uint r)
{
	byte a[4], b[4], d[4], kr1[4], kr2[4], t, s[4];

	for (uint i = 0; i < 4; i++) {
		a[i] = k[i], b[i] = k[i + 4];
		kr1[i] = k[i + 8], kr2[i] = k[i + 12];
		d[i] = 0;
	}

	for (uint i = 0; i < r + 8; i += 2) {
		for (uint j = 0; j < 4; j++) {
			s[j] = b[j];
			if ((i / 2) % 3 == 0) {
				s[j] ^= (kr1[j] ^ kr2[j]);
			}
			else if ((i / 2) % 3 == 1) {
				s[j] ^= kr1[j];
			}
			else {
				s[j] ^= kr2[j];
			}
			s[j] ^= d[j];
			d[j] = a[j]; /* for next steps */
		}
		FEAL_Fk(a, s);

		for (uint j = 0; j < 4; j++) {
			e[2 * i + j] = a[j];
		}

		for (uint j = 0; j < 4; j++) {
			t = a[j];
			a[j] = b[j], b[j] = t;
		}
	}
}

void FEAL_encrypt(byte *p, uint r, byte *e, byte *c)
{
	byte a[4], b[4], t, s[4];

	for (uint j = 0; j < 4; j++) {
		a[j] = p[j] ^ e[2 * r + j];
		b[j] = p[j + 4] ^ e[2 * r + j + 4] ^ a[j];
	}

	for (uint i = 0; i < r; i++) {
		FEAL_F(s, b, e + 2 * i);

		for (uint j = 0; j < 4; j++) {
			a[j] ^= s[j];
		}

		for (uint j = 0; j < 4; j++) {
			t = a[j];
			a[j] = b[j], b[j] = t;
		}
	}

	for (uint j = 0; j < 4; j++) {
		a[j] ^= b[j];
	}

	for (uint j = 0; j < 4; j++) {
		c[j] = (b[j] ^ e[2 * r + j + 8]);
		c[j + 4] = (a[j] ^ e[2 * r + j + 12]);
	}
}

void FEAL_decrypt(byte *c, uint r, byte *e, byte *p)
{
	byte a[4], b[4], t, s[4];

	for (uint j = 0; j < 4; j++) {
		a[j] = c[j] ^ e[2 * r + j + 8];
		b[j] = c[j + 4] ^ e[2 * r + j + 12] ^ a[j];
	}

	for (uint i = 0; i < r; i++) {
		FEAL_F(s, b, e + 2 * (r - 1 - i));

		for (uint j = 0; j < 4; j++) {
			a[j] ^= s[j];
		}

		for (uint j = 0; j < 4; j++) {
			t = a[j];
			a[j] = b[j], b[j] = t;
		}
	}

	for (uint j = 0; j < 4; j++) {
		a[j] ^= b[j];
	}

	for (uint j = 0; j < 4; j++) {
		p[j] = (b[j] ^ e[2 * r + j]);
		p[j + 4] = (a[j] ^ e[2 * r + j + 4]);
	}
}
</syntaxhighlight>

==קריפטואנליזה דיפרנציאלית של FEAL-4==
קריפטואנליזה דיפרנציאלית פועלת לפי מודל התקפת גלוי-נבחר, כלומר המתקיף רשאי לבחור זוגות של טקסטים גלויים וטקסטים מוצפנים המתאימים להם שהוצפנו עם מפתח שאינו ידוע לו ותפקידו הוא לגלות את המפתח הסודי ששימש להצפנתם. המתקיף בוחר את הטקסטים באופן כזה שהדיפרנציאל (ההפרש) שלהם עונה על "מאפיין" מסוים המתאים לצורך ההתקפה. כאן הדיפרנציאל הוא מעל פעולת XOR ולכן הדברים נעשים פשוטים יותר כי בגלל התכונה הידועה שאם מבצעים XOR בין שני טקסטים מוצפנים שהוצפנו עם אותו קטע מהמפתח למעשה מבטלים את השפעת המפתח כאילו לא היה קיים (ראו פנקס חד-פעמי). במקרה של FEAL-4 התגלתה עובדה מעניינת: נתונה הפונקציה הפנימית של הצופן <math>F</math>, עבור כל זוג טקסטים <math>A_0</math> ו-<math>A_1</math> אם <math>A_0\oplus A_1=\text{0x808000000}</math> (בבסיס הקסדצימלי) אז מתקיים <math>F(A_0)\oplus F(A_1)=\text{0x02000000}</math>. למרבה ההפתעה זהו דיפרנציאל בעל הסתברות של 1 שלא קשה לחשב והוא משמש לשבירת הצופן. 

FEAL-4 זהה לתיאור FEAL-XN למעט העובדה שהפונקציה הפנימית מבוצעת רק 4 פעמים ותהליך הכנת מפתח שונה. אפשר להציג את הצופן בכמה דרכים, אולם לצורך הקריפטואנליזה הדיפרנציאלית שלו הוא מוצג כאן בדרך קצת שונה מהקודמת (קל להוכיח ששתיהן למעשה שקולות). המפתח מחולק לשישה תת-מפתחות באורך 32 סיביות כל אחד (במקום 12 תת-מפתחות באורך 16 סיביות בתיאור המקורי). אפשר להתעלם מתהליך הכנת המפתח כולו כי ההתקפה מתמקדת בשחזור תת-המפתחות ואם מצליחים לנחש אותם אז אפשר לשחזר את המפתח הסודי בקלות. פונקציית הסבב הפנימית <math>F</math> מקבלת ארבעה בתים <math>(x_0,x_1,x_2,x_3)</math> ומחזירה ארבעה בתים <math>(y_0,y_1,y_2,y_3)</math>, היא עושה שימוש בפונקציות <math>S_0</math> ו-<math>S_1</math> המתוארות לעיל והיא נראית כך:
{| dir="ltr"
|-
| 
:<math>y_1=S_1(x_0\oplus x_1, x_2\oplus x_3)</math>
:<math>y_0=S_0(x_0,y_1)</math>
:<math>y_2=S_0(y_1,x_2\oplus x_3)</math>
:<math>y_3=S_1(y_2,x_3)</math>
|}
תיאור ההתקפה הדיפרנציאלית על צופן FEAL-4
לצורך ההתקפה המתקיף בוחר טקסט גלוי אקראי <math>P_0</math> ומחשב את הטקסט הגלוי <math>P_1</math> המקיים <math>P_1=P_0\oplus \text{0x8080000080800000}</math> וכן מניחים (לפי הגדרת מודל ההתקפה) שהמתקיף השיג את הטקסטים המוצפנים המתאימים להם <math>C_0</math> ו-<math>C_1</math> בהתאמה ואז הוא מחשב את הדיפרנציאלים שלהם <math>P'=P_0\oplus P_1</math> וכן <math>C'=C_0\oplus C_1</math> וכן מחשב את הדיפרנציאלים של כל ערכי הביניים של הצופן המתקבלים משני הטקסטים שהוצפנו <math>P_0</math> ו-<math>P_1</math> ומה שמתקבל מופיע בתרשים משמאל. העובדה שהמפתח לא מופיע בתרשים אינה טעות, כיוון שמדובר על דיפרנציאל של שני טקסטים שהוצפנו עם אותו מפתח לכן אפשר להתעלם ממנו כרגע. הדיפרנציאל האמור יחד עם הטקסטים הידועים עוזר לגלות את המפתח בשלב הבא של ההתקפה. אם מנסים לנוע בכיוון ההפוך בשיטת היפגשות באמצע, כלומר מנסים לחשב את ערכי הביניים מהטקסט המוצפן כלפי מעלה, רואים שיש אפשרות להשיג את הקלט והפלט לפונקציה הפנימית <math>F</math> במהלך האחרון של הצופן. כי <math>C_0</math> ו-<math>C_1</math> ידועים וכן אפשר לחשב את הדפירנציאלים <math>C', L', R'</math> כך שמתקיים <math>L'=\text{0x2000000}\oplus Z'</math> וכן <math>R'=L'\oplus Y'</math> מה שמאפשר לחשב את <math>Y'=\text{0x80800000}\oplus X'</math>. היות שהטקסט המוצפן ידוע מתקבל <math>Y=L\oplus R</math>. 

עם כל המידע הזה אפשר לפצח את הצופן תחילה על ידי ניחוש תת-המפתח השלישי <math>K_3</math>. מחשבים את <math>Z'</math> ואז מחשבים את <math>Y_0</math> ו-<math>Y_1</math> (המתאימים ל-<math>C_0</math> ו-<math>C_1</math>) אותם אפשר להשיג על ידי חישוב מהסוף להתחלה. היות ש-<math>K_3</math> הוא באורך 32 סיביות ישנם למעשה <math>2^{32}</math> ערכים אפשריים. אם נסמן ניחוש אחד ב-<math>\tilde K_3</math>, אז בידיעת <math>Y_0</math> אפשר לחשב את <math>\tilde Z_0</math> ובידיעת <math>Y_1</math> אפשר לחשב את <math>\tilde Z_1</math> כך שיתקבל <math>Z'=\tilde Z_0\oplus\tilde Z_1</math>. אם המשוואה הזו מתקיימת אז הניחוש הצליח ו-<math>\tilde K_3</math> הוא "מועמד" מתאים ושומרים אותו. היות שיכולים להיות מועמדים רבים שמקיימים את התנאי האמור, יש צורך לבדוק נכונות מול זוגות טקסטים נוספים. אם בודקים לפחות עם ארבעה זוגות כאלה הסיכויים הם מאוד גבוהים שאפשר להגיע לניחוש מוצלח והוא יהיה יחיד. אם התנאי האמור לא מתקיים נפטרים מערך זה ומחפשים ערכים אחרים. פקטור העבודה לגילוי תת-מפתח אחד הוא ברמה של <math>2^{32}</math> שזה לא מהיר במיוחד, אבל כאן נעזרים במבנה הפנימי של הפונקציה <math>F</math> כדי להאיץ את החיפוש לכדי פקטור של <math>2^{17}</math>. לצורך כך מגדירים תחילה פונקציה המקבלת ארבעה בתים ומחשבת <math>M(A)=M(a_0,a_1,a_2,a_3)=(0,a_0\oplus a_1, a_2\oplus a_3, 0)</math>. ההתקפה המשופרת לניחוש <math>K_3</math> פועלת בשני שלבים. תחילה עבור כל ערך אפשרי של <math>A=(0,a_0,a_1,0)</math> מחשבים את:
:<math>Q_0=F(M(Y_0)\oplus A), Q_1=F(M(Y_1)\oplus A)</math>.
אם מתבוננים בהגדרה של <math>F</math> רואים שאם <math>A=M(K_3) </math> אז מתקיים <math>\langle Q_0\oplus Q_1\rangle _{8...23}=\langle Z'\rangle_{8...23}</math> כאשר המספרים מייצגים את 16 הסיביות האמצעיות החל מהסיבית השמינית (כאשר הספירה מתחילה מאפס) ועד הסיבית ה-23. אפשר להשתמש בעובדה זו כדי למצוא מועמדים עבור <math>M(K_3)</math> ובכך למעשה מגלים 16 סיביות של <math>K_3</math>. בשלב השני כל מועמד ששרד את שלב אחד נבדק שוב כך שבהינתן מועמד <math>A=(0,a_0,a_1,0)</math>, מגרילים תחילה שני בתים <math>B=b_0,b_1</math> ומחשבים את <math>\tilde K_3=(b_0,a_0\oplus b_0,a_1\oplus b_1, b_1)</math> ואז מחשבים את <math>\tilde Z_0</math> ו-<math>\tilde Z_1</math> כמו בשלב אחד ובודקים אם מתקיים <math>Z'=\tilde Z_0\oplus \tilde Z_1</math>. בדרך זו לאחר בדיקה מקיפה עם מספר זוגות טקסטים ידועים אפשר לשחזר את תת-המפתח <math>K_3</math> או לפחות לנחש מספר קטן של מועמדים אפשריים ואז אפשר לעבור לשלב הבא של שחזור תת-המפתח <math>K_2</math> וכן <math>K_1, K_4, K_5</math> עד שמנחשים את כל המפתח. בכל שלב נעזרים בניחוש תת-המפתח מהשלב הקודם כדי לנחש את הקלט והפלט של הפונקציה הפנימית.

ההתקפה המתוארת מצליחה בפקטור של <math>2^{17}</math> בקירוב עם ארבעה טקסטים גלויים ידועים בלבד ואינה אורכת יותר ממספר שניות על מחשב פשוט כך שגרסת FEAL-4 אינה ראויה לשימוש כלל. ההתקפה הדיפרנציאלית הורחבה ויושמה נגד כל גרסאות FEAL ונמצא שבכולן היא מצליחה בפקטור עבודה שהוא נמוך מכוח גס, למעט גרסת FEAL-NX כאשר <math>N>32</math>, אולם בשל העובדה שפגיעות הצופן להתקפה זו מעידה על פגם מהותי בתכנונו, השימוש בכל הגרסאות שלו נזנח עקב כך.

==ראו גם==
* צופן בלוקים
* קמליה

==הערות שוליים==

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