בקריפטוגרפיה, **ARIA** הוא צופן בלוקים סימטרי שפותח ב-2004 על ידי קבוצת חוקרים ב-NSRI עבור המשרד לתקנים וטכנולוגיה של דרום קוריאה (KATS), החבר בגופי התקינה הבינלאומיים ISO ו-IEC.

האלגוריתם בנוי מרשת החלפה-תמורה אינוולוציונית ולמעשה המפרט והממשק שלו דומים במידה רבה ל-AES. הוא מקבל בלוק טקסט קריא באורך 128 סיביות ומפתח הצפנה בשלושה אורכים אפשריים: 128, 192 או 256 סיביות ומפיק מהטקסט הקריא בלוק מוצפן באורך 128 סיביות. הוא עושה שימוש בתיבות החלפה (Sbox) בגודל {\displaystyle 8\times 8} סיביות המבוססות על תיבות ההחלפה של ריינדל והוא פועל ב-12, 14, או 16 סבבים בהתאם לאורך המפתח. תהליך הכנת מפתח ההצפנה מרחיב את המפתח המסופק על ידי המשתמש באמצעות רשת פייסטל משולשת בתוספת קבועים שהם הייצוג הבינארי של {\displaystyle \pi ^{-1}} (זאת במטרה להוכיח שאינו מכיל דלתות סתר).

האלגוריתם הפך לתקן רשמי של KATS וכן IETF, הוצע בטיוטה RFC 5794 וכן הוצע כתוסף לפרוטוקול SSL/TLS בטיוטה RFC 6209. ביטחונו נחקר היטב על ידי מומחי הצפנה, ביניהם ניתן למנות כמה מחקרים שמראים שהצופן בטוח לשימוש בגרסה העדכנית שלו ולא נמצאו בו פגמים רציניים.

גרסאות והיבטי יישום
-------------------

תרשים כללי של צופן ARIA
ARIA 0.8 הוצע לראשונה ב-2003 בוועידה השנתית לאבטחת מידע של דרום קוריאה. בתחילה הצופן הכיל רק 10, 12, או 14 סבבים בהתאם לאורך המפתח 128/192/256 והכיל רק שתי תיבות החלפה בהן נעשה שימוש לסירוגין. בגרסה 0.9 שהוצעה ב-ICIS 2003 נוספו שתי תיבות החלפה. גרסה 1.0 הנוכחית הוכרזה והופצה על ידי NSRI ב-2004. מספר הסבבים עלה ל-12/14/16 בהתאמה וכן בוצעו שינויים בתהליך הרחבת המפתח. בדצמבר 2004 הכניס מכון התקנים של דרום קוריאה את הצופן לתקן KS X 1213.

ARIA מתאים ליישום בחומרת 8 ביט וכן ב-32 ביט הן בתוכנה והן בחומרה. רוב הפעולות בצופן הן פעולות החלפה פשוטות אותן אפשר לבצע ביעילות עם טבלאות חיפוש (lookup table). אם הזיכרון זמין ניתן להמיר את שכבת הפיזור להכפלה בארבע מטריצות וכן אפשר לשלב את שכבת ההחלפה יחד עם שכבת הפיזור באופן יעיל ולהשיג בכך שיפור משמעותי בתפוקת הצופן. באופן כללי תפוקת ARIA דומה לזו של AES וטובה מקמליה.

תיאור כללי
----------

הצופן בנוי מרשת החלפה תמורה המבצעת סדרה של פעולות הפיכות על בלוק קלט באורך 128 סיביות הנקרא "מצב" (state) באופן אחיד. הפעולות הן ברמה של בתים והמצב הפנימי מיוצג כמערך המכיל 16 בתים. הצופן מבצע את פעולות המצב באופן חוזר ונשנה 12, 14 או 16 פעמים בהתאם לאורך המפתח. עבור מפתח 128 סיביות מבוצעים בסך הכול 12 סבבים, עבור מפתח באורך 192 סיביות מבוצעים בסך הכול 14 סבבים ואילו עבור מפתח באורך 256 סיביות מבוצעים 16 סבבים. המצב הפנימי מאותחל בתחילה עם סיביות הקלט, בכל סבב הצופן מעדכן את המצב והפלט הסופי הוא המצב האחרון לאחר כל הסבבים. פעולות הצופן מחולקות לשלושה מרכיבים:

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

כמו כן פעולת הרחבת המפתח מקבלת את המפתח הסודי המסופק על ידי המשתמש ומרחיבה אותו בסך הכול ל-13, 15 או 17 מקטעים באורך 16 בתים כל אחד, בהתאם לאורך המפתח. כלומר 13 מקטעים עבור מפתח באורך 128 סיביות, 15 מקטעים עבור מפתח באורך 192 סיביות ו-17 מקטעים עבור מפתח באורך 256. הסיבה היא משום שבסבב האחרון במקום שכבת הפיזור מבוצעת שכבת הוספת המפתח פעם נוספת, ראו תרשים.

פירוט פעולות הצופן
------------------

הפעולות הבאות מבוצעות על כל בתי המצב באופן אחיד.

### שכבת החלפה

בשכבת ההחלפה (substitution layer) משתמש ARIA בשתי תיבות החלפה {\displaystyle S\_{1}} ו-{\displaystyle S\_{2}} וכן התיבות ההופכיות שלהן {\displaystyle S\_{1}^{-1}} ו-{\displaystyle S\_{2}^{-1}}. תיבות ההחלפה נתונות בארבע הטבלאות להלן. הטבלאות בנויות מ-16 שורות ו-16 עמודות, בסך הכול 256 כניסות, כל כניסה מכילה מספר באורך 8 סיביות בטווח בין 0 ל-256 (או שתי ספרות הקסדצימליות בין {\displaystyle {\text{0x00}}} ל-{\displaystyle {\text{0xff}}}). הקלט לפונקציית ההחלפה הוא בית אחד המשמש כאינדקס לשורה והעמודה בטבלה, הניבל הראשון (ספרה הקסדצימלית ראשונה בטווח בין 0 ל-15) מציין עמודה ואילו הניבל השני מציין שורה. למשל אם הקלט הוא {\displaystyle {\text{0x00}}} הטבלה {\displaystyle S\_{1}} תחזיר {\displaystyle {\text{0x63}}} (בבסיס הקסדצימלי) ואילו הטבלה {\displaystyle S\_{2}} תחזיר {\displaystyle {\text{0xe2}}} וכן {\displaystyle S\_{1}^{-1}({\text{0x95}})={\text{0xad}}} או {\displaystyle S\_{2}^{-1}({\text{0x48}})={\text{0x67}}}:

|  |  |
| --- | --- |
| {\displaystyle S\_{1}} | {\displaystyle S\_{1}^{-1}} |
| 
```
  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
0 63 7c 77 7b f2 6b 6f c5 30 01 67 2b fe d7 ab 76
1 ca 82 c9 7d fa 59 47 f0 ad d4 a2 af 9c a4 72 c0
2 b7 fd 93 26 36 3f f7 cc 34 a5 e5 f1 71 d8 31 15
3 04 c7 23 c3 18 96 05 9a 07 12 80 e2 eb 27 b2 75
4 09 83 2c 1a 1b 6e 5a a0 52 3b d6 b3 29 e3 2f 84
5 53 d1 00 ed 20 fc b1 5b 6a cb be 39 4a 4c 58 cf
6 d0 ef aa fb 43 4d 33 85 45 f9 02 7f 50 3c 9f a8
7 51 a3 40 8f 92 9d 38 f5 bc b6 da 21 10 ff f3 d2
8 cd 0c 13 ec 5f 97 44 17 c4 a7 7e 3d 64 5d 19 73
9 60 81 4f dc 22 2a 90 88 46 ee b8 14 de 5e 0b db
a e0 32 3a 0a 49 06 24 5c c2 d3 ac 62 91 95 e4 79
b e7 c8 37 6d 8d d5 4e a9 6c 56 f4 ea 65 7a ae 08
c ba 78 25 2e 1c a6 b4 c6 e8 dd 74 1f 4b bd 8b 8a
d 70 3e b5 66 48 03 f6 0e 61 35 57 b9 86 c1 1d 9e
e e1 f8 98 11 69 d9 8e 94 9b 1e 87 e9 ce 55 28 df
f 8c a1 89 0d bf e6 42 68 41 99 2d 0f b0 54 bb 16

```
 | 
