SAFER (צופן)

בקריפטוגרפיה, SAFER(קיצור של "Secure And Fast Encryption Routine", בעברית רוטינת הצפנה בטוחה ומהירה) הוא שם כולל למשפחה של צפני בלוקים סימטריים איטרטיביים שפותחו עבור חברת Cylink ארצות הברית, בעיקר על ידי ג'יימס מסי (James Massey) מהמכון הטכנולוגי של ציריך. הגרסאה הראשונה SAFER K פותחה בדצמבר 1993 לאחריה פותחה SAFER SK הנבדלת ממנה במספר הסבבים ותהליך הכנת המפתח. גרסאות מתקדמות יותר הנקראות SAFER+‎ ו-SAFER++‎ פותחו בשנת 2000 והוצעו כמועמדים לתקן AES ולפרויקט NESSIE בהתאמה, אך לא הגיעו לגמר. כל האלגוריתמים חופשיים לשימוש ואינם מוגנים בפטנט כלשהו. SAFER+‎ אומץ על ידי בלוטות' כחלק מפרוטוקול אתגר-מענה לאימות זהויות בתקשורת אלחוטית בגרסאות עד 4.0.

משפחת האלגוריתמים SAFER כוללת נכון ל-2017 את הגרסאות הבאות לפי סדר כרונולוגי:

• SAFER K-64
• SAFER K-128
• SAFER SK-64
• SAFER SK-128
• SAFER SK-40
• SAFER+‎
• SAFER++‎

גודל הבלוק בחמש הגרסאות הראשונות הוא 64 סיביות, גודל המפתח בסיביות נרמז במספר המופיע לאחר השם, כאשר בגרסאות SK תהליך הכנת המפתח חוזק בגלל חולשות שהתגלו בקריפטואנליזה של הגרסאות הראשונות. בשתי האחרונות, גודל הבלוק שונה ל-128 סיביות כדי להכשירן כמועמדות לתקני ההצפנה הבינלאומיים. בדומה ל-AES אורך המפתח הנתמך מגיע בשלוש וריאציות 128/192/256 בהתאמה. שתי הגרסאות האחרונות פותחו על ידי מסי ועמיתיו מהאקדמיה הלאומית הארמנית והן מציעות שיפור נוסף על פני קודמותיהן הן ביעילות והן בביטחון. אפקט הפיזור של SAFER מושג על ידי טרנספורמציה ליניארית רב-ממדית הנקראת PHT שהיא התמרת פסבדו-אדמר המפורטת בהמשך. בכל הגרסאות הראשונות נעשה שימוש ב-PHT דו-נקודתית ${\text{2-PHT}}$). בגרסה SAFER+‎ מתבצע פיזור מהיר יותר על ידי מה שנקרא "הערבוב הארמני" שנקרא כך על שם ממציאיו Gurgen Khachatrian ו-Melsik Kuregian. בגרסה SAFER++‎ בנוסף לשיפורים המנויים, שופר הפיזור באמצעות PHT בארבע נקודות ${\text{4-PHT}}$). גרסה זו כוללת גם גרסת מורשת (legacy) עם בלוק באורך 40 סיביות.

שיקולי פיתוח ומאפיינים כלליים

שם הצופן ניתן על ידי ג'יימס מסי שהיה ממפתחי IDEA והרעיונות ששולבו לראשונה ב-IDEA היוו מקור השראה ל-SAFER. התוספת SK בגרסאות המתקדמות היא ראשי התיבות Strengthened Key (מפתח מחוזק) והיא ניתנה בעקבות קריפטואנליזה שבוצעה על ידי לארס קנודסן שגילה שאם הצופן משמש בתצורת פונקציית גיבוב, בגלל "קיבעון" כלשהו של בתי המפתח אפשר למצוא התנגשויות בפחות מהזמן הדרוש בכוח גס. הוא הציע לשנות את התהליך כדי למנוע חולשה זו ובעקבות כך פותחה הגרסה SK. יש המפרשים בהלצה את ראשי התיבות SK כ-Stop Knudesen שהיא "עצה טובה לפיתוח כל צופן בלוקים".

העקרונות המובילים בפיתוח אלגוריתם SAFER במיוחד SAFER++‎ הם:

