קמליה (צופן)

קמליה - Camellia^[1] הוא צופן בלוקים סימטרי שפותח בשנת 2000 בשיתוף פעולה של מיצובישי ו-NTT על ידי צוות קריפטוגרפים בראשות מיצורו מצואי (אנ'). הוצע לגופי תקינה רבים, נכלל ברשימת הצפנים המומלצים של פרויקט NESSIE האירופאי משנת 2003 ופרויקט CRYPTREC של ממשלת יפן, הוצע במזכר RFC 3713 של IETF כתוספת ל-IPSec, אושר על ידי ארגון התקינה הבינלאומי בתקן ISO/IEC 18033-3 ונכלל בפרוטוקולי אבטחה פופולריים רבים, ביניהם SSL, OpenPGP ו-S/MIME. ספריות אבטחה רבות מספקות תמיכה לקמליה, ביניהן Crypto++, GPG, OpenSSL. קמליה מוגן בפטנט והותר על ידי NTT לשימוש ברישיון חופשי.

הצופן מקבל בלוק מידע בגודל 128 סיביות ומפתח הצפנה בשלושה גדלים אפשריים 128, 192 או 256 סיביות והפלט הוא בלוק מוצפן בגודל 128 סיביות. הצופן בעל סגנון ייחודי - מעין רשת פייסטל רקורסיבית, בשמונה-עשר או עשרים וארבעה סבבים בהתאם לאורך המפתח ופועל ברמה של בתים. הפונקציה הפנימית מתנהגת כרשת החלפה-תמורה על שמונה בתים, שכבת ההחלפה מתבצעת במקביל באמצעות שמונה תיבות החלפה (S-box) בגודל 8x8 סיביות ושכבת התמורה היא קומבינציה של XOR בין בתי הקלט. בנוסף, בדומה לMISTY ו-KASUMI כולל גם שכבת טרנספורמציה ליניארית תלוית מפתח שמופעלת אחת לשישה סבבים.

ביטחון

צופן קמליה קיבל הכרה כצופן מודרני בטוח ואינו נופל ברמתו מ-AES. הוא זוכה לפופולריות רבה גם עקב פשטותו ויעילותו הרבה הן בחומרה והן בתוכנה. ההתקפות הטובות ביותר הידועות נגד הצופן הן התקפה שנקראת Square Attack^[2] על גרסה מצומצמת (תשעה סבבים) בסיבוכיות של $2^{202}$ הצפנות ועם $2^{61}$ טקסטים מוצפנים. התקפה אחרת שנקראת Rectangle Attack^[3] של Shirai מצליחה לשבור את הצופן בעשרה סבבים בסיבוכיות של $2^{241}$ קריאות זיכרון עם $2^{127}$ טקסטים נבחרים. התקפה נוספת שהיא סוג של התקפה דיפרנציאלית^[4] אינה טובה משמעותית מכוח גס. בכללות אילו התקפות תאורטיות שאינן מסכנות את ביטחון הצופן. יש לציין שהטרנספורמציה הליניארית הנוספת (להלן), אחראית בין היתר על חוזקו.

תיאור הצופן

צופן קמליה (על שם צמח התה) הוא ממשיכו של E2 שהיה מהמועמדים ל-AES והסגנון הייחודי שלו מבוסס עליו במידה רבה. הפעולות בצופן הן בעיקר פעולות החלפה ופעולות לוגיות OR, XOR ו-AND על מילים או בתים. כאשר המרות ממילים לבתים וההפך הן לפי סדר בתים גדול (למשל אם המילה מכילה את הערך 0x01234567 (בבסיס הקסדצימלי) בהמרה לבתים הבית הראשון יכיל 0x01, השני 0x23, השלישי 0x45 והרביעי 0x67). בגרסת מפתח 128 סיביות, בלוק המידע עובר 18 סבבים של טרנספורמציה במבנה פייסטל בנוסף לשכבות הטרנספורמציה הליניארית $FL$ והטרנספורמציה ההופכית $FL^{-1}$ לאחר הסבב השישי והסבב השנים-עשר (כמתואר בתרשים משמאל). פונקציית הרחבת המפתח מקבלת את המפתח הסודי המסופק על ידי המשתמש ומייצרת ממנו תת-מפתחות מורחבים לכל הסבבים שהם ארבעה מפתחות הלבנה המסומנים $kw_{t}$ כאשר $t=1,2,3,4$ , שמונה עשר מפתחות סבבים $k_{u}$ כאשר $u=1,2,...,18$ וכן ארבעה מפתחות $kl_{v}$ (עבור הפונקציות הליניאריות) כאשר $v=1,2,3,4$ , כולם מילים באורך 64 סיביות. תחילה בלוק הטקסט $M$ מחובר ב-XOR (המסומן כאן ב- $\oplus$ ) עם שני המפתחות הראשונים $kw_{1},kw_{2}$ בהתאמה, פעולה זו נקראת הלבנה. התוצאה מחולקת לשני חצאים $L$ ו- $R$ ואז הפעולות הבאות מבוצעות $r$ פעמים כאשר $r=1,...,18$ למעט הסבבים 6 ו-12:

L_{r}=R_{r-1}\oplus F(L_{r-1},k_{r})

,

R_{r}=L_{r-1}

.

עבור הסבבים 6 ו-12 מבצעים כדלהלן:

L_{r}^{'}=R_{r-1}\oplus F(L_{r-1},k_{r})

,

R_{r}^{'}=L_{r-1}

,

L_{r}=FL(L_{r}^{'},kl_{2r/6-1})

,

R_{r}=FL^{-1}(R_{r}^{'},kl_{2r/6})

.

לבסוף התוצאות האחרונות $R_{18}$ ו- $L_{18}$ עוברים שוב הלבנה עם המפתחות $kw_{3},kw_{4}$ בהתאמה. במילים אחרות פלט הצופן הוא $C=(R_{18}\oplus kw_{3}\ \|\ L_{18}\oplus kw_{4})$ .

מפתחות 192 ו-256 סיביות

כאשר נבחר מפתח באורך 192 או 256 סיביות יחולו השינויים הבאים. יהיו שישה מפתחות עבור הפונקציות הליניאריות כלומר נוספו שני מפתחות $kl_{5},kl_{6}$ . יהיו 24 מפתחות $k_{u}$ במקום 18 וכן קוראים לטרנספורמציה הליניארית והטרנספורמציה ההופכית שלה שלוש פעמים; בסבבים 6, 12 ו-18. כל היתר זהה.

פענוח

הפענוח בקמליה זהה להצפנה למעט היפוך סדר תת-המפתחות. אם המפתח הוא באורך 128 סיביות, תחילה מבטלים את ההלבנה על ידי חיבור ב-XOR עם המפתחות $kw_{3},kw_{4}$ בהתאמה ומתקבלים החצאים $L_{18},R_{18}$ מהסבב האחרון של ההצפנה ואז מבצעים עבור $r=18$ עד $r=1$ בסדר יורד למעט הסבבים 13 ו-7 כדלהלן:

R_{r-1}=L_{r}\oplus F(R_{r},k_{r})

,

L_{r-1}=R_{r}

.

בסבבים 13 ו-7 מבצעים:

R_{r-1}^{'}=L_{r}\oplus F(R_{r},k_{r})

,

L_{r-1}^{'}=R_{r}

,

R_{r-1}=FL(R_{r-1}',kl_{2(r-1)/6})

,

L_{r-1}=FL^{-1}(L_{r-1}^{'},kl_{2(r-1)/6-1})

.

הטקסט הקריא יהיה $M=(L_{0}\oplus kw_{1}\ \|\ R_{0}\oplus kw_{2})$ .

אם המפתח הנבחר הוא באורך 192 או 256 סיביות, ההבדלים הם שמתבצעים בסך הכול 24 סבבים בסדר יורד והטרנספורמציה הליניארית מתבצעת בסבבים 19, 13 ו-7.

הכנת מפתח

הכנת המפתח נעשית באמצעות גרסה מצומצמת של רשת פייסטל כמתואר בתרשים משמאל. תחילה מגדירים שני משתנים מקומיים $K_{L},K_{R}$ באורך 128 סיביות כל אחד בהם מציבים את המפתח המסופק על ידי המשתמש. לכל משתנה אפשר להתייחס כאל מילה אחת באורך 128 סיביות או שתי מילים באורך 64 סיביות המייצגים את שני החצאים של משתנה האב, צד ימין של $K_{L}$ ייקרא $K_{LR}$ וצד שמאל $K_{LL}$ וכן לגבי $K_{R}$ , בסך הכול ארבעה רבעים $K_{LL},K_{LR},K_{RL}$ ו- $K_{RR}$ באורך 64 סיביות כל אחד. כאשר המפתח המסופק על ידי המשתמש הוא באורך 128 סיביות מציבים אותו ב- $K_{L}$ ואילו המילה $K_{R}=0$ . את המפתח המסופק על ידי המשתמש טוענים למשתנים הפנימיים כך שהכללים הבאים מתקיימים:

עבור מפתח 128 סיביות; המפתח בחצי השמאלי $K_{L}$ ואילו החצי הימני $K_{R}=0$ . שים לב ש- $K_{LL}$ ו- $K_{LR}$ מכילים את שני חצאי $K_{L}$ בהתאמה.
עבור מפתח 192 סיביות; המפתח מחולק כך ש- $K=K_{L}\ \|\ K_{RL},K_{RR}={\overline {K_{RL}}}$ . הסמל ${\overline {x}}$ הוא המשלים ל-1 של $x$ (אותו אפשר לקבל על ידי חיבור XOR עם וקטור של 64 אחדים). המפתח מתפרס על פני $K_{L}$ ומחצית מ- $K_{R}$ - כלומר $K_{RL}$ ואילו החלק האחרון $K_{RR}$ מכיל את המשלים של $K_{RL}$ .
עבור מפתח 256 סיביות; המפתח מחולק כך ש- $K=K_{L}\ \|\ K_{R}$ .
עבור כל המפתחות; $K_{L}=K_{LL}\ \|\ K_{LR}$ וכן $K_{R}=K_{RL}\ \|\ K_{RR}$ .

בנוסף מגדירים שני משתנים $K_{A}$ ו- $K_{B}$ באורך 128 סיביות כל אחד, אותם מאתחלים כדלהלן. תחילה מבצעים $K_{L}\oplus K_{R}$ , את התוצאה מצפינים בהצפנה מקוצרת ברשת פייסטל בשני סבבים עם הפונקציה $F$ המתוארת להלן כאשר הערכים $\Sigma _{1},\Sigma _{2}$ מתוך הטבלה להלן משמשים כמפתחות הצפנה. את התוצאה מחברים ב-XOR עם $K_{L}$ ושוב מצפינים עם $\Sigma _{3}$ ו- $\Sigma _{4}$ והתוצאה האחרונה תהיה $K_{A}$ . את $K_{A}$ מחברים שוב ב-XOR עם $K_{R}$ ומצפינים עם $\Sigma _{5},\Sigma _{6}$ והתוצאה האחרונה היא $K_{B}$ . התהליך מומחש בתרשים משמאל.

ערכי הקבועים הם 16 ספרות החל מהספרה השנייה ועד הספרה ה-17 של הייצוג ההקסדצימלי של חלק השבר של השורש הריבועי של ששת המספרים הראשוניים הראשונים.

משתנה	ערך
$\Sigma _{1}$	${\text{0xA09E667F3BCC908B}}$
$\Sigma _{2}$	${\text{0xB67AE8584CAA73B2}}$
$\Sigma _{3}$	${\text{0xC6EF372FE94F82BE}}$
$\Sigma _{4}$	${\text{0x54FF53A5F1D36F1C}}$
$\Sigma _{5}$	${\text{0x10E527FADE682D1D}}$
$\Sigma _{6}$	${\text{0xB05688C2B3E6C1FD}}$

מתוך המשתנים $K_{L},K_{R},K_{A},K_{B}$ גוזרים תת-מפתחות $(kw_{t},k_{u},kl_{v})$ כל אחד באורך 64 סיביות. כל מפתח נגזר מהחלק השמאלי או הימני של הזזה מעגלית של אחד מהמשתנים האמורים לפי הטבלה הבאה. למשל אם המפתח הנבחר הוא 192 או 256 סיביות אזי לפי הטבלה הימנית, ערכו של תת-המפתח $k_{8}$ עבור הסבב השמיני הוא החצי הימני של $K_{B}$ המסומן בטבלה $K_{BR}$ לאחר הזזה מעגלית 30 פוזיציות לשמאל.

192/256 סיביות
סבב	תת-מפתח	ערך
הלבנה	$kw_{1}$	$K_{LL}$
הלבנה	$kw_{2}$	$K_{LR}$
סבב 1	$k_{1}$	$K_{BL}$
סבב 2	$k_{2}$	$K_{BR}$
סבב 3	$k_{3}$	$K_{RL}\lll 15$
סבב 4	$k_{4}$	$K_{RR}\lll 15$
סבב 5	$k_{5}$	$K_{AL}\lll 15$
סבב 6	$k_{6}$	$K_{AR}\lll 15$
$FL$	$kl_{1}$	$K_{RL}\lll 30$
$FL^{-1}$	$kl_{2}$	$K_{RR}\lll 30$
סבב 7	$k_{7}$	$K_{BL}\lll 30$
סבב 8	$k_{8}$	$K_{BR}\lll 30$
סבב 9	$k_{9}$	$K_{LL}\lll 45$
סבב 10	$k_{10}$	$K_{LR}\lll 45$
סבב 11	$k_{11}$	$K_{AL}\lll 45$
סבב 12	$k_{12}$	$K_{AR}\lll 45$
$FL$	$kl_{3}$	$K_{LL}\lll 60$
$FL^{-1}$	$kl_{4}$	$K_{LR}\lll 60$
סבב 13	$k_{13}$	$K_{RL}\lll 60$
סבב 14	$k_{14}$	$K_{RR}\lll 60$
סבב 15	$k_{15}$	$K_{BL}\lll 60$
סבב 16	$k_{16}$	$K_{BR}\lll 60$
סבב 17	$k_{17}$	$K_{LL}\lll 77$
סבב 18	$k_{18}$	$K_{LR}\lll 77$
$FL$	$kl_{5}$	$K_{AL}\lll 77$
$FL^{-1}$	$kl_{6}$	$K_{AR}\lll 77$
סבב 19	$k_{19}$	$K_{RL}\lll 94$
סבב 20	$k_{20}$	$K_{RR}\lll 94$
סבב 21	$k_{21}$	$K_{AL}\lll 94$
סבב 22	$k_{22}$	$K_{AR}\lll 94$
סבב 23	$k_{23}$	$K_{LL}\lll 111$
סבב 24	$k_{24}$	$K_{LR}\lll 111$
הלבנה	$kw_{3}$	$K_{BL}\lll 111$
הלבנה	$kw_{4}$	$K_{BR}\lll 111$

128 סיביות
סבב	תת-מפתח	ערך
הלבנה	$kw_{1}$	$K_{LL}$
הלבנה	$kw_{2}$	$K_{LR}$
סבב 1	$k_{1}$	$K_{AL}$
סבב 2	$k_{2}$	$K_{AR}$
סבב 3	$k_{3}$	$K_{LL}\lll 15$
סבב 4	$k_{4}$	$K_{LR}\lll 15$
סבב 5	$k_{5}$	$K_{AL}\lll 15$
סבב 6	$k_{6}$	$K_{AR}\lll 15$
$FL$	$kl_{1}$	$K_{AL}\lll 30$
$FL^{-1}$	$kl_{2}$	$K_{AR}\lll 30$
סבב 7	$k_{7}$	$K_{LL}\lll 45$
סבב 8	$k_{8}$	$K_{LR}\lll 45$
סבב 9	$k_{9}$	$K_{AL}\lll 45$
סבב 10	$k_{10}$	$K_{LR}\lll 60$
סבב 11	$k_{11}$	$K_{AL}\lll 60$
סבב 12	$k_{12}$	$K_{AR}\lll 60$
$FL$	$kl_{3}$	$K_{LL}\lll 77$
$FL^{-1}$	$kl_{4}$	$K_{LR}\lll 77$
סבב 13	$k_{13}$	$K_{LL}\lll 94$
סבב 14	$k_{14}$	$K_{LR}\lll 94$
סבב 15	$k_{15}$	$K_{AL}\lll 94$
סבב 16	$k_{16}$	$K_{AR}\lll 94$
סבב 17	$k_{17}$	$K_{LL}\lll 111$
סבב 18	$k_{18}$	$K_{LR}\lll 111$
הלבנה	$kw_{3}$	$K_{AL}\lll 111$
הלבנה	$kw_{4}$	$K_{AR}\lll 111$
‎	‎
‎	‎
‎	‎
‎	‎
‎	‎
‎	‎
‎	‎
‎	‎

הביטוי $x\lll y$ פירושו כאן הזזה מעגלית של $x$ במספר סיביות המצוין על ידי $y$ בגבולות מילה באורך 64 סיביות. לדוגמה אם המשתנה באורך 8 סיביות (בית), והוא מכיל את הערך 169 או 'A9' (בבסיס בינארי "10101001") לאחר הזה מעגלית לשמאל שלוש סיביות יתקבל 53 או '35' ("110101").

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

פונקציות עזר

להלן תיאור הפונקציות המרכיבות את הצופן מהגדול לקטן. הפונקציה $F$ המופיעה בתרשים משמאל מוגדרת כדלהלן:

{\boldsymbol {F(X,k)\longmapsto Y=P(S(X\oplus k)}}

הפונקציה מקבלת שני פרמטרים, ערך $X$ וקטע מתאים מהמפתח המורחב $k$ באורך 64 סיביות כל אחד ומחזירה את $Y$ גם הוא באורך 64 סיביות תוך שימוש בפונקציות $S$ ו- $P$ המייצגות החלפה ותמורה בהתאמה בנוסף לחיבור עם $k$ .

הפונקציה FL

הפונקציה הליניארית $FL$ מקבלת שני פרמטרים; $X$ באורך 64 סיביות המחולק לצד ימין וצד שמאל $X_{L}$ ו- $X_{R}$ בהתאמה ואת $kl$ המחולק גם הוא לשני חצאים $kl_{L},kl_{R}$ ומחזירה את $Y$ באורך 64 סיביות כדלהלן:

FL(X_{L}\ \|\ X_{R},kl_{L}\ \|\ kl_{R})\longmapsto Y_{L}\ \|\ Y_{R}

כאשר

Y_{R}=((X_{L}\land kl_{L})\lll 1)\oplus X_{R}

,

Y_{L}=(Y_{R}\lor kl_{R})\oplus X_{L}

.

הסימן $\land$ מייצג את האופרטור הלוגי AND והסימן $\lor$ מייצג את האופרטור הלוגי OR.

הפונקציה הליניארית ההופכית

הפונקציה ההופכית מוגדרת כך:

FL^{-1}(Y_{L}\ \|\ Y_{R},kl_{L}\ \|\ kl_{R})\longmapsto X_{L}\ \|\ X_{R}

כאשר

X_{L}=(Y_{R}\lor kl_{R})\oplus Y_{L}

,

X_{R}=((X_{L}\land kl_{L})\lll 1)\oplus Y_{R}

.

התרשים משמאל מתאר את שתי הפונקציות הליניאריות.

הפונקציה S

פונקציית ההחלפה מקבלת קלט $l$ באורך 8 בתים ונעזרת בארבע טבלאות החלפה $s_{1},s_{2},s_{3}$ ו- $s_{4}$ להלן כדי להחליף את ערכי הבתים בבתים שבטבלה לפי אינדקסים - בכל טבלה בסך הכול 256 ערכים אפשריים. כדלהלן:

l_{1}=s_{1}(l_{1}),l_{2}=s_{2}(l_{2}),l_{3}=s_{3}(l_{3}),l_{4}=s_{4}(l_{4})

l_{5}=s_{2}(l_{5}),l_{6}=s_{3}(l_{6}),l_{7}=s_{4}(l_{7}),l_{8}=s_{1}(l_{8})

לדוגמה אם ערכו של הבית $l_{1}=12$ , התוצאה לפי הטבלה הראשונה היא $l_{1}=s_{1}(12)=234$ .

תיבות ההחלפה

תיבות ההחלפה של קמליה (s-box) הן ערכי שקילות אפינית של פונקציות הופכיות מעל השדה $GF(2^{8})$ . בהצגה אלגברית:

s_{1}(x)\longmapsto \mathbf {h} (\mathbf {g} (\mathbf {f} ({\text{0xc5}}\oplus x)))\oplus {\text{0x6a}}

s_{2}(x)\longmapsto s_{1}(x)\lll 1

s_{3}(x)\longmapsto s_{1}(x)\ggg 1

s_{4}(x)\longmapsto s_{1}(x\lll 1)

הפונקציה $\mathbf {f}$ היא צירוף ליניארי של סיביות הקלט לפי הנוסחה:

b_{1}=a_{6}\oplus a_{2},b_{2}=a_{7}\oplus a_{1},b_{3}=a_{8}\oplus a_{5}\oplus a_{3},b_{4}=a_{8}\oplus a_{3}

,

b_{5}=a_{7}\oplus a_{4},b_{6}=a_{5}\oplus a_{2},b_{7}=a_{8}\oplus a_{1},b_{8}=a_{6}\oplus a_{4}

.

הפונקציה $\mathbf {g}$ מוגדרת כך:

(b_{8}+b_{7}\alpha +b_{6}\alpha ^{2}+b_{5}\alpha ^{3})+(b_{4}+b_{3}\alpha +b_{2}\alpha ^{2}+b_{1}\alpha ^{3})\beta

=1/((a_{8}+a_{7}\alpha +a_{6}\alpha ^{2}+a_{5}\alpha ^{3})+(a_{1}+a_{3}\alpha +a_{2}\alpha ^{2}+a_{1}\alpha ^{3})\beta )

כאשר $\beta$ מקיים $\beta ^{8}+\beta ^{6}+\beta ^{5}+\beta ^{3}+1=0$ וכן $\alpha =\beta ^{238}=\beta ^{6}+\beta ^{5}+\beta ^{3}+\beta ^{2}$ הוא אלמנט בשדה $GF(2^{4})$ המקיים $\alpha ^{4}+\alpha +1=0$ .

הפונקציה $\mathbf {h}$ מוגדרת בסיביות עבור הקלט $a=a_{1}a_{2}a_{3}a_{4}a_{5}a_{6}a_{7}a_{8}$ כך:

b_{1}=a_{5}\oplus a_{6}\oplus a_{2},b_{2}=a_{6}\oplus a_{2},b_{3}=a_{7}\oplus a_{4},b_{4}=a_{8}\oplus a_{2}

b_{5}=a_{7}\oplus a_{3},b_{6}=a_{8}\oplus a_{1},b_{7}=a_{5}\oplus a_{1},b_{8}=a_{6}\oplus a_{3}

אפשר לראות שערכי התיבות $s_{2},s_{3}$ ו- $s_{4}$ למעשה נגזרות מהתיבה הראשונה. לכן אם הזיכרון מוגבל כמו בכרטיס חכם, אפשר לאחסן בזיכרון רק את הטבלה הראשונה ולחשב את ההחלפה במקום על ידי הנוסחאות המתוארות. למשל אם $x=20$ החלפה של $x$ לפי טבלה 3 היא: $\textstyle s_{1}(20)\ggg 1=69\ggg 1=162$ .

להלן ערכי תיבות ההחלפה:

$\mathbf {s_{1}}$

 112, 130,  44, 236, 179,  39, 192, 229, 228, 133,  87,  53, 234,  12, 174,  65,
  35, 239, 107, 147,  69,  25, 165,  33, 237,  14,  79,  78,  29, 101, 146, 189,
 134, 184, 175, 143, 124, 235,  31, 206,  62,  48, 220,  95,  94, 197,  11,  26,
 166, 225,  57, 202, 213,  71,  93,  61, 217,   1,  90, 214,  81,  86, 108,  77,
 139,  13, 154, 102, 251, 204, 176,  45, 116,  18,  43,  32, 240, 177, 132, 153,
 223,  76, 203, 194,  52, 126, 118,   5, 109, 183, 169,  49, 209,  23,   4, 215,
  20,  88,  58,  97, 222,  27,  17,  28,  50,  15, 156,  22,  83,  24, 242,  34,
 254,  68, 207, 178, 195, 181, 122, 145,  36,   8, 232, 168,  96, 252, 105,  80,
 170, 208, 160, 125, 161, 137,  98, 151,  84,  91,  30, 149, 224, 255, 100, 210,
  16, 196,   0,  72, 163, 247, 117, 219, 138,   3, 230, 218,   9,  63, 221, 148,
 135,  92, 131,   2, 205,  74, 144,  51, 115, 103, 246, 243, 157, 127, 191, 226,
  82, 155, 216,  38, 200,  55, 198,  59, 129, 150, 111,  75,  19, 190,  99,  46,
 233, 121, 167, 140, 159, 110, 188, 142,  41, 245, 249, 182,  47, 253, 180,  89,
 120, 152,   6, 106, 231,  70, 113, 186, 212,  37, 171,  66, 136, 162, 141, 250,
 114,   7, 185,  85, 248, 238, 172,  10,  54,  73,  42, 104,  60,  56, 241, 164,
  64,  40, 211, 123, 187, 201,  67, 193,  21, 227, 173, 244, 119, 199, 128, 158

$\mathbf {s_{2}}$

 224,   5,  88, 217, 103,  78, 129, 203, 201,  11, 174, 106, 213,  24,  93, 130,
  70, 223, 214,  39, 138,  50,  75,  66, 219,  28, 158, 156,  58, 202,  37, 123,
  13, 113,  95,  31, 248, 215,  62, 157, 124,  96, 185, 190, 188, 139,  22,  52,
  77, 195, 114, 149, 171, 142, 186, 122, 179,   2, 180, 173, 162, 172, 216, 154,
  23,  26,  53, 204, 247, 153,  97,  90, 232,  36,  86,  64, 225,  99,   9,  51,
 191, 152, 151, 133, 104, 252, 236,  10, 218, 111,  83,  98, 163,  46,   8, 175,
  40, 176, 116, 194, 189,  54,  34,  56, 100,  30,  57,  44, 166,  48, 229,  68,
 253, 136, 159, 101, 135, 107, 244,  35,  72,  16, 209,  81, 192, 249, 210, 160,
  85, 161,  65, 250,  67,  19, 196,  47, 168, 182,  60,  43, 193, 255, 200, 165,
  32, 137,   0, 144,  71, 239, 234, 183,  21,   6, 205, 181,  18, 126, 187,  41,
  15, 184,   7,   4, 155, 148,  33, 102, 230, 206, 237, 231,  59, 254, 127, 197,
 164,  55, 177,  76, 145, 110, 141, 118,   3,  45, 222, 150,  38, 125, 198,  92,
 211, 242,  79,  25,  63, 220, 121,  29,  82, 235, 243, 109,  94, 251, 105, 178,
 240,  49,  12, 212, 207, 140, 226, 117, 169,  74,  87, 132,  17,  69,  27, 245,
 228,  14, 115, 170, 241, 221,  89,  20, 108, 146,  84, 208, 120, 112, 227,  73,
 128,  80, 167, 246, 119, 147, 134, 131,  42, 199,  91, 233, 238, 143,   1,  61

$\mathbf {s_{3}}$

  56,  65,  22, 118, 217, 147,  96, 242, 114, 194, 171, 154, 117,   6,  87, 160,
 145, 247, 181, 201, 162, 140, 210, 144, 246,   7, 167,  39, 142, 178,  73, 222,
  67,  92, 215, 199,  62, 245, 143, 103,  31,  24, 110, 175,  47, 226, 133,  13,
  83, 240, 156, 101, 234, 163, 174, 158, 236, 128,  45, 107, 168,  43,  54, 166,
 197, 134,  77,  51, 253, 102,  88, 150,  58,   9, 149,  16, 120, 216,  66, 204,
 239,  38, 229,  97,  26,  63,  59, 130, 182, 219, 212, 152, 232, 139,   2, 235,
  10,  44,  29, 176, 111, 141, 136,  14,  25, 135,  78,  11, 169,  12, 121,  17,
 127,  34, 231,  89, 225, 218,  61, 200,  18,   4, 116,  84,  48, 126, 180,  40,
  85, 104,  80, 190, 208, 196,  49, 203,  42, 173,  15, 202, 112, 255,  50, 105,
   8,  98,   0,  36, 209, 251, 186, 237,  69, 129, 115, 109, 132, 159, 238,  74,
 195,  46, 193,   1, 230,  37,  72, 153, 185, 179, 123, 249, 206, 191, 223, 113,
  41, 205, 108,  19, 100, 155,  99, 157, 192,  75, 183, 165, 137,  95, 177,  23,
 244, 188, 211,  70, 207,  55,  94,  71, 148, 250, 252,  91, 151, 254,  90, 172,
  60,  76,   3,  53, 243,  35, 184,  93, 106, 146, 213,  33,  68,  81, 198, 125,
  57, 131, 220, 170, 124, 119,  86,   5,  27, 164,  21,  52,  30,  28, 248,  82,
  32,  20, 233, 189, 221, 228, 161, 224, 138, 241, 214, 122, 187, 227,  64,  79

$\mathbf {s_{4}}$

 112,  44, 179, 192, 228,  87, 234, 174,  35, 107,  69, 165, 237,  79,  29, 146,
 134, 175, 124,  31,  62, 220,  94,  11, 166,  57, 213,  93, 217,  90,  81, 108,
 139, 154, 251, 176, 116,  43, 240, 132, 223, 203,  52, 118, 109, 169, 209,   4,
  20,  58, 222,  17,  50, 156,  83, 242, 254, 207, 195, 122,  36, 232,  96, 105,
 170, 160, 161,  98,  84,  30, 224, 100,  16,   0, 163, 117, 138, 230,   9, 221,
 135, 131, 205, 144, 115, 246, 157, 191,  82, 216, 200, 198, 129, 111,  19,  99,
 233, 167, 159, 188,  41, 249,  47, 180, 120,   6, 231, 113, 212, 171, 136, 141,
 114, 185, 248, 172,  54,  42,  60, 241,  64, 211, 187,  67,  21, 173, 119, 128,
 130, 236,  39, 229, 133,  53,  12,  65, 239, 147,  25,  33,  14,  78, 101, 189,
 184, 143, 235, 206,  48,  95, 197,  26, 225, 202,  71,  61,   1, 214,  86,  77,
  13, 102, 204,  45,  18,  32, 177, 153,  76, 194, 126,   5, 183,  49,  23, 215,
  88,  97,  27,  28,  15,  22,  24,  34,  68, 178, 181, 145,   8, 168, 252,  80,
 208, 125, 137, 151,  91, 149, 255, 210, 196,  72, 247, 219,   3, 218,  63, 148,
  92,   2,  74,  51, 103, 243, 127, 226, 155,  38,  55,  59, 150,  75, 190,  46,
 121, 140, 110, 142, 245, 182, 253,  89, 152, 106,  70, 186,  37,  66, 162, 250,
   7,  85, 238,  10,  73, 104,  56, 164,  40, 123, 201, 193, 227, 244, 199, 158

הפונקציה P

הפונקציה $P$ מקבלת מערך של שמונה בתים $z_{1},...,z_{8}$ ומחזירה את התמורה שלהם לפי:

z_{1}=z_{1}\oplus z_{3}\oplus z_{4}\oplus z_{6}\oplus z_{7}\oplus z_{8}

z_{2}=z_{1}\oplus z_{2}\oplus z_{4}\oplus z_{5}\oplus z_{7}\oplus z_{8}

z_{3}=z_{1}\oplus z_{2}\oplus z_{3}\oplus z_{5}\oplus z_{6}\oplus z_{8}

z_{4}=z_{2}\oplus z_{3}\oplus z_{4}\oplus z_{5}\oplus z_{6}\oplus z_{7}

z_{5}=z_{1}\oplus z_{2}\oplus z_{6}\oplus z_{7}\oplus z_{8}

z_{6}=z_{2}\oplus z_{3}\oplus z_{5}\oplus z_{7}\oplus z_{8}

z_{7}=z_{3}\oplus z_{4}\oplus z_{5}\oplus z_{6}\oplus z_{8}

z_{8}=z_{1}\oplus z_{4}\oplus z_{5}\oplus z_{6}\oplus z_{7}

דרך אחרת להציג זאת היא על ידי כפל מטריצות:

{\begin{pmatrix}z_{8}\\z_{7}\\\vdots \\z_{1}\end{pmatrix}}\longmapsto {\begin{pmatrix}z_{8}\\z_{7}\\\vdots \\z_{1}\end{pmatrix}}=P{\begin{pmatrix}z_{8}\\z_{7}\\\vdots \\z_{1}\end{pmatrix}}

כאשר

P={\begin{pmatrix}0&1&1&1&1&0&0&1\\1&0&1&1&1&1&0&0\\1&1&0&1&0&1&1&0\\1&1&1&0&0&0&1&1\\0&1&1&1&1&1&1&0\\1&0&1&1&0&1&1&1\\1&1&0&1&1&0&1&1\\1&1&1&0&1&1&0&1\\\end{pmatrix}}

קוד לדוגמה

להלן קוד שלם בשפת ++C של הצפנת קמליה לפי RFC 3713:

const unsigned char SIGMA[48] = {
   0xa0,0x9e,0x66,0x7f,0x3b,0xcc,0x90,0x8b, 0xb6,0x7a,0xe8,0x58,0x4c,0xaa,0x73,0xb2,
   0xc6,0xef,0x37,0x2f,0xe9,0x4f,0x82,0xbe, 0x54,0xff,0x53,0xa5,0xf1,0xd3,0x6f,0x1c,
   0x10,0xe5,0x27,0xfa,0xde,0x68,0x2d,0x1d, 0xb0,0x56,0x88,0xc2,0xb3,0xe6,0xc1,0xfd
};
const int KSFT1[26] = {
    0,64,0,64,15,79,15,79,30,94,45,109,45,124,60,124,77,13,94,30,94,30,111,47,111,47
};
const int KIDX1[26] = {
    0,0,4,4,0,0,4,4,4,4,0,0,4,0,4,4,0,0,0,0,4,4,0,0,4,4
};
const int KSFT2[34] = {
    0,64,0,64,15,79,15,79,30,94,30,94,45,109,45,109,60,124,60,124,60,124,77,13,77,13,
    94,30,94,30,111,47,111,47
};
const int KIDX2[34] = {
    0,0,12,12,8,8,4,4,8,8,12,12,0,0,4,4,0,0,8,8,12,12,0,0,4,4,8,8,4,4,0,0,12,12
};

const unsigned char SBOX[256] = {
    112,130, 44,236,179, 39,192,229,228,133, 87, 53,234, 12,174, 65, 35,239,107,147,
     69, 25,165, 33,237, 14, 79, 78, 29,101,146,189,134,184,175,143,124,235, 31,206,
     62, 48,220, 95, 94,197, 11, 26,166,225, 57,202,213, 71, 93, 61,217,  1, 90,214,
     81, 86,108, 77,139, 13,154,102,251,204,176, 45,116, 18, 43, 32,240,177,132,153,
    223, 76,203,194, 52,126,118,  5,109,183,169, 49,209, 23,  4,215, 20, 88, 58, 97,
    222, 27, 17, 28, 50, 15,156, 22, 83, 24,242, 34,254, 68,207,178,195,181,122,145,
     36,  8,232,168, 96,252,105, 80,170,208,160,125,161,137, 98,151, 84, 91, 30,149,
    224,255,100,210, 16,196,  0, 72,163,247,117,219,138,  3,230,218,  9, 63,221,148,
    135, 92,131,  2,205, 74,144, 51,115,103,246,243,157,127,191,226, 82,155,216, 38,
    200, 55,198, 59,129,150,111, 75, 19,190, 99, 46,233,121,167,140,159,110,188,142,
     41,245,249,182, 47,253,180, 89,120,152,  6,106,231, 70,113,186,212, 37,171, 66,
    136,162,141,250,114,  7,185, 85,248,238,172, 10, 54, 73, 42,104, 60, 56,241,164,
     64, 40,211,123,187,201, 67,193, 21,227,173,244,119,199,128,158
};

#define SBOX1(n) SBOX[(n)]
#define SBOX2(n) (unsigned char )((SBOX[(n)] >> 7 ^ SBOX[(n)] << 1) & 0xff)
#define SBOX3(n) (unsigned char )((SBOX[(n)] >> 1 ^ SBOX[(n)] << 7) & 0xff)
#define SBOX4(n) SBOX[((n) << 1 ^ (n) >> 7) & 0xff]

void Camellia_Ekeygen( const int n, const unsigned char  *k, unsigned char *e )
{
	unsigned char  t[64] = {0};
	Word u[20];
	if( n == 128 ){
		for(int i=0 ; i<16; i++ ) t[i] = k[i];
	}
	else if( n == 192 ){
		for(int i=0 ; i<24; i++ ) t[i] = k[i];
		for(int i=24; i<32; i++ ) t[i] = k[i-8] ^ 0xff;
	}
	else if( n == 256 ){
		for(int i=0 ; i<32; i++ ) t[i] = k[i];
	}

	XorBlock( t+0, t+16, t+32 );

	Camellia_Feistel( t+32, SIGMA+0, t+40 );
	Camellia_Feistel( t+40, SIGMA+8, t+32 );

	XorBlock( t+32, t+0, t+32 );

	Camellia_Feistel( t+32, SIGMA+16, t+40 );
	Camellia_Feistel( t+40, SIGMA+24, t+32 );

	ByteWord( t+0,  u+0 );
	ByteWord( t+32, u+4 );

	if( n == 128 ){
		for(int i=0; i<26; i+=2 ){
			RotBlock( u+KIDX1[i+0], KSFT1[i+0], u+16 );
			RotBlock( u+KIDX1[i+1], KSFT1[i+1], u+18 );
			WordByte( u+16, e+i*8 );
		}
	}else{
		XorBlock( t+32, t+16, t+48 );
		Camellia_Feistel( t+48, SIGMA+32, t+56 );
		Camellia_Feistel( t+56, SIGMA+40, t+48 );

		ByteWord( t+16, u+8  );
		ByteWord( t+48, u+12 );

		for(int i=0; i<34; i+=2 ){
			RotBlock( u+KIDX2[i+0], KSFT2[i+0], u+16 );
			RotBlock( u+KIDX2[i+1], KSFT2[i+1], u+18 );
			WordByte( u+16, e+(i<<3) );
		}
	}
}

void Camellia_Encrypt( const int n, const unsigned char  *p, const unsigned char  *e, unsigned char  *c )
{
	XorBlock(p, e+0, c);
	for(int i=0; i<3; i++){
		Camellia_Feistel(c+0, e+16+(i<<4), c+8);
		Camellia_Feistel(c+8, e+24+(i<<4), c+0);
	}
	Camellia_FLlayer(c, e+64, e+72);

	for(int i=0; i<3; i++){
		Camellia_Feistel(c+0, e+80+(i<<4), c+8);
		Camellia_Feistel(c+8, e+88+(i<<4), c);
	}
	Camellia_FLlayer(c, e+128, e+136);

	for(int i=0; i<3; i++){
		Camellia_Feistel(c+0, e+144+(i<<4), c+8);
		Camellia_Feistel(c+8, e+152+(i<<4), c);
	}

	if(n == 128){
		SwapHalf(c);
		XorBlock(c, e+192, c);
	}else{
		Camellia_FLlayer(c, e+192, e+200);
		for(int i=0; i<3; i++ ){
			Camellia_Feistel(c+0, e+208+(i<<4), c+8);
			Camellia_Feistel(c+8, e+216+(i<<4), c);
		}
		SwapHalf(c);
		XorBlock(c, e+256, c);
	}
}

void Camellia_Decrypt( const int n, const unsigned char *c, const unsigned char *e, unsigned char *p )
{
	if(n == 128){
		XorBlock(c, e+192, p);
	}else{
		XorBlock(c, e+256, p);

		for(int i=2; i>=0; i-- ){
			Camellia_Feistel(p+0, e+216+(i<<4), p+8);
			Camellia_Feistel(p+8, e+208+(i<<4), p);
		}
		Camellia_FLlayer(p, e+200, e+192);
	}

	for(int i=2; i>=0; i--){
		Camellia_Feistel(p+0, e+152+(i<<4), p+8);
		Camellia_Feistel(p+8, e+144+(i<<4), p);
	}

	Camellia_FLlayer(p, e+136, e+128);

	for(int i=2; i>=0; i-- ){
		Camellia_Feistel(p+0, e+88+(i<<4), p+8);
		Camellia_Feistel(p+8, e+80+(i<<4), p);
	}
	Camellia_FLlayer(p, e+72, e+64);

	for(int i=2; i>=0; i-- ){
		Camellia_Feistel(p+0, e+24+(i<<4), p+8);
		Camellia_Feistel(p+8, e+16+(i<<4), p);
	}
	SwapHalf(p);
	XorBlock(p, e+0, p);
}

void Camellia_Feistel(const unsigned char *x, const unsigned char *k, unsigned char *y)
{
	unsigned char t[8] = {
		SBOX1(x[0]^k[0]), SBOX2(x[1]^k[1]), SBOX3(x[2]^k[2]), SBOX4(x[3]^k[3]),
		SBOX2(x[4]^k[4]), SBOX3(x[5]^k[5]), SBOX4(x[6]^k[6]), SBOX1(x[7]^k[7])
	};

	y[0] ^= t[0]^t[2]^t[3]^t[5]^t[6]^t[7];
	y[1] ^= t[0]^t[1]^t[3]^t[4]^t[6]^t[7];
	y[2] ^= t[0]^t[1]^t[2]^t[4]^t[5]^t[7];
	y[3] ^= t[1]^t[2]^t[3]^t[4]^t[5]^t[6];
	y[4] ^= t[0]^t[1]^t[5]^t[6]^t[7];
	y[5] ^= t[1]^t[2]^t[4]^t[6]^t[7];
	y[6] ^= t[2]^t[3]^t[4]^t[5]^t[7];
	y[7] ^= t[0]^t[3]^t[4]^t[5]^t[6];
}

void Camellia_FLlayer(unsigned char *x, const unsigned char *kl, const unsigned char *kr)
{
	unsigned int t[4],u[4],v[4];
	ByteWord(x, t);
	ByteWord(kl, u);
	ByteWord(kr, v);
	t[1] ^= (t[0] & u[0]) << 1 ^ (t[0] & u[0]) >> 31;
	t[0] ^= t[1] | u[1];
	t[2] ^= t[3] | v[1];
	t[3] ^= (t[2] & v[0]) << 1 ^ (t[2] & v[0]) >> 31;
	WordByte(t, x);
}

void ByteWord(const unsigned char *x, unsigned int *y)
{
	for(int i=0; i<4; i++){
		y[i] = ((unsigned int)x[(i << 2)] << 24) + 
                       ((unsigned int)x[(i << 2) + 1] << 16) +
                       ((unsigned int)x[(i << 2) + 2] << 8 ) +
                       ((unsigned int)x[(i << 2) + 3]);
	}
}

void WordByte(const unsigned int *x, unsigned char *y)
{
	for(int i=0; i<4; i++){
		y[(i << 2)] = (unsigned char)(x[i] >> 24 & 0xff);
		y[(i << 2) + 1] = (unsigned char)(x[i] >> 16 & 0xff);
		y[(i << 2) + 2] = (unsigned char)(x[i] >>  8 & 0xff);
		y[(i << 2) + 3] = (unsigned char)(x[i] & 0xff);
	}
}

void RotBlock(const unsigned int *x, const int n, unsigned int *y)
{
	int r;
	if(r = (n & 31)){
		y[0] = x[((n >> 5) + 0) & 3] << r ^ x[((n >> 5) + 1) & 3] >> (32-r);
		y[1] = x[((n >> 5) + 1) & 3] << r ^ x[((n >> 5) + 2) & 3] >> (32-r);
	}
	else{
		y[0] = x[((n >> 5)) & 3];
		y[1] = x[((n >> 5) + 1) & 3];
	}
}

void SwapHalf(unsigned char *x)
{
	unsigned char t;
	for(int i = 0; i < 8; i++){
		t = x[i];
		x[i] = x[8+i];
		x[8+i] = t;
	}
}

void XorBlock(const unsigned char *x, const unsigned char *y, unsigned char *z)
{
	for(int i = 0; i < 16; i++ ) z[i] = x[i] ^ y[i];
}

ראו גם

הערות שוליים

^ Specification of Cammelia - a 128-bit Block Cipher
^ Yeom, Y., S. Park, and I. Kim (2002). "On the security of Camellia against the square attack." Fast Software Encryption, FSE 2002, Lecture Notes in Computer Science, vol. 2365, eds. J. Daemen and V. Rijmen. Springer-Verlag, Berlin, 89–99.
^ Shirai, T. (2002). "Differential, linear, boomerang and rectangle cryptanalysis of reduced-round Camellia." Proceedings of the Third NESSIE Workshop, NESSIE, November 2002.
^ Hatano, Y., H. Sekine, and T. Kaneko (2002). "Higher order differential attack of Camellia (II)." Selected Areas in Cryptography, SAC 2002. Lecture Notes in Computer Science, eds. H. Heys and K. Nyberg. Springer-Verlag, Berlin, 39–56.

[1] Specification of Cammelia - a 128-bit Block Cipher

[On_the_security_of_Camellia_against_the_square_attack-2] Yeom, Y., S. Park, and I. Kim (2002). "On the security of Camellia against the square attack." Fast Software Encryption, FSE 2002, Lecture Notes in Computer Science, vol. 2365, eds. J. Daemen and V. Rijmen. Springer-Verlag, Berlin, 89–99.

[Differential,_linear,_boomerang_and_rectangle_cryptanalysis_of_reduced-round_Camellia-3] Shirai, T. (2002). "Differential, linear, boomerang and rectangle cryptanalysis of reduced-round Camellia." Proceedings of the Third NESSIE Workshop, NESSIE, November 2002.

[Higher_order_differential_attack_of_Camellia-4] Hatano, Y., H. Sekine, and T. Kaneko (2002). "Higher order differential attack of Camellia (II)." Selected Areas in Cryptography, SAC 2002. Lecture Notes in Computer Science, eds. H. Heys and K. Nyberg. Springer-Verlag, Berlin, 39–56.

[1]

[2]

[3]

[4]