```
  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
0 52 09 6a d5 30 36 a5 38 bf 40 a3 9e 81 f3 d7 fb
1 7c e3 39 82 9b 2f ff 87 34 8e 43 44 c4 de e9 cb
2 54 7b 94 32 a6 c2 23 3d ee 4c 95 0b 42 fa c3 4e
3 08 2e a1 66 28 d9 24 b2 76 5b a2 49 6d 8b d1 25
4 72 f8 f6 64 86 68 98 16 d4 a4 5c cc 5d 65 b6 92
5 6c 70 48 50 fd ed b9 da 5e 15 46 57 a7 8d 9d 84
6 90 d8 ab 00 8c bc d3 0a f7 e4 58 05 b8 b3 45 06
7 d0 2c 1e 8f ca 3f 0f 02 c1 af bd 03 01 13 8a 6b
8 3a 91 11 41 4f 67 dc ea 97 f2 cf ce f0 b4 e6 73
9 96 ac 74 22 e7 ad 35 85 e2 f9 37 e8 1c 75 df 6e
a 47 f1 1a 71 1d 29 c5 89 6f b7 62 0e aa 18 be 1b
b fc 56 3e 4b c6 d2 79 20 9a db c0 fe 78 cd 5a f4
c 1f dd a8 33 88 07 c7 31 b1 12 10 59 27 80 ec 5f
d 60 51 7f a9 19 b5 4a 0d 2d e5 7a 9f 93 c9 9c ef
e a0 e0 3b 4d ae 2a f5 b0 c8 eb bb 3c 83 53 99 61
f 17 2b 04 7e ba 77 d6 26 e1 69 14 63 55 21 0c 7d

```
 |

|  |  |
| --- | --- |
| {\displaystyle S\_{2}} | {\displaystyle S\_{2}^{-1}} |
| 
```
  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
0 e2 4e 54 fc 94 c2 4a cc 62 0d 6a 46 3c 4d 8b d1
1 5e fa 64 cb b4 97 be 2b bc 77 2e 03 d3 19 59 c1
2 1d 06 41 6b 55 f0 99 69 ea 9c 18 ae 63 df e7 bb
3 00 73 66 fb 96 4c 85 e4 3a 09 45 aa 0f ee 10 eb
4 2d 7f f4 29 ac cf ad 91 8d 78 c8 95 f9 2f ce cd
5 08 7a 88 38 5c 83 2a 28 47 db b8 c7 93 a4 12 53
6 ff 87 0e 31 36 21 58 48 01 8e 37 74 32 ca e9 b1
7 b7 ab 0c d7 c4 56 42 26 07 98 60 d9 b6 b9 11 40
8 ec 20 8c bd a0 c9 84 04 49 23 f1 4f 50 1f 13 dc
9 d8 c0 9e 57 e3 c3 7b 65 3b 02 8f 3e e8 25 92 e5
a 15 dd fd 17 a9 bf d4 9a 7e c5 39 67 fe 76 9d 43
b a7 e1 d0 f5 68 f2 1b 34 70 05 a3 8a d5 79 86 a8
c 30 c6 51 4b 1e a6 27 f6 35 d2 6e 24 16 82 5f da
d e6 75 a2 ef 2c b2 1c 9f 5d 6f 80 0a 72 44 9b 6c
e 90 0b 5b 33 7d 5a 52 f3 61 a1 f7 b0 d6 3f 7c 6d
f ed 14 e0 a5 3d 22 b3 f8 89 de 71 1a af ba b5 81

```
 | 
```
  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f
0 30 68 99 1b 87 b9 21 78 50 39 db e1 72 09 62 3c
1 3e 7e 5e 8e f1 a0 cc a3 2a 1d fb b6 d6 20 c4 8d
2 81 65 f5 89 cb 9d 77 c6 57 43 56 17 d4 40 1a 4d
3 c0 63 6c e3 b7 c8 64 6a 53 aa 38 98 0c f4 9b ed
4 7f 22 76 af dd 3a 0b 58 67 88 06 c3 35 0d 01 8b
5 8c c2 e6 5f 02 24 75 93 66 1e e5 e2 54 d8 10 ce
6 7a e8 08 2c 12 97 32 ab b4 27 0a 23 df ef ca d9
7 b8 fa dc 31 6b d1 ad 19 49 bd 51 96 ee e4 a8 41
8 da ff cd 55 86 36 be 61 52 f8 bb 0e 82 48 69 9a
9 e0 47 9e 5c 04 4b 34 15 79 26 a7 de 29 ae 92 d7
a 84 e9 d2 ba 5d f3 c5 b0 bf a4 3b 71 44 46 2b fc
b eb 6f d5 f6 14 fe 7c 70 5a 7d fd 2f 18 83 16 a5
c 91 1f 05 95 74 a9 c1 5b 4a 85 6d 13 07 4f 4e 45
d b2 0f c9 1c a6 bc ec 73 90 7b cf 59 8f a1 f9 2d
e f2 b1 00 94 37 9f d0 2e 9c 6e 28 3f 80 f0 3d d3
f 25 8a b5 e7 42 b3 c7 ea f7 4c 11 33 03 a2 ac 60

```
 |

הצופן עושה שימוש בתיבות ההחלפה בשני אופנים (כמתואר בתרשים לעיל). באופן הראשון הנקרא type 1 הבית הראשון מוחלף לפי התיבה הראשונה {\displaystyle S\_{1}} הבית השני לפי התיבה {\displaystyle S\_{2}}, השלישי והרביעי לפי ההופכיות שלהן {\displaystyle S\_{1}^{-1}} ו-{\displaystyle S\_{2}^{-1}} בהתאמה, החמישי והשישי שוב בתיבה הראשונה והשנייה וחוזר חלילה עד שמחליפים את כל בתי המצב. באופן השני הנקרא type 2 מבצעים את ההחלפה בסדר הפוך תחילה בתיבות ההופכיות {\displaystyle S\_{1}^{-1}} ו-{\displaystyle S\_{2}^{-1}} ולאחר מכן {\displaystyle S\_{1}} ו-{\displaystyle S\_{2}} לסירוגין, כמתואר בתרשים להלן. הפסאודו קוד הבא מתאר את פונקציות ההחלפה {\displaystyle SL\_{1}} ו-{\displaystyle SL\_{2}} לפי type 1 ו-type 2 בהתאמה, הקלט הוא המצב הנוכחי {\displaystyle X=x\_{0},...x\_{15}} והפלט הוא המצב החדש {\displaystyle Y=y\_{0},...y\_{15}}:


|  |
| --- |
| {\displaystyle Y=SL\_{1}(X)} |
| {\displaystyle y\_{0}=S\_{1}(x\_{0}),} | {\displaystyle y\_{1}=S\_{2}(x\_{1}),} | {\displaystyle y\_{2}=S\_{1}^{-1}(x\_{2}),} | {\displaystyle y\_{3}=S\_{2}^{-1}(x\_{3}),} |
| {\displaystyle y\_{4}=S\_{1}(x\_{4}),} | {\displaystyle y\_{5}=S\_{2}(x\_{5}),} | {\displaystyle y\_{6}=S\_{1}^{-1}(x\_{6}),} | {\displaystyle y\_{7}=S\_{2}^{-1}(x\_{7}),} |
| {\displaystyle y\_{8}=S\_{1}(x\_{8}),} | {\displaystyle y\_{9}=S\_{2}(x\_{9}),} | {\displaystyle y\_{10}=S\_{1}^{-1}(x\_{10}),} | {\displaystyle y\_{11}=S\_{2}^{-1}(x\_{11}),} |
| {\displaystyle y\_{12}=S\_{1}(x\_{12}),} | {\displaystyle y\_{13}=S\_{2}(x\_{13}),} | {\displaystyle y\_{14}=S\_{1}^{-1}(x\_{14}),} | {\displaystyle y\_{15}=S\_{2}^{-1}(x\_{15})} |