• סגנון רשת החלפה-תמורה. למרות היתרון של רשת פייסטל בכך שאין צורך ליישם פונקציית פענוח, היתרון ברשת החלפה-תמורה שהיא מאפשרת פיזור או "אפקט מפולת" מהיר הרבה יותר. בנוסף בשיטה זו הפונקציה הפנימית לא צריכה להסתמך על תיבות החלפה ש"ניראות אקראיות" מה שמהווה מקור לחשש שמא הוחדרה בהן דלת אחורית כמו במקרה של DES. צופן SAFER משתמש ברשת של פונקציות החלפה/טרנספורמציה ליניארית הפיכות בעלות מבנה אלגברי בולט. הסגנון של SAFER נותן חופש רב יותר ביצירת אפקט מפולת מהיר במיוחד.
• הצפנה ברמה של בתים. בכל גרסאות SAFER כל פעולות הצופן למעט כמה פעולות חד-פעמיות בתהליך ההכנה, מתבצעות בית לבית. עובדה זו מאפשרת שיפור ביצועים במיוחד בחומרה מוגבלת משאבים.
• פעולות אלגבריות בשתי חבורות שונות. בשלב החיבור עם המפתח הקלט מחולק לשתי חבורות שונות, כאשר באחת מתבצע חיבור מודולו 256 ובשנייה חיבור XOR. בגלל אי-הליניאריות של שילוב הפעולות הללו (כי אסוציאטיביות נהרסת), מתקבל אפקט ערבוב גבוה שמחזק את הצופן נגד קריפטואנליזה דיפרנציאלית. בנוסף, חיבור המפתח לפני הסבב הראשון, שהוא בעצם המפתח המסופק על ידי המשתמש עם הטקסט הקריא, בהנחה שהמפתח נבחר באקראי, מניב מעין סודיות מושלמת כמו בפנקס חד-פעמי. זהו מאפיין רצוי שקיים בצפנים מודרניים רבים, לעיתים נקרא הלבנה.
• שימוש בטבלאות החלפה הפיכות. השכבה האי-ליניארית של SAFER מורכבת מסדרה של פונקציות העלאה בחזקה ולוגריתמים מעל $\mathbb {F} _{256}$ שהן פעולות משלימות. מבנה זה ידוע בתכונות המתמטיות שלו, הוא מציע שקיפות מלאה כיוון שתיבות ההחלפה אינן אקראיות אלא הן פונקציה של הקלט וכן הוכח שבתנאים אילו השכבה זו מפיקה אי-ליניאריות מקסימלית.
• פיזור הפיך באמצעות כפל מטריצות. בכל גרסאות SAFER שכבת הטרנספורמציה הליניארית הציגה נתונים מרשימים, פיזור מלא כמעט בתוך שלושה סבבים בטכניקה לא מסורתית שנקראת "פיזור אדמר" או התמרת פסבדו-אדמר (בקיצור PHT) על שם המתמטיקאי היהודי-צרפתי ז'אק אדמר. הרעיון הוא להכפיל את הבלוק במטריצה עם תכונות פיזור גבוהות כשכל הפעולות האריתמטיות הן בגבולות בתים (מודולו 256). בגרסת SAFER++‎ הפיזור אף שופר משמעותית כך שלא רק שהושג פיזור טוב יותר אלא גם ביעילות רבה יותר. הרעיון הוא שימוש ב-PHT בארבע נקודות ויישומו דורש רק שש פעולות חיבור או חיסור במקרה של הפענוח (כמתואר בתרשים להלן) בנוסף לתמורות קבועות נוספות שקיבלו את הכינוי "הפיזור הארמני" על שם ממציאיו, על פי עיקרון שהבית ה-$i$ בקלט הופך לבית ה-$j$ בפלט כאשר $i$ ו-$j$ שקולים מודולו 4. הם הראו שבחירה זו משיגה פיזור אופטימלי והיא הפיכה.
• סקלביליות. כל גרסאות SAFER הן בעלות סקלביליות גבוהה, כלומר אפשר ליישם גרסת מיני של הצופן למשל בגרסת שתי סיביות שבה הבית הוא כביכול באורך 2 סיביות, הבלוק באורך 32 סיביות וכל הפעולות האריתמטיות הן מודולו 4 או 5 בהתאמה. בגרסת 4 סיביות הבלוק באורך 64 סיביות והפעולות הן מודולו 16 ו-17 בהתאמה. אפשר ליישם את הצופן בגרסת "מקסי" עם בתים באורך של 16 סיביות אך יעילות הצופן יורדת בעקבות כך. גרסאות מיני שימושיות במיוחד לצורך קריפטואנליזה והתגלו יעילות במציאת חולשות ותיקונן.
• תהליך הרחבת מפתח עם הטיה. תהליך הרחבת המפתח מביא בחשבון מפתחות חלשים (מפתחות בעלי תכונה מיוחדת כגון מפתח שמכיל הרבה אפסים, שגורמים לפלט הצופן להתנהג בצורה לא אקראית). ההטיה בתהליך הכנת המפתח מבטלת השפעות חיצוניות וגורמת למפתח המורחב להראות אקראי ללא תלות במפתח המסופק על ידי המשתמש. אף על פי שתוספת זו אינה קריטית היא חשובה במקרים מסוימים, בין היתר כאשר משתמשים בצופן כפונקציית גיבוב חסינת התנגשויות. לארס קנודסן הציע שני שיפורים שהוכנסו בגרסאות החדשות, האחד נקרא "תיבות בחירה" שמתנהגות כתמורות של בתי המפתח שנועדו לפתור את בעיית ה"קיבעון" שלהם לפני הוספת ההטיה והשני הוא הוספת בית זוגיות שהוא חיבור מודולו 2 של כל בתי המפתח.
• מספר סבבים. ההתקפה הכי אפקטיבית נגד גרסאות SAFER לדעת המפתחים היא קריפטואנליזה דיפרנציאלית. התקפה זו מנצלת חולשות שנובעות מערבוב חלש של השכבה האי-ליניארית ולמספר הסבבים השפעה מכרעת על הצלחת ההתקפה. בגרסאות הראשונות מספר הסבבים היה נמוך (6 או 7 סבבים) בגרסת SAFER++‎ עם מפתח באורך 256 סיביות נקבעו עשרה סבבים מה שמספק שולי ביטחון גבוהים מאוד.
• יעילות. הצופן פשוט, גמיש וקל ליישום. חסרונו הוא שפונקציית הפענוח שונה מפונקציית ההצפנה לא רק בסדר המפתחות. ביישום פורטבילי על פלטפורמת פנטיום 3 עם מפתח באורך 128 סיביות SAFER++‎ מצפינה בקצב של 40 מחזורי שעון לבית והכנת המפתח 145 מחזורי שעון לבית. עם מפתח 256 סיביות קצב ההצפנה 57 מחזורי שעון והכנת מפתח 202. צופן SAFER איטי מעט בהשוואה לצפנים ברמה של AES.
• ביטחון. לדעת מפתחי הצופן לא קיימת קריפטואנליזה מוצלחת של SAFER++‎ במלוא הסבבים. בגרסאות הקודמות התגלו בעיות מינוריות שתוקנו כולן בגרסה האחרונה. כיוון שהגרסה האחרונה חדשה קריפטואנליזה שלה דלה יחסית. המפתחים הצהירו שלא קיימת הוכחה מתמטית לביטחון האלגוריתם במונחים של סיבוכיות חישובית, אך יש לציין שהדברים נכונים כמעט לגבי כל צופן בלוקים מודרני ידוע.

התמרת פסבדו-אדמר

הרעיון המרכזי של שאנון לפיתוח צופן בלוקים הוא ליצור "אפקט מפולת" או פיזור (diffusion) מהיר ככל האפשר על ידי פונקציית הצפנה שמבוצעת באופן חוזר ונשנה, כך שתוך מספר מצומצם של חזרות, שינוי קל מאוד בטקסט המקורי יתפתח לשינוי גדול בטקסט המוצפן. ולא יהיה שום יחס או קורלציה בין שני טקסטים מקוריים הנבדלים ביניהם רק בסיבית אחת על ידי יחס דומה בין הטקסטים המוצפנים. לצורך אפקט הפיזור צופן SAFER מיישם מוטיב קריפטוגרפי בלתי שיגרתי; טרנספורמציה ליניארית הנקראת "התמרת פסבדו אדמר" או "התמרת וולש-אדמר".

הנוסחה הסטנדרטית של התמרת וולש-אדמר היא: $b_{1}=a_{1}+a_{2},b_{2}=a_{1}-a_{2}$. אולם הדטרמיננטה של מטריצת המקדמים במקרה זה היא $-2$ ולכן באריתמטיקה מודולו 256 כאשר $-2\equiv 254$ היא אינה הפיכה, בנוסף לעובדה שנדרשת פעולת כפל. הנוסחה של התמרת פסבדו אדמר בשלושה ממדים בשתי נקודות (מקבלת זוג קלטים) המסומנת ${\text{2-PHT}}$ היא:

$b_{1}=2a_{1}+a_{2}$

$b_{2}=a_{1}+a_{2}$

והפעולה ההופכית המסומנת כאן בקיצור ${\text{2-IPHT}}$ היא:

$a_{1}=b_{1}-b_{2}$

$a_{2}=-b_{1}+2b_{2}$

כאשר $a_{1}$ ו-$a_{2}$ הם שני בתי הקלט. עם שינוי זה מתקבלת המטריצה $\textstyle H_{2}={\begin{bmatrix}2&1\\1&1\end{bmatrix}}$ שהדטרמיננטה שלה היא 1 כלומר מטריצה הפיכה וכן אין צורך בפעולת כפל שזה רצוי מהיבט של יעילות. והמטריצה ההופכית היא $\textstyle H_{2}^{-1}={\begin{bmatrix}1&-1\\-1&2\end{bmatrix}}$. בתהליך ההצפנה מבצעים כפל של וקטור הקלט עם המטריצה: $[b_{1},b_{2}]=[a_{1},a_{2}]\cdot H_{2}$ ואילו בפענוח מבצעים $[a_{1},a_{2}]=[b_{1},b_{2}]\cdot H_{2}^{-1}$. לדוגמה:

$[200,30]\cdot {\begin{bmatrix}2&1\\1&1\end{bmatrix}}\equiv [174,230]{\text{ (mod }}256)$ וכן: $[174,230]\cdot {\begin{bmatrix}1&-1\\-1&2\end{bmatrix}}\equiv [200,30]{\text{ (mod }}256)$.

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

פונקציית ההצפנה של SAFER K-64. הסימן $\oplus$ מייצג XOR והסימן $\boxplus$ מייצג חיבור מודולו 256.

SAFER K-64

צופן SAFER K-64 הוא צופן בלוקים איטרטיבי בסגנון רשת החלפה תמורה המקבל בלוק טקסט קריא באורך 8 בתים ומפתח סודי באורך 8 בתים ומפיק טקסט מוצפן באורך 8 בתים. הפונקציה פנימית של הצופן מבוצעת שש פעמים (או יותר) כאשר בכל סבב פלט הפונקציה הופך לקלט בסבב הבא ופלט הצופן הסופי הוא פונקציה מסיימת של התוצאה מהסבב האחרון. בכל סבב שני תת-מפתחות באורך 8 בתים כל אחד, אותם מכינים באמצעות תהליך הכנה שיתואר להלן, מחוברים עם הבלוק הנוכחי בשיטה מיוחדת, מלבד פעולות פיזור וערבוב המפורטים להלן. בסך הכול הצופן משתמש ב-$2r+1$ תת-מפתחות עבור $r$ סבבים, כל אחד באורך שמונה בתים. הפונקציה המסיימת היא XOR של הבתים 1,4,5,8 עם הבתים המתאימים של תת-המפתח $2r+1$ בית אחרי בית וחיבור מודולו 256 של יתר הבתים 2,3,6,7 עם הבתים המתאימים במפתח. לפי המוסכמה סדר הבתים גדול, בית מס' 1 הוא הבית הכי משמעותי (מסדר גבוה). סדר פעולות ההצפנה מתואר בתרשים משמאל.

מבנה פונקציית ההצפנה

הצעד הראשון בתוך הסבב ה-$i$ כמתואר בתרשים משמאל, הוא חיבור בשני אופנים של המפתח עם בלוק הקלט, הבתים 1,4,5,8 מחוברים ב-XOR ואילו הבתים 2,3,6,7 מחוברים בחיבור רגיל מודולו 256 (בגבולות בתים). הסיבה לטכניקה זו היא ניסיון להרוס ליניאריות על ידי שילוב של פעולות מחבורות אלגבריות שונות כך שלא תהיה אסוציאטיביות ביניהן. התוצאה מועברת בשכבה אי-ליניארית אשר מיישמת החלפה לפי שני סוגי תיבות החלפה המשלימים זה את זה, (1) תיבות החלפה שערכיהן הם כל החזקות $j$ של 45 מודולו 257 כאשר $j\leq 0\leq 256$, למעט יוצא דופן אחד $45^{128}=0$ ולא 256 ו(2) תיבות החלפה שערכיהן הם לוגריתם בדידי בבסיס 45 של כל הערכים $j\leq 0<256$ מודולו 257, למעט יוצא דופן אחד במקרה ש-$j=0$ התוצאה היא 128. לפי התיבות הראשונות אם הקלט הוא $x$ התוצאה היא $45^{x}{\text{ mod }}257$, לפי התיבות השניות אם הקלט הוא $x$ הפלט הוא $y$ כך שמתקיים $45^{y}{\text{ mod }}257\equiv x$. בפועל משתמשים בשתי טבלאות אחזור (look-up) שהוכנו מראש. ההחלפה מתבצעת לפי כלל דומה, הבתים 1,4,5,8 מוחלפים לפי התיבות מהסוג הראשון והאחרים לפי התיבות מהסוג השני. הפלט של שמונה הפונקציות האי-ליניאריות משולב עם תת-מפתח אחר באותו אופן אך בסדר הפוך, הבתים 1,4,5,8 מחוברים בחיבור רגיל ואילו הבתים 2,3,6,7 מחוברים ב-XOR. הפלט לאחר החיבור האחרון עם המפתח המתאים עובר בשלוש רמות של הטרנספורמציה הליניארית ${\text{2-PHT}}$ המתוארת לעיל. פונקציה זו פועלת על שני בתים לכן מתבצעות בסך הכול ארבע טרנספורמציות בכל רמה (כל אחת מקבלת שני בתים ופולטת שני בתים) כשבין כל רמה של PHT מתבצעת תמורה (סידור מחדש) ברמה של בתים הנקראת Decimation-by-2 שהיא טריק ידוע מ-FFT שבו פשוט כל זוג מחליף בית אחד עם זוג אחר. למשל הבית השני בפלט של ה-PHT הראשון עובר למיקום השלישי ולאחר ה-PHT השני עובר למיקום החמישי. לאחר הפיזור הליניארי מסתיים הסבב וחוזרים להתחלה.

פונקציית הפענוח של SAFER K-64. הסימן $\oplus$ מייצג XOR והסימן $\boxminus$ מייצג חיסור מודולו 256

מבנה פונקציית הפענוח

מבנה הפענוח כמתואר בתרשים משמאל הוא פשוט הפעולות ההופכיות, בסדר הפוך למבנה ההצפנה צעד אחרי צעד ובסדר הפוך של המפתחות. תחילה מבוצעת טרנספורמציה על הקלט שהיא חיסור מודולו 256 של בתי תת-המפתח $K_{2r+1}$ המתאימים וכן XOR של יתר הבתים. היות ש-XOR הופכי של עצמו פשוט חוזרים עליו שוב ומתקבל הערך המקורי לדוגמה אם המפתח הוא 15 ובית המידע הוא 66 הרי שמתקבל $66\oplus 15=77,77\oplus 15=66$. בחיסור מודולו 256 מספר שלילי הופך להיות חיובי על ידי החסרה מהמודולוס למשל המספר השלילי $-50$ הוא בעצם $256-50\equiv 206$. לאחר מכן מבצעים $r$ סבבים המבטלים את $r$ הסבבים של ההצפנה. תחילה מעבירים את הקלט בטרנספורמציה הליניארית ההופכית IPHT וכן מעבירים בתמורות ההופכיות (ראה חיצים), מחסרים את תת-המפתח $K_{2r+2-2i}$ מהפלט לפי הסדר, בבתים 1,4,5,8 מבצעים חיסור מודולו 256, ביתר הבתים מבצעים XOR. ועוברים לשלב האי-ליניארי ההופכי. בשלב זה פשוט מבצעים החלפה לפי סדר הפוך מסדר ההחלפה בהצפנה, היות שתיבות ההחלפה משלימות זו את זו, האפקט המתקבל הוא ביטול השפעת ההחלפה משלב ההצפנה. אם מחליפים ערך נתון לפי תיבת החלפה מסוג אחד ולאחר מכן מחליפים את התוצאה בתיבת ההחלפה מהסוג השני מתקבל הערך המקורי לדוגמה אם בית המידע הוא 174 אז $45^{174}{\text{ (mod }}257)\equiv 116$ לכן $\log _{45}(116)\equiv 174{\text{ (mod }}257)$. שוב מחסרים את המפתח המתאים לפי הסדר המופיע בהצפנה ובזה הושלם סבב אחד עליו חוזרים כמובן $r$ פעמים עם המפתחות המתאימים. תהליך הפענוח מתואר בתרשים משמאל.