|  |  |  |  |
| --- | --- | --- | --- |
| ‎ | ‎ | ‎ |  |
| {\displaystyle Y=SL\_{2}(X)} |
| {\displaystyle y\_{0}=S\_{1}^{-1}(x\_{0}),} | {\displaystyle y\_{1}=S\_{2}^{-1}(x\_{1}),} | {\displaystyle y\_{2}=S\_{1}(x\_{2}),} | {\displaystyle y\_{3}=S\_{2}(x\_{3}),} |
| {\displaystyle y\_{4}=S\_{1}^{-1}(x\_{4}),} | {\displaystyle y\_{5}=S\_{2}^{-1}(x\_{5}),} | {\displaystyle y\_{6}=S\_{1}(x\_{6}),} | {\displaystyle y\_{7}=S\_{2}(x\_{7}),} |
| {\displaystyle y\_{8}=S\_{1}^{-1}(x\_{8}),} | {\displaystyle y\_{9}=S\_{2}^{-1}(x\_{9}),} | {\displaystyle y\_{10}=S\_{1}(x\_{10}),} | {\displaystyle y\_{11}=S\_{2}(x\_{11}),} |
| {\displaystyle y\_{12}=S\_{1}^{-1}(x\_{12}),} | {\displaystyle y\_{13}=S\_{2}^{-1}(x\_{13}),} | {\displaystyle y\_{14}=S\_{1}(x\_{14}),} | {\displaystyle y\_{15}=S\_{2}(x\_{15})} |

סדר השימוש בתיבות ההחלפה
### שכבת פיזור

שכבת הפיזור היא פונקציה המסומנת באות **A** הממפה קלט באורך 16 בתים {\displaystyle (x\_{0},x\_{1},...x\_{15})} לפלט באורך דומה {\displaystyle (y\_{0},y\_{1},...y\_{15})} והיא מוגדרת כדלהלן:

|  |  |
| --- | --- |
| 
{\displaystyle y\_{0}=x\_{3}\oplus x\_{4}\oplus x\_{6}\oplus x\_{8}\oplus x\_{9}\oplus x\_{13}\oplus x\_{14},}
{\displaystyle y\_{1}=x\_{2}\oplus x\_{5}\oplus x\_{7}\oplus x\_{8}\oplus x\_{9}\oplus x\_{12}\oplus x\_{15},}
{\displaystyle y\_{2}=x\_{1}\oplus x\_{4}\oplus x\_{6}\oplus x\_{10}\oplus x\_{11}\oplus x\_{12}\oplus x\_{15},}
{\displaystyle y\_{3}=x\_{0}\oplus x\_{5}\oplus x\_{7}\oplus x\_{10}\oplus x\_{11}\oplus x\_{13}\oplus x\_{14},}
{\displaystyle y\_{4}=x\_{0}\oplus x\_{2}\oplus x\_{5}\oplus x\_{8}\oplus x\_{11}\oplus x\_{14}\oplus x\_{15},}
{\displaystyle y\_{5}=x\_{1}\oplus x\_{3}\oplus x\_{4}\oplus x\_{9}\oplus x\_{10}\oplus x\_{14}\oplus x\_{15},}
{\displaystyle y\_{6}=x\_{0}\oplus x\_{2}\oplus x\_{7}\oplus x\_{9}\oplus x\_{10}\oplus x\_{12}\oplus x\_{13},}
{\displaystyle y\_{7}=x\_{1}\oplus x\_{3}\oplus x\_{6}\oplus x\_{8}\oplus x\_{11}\oplus x\_{12}\oplus x\_{13},}
 | {\displaystyle y\_{8}=x\_{0}\oplus x\_{1}\oplus x\_{4}\oplus x\_{7}\oplus x\_{10}\oplus x\_{13}\oplus x\_{15},}
{\displaystyle y\_{9}=x\_{0}\oplus x\_{1}\oplus x\_{5}\oplus x\_{6}\oplus x\_{11}\oplus x\_{12}\oplus x\_{14},}
{\displaystyle y\_{10}=x\_{2}\oplus x\_{3}\oplus x\_{5}\oplus x\_{6}\oplus x\_{8}\oplus x\_{13}\oplus x\_{15},}
{\displaystyle y\_{11}=x\_{2}\oplus x\_{3}\oplus x\_{4}\oplus x\_{7}\oplus x\_{9}\oplus x\_{12}\oplus x\_{14},}
{\displaystyle y\_{12}=x\_{1}\oplus x\_{2}\oplus x\_{6}\oplus x\_{7}\oplus x\_{9}\oplus x\_{11}\oplus x\_{12},}
{\displaystyle y\_{13}=x\_{0}\oplus x\_{3}\oplus x\_{6}\oplus x\_{7}\oplus x\_{8}\oplus x\_{10}\oplus x\_{13},}
{\displaystyle y\_{14}=x\_{0}\oplus x\_{3}\oplus x\_{4}\oplus x\_{5}\oplus x\_{9}\oplus x\_{11}\oplus x\_{14},}
{\displaystyle y\_{15}=x\_{1}\oplus x\_{2}\oplus x\_{4}\oplus x\_{5}\oplus x\_{8}\oplus x\_{10}\oplus x\_{15}.} |

שכבת הפיזור של ARIA תוכננה כך שהיא תהיה אינוולוציה כלומר עבור כל וקטור x מתקיים {\displaystyle A(A(x))=x}. דרך אחרת להציג את המיפוי של A היא על ידי כפל מטריצות הבא:

שכבת הפיזור של ARIA המבוצעת ככפל מטריצות
### פונקציות סבב

בכל סבב של צופן ARIA מופעלת אחת משתי הפונקציות {\displaystyle F\_{e}} ו-{\displaystyle F\_{o}} שהן פונקציות סבב זוגית ואי זוגית בהתאמה המבצעות את שלוש הפעולות המתוארות לפי הסדר: הוספת מפתח, החלפה ופיזור, או בניסוח רשמי: 

{\displaystyle F\_{o}(P\_{i},ek\_{i})=A(SL\_{1}(P\_{i}\oplus ek\_{i}))}
{\displaystyle F\_{e}(P\_{i},ek\_{i})=A(SL\_{2}(P\_{i}\oplus ek\_{i}))}

כאשר P\_i הוא הבלוק הקלט של סבב i ו-A היא פונקציית הפיזור, {\displaystyle SL\_{i}} מתייחס לשכבת ההחלפה והערכים {\displaystyle ek\_{i}} הם מפתחות הסבב אותם מכינים לפי תיאור תהליך הכנת המפתחות להלן. ההבדל בין שתי הפונקציות הוא סדר ההחלפה, ב-{\displaystyle F\_{o}} ההחלפה מבוצעת לפי type 1 ואילו {\displaystyle F\_{e}} היא לפי type 2.

### הכנת מפתח

תיאור תהליך הרחבת המפתח של ARIA
תהליך ההכנה של מפתחות ההצפנה עבור כל הסבבים כולל שני שלבים: בשלב הראשון מכינים ארבעה ערכים באורך 128 סיביות כל אחד המסומנים {\displaystyle W\_{0},W\_{1},W\_{2},W\_{3}} בהם מציבים את המפתח הסודי {\displaystyle MK} (מפתח מאסטר) שהוא המפתח הסודי שסופק על ידי המשתמש, תוך שימוש ברשת פייסטל בשלושה סבבים לפי השיטה הבאה. תחילה מחלקים את המפתח הסודי לשני חצאים ימין ושמאל, כלומר מציבים את 128 הסיביות הראשונות של {\displaystyle MK} במשתנה זמני {\displaystyle KL} ומה שנותר מהמפתח מציבים במשתנה זמני נוסף {\displaystyle KR}. יתר סיביות המשתנה הזמני {\displaystyle KR} מאופסות. כך שמתקבל:

{\displaystyle KL\ \|\ KR=MK\ \|\ 0...0}

הסימן \| מייצג שרשור. בשלב השני מיישמים את רשת פייסטל בשלושה סבבים כך:


|  |
| --- |
| 
{\displaystyle W\_{0}=KL}
{\displaystyle W\_{1}=F\_{o}(W\_{0},CK\_{1})\oplus KR}
{\displaystyle W\_{2}=F\_{e}(W\_{1},CK\_{2})\oplus W\_{0}}
{\displaystyle W\_{3}=F\_{o}(W\_{2},CK\_{3})\oplus W\_{1}}
 |

הפונקציות {\displaystyle F\_{e}} ו-{\displaystyle F\_{o}} הן פונקציות הסבב המתוארות לעיל כאשר הקבועים {\displaystyle CK\_{i}} משמשים כמפתחות הצפנה. כדי להכין את הקבועים {\displaystyle CK\_{i}} תחילה מחשבים את {\displaystyle 128\times 3} הסיביות הראשונות של חלק השבר של {\displaystyle \pi ^{-1}} כשהן מחולקות לשלושה המשתנים. הערכים הם:

{\displaystyle C\_{1}={\text{0x517cc1b727220a94fe12abe8fa9a6ee0}}}
{\displaystyle C\_{2}={\text{0x6db14acc9e21c820ff28b1d5ef5de2b0}}}
{\displaystyle C\_{3}={\text{0xdb92371d2126e9700324977504e8c90e}}}

ואז הקבועים {\displaystyle CK\_{i}} מוגדרים בהתאם לאורך המפתח, לדוגמה עבור מפתח 128 סיביות משתמשים בקבועים לפי הסדר הזה ואילו עבור מפתחות אחרים משנים את סדר הקבועים לפי הטבלה הבאה:


|  |  |  |  |
| --- | --- | --- | --- |
| גודל מפתח | {\displaystyle CK\_{1}} | {\displaystyle CK\_{2}} | {\displaystyle CK\_{3}} |
| {\displaystyle 128} | C\_{1} | {\displaystyle C\_{2}} | C\_{3} |
| {\displaystyle 192} | {\displaystyle C\_{2}} | C\_{3} | C\_{1} |
| {\displaystyle 256} | C\_{3} | C\_{1} | {\displaystyle C\_{2}} |

את מפתחות כל הסבבים מכינים על ידי שילוב של ערכי W\_{i} ומהם מייצרים את 17 מפתחות ההצפנה והפענוח עבור כל הסבבים:

|  |
| --- |
| 
{\displaystyle ek\_{1}=(W\_{0})\oplus (W\_{1}\lll ^{19}),ek\_{2}=(W\_{1})\oplus (W\_{2}\lll ^{19})},
{\displaystyle ek\_{3}=(W\_{2})\oplus (W\_{3}\lll ^{19}),ek\_{4}=(W\_{0}\lll ^{19})\oplus (W\_{3})},
{\displaystyle ek\_{5}=(W\_{0})\oplus (W\_{1}\lll ^{31}),ek\_{6}=(W\_{1})\oplus (W\_{2}\lll ^{31})},
{\displaystyle ek\_{7}=(W\_{2})\oplus (W\_{3}\lll ^{31}),ek\_{8}=(W\_{0}\lll ^{31})\oplus (W\_{3})},
{\displaystyle ek\_{9}=(W\_{0})\oplus (W\_{1}\lll ^{61}),ek\_{10}=(W\_{1})\oplus (W\_{2}\lll ^{61})},
{\displaystyle ek\_{11}=(W\_{2})\oplus (W\_{3}\lll ^{61}),ek\_{12}=(W\_{0}\lll ^{61})\oplus (W\_{3})},
{\displaystyle ek\_{13}=(W\_{0})\oplus (W\_{1}\lll ^{31}),ek\_{14}=(W\_{1})\oplus (W\_{2}\lll ^{31})},
{\displaystyle ek\_{15}=(W\_{2})\oplus (W\_{3}\lll ^{31}),ek\_{16}=(W\_{0}\lll ^{31})\oplus (W\_{3})},
{\displaystyle ek\_{17}=(W\_{0})\oplus (W\_{1}\lll ^{19})}
 |

הביטוי {\displaystyle \lll ^{n}} פירושו הזזה מעגלית ברמה של סיביות n צעדים לשמאל בגבולות משתנה באורך 32 סיביות.

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

{\displaystyle dk\_{1}=ek\_{n-1},dk\_{2}=A(ek\_{n}),dk\_{3}=A(ek\_{n-1}),...dk\_{n}=A(ek\_{2}),dk\_{n+1}=ek\_{1}}.

### הצפנה ופענוח

להצפנת בלוק טקסט קריא P באורך 16 בתים עם מפתח באורך 128 סיביות, משתמשים ב-13 מפתחות הסבבים {\displaystyle ek\_{1},ek\_{2},...ek\_{13}} מתהליך הכנת המפתחות לעיל ומבצעים:


|  |
| --- |
| 
{\displaystyle P\_{1}=F\_{o}(P,ek\_{1})}
{\displaystyle P\_{2}=F\_{e}(P\_{1},ek\_{2})}
{\displaystyle P\_{3}=F\_{o}(P\_{2},ek\_{3})}
{\displaystyle P\_{4}=F\_{e}(P\_{3},ek\_{4})}
{\displaystyle P\_{5}=F\_{o}(P\_{4},ek\_{5})}
{\displaystyle P\_{6}=F\_{e}(P\_{5},ek\_{6})}
{\displaystyle P\_{7}=F\_{o}(P\_{6},ek\_{7})}
{\displaystyle P\_{8}=F\_{e}(P\_{7},ek\_{8})}
{\displaystyle P\_{9}=F\_{o}(P\_{8},ek\_{9})}
{\displaystyle P\_{10}=F\_{e}(P\_{9},ek\_{10})}
{\displaystyle P\_{11}=F\_{o}(P\_{10},ek\_{11})}
{\displaystyle C=SL\_{2}(P\_{11}\oplus ek\_{12})\oplus ek\_{13}}
 |

C הוא הטקסט המוצפן. הפונקציות {\displaystyle F\_{e}} ו-{\displaystyle F\_{o}} הן פונקציות הסבב המתוארות לעיל. בסבב האחרון הושמטה פונקציית הפיזור A ובמקומה מבוצע חיבור עם המפתח ה-13. במקרה של מפתחות אחרים המבנה נותר זהה ורק מספר הסבבים משתנה. פונקציית הפענוח של ARIA זהה לחלוטין לפונקציית ההצפנה למעט מפתחות הסבבים המוחלפים ב-{\displaystyle dk\_{1},dk\_{2},...dk\_{13}} אותם מכינים ממפתחות ההצפנה כמתואר לעיל.

### וקטור בדיקה

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

|  |  |
| --- | --- |
| טקסט קריא להצפנה | {\displaystyle {\text{00112233445566778899aabbccddeeff}}} |
| מפתח | {\displaystyle {\text{000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f}}} |
| טקסט מוצפן | {\displaystyle {\text{f92bd7c79fb72e2f2b8f80c1972d24fc}}} |

קוד לדוגמה
----------

```
typedef unsigned int uint;
typedef unsigned char byte;
#define ARIA\_BLOCK\_SIZE 16
#define MODE\_ENC 0
#define MODE\_DEC 1
#define SWAPINT32(x) ( \
 (((x) & 0x000000FFUL) << 24) | (((x) & 0x0000FF00UL) << 8) | \
 (((x) & 0x00FF0000UL) >> 8) | (((x) & 0xFF000000UL) >> 24))

typedef struct
{
 uint nr;
 uint k[16];
 uint ek[68];
 uint dk[68];
 bool mode = false;
} AriaContext;

//Move operation
#define MOV128(b, a) \
 { \
 (b)[0] = (a)[0]; (b)[1] = (a)[1]; \
 (b)[2] = (a)[2]; (b)[3] = (a)[3]; \
 }

//XOR operation
#define XOR128(b, a) \
 { \
 (b)[0] ^= (a)[0]; (b)[1] ^= (a)[1]; \
 (b)[2] ^= (a)[2]; (b)[3] ^= (a)[3]; \
 }

//Rotate left operation
#define ROL128(b, a, n) \
 { \
 (b)[0] = ((a)[((n) / 32 + 0) % 4] << ((n) % 32)) | ((a)[((n) / 32 + 1) % 4] >> (32 - ((n) % 32))); \
 (b)[1] = ((a)[((n) / 32 + 1) % 4] << ((n) % 32)) | ((a)[((n) / 32 + 2) % 4] >> (32 - ((n) % 32))); \
 (b)[2] = ((a)[((n) / 32 + 2) % 4] << ((n) % 32)) | ((a)[((n) / 32 + 3) % 4] >> (32 - ((n) % 32))); \
 (b)[3] = ((a)[((n) / 32 + 3) % 4] << ((n) % 32)) | ((a)[((n) / 32 + 0) % 4] >> (32 - ((n) % 32))); \
 }

//Substitution layer SL1
#define SL1(b, a) \
 { \
 byte \*x = (byte \*) (a); \
 byte \*y = (byte \*) (b); \
 y[0] = sb1[x[0]]; y[1] = sb2[x[1]]; \
 y[2] = sb3[x[2]]; y[3] = sb4[x[3]]; \
 y[4] = sb1[x[4]]; y[5] = sb2[x[5]]; \
 y[6] = sb3[x[6]]; y[7] = sb4[x[7]]; \
 y[8] = sb1[x[8]]; y[9] = sb2[x[9]]; \
 y[10] = sb3[x[10]]; y[11] = sb4[x[11]]; \
 y[12] = sb1[x[12]]; y[13] = sb2[x[13]]; \
 y[14] = sb3[x[14]]; y[15] = sb4[x[15]]; \
 }

//Substitution layer SL2
#define SL2(b, a) \
 { \
 byte \*x = (byte \*) (a); \
 byte \*y = (byte \*) (b); \
 y[0] = sb3[x[0]]; y[1] = sb4[x[1]]; \
 y[2] = sb1[x[2]]; y[3] = sb2[x[3]]; \
 y[4] = sb3[x[4]]; y[5] = sb4[x[5]]; \
 y[6] = sb1[x[6]]; y[7] = sb2[x[7]]; \
 y[8] = sb3[x[8]]; y[9] = sb4[x[9]]; \
 y[10] = sb1[x[10]]; y[11] = sb2[x[11]]; \
 y[12] = sb3[x[12]]; y[13] = sb4[x[13]]; \
 y[14] = sb1[x[14]]; y[15] = sb2[x[15]]; \
 }

//Diffusion layer
#define A(b, a) \
 { \
 byte \*x = (byte \*) (a); \
 byte \*y = (byte \*) (b); \
 y[0] = x[3] ^ x[4] ^ x[6] ^ x[8] ^ x[9] ^ x[13] ^ x[14]; \
 y[1] = x[2] ^ x[5] ^ x[7] ^ x[8] ^ x[9] ^ x[12] ^ x[15]; \
 y[2] = x[1] ^ x[4] ^ x[6] ^ x[10] ^ x[11] ^ x[12] ^ x[15]; \
 y[3] = x[0] ^ x[5] ^ x[7] ^ x[10] ^ x[11] ^ x[13] ^ x[14]; \
 y[4] = x[0] ^ x[2] ^ x[5] ^ x[8] ^ x[11] ^ x[14] ^ x[15]; \
 y[5] = x[1] ^ x[3] ^ x[4] ^ x[9] ^ x[10] ^ x[14] ^ x[15]; \
 y[6] = x[0] ^ x[2] ^ x[7] ^ x[9] ^ x[10] ^ x[12] ^ x[13]; \
 y[7] = x[1] ^ x[3] ^ x[6] ^ x[8] ^ x[11] ^ x[12] ^ x[13]; \
 y[8] = x[0] ^ x[1] ^ x[4] ^ x[7] ^ x[10] ^ x[13] ^ x[15]; \
 y[9] = x[0] ^ x[1] ^ x[5] ^ x[6] ^ x[11] ^ x[12] ^ x[14]; \
 y[10] = x[2] ^ x[3] ^ x[5] ^ x[6] ^ x[8] ^ x[13] ^ x[15]; \
 y[11] = x[2] ^ x[3] ^ x[4] ^ x[7] ^ x[9] ^ x[12] ^ x[14]; \
 y[12] = x[1] ^ x[2] ^ x[6] ^ x[7] ^ x[9] ^ x[11] ^ x[12]; \
 y[13] = x[0] ^ x[3] ^ x[6] ^ x[7] ^ x[8] ^ x[10] ^ x[13]; \
 y[14] = x[0] ^ x[3] ^ x[4] ^ x[5] ^ x[9] ^ x[11] ^ x[14]; \
 y[15] = x[1] ^ x[2] ^ x[4] ^ x[5] ^ x[8] ^ x[10] ^ x[15]; \
 }

//S-box 1
static const byte sb1[256] =
{
 0x63, 0x7C, 0x77, 0x7B, 0xF2, 0x6B, 0x6F, 0xC5, 0x30, 0x01, 0x67, 0x2B, 0xFE, 0xD7, 0xAB, 0x76,
 0xCA, 0x82, 0xC9, 0x7D, 0xFA, 0x59, 0x47, 0xF0, 0xAD, 0xD4, 0xA2, 0xAF, 0x9C, 0xA4, 0x72, 0xC0,
 0xB7, 0xFD, 0x93, 0x26, 0x36, 0x3F, 0xF7, 0xCC, 0x34, 0xA5, 0xE5, 0xF1, 0x71, 0xD8, 0x31, 0x15,
 0x04, 0xC7, 0x23, 0xC3, 0x18, 0x96, 0x05, 0x9A, 0x07, 0x12, 0x80, 0xE2, 0xEB, 0x27, 0xB2, 0x75,
 0x09, 0x83, 0x2C, 0x1A, 0x1B, 0x6E, 0x5A, 0xA0, 0x52, 0x3B, 0xD6, 0xB3, 0x29, 0xE3, 0x2F, 0x84,
 0x53, 0xD1, 0x00, 0xED, 0x20, 0xFC, 0xB1, 0x5B, 0x6A, 0xCB, 0xBE, 0x39, 0x4A, 0x4C, 0x58, 0xCF,
 0xD0, 0xEF, 0xAA, 0xFB, 0x43, 0x4D, 0x33, 0x85, 0x45, 0xF9, 0x02, 0x7F, 0x50, 0x3C, 0x9F, 0xA8,
 0x51, 0xA3, 0x40, 0x8F, 0x92, 0x9D, 0x38, 0xF5, 0xBC, 0xB6, 0xDA, 0x21, 0x10, 0xFF, 0xF3, 0xD2,
 0xCD, 0x0C, 0x13, 0xEC, 0x5F, 0x97, 0x44, 0x17, 0xC4, 0xA7, 0x7E, 0x3D, 0x64, 0x5D, 0x19, 0x73,
 0x60, 0x81, 0x4F, 0xDC, 0x22, 0x2A, 0x90, 0x88, 0x46, 0xEE, 0xB8, 0x14, 0xDE, 0x5E, 0x0B, 0xDB,
 0xE0, 0x32, 0x3A, 0x0A, 0x49, 0x06, 0x24, 0x5C, 0xC2, 0xD3, 0xAC, 0x62, 0x91, 0x95, 0xE4, 0x79,
 0xE7, 0xC8, 0x37, 0x6D, 0x8D, 0xD5, 0x4E, 0xA9, 0x6C, 0x56, 0xF4, 0xEA, 0x65, 0x7A, 0xAE, 0x08,
 0xBA, 0x78, 0x25, 0x2E, 0x1C, 0xA6, 0xB4, 0xC6, 0xE8, 0xDD, 0x74, 0x1F, 0x4B, 0xBD, 0x8B, 0x8A,
 0x70, 0x3E, 0xB5, 0x66, 0x48, 0x03, 0xF6, 0x0E, 0x61, 0x35, 0x57, 0xB9, 0x86, 0xC1, 0x1D, 0x9E,
 0xE1, 0xF8, 0x98, 0x11, 0x69, 0xD9, 0x8E, 0x94, 0x9B, 0x1E, 0x87, 0xE9, 0xCE, 0x55, 0x28, 0xDF,
 0x8C, 0xA1, 0x89, 0x0D, 0xBF, 0xE6, 0x42, 0x68, 0x41, 0x99, 0x2D, 0x0F, 0xB0, 0x54, 0xBB, 0x16
};

//S-box 2
static const byte sb2[256] =
{
 0xE2, 0x4E, 0x54, 0xFC, 0x94, 0xC2, 0x4A, 0xCC, 0x62, 0x0D, 0x6A, 0x46, 0x3C, 0x4D, 0x8B, 0xD1,
 0x5E, 0xFA, 0x64, 0xCB, 0xB4, 0x97, 0xBE, 0x2B, 0xBC, 0x77, 0x2E, 0x03, 0xD3, 0x19, 0x59, 0xC1,
 0x1D, 0x06, 0x41, 0x6B, 0x55, 0xF0, 0x99, 0x69, 0xEA, 0x9C, 0x18, 0xAE, 0x63, 0xDF, 0xE7, 0xBB,
 0x00, 0x73, 0x66, 0xFB, 0x96, 0x4C, 0x85, 0xE4, 0x3A, 0x09, 0x45, 0xAA, 0x0F, 0xEE, 0x10, 0xEB,
 0x2D, 0x7F, 0xF4, 0x29, 0xAC, 0xCF, 0xAD, 0x91, 0x8D, 0x78, 0xC8, 0x95, 0xF9, 0x2F, 0xCE, 0xCD,
 0x08, 0x7A, 0x88, 0x38, 0x5C, 0x83, 0x2A, 0x28, 0x47, 0xDB, 0xB8, 0xC7, 0x93, 0xA4, 0x12, 0x53,
 0xFF, 0x87, 0x0E, 0x31, 0x36, 0x21, 0x58, 0x48, 0x01, 0x8E, 0x37, 0x74, 0x32, 0xCA, 0xE9, 0xB1,
 0xB7, 0xAB, 0x0C, 0xD7, 0xC4, 0x56, 0x42, 0x26, 0x07, 0x98, 0x60, 0xD9, 0xB6, 0xB9, 0x11, 0x40,
 0xEC, 0x20, 0x8C, 0xBD, 0xA0, 0xC9, 0x84, 0x04, 0x49, 0x23, 0xF1, 0x4F, 0x50, 0x1F, 0x13, 0xDC,
 0xD8, 0xC0, 0x9E, 0x57, 0xE3, 0xC3, 0x7B, 0x65, 0x3B, 0x02, 0x8F, 0x3E, 0xE8, 0x25, 0x92, 0xE5,
 0x15, 0xDD, 0xFD, 0x17, 0xA9, 0xBF, 0xD4, 0x9A, 0x7E, 0xC5, 0x39, 0x67, 0xFE, 0x76, 0x9D, 0x43,
 0xA7, 0xE1, 0xD0, 0xF5, 0x68, 0xF2, 0x1B, 0x34, 0x70, 0x05, 0xA3, 0x8A, 0xD5, 0x79, 0x86, 0xA8,
 0x30, 0xC6, 0x51, 0x4B, 0x1E, 0xA6, 0x27, 0xF6, 0x35, 0xD2, 0x6E, 0x24, 0x16, 0x82, 0x5F, 0xDA,
 0xE6, 0x75, 0xA2, 0xEF, 0x2C, 0xB2, 0x1C, 0x9F, 0x5D, 0x6F, 0x80, 0x0A, 0x72, 0x44, 0x9B, 0x6C,
 0x90, 0x0B, 0x5B, 0x33, 0x7D, 0x5A, 0x52, 0xF3, 0x61, 0xA1, 0xF7, 0xB0, 0xD6, 0x3F, 0x7C, 0x6D,
 0xED, 0x14, 0xE0, 0xA5, 0x3D, 0x22, 0xB3, 0xF8, 0x89, 0xDE, 0x71, 0x1A, 0xAF, 0xBA, 0xB5, 0x81
};

//S-box 3
static const byte sb3[256] =
{
 0x52, 0x09, 0x6A, 0xD5, 0x30, 0x36, 0xA5, 0x38, 0xBF, 0x40, 0xA3, 0x9E, 0x81, 0xF3, 0xD7, 0xFB,
 0x7C, 0xE3, 0x39, 0x82, 0x9B, 0x2F, 0xFF, 0x87, 0x34, 0x8E, 0x43, 0x44, 0xC4, 0xDE, 0xE9, 0xCB,
 0x54, 0x7B, 0x94, 0x32, 0xA6, 0xC2, 0x23, 0x3D, 0xEE, 0x4C, 0x95, 0x0B, 0x42, 0xFA, 0xC3, 0x4E,
 0x08, 0x2E, 0xA1, 0x66, 0x28, 0xD9, 0x24, 0xB2, 0x76, 0x5B, 0xA2, 0x49, 0x6D, 0x8B, 0xD1, 0x25,
 0x72, 0xF8, 0xF6, 0x64, 0x86, 0x68, 0x98, 0x16, 0xD4, 0xA4, 0x5C, 0xCC, 0x5D, 0x65, 0xB6, 0x92,
 0x6C, 0x70, 0x48, 0x50, 0xFD, 0xED, 0xB9, 0xDA, 0x5E, 0x15, 0x46, 0x57, 0xA7, 0x8D, 0x9D, 0x84,
 0x90, 0xD8, 0xAB, 0x00, 0x8C, 0xBC, 0xD3, 0x0A, 0xF7, 0xE4, 0x58, 0x05, 0xB8, 0xB3, 0x45, 0x06,
 0xD0, 0x2C, 0x1E, 0x8F, 0xCA, 0x3F, 0x0F, 0x02, 0xC1, 0xAF, 0xBD, 0x03, 0x01, 0x13, 0x8A, 0x6B,
 0x3A, 0x91, 0x11, 0x41, 0x4F, 0x67, 0xDC, 0xEA, 0x97, 0xF2, 0xCF, 0xCE, 0xF0, 0xB4, 0xE6, 0x73,
 0x96, 0xAC, 0x74, 0x22, 0xE7, 0xAD, 0x35, 0x85, 0xE2, 0xF9, 0x37, 0xE8, 0x1C, 0x75, 0xDF, 0x6E,
 0x47, 0xF1, 0x1A, 0x71, 0x1D, 0x29, 0xC5, 0x89, 0x6F, 0xB7, 0x62, 0x0E, 0xAA, 0x18, 0xBE, 0x1B,
 0xFC, 0x56, 0x3E, 0x4B, 0xC6, 0xD2, 0x79, 0x20, 0x9A, 0xDB, 0xC0, 0xFE, 0x78, 0xCD, 0x5A, 0xF4,
 0x1F, 0xDD, 0xA8, 0x33, 0x88, 0x07, 0xC7, 0x31, 0xB1, 0x12, 0x10, 0x59, 0x27, 0x80, 0xEC, 0x5F,
 0x60, 0x51, 0x7F, 0xA9, 0x19, 0xB5, 0x4A, 0x0D, 0x2D, 0xE5, 0x7A, 0x9F, 0x93, 0xC9, 0x9C, 0xEF,
 0xA0, 0xE0, 0x3B, 0x4D, 0xAE, 0x2A, 0xF5, 0xB0, 0xC8, 0xEB, 0xBB, 0x3C, 0x83, 0x53, 0x99, 0x61,
 0x17, 0x2B, 0x04, 0x7E, 0xBA, 0x77, 0xD6, 0x26, 0xE1, 0x69, 0x14, 0x63, 0x55, 0x21, 0x0C, 0x7D
};

//S-box 4
static const byte sb4[256] =
{
 0x30, 0x68, 0x99, 0x1B, 0x87, 0xB9, 0x21, 0x78, 0x50, 0x39, 0xDB, 0xE1, 0x72, 0x09, 0x62, 0x3C,
 0x3E, 0x7E, 0x5E, 0x8E, 0xF1, 0xA0, 0xCC, 0xA3, 0x2A, 0x1D, 0xFB, 0xB6, 0xD6, 0x20, 0xC4, 0x8D,
 0x81, 0x65, 0xF5, 0x89, 0xCB, 0x9D, 0x77, 0xC6, 0x57, 0x43, 0x56, 0x17, 0xD4, 0x40, 0x1A, 0x4D,
 0xC0, 0x63, 0x6C, 0xE3, 0xB7, 0xC8, 0x64, 0x6A, 0x53, 0xAA, 0x38, 0x98, 0x0C, 0xF4, 0x9B, 0xED,
 0x7F, 0x22, 0x76, 0xAF, 0xDD, 0x3A, 0x0B, 0x58, 0x67, 0x88, 0x06, 0xC3, 0x35, 0x0D, 0x01, 0x8B,
 0x8C, 0xC2, 0xE6, 0x5F, 0x02, 0x24, 0x75, 0x93, 0x66, 0x1E, 0xE5, 0xE2, 0x54, 0xD8, 0x10, 0xCE,
 0x7A, 0xE8, 0x08, 0x2C, 0x12, 0x97, 0x32, 0xAB, 0xB4, 0x27, 0x0A, 0x23, 0xDF, 0xEF, 0xCA, 0xD9,
 0xB8, 0xFA, 0xDC, 0x31, 0x6B, 0xD1, 0xAD, 0x19, 0x49, 0xBD, 0x51, 0x96, 0xEE, 0xE4, 0xA8, 0x41,
 0xDA, 0xFF, 0xCD, 0x55, 0x86, 0x36, 0xBE, 0x61, 0x52, 0xF8, 0xBB, 0x0E, 0x82, 0x48, 0x69, 0x9A,
 0xE0, 0x47, 0x9E, 0x5C, 0x04, 0x4B, 0x34, 0x15, 0x79, 0x26, 0xA7, 0xDE, 0x29, 0xAE, 0x92, 0xD7,
 0x84, 0xE9, 0xD2, 0xBA, 0x5D, 0xF3, 0xC5, 0xB0, 0xBF, 0xA4, 0x3B, 0x71, 0x44, 0x46, 0x2B, 0xFC,
 0xEB, 0x6F, 0xD5, 0xF6, 0x14, 0xFE, 0x7C, 0x70, 0x5A, 0x7D, 0xFD, 0x2F, 0x18, 0x83, 0x16, 0xA5,
 0x91, 0x1F, 0x05, 0x95, 0x74, 0xA9, 0xC1, 0x5B, 0x4A, 0x85, 0x6D, 0x13, 0x07, 0x4F, 0x4E, 0x45,
 0xB2, 0x0F, 0xC9, 0x1C, 0xA6, 0xBC, 0xEC, 0x73, 0x90, 0x7B, 0xCF, 0x59, 0x8F, 0xA1, 0xF9, 0x2D,
 0xF2, 0xB1, 0x00, 0x94, 0x37, 0x9F, 0xD0, 0x2E, 0x9C, 0x6E, 0x28, 0x3F, 0x80, 0xF0, 0x3D, 0xD3,
 0x25, 0x8A, 0xB5, 0xE7, 0x42, 0xB3, 0xC7, 0xEA, 0xF7, 0x4C, 0x11, 0x33, 0x03, 0xA2, 0xAC, 0x60
};

//Key scheduling constants
static const uint c[12] =
{
 SWAPINT32(0x517CC1B7), SWAPINT32(0x27220A94), SWAPINT32(0xFE13ABE8), SWAPINT32(0xFA9A6EE0),
 SWAPINT32(0x6DB14ACC), SWAPINT32(0x9E21C820), SWAPINT32(0xFF28B1D5), SWAPINT32(0xEF5DE2B0),
 SWAPINT32(0xDB92371D), SWAPINT32(0x2126E970), SWAPINT32(0x03249775), SWAPINT32(0x04E8C90E)
};

static void OF(uint \*d, const uint \*rk)
{
 uint t[4];
 XOR128(d, rk); //XOR D with RK
 SL1(t, d); //Substitution layer SL1
 A(d, t); //Diffusion layer
}

static void EF(uint \*d, const uint \*rk)
{
 uint t[4];
 XOR128(d, rk); //XOR D with RK
 SL2(t, d); //Substitution layer SL2
 A(d, t); //Diffusion layer
}

int ariaInit(AriaContext \*context, const byte \*key, size\_t keyLength)
{
 uint i;
 uint \*ek, \*dk;
 const uint \*ck1, \*ck2, \*ck3;
 uint w[16];

 //128-bit master key?
 if (keyLength == 16)
 {
 ck1 = c + 0; //Select the relevant constants
 ck2 = c + 4;
 ck3 = c + 8;
 //The number of rounds depends on the size of the master key
 context->nr = 12;
 } else if (keyLength == 24) { //192-bit master key?
 ck1 = c + 4; //Select the relevant constants
 ck2 = c + 8;
 ck3 = c + 0;
 //The number of rounds depends on the size of the master key
 context->nr = 14;
 } else if (keyLength == 32) { //256-bit master key?
 ck1 = c + 8; //Select the relevant constants
 ck2 = c + 0;
 ck3 = c + 4;
 //The number of rounds depends on the size of the master key
 context->nr = 16;
 }
 else return -1;

 //Compute 128-bit values KL and KR
 memset(w, 0, sizeof(w));
 memcpy(w, key, keyLength);

 //Save KR...
 MOV128(w + 8, w + 4);

 //Compute intermediate values W0, W1, W2, and W3
 MOV128(w + 4, w + 0);
 OF(w + 4, ck1);
 XOR128(w + 4, w + 8);

 MOV128(w + 8, w + 4);
 EF(w + 8, ck2);
 XOR128(w + 8, w + 0);

 MOV128(w + 12, w + 8);
 OF(w + 12, ck3);
 XOR128(w + 12, w + 4);

 //Convert from big-endian byte order to host byte order
 for (i = 0; i < 16; i++)
 w[i] = SWAPINT32(w[i]);

 //Point to the encryption round keys
 ek = context->ek;

 //Compute ek1, ... ek17 as follow
 ROL128(ek + 0, w + 4, 109); XOR128(ek + 0, w + 0);
 ROL128(ek + 4, w + 8, 109); XOR128(ek + 4, w + 4);
 ROL128(ek + 8, w + 12, 109); XOR128(ek + 8, w + 8);
 ROL128(ek + 12, w + 0, 109); XOR128(ek + 12, w + 12);
 ROL128(ek + 16, w + 4, 97); XOR128(ek + 16, w + 0);
 ROL128(ek + 20, w + 8, 97); XOR128(ek + 20, w + 4);
 ROL128(ek + 24, w + 12, 97); XOR128(ek + 24, w + 8);
 ROL128(ek + 28, w + 0, 97); XOR128(ek + 28, w + 12);
 ROL128(ek + 32, w + 4, 61); XOR128(ek + 32, w + 0);
 ROL128(ek + 36, w + 8, 61); XOR128(ek + 36, w + 4);
 ROL128(ek + 40, w + 12, 61); XOR128(ek + 40, w + 8);
 ROL128(ek + 44, w + 0, 61); XOR128(ek + 44, w + 12);
 ROL128(ek + 48, w + 4, 31); XOR128(ek + 48, w + 0);
 ROL128(ek + 52, w + 8, 31); XOR128(ek + 52, w + 4);
 ROL128(ek + 56, w + 12, 31); XOR128(ek + 56, w + 8);
 ROL128(ek + 60, w + 0, 31); XOR128(ek + 60, w + 12);
 ROL128(ek + 64, w + 4, 19); XOR128(ek + 64, w + 0);

 //Convert from host byte order to big-endian byte order
 for (i = 0; i < 68; i++)
 ek[i] = SWAPINT32(ek[i]);

 //Decryption round keys are derived from the encryption round keys
 dk = context->dk;
 //Compute dk1
 MOV128(dk + 0, ek + context->nr \* 4);

 //Compute dk2, ... dk(n)
 for (i = 1; i < context->nr; i++)
 A(dk + i \* 4, ek + (context->nr - i) \* 4);

 //Compute dk(n + 1)
 MOV128(dk + i \* 4, ek + 0);

 //No error to report
 return 0;
}

void ariaEncryptBlock(AriaContext \*context, const byte \*input, byte \*output, bool mode)
{
 uint \*ek;
 uint p[4], q[4];

 //Copy the plaintext to the buffer
 memcpy(p, input, ARIA\_BLOCK\_SIZE);

 //Point to the encryption/decryption round keys
 if(mode == MODE\_DEC) ek = context->dk;
 else ek = context->ek;
 
 //Apply 11 rounds
 OF(p, ek + 0); EF(p, ek + 4);
 OF(p, ek + 8); EF(p, ek + 12);
 OF(p, ek + 16); EF(p, ek + 20);
 OF(p, ek + 24); EF(p, ek + 28);
 OF(p, ek + 32); EF(p, ek + 36);
 OF(p, ek + 40);

 //128-bit master keys require a total of 12 rounds
 if (context->nr == 12)
 {
 XOR128(p, ek + 44);
 SL2(q, p);
 XOR128(q, ek + 48);
 } else if (context->nr == 14) { //192-bit master keys require a total of 14 rounds
 EF(p, ek + 44);
 OF(p, ek + 48);
 XOR128(p, ek + 52);
 SL2(q, p);
 XOR128(q, ek + 56);
 } else { //256-bit master keys require a total of 16 rounds
 EF(p, ek + 44);
 OF(p, ek + 48);
 EF(p, ek + 52);
 OF(p, ek + 56);
 XOR128(p, ek + 60);
 SL2(q, p);
 XOR128(q, ek + 64);
 }
 //Copy the resulting ciphertext from the buffer
 memcpy(output, q, ARIA\_BLOCK\_SIZE);
}

```