הכנת מפתח

הכנת המפתח של SAFER K-128

תהליך הכנת המפתח (key schedule) של SAFER K-64 מייצר סדרה של $2r+1$ תת-מפתחות $K_{1},K_{2},...,K_{2r+1}$ שכל אחד מהם באורך 8 בתים וכל זוג מתאים לסבב בודד. המפתח הנוסף משמש בסוף התהליך לצורך הפונקציה המסיימת. את המפתחות מכינים ממפתח המאסטר שסופק על ידי המשתמש באופן כזה שהמפתחות "ייראו" אקראיים ובלתי תלויים זה בזה. כדי להימנע ממפתחות חלשים (מפתחות שמכילים הרבה אפסים) מבצעים "הטיה" של כל המפתחות למעט הראשון על ידי חיבור עם רצף של בתי הטיה $B_{2},B_{3},...,B_{2r-1}$. המפתח הראשון $K_{1}$ הוא בעצם המפתח שסופק על ידי המשתמש כמו שהוא. הפונקציות להכנת ערכי ההטייה הן העלאה כפולה בחזקת 45 כדלהלן:

$B[i,j]=45^{45^{9i+j}{\text{ mod }}257}{\text{ mod }}257$

כאשר $B[i,j]$ מתייחס לבית ה-$j$ של ההטייה $i$. את ההטיות כמובן אפשר לחשב מראש ולאחסן בטבלה. את כל תת-המפתחות מייצרים כך: המפתח $K_{1}$ שהוא מפתח המאסטר שהמשתמש בחר מועתק ל-$K_{2}$ ו"מסובב" על ידי הזזה מעגלית של הסיביות בתוך כל בית 3 פוזיציות ואז חיבור עם ההטייה המתאימה $B_{2}$ מודולו 256. עוברים למפתח הבא וכן הלאה עבור כל המפתחות.

SAFER K-128

הצופן SAFER K-128 שונה מקודמו באורך המפתח ובמספר הסבבים וכן בתהליך הכנת המפתח בהתאם והוא מומחש בתרשים משמאל. גודל הבלוק, מבנה פונקציות ההצפנה והפענוח כולל טבלת ההטיות של המפתחות זהים לחלוטין ל-SAFER K-64. ההבדל הוא ש-$2r+1$ מפתחות הסבבים מופקים ממפתח באורך 128 סיביות במקום 64 סיביות כפי שהיה בצופן הקודם. תהליך ההכנה החדש פותח על ידי קבוצת מפתחים מסינגפור. הם המליצו על לפחות $r=10$ סבבים של הצפנה ופענוח עם מפתח 128 סיביות ולא יותר מ-12 סבבים.

תהליך הכנת המפתח תואם בצורה כזו שניתן יהיה להשתמש באותו קוד של האלגוריתם לשני המפתחות. תהליך הכנת המפתח מחלק את המפתח לשני חצאים ימין ושמאל המסומנים $K_{a}$ ו-$K_{b}$ באורך של 64 סיביות כל אחד. במידה שמעוניינים במפתח באורך 64 סיביות פשוט מעתיקים את המפתח פעמיים כך שמתקבל $k_{a}=k_{b}$ ואז תוצאת תהליך ההרחבה של שני החצאים מפיק תת-מפתחות זהים בדיוק לצופן SAFER K-64. במידה שמעוניינים במפתח 128 סיביות מעתיקים מחצית מהמפתח ל-$K_{a}$ והמחצית השנייה ל-$K_{b}$.

SAFER SK-64 ו-SAFER SK-128

כאמור לאור קריפטואנליזה התגלה שהיות ובתי המפתח נשארים קבועים במקומם והשינויים מתרחשים רק בתוך הבתים עובדה זו משפיעה לרעה על התוצאות, כפי שהוכח, חומר המפתח במקרה זה מאפשר בתנאים מסוימים מציאת התנגשויות בדרך קלה יותר מאשר בכוח גס. כלומר שני ערכים שונים של מפתח שמפיקים טקסט מוצפן זהה מה שגורם לכך שהאלגוריתם לא יהיה מומלץ לשימוש כחלק מפונקציית גיבוב שמסתמכת על ההנחה שקשה למצוא התנגשויות. לאור זאת ביצע מסי שינויים בתהליך הכנת המפתח של אלגוריתם SAFER SK כאשר האותיות SK מציינות "מפתח מחוזק". ביתר פירוט בוצעו שני שינויים חשובים. תחילה נוסף בית זוגיות. כלומר המפתח הורחב משמונה בתים במקרה של SK-64 לתשעה בתים. ושבעה עשר בתים במקום שישה עשר במקרה של SK-128. הבית הנוסף הוא תוצאה של XOR של כל בתי המפתח. השינוי השני הוא הוספת הזזה מעגלית ברמה של בתים של כל בתי המפתח כולל בית הזוגיות. במילים אחרות מתחילים ממאגר של תשעה בתים או שבעה עשר בתים (מפתח 64 או 128 סיביות בהתאמה) וכל תת-מפתח נלקח מבתים אחרים לפי הסדר הבא: המפתח הראשון נלקח מהבתים הראשונים (כלומר לא נעשה כל שינוי בסדר). כעת אם מדובר על מפתח באורך 64 סיביות. תת-המפתח השני נלקח מהבתים 2 עד 9, השלישי מהבתים 3 עד 1 הרביעי מ-4 עד 2 (במעין מעגל סגור) וכן הלאה. במקרה של מפתח באורך 128 סיביות מתחילים מהבתים 1 עד 16, לאחר מכן הבתים 2 עד 17, לאחר מכן הבתים 3 עד 1, הבתים 4 עד 2 וכן הלאה. זאת בנוסף ליתר הפעולות המתוארות בסעיפים הקודמים. טריק דומה בוצע בצופן Threefish ובצפנים מודרניים נוספים.

SAFER+‎