ראו גם
------

* צופן בלוקים
* AES
* SSL

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

1. ↑  New Block Cipher: ARIA
2. ↑  A. Biryukov; C. De Canni're; J. Lano; B. Preneel; S. B. Ors (January 7, 2004). "Security and Performance Analysis of ARIA"(PostScript). Version 1.2-Final Report. Katholieke Universiteit Leuven. Retrieved March 2, 2007.
3. ↑  Wenling Wu; Wentao Zhang; Dengguo Feng (2006). Impossible Differential Cryptanalysis of ARIA and Camellia (PDF). Retrieved January 19, 2007.
4. ↑  Xuehai Tang; Bing Sun; Ruilin Li; Chao Li (March 30, 2010). "A Meet-in-the-Middle Attack on ARIA" (PDF). Retrieved April 24, 2010.
5. ↑  Linear Cryptanalysis of ARIA Block Cipher
6. ↑  Security Analysis of the Keyschedule of ARIA-128

| * צ
* ש
* ע
קריפטוגרפיה |
| --- |
| 

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

 |

 |
| 

| הצפנה קלאסית |
| --- |
| 
* מכונת הצפנה
* צופן החלפה
* צופן אתב"ש
* צופן קיסר
* צופן ויז'נר
* צופן ורנם
* צופן פלייפייר
* צופן היל
* אולטרה
* אניגמה
* ציקלומטר
* קולוסוס
* PURPLE
* ג'ייד
* מג'יק
* צופן שחלוף

 |

 |