SAFER+‎ פותח בשנת 2000 על ידי ג'יימס מסי ועמיתיו מהאקדמיה הארמנית הלאומית Gurgen Khahatrian ו-Melsik K. Kuregian. בניגוד לגרסאות קודמות של SAFER, בגרסה זו הושג שיפור נוסף באפקט הפיזור על ידי בחירה מושכלת של התמורות בין שכבות ה-PHT. התמורות החדשות של SAFER+‎ נקראו על ידי מסי "הערבוב הארמני" על שם ממציאיו. השם SAFER+‎ נועד להגדיש את השיפור המשמעותי בצופן זה לעומת קודמיו במשפחה. בנוסף גודל הבלוק ב-SAFER+‎ הורחב ל-128 סיביות, זאת כדי להתאימו לתקנים הבינלאומיים.

תיאור סכמתי של צופן SAFER+‎

SAFER+‎ הוא צופן בלוקים איטרטיבי בשמונה סבבים (חזרות). הצופן מקבל בלוק טקסט קריא שהוא מחרוזת באורך 16 בתים ומפתח הצפנה באורך 16 בתים ומחזיר בלוק טקסט מוצפן באורך 16 בתים. בנוסף קיים תהליך מקביל של הכנת מפתח המפורט להלן שמפיק מהמפתח שנבחר על ידי המשתמש 17 תת-מפתחות כל אחד באורך 16 בתים, כל זוג מתאים לסבב אחד והאחרון משמש לפונקציה המסיימת. הפונקציה המסיימת פשוטה. היא מחברת את בתי המפתח $K_{2r+1}$ עם בתי התוצאה מהסבב האחרון של הפונקציה הפנימית. החיבור דומה לצפנים הקודמים במשפחה. כלומר מחצית מבתי הבלוק לסירוגין (הבתים שמספרם לפי הסדר משמאל לימין הוא 1,4,5,8,9,12,13,16) מחוברים ב-XOR המסומן $\oplus$ והמחצית השנייה הבתים שמספרם הוא 2,3,6,7,10,11,14,15 בחיבור רגיל מודולו 256 המסומן $\boxplus$.

פונקציית הסבב הפנימית

התרשים משמאל מתאר את הפונקציה הפנימית של SAFER+‎. בסגנון דומה לצפנים הקודמים במשפחת SAFER, הפונקציה הפנימית מבצעת בכל סבב סדרת פעולות כדלהלן:

• תחילה חיבור עם תת-המפתח הראשון של הסבב הנוכחי.
• לאחר מכן החלפה באמצעות שני סוגי תיבות החלפה אי-ליניאריות המשלימות זו את זו המובאות להלן.
• הוספת תת-המפתח השני של הסבב הנוכחי.
• ואז שלוש רמות של "התמרת פסבדו אדמר" תלת־ממדית בשתי נקודות ${\text{2-PHT}}$ כשבין כל רמה קיים שלב פיזור נוסף שהוא תמורה הפיכה ייחודית שנקראת "ערבוב ארמני". התמורה היא:

0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
8	11	12	15	2	1	6	5	10	9	14	13	0	7	4	3

תיבות ההחלפה

תיבות ההחלפה מתחלקות לשני סוגים שהם הופכיים הדדית. מחצית מהן למעט יוצא דופן אחד, הן כל החזקות האפשריות של 45 מודולו 257 והמחצית השנייה כל הלוגריתמים הבדידיים מודולו 257. באופן פורמלי תיבות ההחלפה $e[i]$ ו-$l[i]$ כאשר $0\leq i\leq 256$ הן:

$e[i]=(45^{i}{\text{ mod }}257){\text{ mod }}256$

$l[i]=j$ כך שמתקיים $e[j]=i$.

הכנת מפתחות

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

1. בתוך כל בית של בלוק המפתח מבצעים הזזה מעגלית שלוש סיביות שמאלה.
2. משתמשים ב"תיבות בחירה" שהן בעצם תמורה המסובבת את כל 17 בתי המפתח בהזזה מעגלית לשמאל בית אחד. במילים אחרות, בסבב הראשון נוטלים את הבתים 0 עד 15, בסבב השני את הבתים 1 עד 16, בשלישי 2 עד 0 וכן הלאה.
3. מחברים את הבתים שנבחרו עם קבועים שנקראים בתי "הטייה". כל בית הטיה $B[i,j]$ כאשר $i$ הוא אינדקס של תת-המפתח ו-$j$ מתייחס למספר הבית משמאל, הוא:

$B[i,j]=(45^{45^{17i+j+1}{\text{ mod }}257}){\text{ mod }}257$.

התוצאה המתקבלת תהיה 16 בתי תת-המפתח הראשון $K_{1}$. כך חוזרים על התהליך עד שמפיקים את כל 17 המפתחות.

תקן בלוטות'

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

SAFER++‎

SAFER++‎ הוא צופן בלוקים איטרטיבי המהווה שיפור נוסף על הצפנים הקודמים במשפחת SAFER. הצופן מקבל בלוק טקסט קריא באורך 128 סיביות ומפתח הצפנה שמגיע בשתי אופציות 128 סיביות או 256 סיביות ומפיק בלוק טקסט מוצפן באורך 128 סיביות. הפונקציה הפנימית מבוצעת 7 פעמים במקרה של מפתח 128 סיביות ו-10 פעמים במקרה של מפתח באורך 256 סיביות. בסך הכול הצופן עושה שימוש ב-$2r+1$ מפתחות עבור $r$ הסבבים של הפונקציה הפנימית, כל אחד באורך 16 בתים, לכל סבב של הפונקציה הפנימית מתאימים שני תת-מפתחות. את המפתחות מפיקים באמצעות תהליך הרחבה שיתואר בהמשך. המפתח הנוסף $K_{2r+1}$ מתאים לפונקציה המסיימת לאחר כל הסבבים. לפענוח משתמשים במפתחות בסדר הפוך.

הפונקציה המסיימת מבצעת חיבור עם המפתח האחרון בשיטה זו: הבתים 1,4,5,8,9,12,13,16 של הקלט מחוברים סיבית אחר סיבית מודולו 2 (פעולת XOR) ואילו הבתים 2,3,6,7,10,11,14,15 מחוברים בחיבור רגיל מודולו 256, ובפענוח מבצעים חיסור במקום חיבור.

מבנה הפונקציה הפנימית

בדומה לפונקציות הקודמות במשפחה, הפונקציה הפנימית מורכבת מפעולת חיבור עם המפתח הסודי, פעולת החלפה הנשלטת על ידי מפתח ההצפנה ואחריה טרנספורמציה ליניארית הפיכה. הפעולה הראשונה בסבב ה-$i$ היא חיבור של הקלט עם מפתח הסבב הראשון $K_{2i-1}$ ברמה של בתים. הבתים 1,4,5,8,9,12,13,16 מחוברים ב-XOR והבתים 2,3,6,7,10,11,14,15 מחוברים בחיבור רגיל מודולו 256. התוצאה עוברת בשכבה האי-ליניארית המורכבת משני סוגי החלפה, הראשונה היא המרה של הערך $x$ של הבית ה-$j$ ל-$45^{x}$ מודולו 257. כאשר $j=1,4,5,8,9,12,13,16$. והמוסכמה היא שהתוצאה של $45^{x}$ צריכה להיות מודולו 256, כלומר אם התוצאה היא 256 היא מאופסת. במילים אחרות $45^{128}{\text{ mod }}257=0$ ולא 256. ההחלפה השנייה היא המרה של הערך $x$ של הבית ה-$j$ ללוגריתם בדידי בבסיס 45 של $x$ עבור $j=2,3,6,7,10,11,14,15$. במילים אחרות תוצאת הפונקציה על הערך $x$ היא הערך $y$ כך שמתקיים $45^{y}\equiv x{\text{ mod }}257$. בשלב זה מחברים לתוצאה האחרונה את תת-המפתח השני של הסבב הנוכחי $K_{2i}$, אך הפעם בסדר הפוך, הבתים 2,3,6,7,10,11,14,15 מחוברים ב-XOR והבתים 1,4,5,8,9,12,13,16 מחוברים מודולו 256. התוצאה בשלב זה מועברת בטרנספורמציה הליניארית הפיכה להוספת פיזור.

הטרנספורמציה הליניארית

הכפל במטריצת ${\text{4-PHT}}$ והמטריצה ההופכית ${\text{4-IPHT}}$. הסימן $\boxplus$ הוא חיבור מודולו 256 והסימן $\boxminus$ הוא חיסור מודולו 256.

הטרנספורמציה הליניארית מורכבת מפיזור ראשון שהוא התמורה $[9,6,3,16,1,14,11,8,5,2,15,12,13,10,7,4]$ לפי קואורדינטות בהתאם לכלל סדר בתים גדול כמו ב-DES. כלומר הבית הראשון עובר להיות התשיעי, הבית השני עובר להיות השישי וכן הלאה. מחלקים את הבתים לאחר התמורה לארבע קבוצות וכל אחת מהן משמשת קלט לטרנספורמציית ${\text{4-PHT}}$ שהיא התמרת פסבדו-אדמר בארבע נקודות, אותה מציגים כמטריצה הפיכה מסדר $4\times 4$:

$H_{4}={\begin{bmatrix}2&1&1&1\\1&2&1&1\\1&1&2&1\\1&1&1&1\end{bmatrix}}$

הווקטור של ארבעה בתי הקלט של טרנספורמציה הליניארית מומרים לארבעה בתי הפלט כך:

$[A\ B\ C\ D]=[a\ b\ c\ d]H_{4}$.

כאשר כל הפעולות הן מודולו 256. מבחינה מעשית הכפל במטריצות הללו כמתואר בתרשים משמאל דורש רק שש פעולות חיבור או חיסור במקרה של המטריצה ההפיכה. לאחר פעולה זו מבצעים תמורה אמצעית שהיא זהה לתמורה הראשונה. כשהתוצאה מועברת שוב ב-${\text{4-PHT}}$. לבסוף תוצאה זו היא פלט פונקציית הסבב.

פענוח

פענוח מושג על ידי ביצוע הפעולות ההפוכות ובסדר הפוך של המפתחות. הפעולה הראשונה מתחילה משכבת הכפלה במטריצה ההופכית ${\text{4-IPHT}}$ הבאה:

$H_{4}^{-1}={\begin{bmatrix}1&0&0&-1\\0&1&0&-1\\0&0&1&-1\\-1&-1&-1&4\end{bmatrix}}$

לאחריה מעבירים בתמורה ההפוכה: $[5,10,3,16,9,2,15,8,1,14,7,12,13,6,11,4]$. חוזרים שוב על ${\text{4-IPHT}}$ ושוב מעבירים בתמורה האמורה. מחסרים מהתוצאה את המפתח $K_{2r-2i+2}$, החיסור מתבצע באופן הבא, את הבתים 1,4,5,8,9,12,13,16 מחסרים פשוט על ידי XOR ואת הבתים 2,3,6,7,10,11,14,15 מחסרים מודולו 256. את התוצאה מחליפים לפי תיבות ההחלפה אך בסדר הפוך. כלומר הבתים 1,4,5,8,9,12,13,16 מוחלפים בלוגריתם בבסיס 45 של הערך שלהם מודולו 257 ואילו הבתים 2,3,6,7,10,11,14,15 מוחלפים על ידי העלאה של 45 בחזקת הערך שלהם מודולו 257. יש לזכור שבמקרה שהתוצאה היא 256 מחזירים אפס (הערך 256 לא נכנס בבית אחד) וזה קורה כאשר הקלט הוא 128 לכן $45^{128}\equiv 0$ וכן $\log _{45}(0)\equiv 128$. מחסרים את המפתח $K_{2r-2i+1}$ לפי כלל דומה למפתח הקודם. הבתים 1,4,5,8,9,12,13,16 מחוסרים ב-XOR ואילו היתר בחיסור מודולו 256.

הכנת מפתחות

תהליך הכנת תת-המפתחות של SAFER++‎ מפיק מהמפתח המסופק על ידי המשתמש $2r+1$ מפתחות באורך 16 בתים כל אחד, כל זוג מתאים לסבב אחד של הפונקציה הפנימית של הצופן. בגלל שמספר הסבבים שונה בהתאם לאורך המפתח של המשתמש ובגלל שבגרסאות הישנות גודל המפתח היה רק 64 סיביות, את המפתחות מפיקים באופן כזה שכל תת-המפתחות הם למעשה קינון של המפתחות בהתאם לסוג הצופן, כלומר המפתחות הראשונים מתאימים לגרסת 64 סיביות, אחריהם המפתחות של גרסת מפתח 128 סיביות ואחריהם המפתחות לגרסת 256. כך שאפשר להשתמש באותו תהליך הכנה לכל הווריאציות של הצופן. את המפתחות מכינים בדרך מאוד פשוטה תחילה מוסיפים בית זוגיות שהוא XOR של כל בתי המפתח שנבחר על ידי המשתמש. ואז מפיקים את כל תת-המפתחות על ידי שילוב של הזזה מעגלית ברמה של סיביות בתוך כל בית, הזזה מעגלית ברמה של בתים של כל מפתח וחיבור עם קבועים הנקראים בתי "הטיה" שמספרם תלוי באורך המפתח. את בתי ההטייה מחשבים על ידי:

$B[i,j]=45^{(45^{17i+j}{\text{ mod }}257)}{\text{ mod }}257$

כאשר $i$ מתייחס לאינדקס המפתח ו-$j$ מתייחס למספר הבית בתוך המפתח. עבור מפתח 256 סיביות מחשבים את 48 הבתים האחרונים כך:

$B[i,j]=45^{17i+j}{\text{ mod }}257$

בסך הכול קיימים לכל היותר $20\cdot 16$ בתי הטיה.

סיכום סדר הפעולות להכנת המפתחות

1. מתחילים עם המפתח שהמשתמש בחר בסך הכול 16 בתים.
2. מוסיפים בית זוגיות כך שמתקבלים 17 בתים.
3. המפתח הראשון $K_{1}$ הוא בעצם המפתח שהמשתמש בחר כמו שהוא.
4. מסובבים בהזזה מעגלית את סיביות כל בתי המפתח 6 פוזיציות שמאלה, בגבולות בית אחד.
5. מסובבים את בתי המפתח בסך הכול שני בתים לשמאל כלומר מתקבל 3,4,5,...,17,1
6. מחברים עם בתי ההטייה והתוצאה היא המפתח הבא.