| 

| צופן בלוקים |
| --- |
| 
* לוציפר
* AES
* 3DES
* DES
* Threefish
* Twofish
* Blowfish
* FEAL
* SEED
* CAST
* IDEA
* RC2
* RC6
* MARS
* RC5
* GOST
* Serpent
* MISTY
* KASUMI
* קמליה
* ARIA
* SAFER
* TEA
* LEA
* CLEFIA
* SEA
* Hummingbird
* PRESENT
* KATAN
* KeeLoq
* Simon & Speck
* אנוביס

 |

 |
| 

| אופני הפעלה |
| --- |
| 
* אופן הפעלה של צופן בלוקים
* EAX
* OCB
* IAPM
* CWC mode
* GCM
* CCM

 |

 |
| 

| צופן זרם |
| --- |
| 
* RC4
* Salsa20
* SOSEMANUK
* Grain
* E0
* A5/1
* A5/2
* A5/3
* A5/4
* MICKEY
* HC-128
* SNOW
* Trivium
* Rabbit
* ZUC
* ChaCha

 |

 |
| 

| הצפנה אסימטרית |
| --- |
| 
* פרוטוקול דיפי-הלמן
* חידות מרקל
* חתימת למפורט
* הצפנת תרמיל
* RSA
* הצפנת רבין
* חתימה דיגיטלית רבין
* צופן אל-גמאל
* חתימה דיגיטלית אל-גמאל
* DSA
* הצפנת בלום-גולדווסר
* ECC
* הצפנת קריימר-שופ
* הצפנת פאיי
* הצפנת מקאליס
* GGH
* NTRU
* עקום 25519
* חתימה דיגיטלית של שנור
* הצפנת אוקמוטו-אושיאמה

 |

 |
| 

| פרוטוקולים |
| --- |
| 
* עץ מרקל
* פרוטוקול אתגר-מענה
* פרוטוקול נידהאם-שרודר
* פרוטוקול קרברוס
* הוכחה באפס ידע
* פרוטוקול פייגה-פיאט-שמיר
* העברה עלומה
* חלוקת סוד
* TLS (SSL)
* Secure Shell
* MQV
* X.509
* פרוטוקול שיתוף מפתח
* מיסור שלא לפרסום
* פרוטוקול סיגנל

 |

 |
| 

| פרימיטיבים תאורטיים |
| --- |
| 
* מחולל פסבדו-אקראי קריפטוגרפי
* פונקציה חד-כיוונית
* תמורה חד-כיוונית
* סיבית קשה
* פונקציה פסבדו-אקראית קריפטוגרפית
* תמורה פסאודו-אקראית
* פונקציית גיבוב קריפטוגרפית
* וקטור אתחול
* פונקציית ספוג
* הצפנה מבוססת סריג

 |

 |
| 

| קריפטואנליזה |
| --- |
| 
* ניתוח תדירויות
* כוח גס
* התקפת איזון זמן/זיכרון
* תקיפת היפגשות באמצע
* קריפטואנליזה ליניארית
* קריפטואנליזה דיפרנציאלית
* התקפת גלוי-ידוע
* התקפת גלוי-נבחר
* התקפת מוצפן-נבחר
* פירוק לגורמים של מספר שלם
* התקפת ערוץ צדדי
* התקפת קורלציה
* התקפת שיבוש
* מודל אורקל אקראי
* התקפת התנגשויות

 |

 |
| 

| בעיות מתמטיות ואלגוריתמים |
| --- |
| 
* בעיית לוגריתם דיסקרטי
* תחשיב אינדקסים
* נפה ריבועית
* אלגוריתם rho של פולרד
* נפת שדה מספרים
* אלגוריתם רו של פולרד ללוגריתמים
* אלגוריתם פוליג-הלמן

 |

 |
| 

| פונקציות גיבוב קריפטוגרפיות |
| --- |
| 
* SHA
* MD5
* MD4
* SHA-1
* SHA-2
* SHA-3
* RIPEMD
* Skein
* BLAKE
* Grøstl
* SipHash

 |

 |
| 

| אימות וזיהוי |
| --- |
| 
* אימות זהות
* סיסמה
* קוד אימות מסרים
* Poly1305
* סיסמה חד-פעמית

 |

 |
| 

| נושאים נלווים |
| --- |
| 
* מספר אקראי
* מספר ראשוני
* יתירות
* מפתח שיחה
* סטגנוגרפיה
* הצפנה קוונטית
* הצפנה פוסט-קוונטית
* עקרון קרקהופס
* אבטחת מידע
* קריפטוגרפיה ויזואלית
* אליס ובוב
* מסיבת חתימה על מפתחות ציבוריים
* שידור מוצפן
* הצפנת דיסקים
* הצפנת סף
* חתימה דיגיטלית מבוססת פונקציית גיבוב
* פונקציה זניחה
* רשת פייסטל
* רשת החלפה-תמורה
* הלבנה
* אימות מסרים
* חתימה עיוורת
* חישוב רב משתתפים בטוח

 |

 |