חוזרים על הפעולות הללו עד שמקבלים את כל המפתחות הדרושים. עבור מפתח באורך 256 סיביות דרושים בסך הכול 21 תת-מפתחות.

$20\cdot 16$ בתי ההטייה מופיעים בטבלה הבאה:

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

קוד לדוגמה

להלן קוד C++‎ שלם של אלגוריתם SAFER+‎ כפי שאומץ בתקן בלוטות'. הקוד אינו אופטימלי ונותר כך למען הפשטות והבהירות. קובץ הכותר SAFER.h מכיל את השורות הבאות:

typedef unsigned char BYTE; /* an 8 bit unsigned character type */
typedef unsigned int  UINT; /* a 32 bit unsigned integer type   */

void set_key(const UINT in_key[], const UINT key_len);
void encrypt(const UINT in_blk[4], UINT out_blk[4]);
void decrypt(const UINT in_blk[4], UINT out_blk[4]);

#define rotr(x,n)   (((x) >> ((int)(n))) | ((x) << (32 - (int)(n))))
#define rotl(x,n)   (((x) << ((int)(n))) | ((x) >> (32 - (int)(n))))

#define get_block(x)                   \
    ((UINT*)(x))[0] = in_blk[0];     \
    ((UINT*)(x))[1] = in_blk[1];     \
    ((UINT*)(x))[2] = in_blk[2];     \
    ((UINT*)(x))[3] = in_blk[3]

#define put_block(x)                   \
    out_blk[0] = ((UINT*)(x))[0];    \
    out_blk[1] = ((UINT*)(x))[1];    \
    out_blk[2] = ((UINT*)(x))[2];    \
    out_blk[3] = ((UINT*)(x))[3]

#define get_key(x,len)                          \
    ((UINT*)(x))[4] = ((UINT*)(x))[5] =     \
    ((UINT*)(x))[6] = ((UINT*)(x))[7] = 0;  \
    switch((((len) + 63) / 64)) {               \
    case 4:                                     \
    ((UINT*)(x))[6] = in_key[6];     \
    ((UINT*)(x))[7] = in_key[7];     \
    case 3:                            \
    ((UINT*)(x))[4] = in_key[4];     \
    ((UINT*)(x))[5] = in_key[5];     \
    case 2:                            \
    ((UINT*)(x))[0] = in_key[0];     \
    ((UINT*)(x))[1] = in_key[1];     \
    ((UINT*)(x))[2] = in_key[2];     \
    ((UINT*)(x))[3] = in_key[3];     \
    }

הקוד בקובץ SAFER.cpp הוא:

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

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

BYTE  l_key[33 * 16];
UINT  k_bytes;

void set_key(const UINT in_key[], const UINT key_len)
{
    BYTE  by, lk[33];
	UINT  i, j, k, l, m;

	get_key(lk, key_len);
	k_bytes = key_len / 8; lk[k_bytes] = 0;

	for (i = 0; i < k_bytes; ++i){
		lk[k_bytes] ^= lk[i]; l_key[i] = lk[i];
	}

	for (i = 0; i < k_bytes; ++i){
		for (j = 0; j <= k_bytes; ++j){
			by = lk[j]; lk[j] = by << 3 | by >> 5;
		}
		k = 17 * i + 35; l = 16 * i + 16; m = i + 1;

		if (i < 16){
			for (j = 0; j < 16; ++j){
				l_key[l + j] = lk[m] + expf[expf[(k + j) & 255]];

				m = (m == k_bytes ? 0 : m + 1);
			}
		}	else	{
			for (j = 0; j < 16; ++j){
				l_key[l + j] = lk[m] + expf[(k + j) & 255];

				m = (m == k_bytes ? 0 : m + 1);
			}
		}
	}
};

void do_forward_round(BYTE x[16], BYTE *kp)
{
    BYTE  t;

	x[0] = expf[x[0] ^ kp[0]] + kp[16];
	x[1] = logf[x[1] + kp[1]] ^ kp[17];
	x[2] = logf[x[2] + kp[2]] ^ kp[18];
	x[3] = expf[x[3] ^ kp[3]] + kp[19];

	x[4] = expf[x[4] ^ kp[4]] + kp[20];
	x[5] = logf[x[5] + kp[5]] ^ kp[21];
	x[6] = logf[x[6] + kp[6]] ^ kp[22];
	x[7] = expf[x[7] ^ kp[7]] + kp[23];

	x[8] = expf[x[8] ^ kp[8]] + kp[24];
	x[9] = logf[x[9] + kp[9]] ^ kp[25];
	x[10] = logf[x[10] + kp[10]] ^ kp[26];
	x[11] = expf[x[11] ^ kp[11]] + kp[27];

	x[12] = expf[x[12] ^ kp[12]] + kp[28];
	x[13] = logf[x[13] + kp[13]] ^ kp[29];
	x[14] = logf[x[14] + kp[14]] ^ kp[30];
	x[15] = expf[x[15] ^ kp[15]] + kp[31];

	x[1] += x[0]; x[0] += x[1];
	x[3] += x[2]; x[2] += x[3];
	x[5] += x[4]; x[4] += x[5];
	x[7] += x[6]; x[6] += x[7];
	x[9] += x[8]; x[8] += x[9];
	x[11] += x[10]; x[10] += x[11];
	x[13] += x[12]; x[12] += x[13];
	x[15] += x[14]; x[14] += x[15];

	x[7] += x[0]; x[0] += x[7];
	x[1] += x[2]; x[2] += x[1];
	x[3] += x[4]; x[4] += x[3];
	x[5] += x[6]; x[6] += x[5];
	x[11] += x[8]; x[8] += x[11];
	x[9] += x[10]; x[10] += x[9];
	x[15] += x[12]; x[12] += x[15];
	x[13] += x[14]; x[14] += x[13];

	x[3] += x[0]; x[0] += x[3];
	x[15] += x[2]; x[2] += x[15];
	x[7] += x[4]; x[4] += x[7];
	x[1] += x[6]; x[6] += x[1];
	x[5] += x[8]; x[8] += x[5];
	x[13] += x[10]; x[10] += x[13];
	x[11] += x[12]; x[12] += x[11];
	x[9] += x[14]; x[14] += x[9];

	x[13] += x[0]; x[0] += x[13];
	x[5] += x[2]; x[2] += x[5];
	x[9] += x[4]; x[4] += x[9];
	x[11] += x[6]; x[6] += x[11];
	x[15] += x[8]; x[8] += x[15];
	x[1] += x[10]; x[10] += x[1];
	x[3] += x[12]; x[12] += x[3];
	x[7] += x[14]; x[14] += x[7];

	t = x[0]; x[0] = x[14]; x[14] = x[12]; x[12] = x[10]; x[10] = x[2];
	x[2] = x[8]; x[8] = x[4]; x[4] = t;

	t = x[1]; x[1] = x[7]; x[7] = x[11]; x[11] = x[5]; x[5] = x[13]; x[13] = t;
	t = x[15]; x[15] = x[3]; x[3] = t;
};

void do_inverse_round(BYTE x[16], BYTE *kp)
{
    BYTE  t;

	t = x[3]; x[3] = x[15]; x[15] = t;
	t = x[13]; x[13] = x[5]; x[5] = x[11]; x[11] = x[7]; x[7] = x[1]; x[1] = t;
	t = x[4]; x[4] = x[8]; x[8] = x[2]; x[2] = x[10];
	x[10] = x[12]; x[12] = x[14]; x[14] = x[0]; x[0] = t;

	x[14] -= x[7]; x[7] -= x[14];
	x[12] -= x[3]; x[3] -= x[12];
	x[10] -= x[1]; x[1] -= x[10];
	x[8] -= x[15]; x[15] -= x[8];
	x[6] -= x[11]; x[11] -= x[6];
	x[4] -= x[9]; x[9] -= x[4];
	x[2] -= x[5]; x[5] -= x[2];
	x[0] -= x[13]; x[13] -= x[0];

	x[14] -= x[9]; x[9] -= x[14];
	x[12] -= x[11]; x[11] -= x[12];
	x[10] -= x[13]; x[13] -= x[10];
	x[8] -= x[5]; x[5] -= x[8];
	x[6] -= x[1]; x[1] -= x[6];
	x[4] -= x[7]; x[7] -= x[4];
	x[2] -= x[15]; x[15] -= x[2];
	x[0] -= x[3]; x[3] -= x[0];

	x[14] -= x[13]; x[13] -= x[14];
	x[12] -= x[15]; x[15] -= x[12];
	x[10] -= x[9]; x[9] -= x[10];
	x[8] -= x[11]; x[11] -= x[8];
	x[6] -= x[5]; x[5] -= x[6];
	x[4] -= x[3]; x[3] -= x[4];
	x[2] -= x[1]; x[1] -= x[2];
	x[0] -= x[7]; x[7] -= x[0];

	x[14] -= x[15]; x[15] -= x[14];
	x[12] -= x[13]; x[13] -= x[12];
	x[10] -= x[11]; x[11] -= x[10];
	x[8] -= x[9]; x[9] -= x[8];
	x[6] -= x[7]; x[7] -= x[6];
	x[4] -= x[5]; x[5] -= x[4];
	x[2] -= x[3]; x[3] -= x[2];
	x[0] -= x[1]; x[1] -= x[0];

	x[0] = logf[x[0] - kp[16] + 256] ^ kp[0];
	x[1] = expf[x[1] ^ kp[17]] - kp[1];
	x[2] = expf[x[2] ^ kp[18]] - kp[2];
	x[3] = logf[x[3] - kp[19] + 256] ^ kp[3];

	x[4] = logf[x[4] - kp[20] + 256] ^ kp[4];
	x[5] = expf[x[5] ^ kp[21]] - kp[5];
	x[6] = expf[x[6] ^ kp[22]] - kp[6];
	x[7] = logf[x[7] - kp[23] + 256] ^ kp[7];

	x[8] = logf[x[8] - kp[24] + 256] ^ kp[8];
	x[9] = expf[x[9] ^ kp[25]] - kp[9];
	x[10] = expf[x[10] ^ kp[26]] - kp[10];
	x[11] = logf[x[11] - kp[27] + 256] ^ kp[11];

	x[12] = logf[x[12] - kp[28] + 256] ^ kp[12];
	x[13] = expf[x[13] ^ kp[29]] - kp[13];
	x[14] = expf[x[14] ^ kp[30]] - kp[14];
	x[15] = logf[x[15] - kp[31] + 256] ^ kp[15];
};

void encrypt(const UINT in_blk[4], UINT out_blk[4])
{
BYTE  blk[16], *kp;

	get_block(blk);

	do_forward_round(blk, l_key);       do_forward_round(blk, l_key + 32);
	do_forward_round(blk, l_key + 64);  do_forward_round(blk, l_key + 96);
	do_forward_round(blk, l_key + 128); do_forward_round(blk, l_key + 160);
	do_forward_round(blk, l_key + 192); do_forward_round(blk, l_key + 224);

	if (k_bytes > 16){
		do_forward_round(blk, l_key + 256);
                do_forward_round(blk, l_key + 288);
		do_forward_round(blk, l_key + 320);
                do_forward_round(blk, l_key + 352);
	}

	if (k_bytes > 24){
		do_forward_round(blk, l_key + 384);
                do_forward_round(blk, l_key + 416);
		do_forward_round(blk, l_key + 448);
                do_forward_round(blk, l_key + 480);
	}

	kp = l_key + 16 * k_bytes;

	blk[0] ^= kp[0]; blk[1] += kp[1];
	blk[2] += kp[2]; blk[3] ^= kp[3];
	blk[4] ^= kp[4]; blk[5] += kp[5];
	blk[6] += kp[6]; blk[7] ^= kp[7];
	blk[8] ^= kp[8]; blk[9] += kp[9];
	blk[10] += kp[10]; blk[11] ^= kp[11];
	blk[12] ^= kp[12]; blk[13] += kp[13];
	blk[14] += kp[14]; blk[15] ^= kp[15];

	put_block(blk);
};

void decrypt(const UINT in_blk[4], UINT out_blk[4])
{
BYTE  blk[16], *kp;

	get_block(blk);
	kp = l_key + 16 * k_bytes;

	blk[0] ^= kp[0]; blk[1] -= kp[1];
	blk[2] -= kp[2]; blk[3] ^= kp[3];
	blk[4] ^= kp[4]; blk[5] -= kp[5];
	blk[6] -= kp[6]; blk[7] ^= kp[7];
	blk[8] ^= kp[8]; blk[9] -= kp[9];
	blk[10] -= kp[10]; blk[11] ^= kp[11];
	blk[12] ^= kp[12]; blk[13] -= kp[13];
	blk[14] -= kp[14]; blk[15] ^= kp[15];

	if (k_bytes > 24){
		do_inverse_round(blk, l_key + 480); do_inverse_round(blk, l_key + 448);
		do_inverse_round(blk, l_key + 416); do_inverse_round(blk, l_key + 384);
	}

	if (k_bytes > 16){
		do_inverse_round(blk, l_key + 352); do_inverse_round(blk, l_key + 320);
		do_inverse_round(blk, l_key + 288); do_inverse_round(blk, l_key + 256);
	}

	do_inverse_round(blk, l_key + 224); do_inverse_round(blk, l_key + 192);
	do_inverse_round(blk, l_key + 160); do_inverse_round(blk, l_key + 128);
	do_inverse_round(blk, l_key + 96);  do_inverse_round(blk, l_key + 64);
	do_inverse_round(blk, l_key + 32);  do_inverse_round(blk, l_key);

	put_block(blk);
};

ראו גם

• צופן בלוקים
• AES

קישורים חיצוניים

מדיה וקבצים בנושא SAFER בוויקישיתוף