בתורת המספרים ובקריפטוגרפיה, **אלגוריתם רו של פולרד ללוגריתם הדיסקרטי** (באנגלית: Pollard’s rho algorithm for discrete logarithms) הוא אלגוריתם הסתברותי לחישוב לוגריתם בדיד בחבורה ציקלית סופית מסדר ראשוני עם זמן ריצה דומה לשיטת כוח גס גנרית הנקראת אלגוריתם צעד-קטן צעד-גדול אך עם צריכת זיכרון שולית ביחס אליה. האלגוריתם פותר את בעיית הלוגריתם הבדיד בהסתברות גבוהה, בסיבוכיות בסדר גודל של {\displaystyle O({\sqrt {n}})} כאשר {\displaystyle n} הוא סדר החבורה. לצורך אלגוריתם פולרד ההנחה היא שסדר החבורה הוא מספר ראשוני, שאם לא כן, אפשר בשילוב עם אלגוריתם פוליג-הלמן לפתור את בעיית הלוגריתם הבדיד בזמן ריצה שהוא בסדר גודל {\displaystyle O({\sqrt {p}})} כאשר {\displaystyle p} הוא הגורם הראשוני הגדול ביותר של {\displaystyle n}.

היסטוריה
--------

צורת האות היוונית "רו" של מיפוי אקראי
אלגוריתם רו הומצא על ידי המתמטיקאי הבריטי ג'ון פולרד והתפרסם במאמר "שיטת מונטה קרלו לחישוב אינדקסים" בכתב העת המדעי "Mathematics of Computation" ביולי 1978. בדומה לאלגוריתם רו של פולרד לפירוק לגורמים הוא נקרא בשם זה בשל העובדה שבמיפוי אקראי (או הילוך מקרי) בקבוצה סופית, נוצר מעין "מעגל" אליו מחובר "שובל" קצר וצורתו דומה במקצת לאות היוונית {\displaystyle \rho } (כמתואר בתרשים משמאל), כלומר בהינתן פונקציה אקראית לאחר מספר מוגבל של ערכים מגיעים לנקודה בה הערכים מתחילים לחזור על עצמם במעגל אין סופי. הרעיון של פולרד ניתן להרחבה לכל סוג של חבורה ציקלית, כמו חבורה אבלית מעל עקום אליפטי הידועה בפופולריות שלה בהצפנה המודרנית ולמעשה לא ידוע על אלגוריתם שמציג סיבוכיות טובה יותר לפתרון בעיית הלוגריתם הבדיד בעקום אליפטי. בחבורה ציקלית מעל מספר ראשוני קיים אלגוריתם תחשיב אינדקסים עם זמן ריצה תת-מעריכי והוא נחשב ליעיל ביותר הידוע כיום למספרים גדולים אך אינו בר ביצוע בעקום אליפטי.

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

בעיית הלוגריתם הבדיד
--------------------

 ערך מורחב – **בעיית הלוגריתם הבדיד**  

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

בעיית הלוגריתם הבדיד המסומנת בקיצור DLP היא כדלקמן:

|  |
| --- |
| **נתונה חבורה ציקלית סופית מסדר {\displaystyle n} המסומנת {\displaystyle G} ונתון יוצר {\displaystyle \alpha } של החבורה ויהי {\displaystyle \beta \in G} אלמנט כלשהו. מצא את הלוגריתם הבדיד של {\displaystyle \beta } בבסיס {\displaystyle \alpha } בקיצור {\displaystyle \log \_{\alpha }\beta } שהוא אלמנט יחיד {\displaystyle x} בטווח {\displaystyle 0\leq x\leq n-1} המקיים: {\displaystyle \beta =\alpha ^{x}}.** |

בעיית דיפי-הלמן בקיצור DHP, היא בעיה דומה שהועלתה לראשונה על ידי ויטפילד דיפי ומרטין הלמן במאמר המפורסם שלהם שבו הציגו לראשונה את הצפנת מפתח ציבורי ופרוטוקול שיתוף מפתח המבוסס על הבעיה הבאה: נתון המספר הראשוני {\displaystyle p} ויוצר {\displaystyle \alpha } של החבורה {\displaystyle \mathbb {Z} \_{p}^{\*}} וכן נתונים {\displaystyle \alpha ^{x}} ו-{\displaystyle \alpha ^{y}} (מודולו {\displaystyle p}). מצא את {\displaystyle \alpha ^{xy}} מודולו {\displaystyle p}. בעיה זו נחשבת גם היא לבעיה קשה אם כי לא הוכח האם היא קשה לפחות כבעיית הלוגריתם הבדיד. מאידך, כל דרך לפתרון בעיית הלוגריתם הדיקסרטי יכולה לשמש לפתרון בעיית דיפי-הלמן.

לדוגמה אם נתון המספר הראשוני {\displaystyle p=97} החבורה {\displaystyle \mathbb {Z} \_{97}^{\*}} היא חבורה ציקלית מסדר {\displaystyle n=96}. יוצר אפשרי אחד של חבורה זו יכול להיות {\displaystyle \alpha =5}. (קל לראות שאם מעלים את 5 בחזקת כל המספרים מ-1 עד 96 (מודולו 97) מתקבלים כל האלמנטים של החבורה בלי יוצא מן הכלל לא בהכרח לפי סדר עולה). אם נבחר {\displaystyle x=32} בחשבון פשוט מתקבל {\displaystyle 5^{32}\equiv 35{\text{ (mod }}97)} לכן {\displaystyle \log \_{5}35=32} בחבורה {\displaystyle \mathbb {Z} \_{97}^{\*}}. וכן, אם {\displaystyle y=17} אז {\displaystyle 5^{17}\equiv 83{\text{ (mod }}97)}. אם נתונים האלמנטים {\displaystyle 5^{32}\equiv 35} ו-{\displaystyle 5^{17}\equiv 83} (מודולו 97) בעיית דיפי-הלמן היא לגלות את {\displaystyle 5^{32\cdot 17}\equiv 61{\text{ (mod }}97)} (כשהאלמנטים {\displaystyle x} ו-{\displaystyle y} אינם ידועים).

הבעיה נקראת לוגריתם **בדיד** כיוון שהיא עוסקת בקבוצה סופית מודולו שלם כלשהו הנקרא מודולוס. ראוי לציין שאף-על-פי שקל לחשב לוגריתמים באופן כללי, אין הדבר נכון לגבי לוגריתם בדיד מכיוון שהתנהגות התוצאה נראית אקראית על פניה ולא ניתן לבצע קירוב. הסיבה שהבסיס הוא יוצר היא כדי שהחבורה תהיה ציקלית כך שכל אלמנט בחבורה ניתן לייצוג כחזקה של היוצר. הדרישה שהחבורה תהיה ציקלית אינה הכרחית, הגדרה כללית יותר של הבעיה, הנקראת בקיצור GDLP, היא מציאת אלמנט {\displaystyle x} המקיים {\displaystyle \alpha ^{x}=\beta }, בהנחה שקיים, עבור האלמנטים {\displaystyle \alpha ,\beta \in G} (כאשר {\displaystyle \alpha } אינו בהכרח יוצר). החבורה החיבורית הנוצרת על ידי עקום אליפטי כאשר הפעולה היא חיבור נקודות בעקום היא דוגמה לחבורה שבה בעיית הלוגריתם הבדיד קשה. אחת הדרכים לפתור את הבעיה היא בעצם חישוב איזומורפיזם בין חבורות. אפילו אם שתי חבורות איזומורפיות זו לזו, אלגוריתם יעיל לפתרון בעיית הלוגריתם הבדיד בחבורה אחת, אינו בהכרח יעיל בחבורה השנייה. למשל כל חבורה כפלית ציקלית מסדר {\displaystyle n} איזומורפית לחבורה החיבורית הציקלית {\displaystyle \mathbb {Z} \_{n}}. על כל פנים, בעוד שקיים אלגוריתם יעיל לחישוב לוגריתמים בחבורה החיבורית מעל המספרים השלמים מודולו מספר ראשוני, כלומר מציאת שלם המקיים {\displaystyle ax\equiv b{\text{ (mod }}n)}, לא ניתן ליישמו לפתרון הלוגריתם הבדיד בחבורה הכפלית.

הדרך הישירה והפשוטה ביותר לפתרון בעיית הלוגריתם הבדיד היא שיטת כוח גס, סריקת כל החזקות של {\displaystyle \alpha } בזה אחר זה מ-1 עד {\displaystyle n} עד שמתקבל {\displaystyle \beta } וסיבוכיותה היא מסדר גודל {\displaystyle O(n)}. היא אינה יעילה מהיבט קריפטוגרפי כיוון שאם {\displaystyle n} גדול (נניח באורך {\displaystyle n\geq 2^{128}} סיביות) התקפה כזו אינה פרקטית. שיטה מעט יותר טובה נקראת "צעד-קטן צעד-גדול" והיא מבוססת על העובדה שאם {\displaystyle \beta =\alpha ^{x}} אפשר לכתוב את {\displaystyle x} בצורה: {\displaystyle x=im+j} (לפי כלל החילוק המודולרי) כאשר {\displaystyle j<m} ו-{\displaystyle m=\left\lceil {\sqrt {n}}\right\rceil }. לכן {\displaystyle \alpha ^{x}=\alpha ^{im}\alpha ^{j}} לאחר העברת אגפים מתקבל {\displaystyle \beta (\alpha ^{-m})^{i}=\alpha ^{j}}. מהאמור עולה שאם מכינים טבלה המכילה את הזוגות ({\displaystyle j,\alpha ^{j}}) עבור כל המספרים מ-1 עד {\displaystyle m}, הממויינת לפי האלמנט השני, מובטח שיימצא אלמנט אחד (אם קיים פתרון) השווה ל-{\displaystyle \beta (\alpha ^{-m})^{i}}. היות שהטבלה היא בסדר גודל של השורש הריבועי של סדר החבורה וחיפוש בטבלה ממויינת אינו קשה, יוצא שסיבוכיות השיטה היא {\displaystyle O({\sqrt {n}})} אך היא דורשת סיבוכיות מקום בסדר גודל של {\displaystyle O({\sqrt {n}})} ועל כן אם {\displaystyle n} גדול מאוד (נניח {\displaystyle n\geq 2^{128}}) היא אינה פרקטית.

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

אלגוריתם רו של פולרד מנסה לייצר "סדרה פסידו-אקראית" של אלמנטים מהחבורה בהתבסס על רעיון מונטה קרלו וחיפוש אחר התנגשויות, כלומר שני אלמנטים זהים בסדרה. אם נמצאה התנגשות הדבר מוביל לפתרון בעיית הלוגריתם הבדיד בהסתברות גבוהה. שני רעיונות מרכזיים של פולרד הם **פונקציה איטרטיבית** אקראית קלה לחישוב, איתה מכינים את הסדרה הפסאודו-אקראית ואלגוריתם **מציאת מחזוריות** שמנסה למצוא בה התנגשות בזמן הקצר ביותר ללא שימוש בטבלאות. לצורך הפשטות נניח שנתונה חבורה ציקלית {\displaystyle G} מסדר {\displaystyle n} ראשוני.

תחילה מחלקים את {\displaystyle G} לשלוש קבוצות בגודל זהה בקירוב {\displaystyle S\_{1},S\_{2},S\_{3}}, בחלוקה לוגית בהתבסס על כלל מנחה קל לבדיקה. אפשר למשל לחלק לפי משקלו של כל אלמנט באופן הבא הקבוצה {\displaystyle S\_{1}} תכיל את כל האלמנטים: {\displaystyle \textstyle 0<x\_{i}<{\frac {1}{3}}n}, הקבוצה {\displaystyle S\_{2}} את האלמנטים {\displaystyle \textstyle {\frac {1}{3}}n<x\_{i}<{\frac {2}{3}}n} והשלישית {\displaystyle \textstyle {\frac {2}{3}}n<x\_{i}<n}. דרך אחרת יותר יעילה היא לחלק לפי הערך של {\displaystyle t} הסיביות הכי פחות משמעותיות של כל {\displaystyle x\_{i}} כאשר {\displaystyle t} תלוי במספר החלוקות (במקרה זה מספיק לבחון את שתי הסיביות האחרונות). מספר החלוקות שרירותי וניתן לשינוי, אך יש צורך לשים לב לכמה היבטים חשובים בנוגע לחלוקה למשל {\displaystyle 1\notin S\_{2}}.

מחשבים סדרה פסידו-אקראית של אלמנטים מהחבורה לפי הכלל הבא. בוחרים אלמנט התחלתי {\displaystyle x\_{0}=1} ועבור כל {\displaystyle i\geq 0} מחשבים:

{\displaystyle x\_{i+1}=f(x\_{i}){\overset {\underset {\mathrm {def} }{}}{=}}{\begin{cases}\beta \cdot x\_{i},&{\mbox{ if }}x\_{i}\in S\_{1}\\x\_{i}^{2},&{\mbox{ if }}x\_{i}\in S\_{2}\\\alpha \cdot x\_{i},&{\mbox{ if }}x\_{i}\in S\_{3}\end{cases}}}
בנוסף מתוך הסדרה האמורה מכינים שתי רשימות של שלמים {\displaystyle a\_{0},a\_{1},a\_{2},...} וכן {\displaystyle b\_{0},b\_{1},b\_{2},...} כאשר {\displaystyle a\_{0}=0} ו-{\displaystyle b\_{0}=0} ועבור כל {\displaystyle i\geq 0} מחשבים את

{\displaystyle a\_{i+1}={\begin{cases}a\_{i},&{\mbox{ if }}x\_{i}\in S\_{1}\\2a\_{i}{\text{ mod }}n,&{\mbox{ if }}x\_{i}\in S\_{2}\\a\_{i}+1{\text{ mod }}n,&{\mbox{ if }}x\_{i}\in S\_{3}\end{cases}}}
וכן

{\displaystyle b\_{i+1}={\begin{cases}b\_{i}+1{\text{ mod }}n,&{\mbox{ if }}x\_{i}\in S\_{1}\\2b\_{i}{\text{ mod }}n,&{\mbox{ if }}x\_{i}\in S\_{2}\\b\_{i},&{\mbox{ if }}x\_{i}\in S\_{3}\end{cases}}}
הערכים של {\displaystyle a\_{i}} ו-{\displaystyle b\_{i}} מחושבים כך שעבור כל {\displaystyle i} מתקיים {\displaystyle x\_{i}=\alpha ^{a\_{i}}\cdot \beta ^{b\_{i}}}. אם {\displaystyle x\_{i}=x\_{j}} כאשר {\displaystyle i\neq j} זה אומר שנמצאה "התנגשות". כדי למצוא התנגשות ביעילות האלגוריתם מנצל טכניקה המיוחסת לרוברט פלויד (לפי דונלד קנות') שנקראת מציאת מחזוריות או "שיטת הצב והארנב" שהיא שיטה יעילה לאיתור מחזוריות של פונקציה איטרטיבית אקראית על עצמה מהצורה {\displaystyle f:X\rightarrow X}. מנסים באופן רקורסיבי לאתר את הנקודה בה הסדרה מתחילה לחזור על עצמה. מבצעים בכל איטרציה שתי הליכות, הליכה איטית והליכה מהירה. בהליכה איטית מחשבים מתוך הערכים מהאיטרציה הקודמת את השלשה החדשה ({\displaystyle x\_{i},a\_{i},b\_{i}}) ובהליכה מהירה את {\displaystyle (x\_{2i},a\_{2i},b\_{2i})} ומשווים בין {\displaystyle x\_{i}} ל-{\displaystyle x\_{2i}}, אם הם שווים אותרה מחזוריות הפונקציה וזה אומר שמנקודה זו ואילך המסלול יחזור על עצמו במעגל אין סופי. סיבוכיות הטכניקה הזו זהה לשיטה הישירה המסתמכת על חיפוש בטבלאות ומבזבזת זיכרון רב. אם נמצאה התאמה המשמעות היא ש-{\displaystyle \alpha ^{a\_{i}}\beta ^{b\_{i}}=\alpha ^{a\_{2i}}\beta ^{b\_{2i}}} ולכן {\displaystyle \beta ^{b\_{i}-b\_{2i}}=\alpha ^{a\_{2i}-a\_{i}}}. אם לוקחים לוגריתם בבסיס {\displaystyle \alpha } של שני האגפים במשוואה האחרונה מתקבל

{\displaystyle (b\_{i}-b\_{2i})\cdot \log \_{\alpha }\beta \equiv (a\_{2i}-a\_{i}){\text{ (mod }}n)}.
בהנחה ש-{\displaystyle b\_{i}\not \equiv b\_{2i}{\text{ (mod }}n)}, שבכל מקרה עלול לקרות בהסתברות מאוד זניחה. מתוך המשוואה האחרונה אפשר לחלץ את {\displaystyle \log \_{\alpha }\beta } על ידי הכפלה בהופכי הכפלי של {\displaystyle (b\_{i}-b\_{2i})}.

פירוט מהלכי האלגוריתם
---------------------

**אלגוריתם רו של פולרד**

**קלט:** החבורה {\displaystyle G} מסדר {\displaystyle n}, יוצר {\displaystyle \alpha } והאלמנט {\displaystyle \beta }.

**פלט:** הלוגריתם הבדיד {\displaystyle x=\log \_{\alpha }\beta }.

1. מציבים {\displaystyle x\_{0}=1,a\_{0}=0,b\_{0}=0}.
2. מבצעים לולאה עם {\displaystyle i=1,2,3,...}
	1. מחשבים את הערכים של {\displaystyle x\_{i},a\_{i},b\_{i}} מתוך הערכים הקודמים {\displaystyle x\_{i-1},a\_{i-1},b\_{i-1}} וכן {\displaystyle x\_{2i-2},a\_{2i-2},b\_{2i-2}} לפי הנוסחאות המתוארות לעיל.
	2. אם {\displaystyle x\_{i}=x\_{2i}} מבצעים:
		1. מציבים {\displaystyle r=b\_{i}-b\_{2i}{\text{ mod }}n}
		2. אם {\displaystyle r=0} אלגוריתם מסתיים בכישלון אחרת מחזירים את {\displaystyle x=r^{-1}(a\_{2i}-a\_{i}){\text{ mod }}n}.

במקרה הנדיר שהאלגוריתם מסתיים בכישלון מגרילים {\displaystyle a\_{0},b\_{0}} אחרים ומתחילים מההתחלה כאשר {\displaystyle x\_{0}=\alpha ^{a\_{0}}\beta ^{b\_{0}}}.

### דוגמה במספרים קטנים

נתונה תת-חבורה {\displaystyle G} של החבורה {\displaystyle \mathbb {Z} \_{383}^{\*}} מסדר {\displaystyle n=191} עם היוצר {\displaystyle \alpha =2} ונתון {\displaystyle \beta =228}.
חלוקת האלמנטים של {\displaystyle G} לשלוש קבוצות מתבצעת לפי הכלל הבא: מחשבים את {\displaystyle x{\text{ mod }}3}, אם השארית 1 הוא שייך ל-{\displaystyle S\_{1}}, אם השארית היא 0 הוא שייך ל-{\displaystyle S\_{2}} ואילו אם השארית היא 2 הוא שייך ל-{\displaystyle S\_{3}}. הטבלה הבאה מסכמת את מהלכי האלגוריתם והערכים של {\displaystyle x\_{i},a\_{i},b\_{i}} וכן {\displaystyle x\_{2i},a\_{2i},b\_{2i}} לאחר כל איטרציה. באיטרציה ה-14 נמצאה התנגשות כי {\displaystyle x\_{14}=x\_{28}=144}. לכן מחשבים את {\displaystyle r=38-104=125{\text{ (mod }}191)} וההופכי שלו {\displaystyle 125^{-1}\equiv 136{\text{ (mod }}191)} ולכן {\displaystyle 136\cdot (10-12)\equiv 110{\text{ (mod }}191)} והפתרון הוא {\displaystyle \log \_{2}228=110} מודולו 191.


|  |  |  |  |  |  |  |
| --- | --- | --- | --- | --- | --- | --- |
| {\displaystyle i} | {\displaystyle x\_{i}} | {\displaystyle a\_{i}} | {\displaystyle b\_{i}} | {\displaystyle x\_{2i}} | {\displaystyle a\_{2i}} | {\displaystyle b\_{2i}} |
| 1 | 228 | 0 | 1 | 279 | 0 | 2 |
| 2 | 279 | 0 | 2 | 184 | 1 | 4 |
| 3 | 92 | 0 | 4 | 14 | 1 | 6 |
| 4 | 184 | 1 | 4 | 256 | 2 | 7 |
| 5 | 205 | 1 | 5 | 304 | 3 | 8 |
| 6 | 14 | 1 | 6 | 121 | 6 | 18 |
| 7 | 28 | 2 | 6 | 144 | 12 | 38 |
| 8 | 256 | 2 | 7 | 235 | 48 | 152 |
| 9 | 152 | 2 | 8 | 72 | 48 | 154 |
| 10 | 304 | 3 | 8 | 14 | 96 | 118 |
| 11 | 372 | 3 | 9 | 256 | 97 | 119 |
| 12 | 121 | 6 | 18 | 304 | 98 | 120 |
| 13 | 12 | 6 | 19 | 121 | 5 | 51 |
| 14 | 144 | 12 | 38 | 144 | 10 | 104 |

אלגוריתם רו של פולרד בעקום אליפטי
---------------------------------

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

|  |
| --- |
| **נתון עקום אליפטי {\displaystyle E} המוגדר מעל השדה {\displaystyle \mathbb {F} \_{q}}, נתונה נקודה {\displaystyle P\in E(\mathbb {F} \_{q})} מסדר {\displaystyle n} ונקודה {\displaystyle Q\in \langle P\rangle }, מצא שלם {\displaystyle l} בטווח {\displaystyle [0,n-1]} המקיים {\displaystyle Q=lP}.** |

השלם {\displaystyle l} נקרא **הלוגריתם הבדיד** של הנקודה {\displaystyle Q} בבסיס הנקודה {\displaystyle P} או בקיצור {\displaystyle l=\log \_{P}Q}. אם הפרמטרים של העקום {\displaystyle E} נבחרו בזהירות כדי להבטיח שלא יהיו קיצורי דרך לפתרון הבעיה בעקום זה, הדרך הטובה ביותר לפתרונה היא באמצעות אלגוריתם רו של פולרד בסיבוכיות של {\displaystyle {\sqrt {n}}}. הסימון {\displaystyle \langle P\rangle } מייצג את כל הנקודות שהן כפולות של {\displaystyle P}. (כגון {\displaystyle P,2P,3P,4P,...} וכן הלאה עד {\displaystyle n}). במילים אחרות, הנקודה {\displaystyle Q} היא תוצאה של חיבור הנקודה {\displaystyle P} בעצמה (הנקראת בקיצור POINT\_DBL) בדיוק {\displaystyle l} פעמים והבעיה היא לגלות כמה פעמים בוצע החיבור, קרי לגלות את ערכו של {\displaystyle l}. לא קיימת דרך פשוטה לבצע זאת כי המסלול של הנקודות נראה אקראי. שיטת כוח גס אינה מעשית משום שבמקרה הממוצע יש צורך לבדוק לפחות מחצית מהנקודות עד שנמצא {\displaystyle lP}. אם {\displaystyle n\geq 2^{128}} כוח גס אינו מעשי. כמובן שיש לשים לב של-{\displaystyle n} יש לפחות גורם ראשוני אחד גדול דיו. שאם לא כן אפשר לנצל את אלגוריתם פוליג-הלמן בזמן שהוא ביחס ישיר לגודל הגורמים הראשוניים שלו. למעשה ככל שהגורם הראשוני שלו (לפחות אחד מהם) גדול יותר סיבוכיות ההתקפה תהיה גבוהה יותר.

### תיאור כללי

כמו בחבורה ציקלית, הרעיון של אלגוריתם רו בעקום אליפטי הוא למצוא שני זוגות שלמים ({\displaystyle c,d}) וכן ({\displaystyle e,f}) מודולו {\displaystyle n} המקיימים:

{\displaystyle cP+dQ=eP+fQ}
ואז

{\displaystyle (c-e)P=(f-d)Q=(f-d)lP}
ולכן

{\displaystyle (c-e)\equiv (f-d)l{\text{ (mod }}n)}
מזה נובע שאפשר לחשב את {\displaystyle l=\log \_{P}Q} על ידי {\displaystyle l=(c-e)(f-d)^{-1}{\text{ mod }}n}.

הדרך הישירה למצוא זוגות המקיימים את המשוואה האמורה היא על ידי בחירה אקראית ואחסון בטבלה. אם מכינים טבלה המכילה את כל השלשות: ({\displaystyle c,d,cP+dQ}) וממיינים לפי הערך השלישי, מובטח שבסופו של דבר הערך הזה יופיע פעם נוספת מה שיאפשר לגלות את הלוגריתם הבדיד כאמור. תופעה שבה הערך השלישי מופיע פעמיים כאשר הערכים האחרים שונים נקראת "התנגשות". לפי פרדוקס יום ההולדת מספר הניסיונות הצפוי לפני שתופיע התנגשות הוא בערך {\displaystyle \textstyle {\sqrt {\pi n/2}}} שזה בערך {\displaystyle \textstyle 1.2533{\sqrt {n}}}. אולם החסרון בשיטה זו הוא שיש צורך בזיכרון רב, ליתר דיוק {\displaystyle \textstyle {\sqrt {\pi n/2}}} שלשות. אלגוריתם רו מנסה להימנע משימוש בזיכרון על ידי **שיטת הצב והארנב**. מגדירים פונקציה איטרטיבית אקראית {\displaystyle \langle P\rangle \rightarrow \langle P\rangle } כך שבהינתן {\displaystyle X\in \langle P\rangle } והערכים {\displaystyle c} ו-{\displaystyle d} כך שמתקיים {\displaystyle X=cP+dQ} יהיה קל לחשב את {\displaystyle {\overline {X}}=f(X)} ואת {\displaystyle {\overline {c}},{\overline {d}}} כך שמתקיים {\displaystyle {\overline {X}}={\overline {c}}P+{\overline {d}}Q}.

לדוגמה, אם מחלקים את החבורה הציקלית {\displaystyle \langle P\rangle } ל-{\displaystyle L} רשימות בגודל זהה בקירוב (למשל {\displaystyle L=32}), מציבים כל נקודה {\displaystyle X\_{i}} ברשימה המתאימה {\displaystyle S\_{j}} אם הערך של 5 הסיביות הכי פחות משעותיות של הקואורדינטה {\displaystyle x} של הנקודה {\displaystyle X\_{i}} הוא {\displaystyle j-1}. נניח ששיטת חלוקה זו תסומן ב-{\displaystyle H(X)} ונניח שהערכים {\displaystyle a\_{j}} ו-{\displaystyle b\_{j}} הם שלמים אקראיים כלשהם הנמוכים מ-{\displaystyle n} כאשר {\displaystyle j} מתפרס על פני כל הרשימות של {\displaystyle L}, במקרה זה פונקציה אקראית איטרטיבית יכולה להיות:



f
(
X
)
=
X
+

a

j

P
+

b

j

Q

{\displaystyle f(X)=X+a\_{j}P+b\_{j}Q}

{\displaystyle f(X)=X+a_{j}P+b_{j}Q} כאשר {\displaystyle j=H(X)}
ולכן אם {\displaystyle X=cP+dQ} אז הפונקציה האקראית היא {\displaystyle f(X)={\overline {X}}={\overline {c}}P+{\overline {d}}Q} כאשר {\displaystyle {\overline {c}}=c+a\_{j}{\text{ mod }}n} וכן {\displaystyle {\overline {d}}=d+b\_{j}{\text{ mod }}n}.
כל נקודה התחלתית {\displaystyle X\_{0}\in \langle P\rangle } מגדירה סדרה אחרת {\displaystyle \{X\_{i}\}\_{i\geq 0}} של נקודות כאשר כל נקודה מחושבת על ידי הנקודה הקודמת, {\displaystyle X\_{i}=f(X\_{i-1})}. היות שהחבורה הזו סופית בהכרח שתיגרם התנגשות, כלומר ערך של {\displaystyle X\_{i}} כלשהו יופיע שוב ומנקודה זו ואילך הסדרה תחזור על עצמה במעגל אין סופי. כלומר יופיע האינדקס הקטן ביותר {\displaystyle t} המקיים {\displaystyle X\_{t}=X\_{t+s}}עבור {\displaystyle s} כלשהו ומכאן ואילך {\displaystyle X\_{i}=X\_{i-s}} עבור כל {\displaystyle i\geq t+s}. כאן {\displaystyle t} הוא אורך השובל ו-{\displaystyle s} הוא היקף מעגל במונחים של מספר האיטרציות של הפונקציה האיטרטיבית האקראית. אם {\displaystyle f} היא פונקציה אקראית אז ההתנגשות הראשונה צפויה לקרות לאחר {\displaystyle \textstyle {\sqrt {\pi n/2}}} צעדים בקירוב. אורך השובל הוא {\displaystyle \textstyle t\approx {\sqrt {\pi n/8}}} ואורך המעגל צריך להיות {\displaystyle \textstyle s\approx {\sqrt {\pi n/8}}} בקירוב.

התנגשות היא מצב שבו {\displaystyle X\_{i}=X\_{j}} כאשר {\displaystyle i\neq j} ואותה אפשר למצוא ללא צורך בזיכרון באמצעות שיטת פלויד או שיטת הצב והארנב. בשיטה זו מחשבים בכל צעד את הנקודות {\displaystyle X\_{i}} ו-{\displaystyle X\_{2i}} ומנסים למצוא התאמה. מספר הזוגות הצפוי שיש לבדוק הוא לכל הפחות {\displaystyle t} זוגות ולכל היותר {\displaystyle t+s} זוגות, עד שתמצא התנגשות. ליתר דיוק בהנחה ש-{\displaystyle f} אקראית מספר הזוגות הצפוי שצריך לבדוק עד שתמצא התנגשות הוא {\displaystyle \textstyle k=1.0308{\sqrt {n}}}. מספר החישובים שיש לבצע בעקום האליפטי הוא בערך {\displaystyle \textstyle 3{\sqrt {n}}} פעולות חיבור נקודות.

### פירוט מהלכי האלגוריתם

אלגוריתם רו של פולרד לחישוב לוגריתם בדיד בעקום אליפטי.

**קלט**: הנקודה {\displaystyle P\in E(\mathbb {F} \_{q})} מסדר {\displaystyle n} והנקודה {\displaystyle Q\in \langle P\rangle }

**פלט**: הלוגריתם הבדיד {\displaystyle l=\log \_{P}Q}.

1. תחילה בוחרים את מספר הענפים או רשימות {\displaystyle L} ואת פונקציית החלוקה {\displaystyle H} שמציבה כל נקודה ברשימה המתאימה לפי הכלל {\displaystyle j}.
2. עבור {\displaystyle j=1} עד {\displaystyle L} מבצעים:
	1. מגרילים שני שלמים {\displaystyle a\_{j},b\_{j}} ומחשבים את {\displaystyle R\_{j}=a\_{j}P+b\_{j}Q}.
3. מגרילים זוג שלמים נוספים {\displaystyle c,d} ומחשבים את {\displaystyle X'=cP+dQ}.
4. מציבים {\displaystyle X''=X',e=c,f=d}.
5. חוזרים על המהלכים הבאים:
	1. {\displaystyle j=H(X')}
	2. {\displaystyle X'=X'+R\_{j},c=c+a\_{j},d=d+b\_{j}{\text{ (mod }}n)}.
	3. עבור {\displaystyle i=1} עד 2 מבצעים:
		1. {\displaystyle j=H(X'')}
		2. {\displaystyle X'=X'+R\_{j},c=c}
		3. {\displaystyle X''=X''+R\_{j},e=e+a\_{j},f=f+b\_{j}{\text{ (mod }}n)}.
	4. עד שמתקבל {\displaystyle X'=X''}.
6. אם {\displaystyle d=f} האלגוריתם הסתיים בכישלון, אחרת מחזירים את {\displaystyle l=(c-e)(f-d)^{-1}{\text{ mod }}n}.

### דוגמה במספרים קטנים

נתון העקום {\displaystyle E(\mathbb {F} \_{229})} עם המשוואה {\displaystyle E:y^{2}=x^{3}+x+44}. נקודה {\displaystyle P=(x,y)=(5,116)} היא מסדר ראשוני {\displaystyle n=239}. תהי הנקודה {\displaystyle Q=(155,166)\in \langle P\rangle }. כדי למצוא את {\displaystyle l=\log \_{P}Q} מגדירים תחילה {\displaystyle L=4} ובוחרים פונקציית חלוקה {\displaystyle H:\langle P\rangle \rightarrow \{1,2,3,4\}} לפי הכלל:

{\displaystyle H(x,y)=(x{\text{ mod }}4)+1}
בוחרים ומחשבים ארבע שלשות:

{\displaystyle [a\_{1},b\_{1},R\_{1}]=[79,163,(135,117)]}
{\displaystyle [a\_{2},b\_{2},R\_{2}]=[206,19,(96,97)]}
{\displaystyle [a\_{3},b\_{3},R\_{3}]=[87,109,(84,62)]}
{\displaystyle [a\_{4},b\_{4},R\_{4}]=[219,68,(72,134)]}
הטבלה הבאה מציגה את השלשות ({\displaystyle c,d,X'}) ו-({\displaystyle e,f,X''}) המתקבלות לאחר הצעד הרביעי באלגוריתם עבור המקרה {\displaystyle (c,d)=(54,175)}.


| {\displaystyle i} | {\displaystyle c} | {\displaystyle d} | {\displaystyle X} | {\displaystyle c} | {\displaystyle d} | {\displaystyle X} |
| --- | --- | --- | --- | --- | --- | --- |
| – | 54 | 175 | (39,159) | 54 | 175 | (39,159) |
| 1 | 34 | 4 | (160,9) | 113 | 167 | (130,182) |
| 2 | 113 | 167 | (130,182) | 180 | 105 | (36,97) |
| 3 | 200 | 37 | (27,17) | 0 | 97 | (108,89) |
| 4 | 180 | 105 | (36,97) | 46 | 40 | (223,153) |
| 5 | 20 | 29 | (119,180) | 232 | 127 | (167,57) |
| 6 | 0 | 97 | (108,89) | 192 | 24 | (57,105) |
| 7 | 79 | 21 | (81,168) | 139 | 111 | (185,227) |
| 8 | 46 | 40 | (223,153) | 193 | 0 | (197,92) |
| 9 | 26 | 108 | (9,18) | 140 | 87 | (194,145) |
| 10 | 232 | 127 | (167,57) | 67 | 120 | (223,153) |
| 11 | 212 | 195 | (75,136) | 14 | 207 | (167,57) |
| 12 | 192 | 24 | (57,105) | 213 | 104 | (57,105) |

אפשר לראות בשורה האחרונה בטבלה שהאלגוריתם מצא התנגשות כי:

{\displaystyle 192P+24Q=213P+104Q}
לכן

{\displaystyle l=(192-213)\cdot (104-24)^{-1}{\text{ mod }}239=176}.
### שיפורים

בגלל הפופולריות של עקומים אליפטיים בקריפטוגרפיה, נעשה מאמץ לשפר את אלגוריתם רו של פולרד בין היתר על ידי עיבוד מקבילי. נניח שזמינים {\displaystyle M} מחשבים לצורך פתרון הבעיה. הדרך הנאיבית היא להריץ את האלגוריתם על כל מחשב בנפרד עם נקודות התחלה אקראיות שונות, עד שאחד מהם יגלה התנגשות. שיטה זו אינה מנצלת את פוטנציאל המקביליות כי השיפור בביצועים הוא בפקטור {\displaystyle {\sqrt {M}}} לכל היותר. פול ואן-אורשוט ומייקל ויינר הציעו גרסה מקבילית של אלגוריתם רו שמניבה שיפור בביצועים בפקטור של {\displaystyle M}. הרעיון הוא לאפשר לכל הסדרות {\displaystyle \{X\_{i}\}\_{i\geq 0}} של כל המעבדים להתנגש אחת עם השנייה. ביתר פירוט, כל מעבד בוחר לעצמו נקודת התחלה {\displaystyle X\_{0}} באופן אקראי בנפרד מהאחרים, אולם כל המעבדים משתמשים באותה פונקציה איטרטיבית כדי לחשב את האלמנט הבא בסדרה {\displaystyle X\_{i+1}}. לכן, אם נוצרת התנגשות בין שתי סדרות, כל הנקודות של שתי הסדרות החל בנקודה שבה הופיעה התנגשות תהיינה זהות. כדי להתאים את אלגוריתם פלויד למציאת מחזוריות בין סדרות נפרדות שנוצרות על ידי מעבדים שונים, נוקטים באסטרטגיה הבאה, בוחרים מאפיין ייחודי קל לזיהוי המשמש כ"נקודה מובחנת" (Distinguished Point). נקודה מובחנת יכולה להיות כזו המכילה למשל רצף של {\displaystyle t} אפסים מובילים בקואורדינטה {\displaystyle x} שלה. בכל פעם שמעבד נתקל בנקודה מובחנת כזו הוא משדר את הנקודה לשרת מרכזי שאוסף את כל הנקודות המובחנות מכל המעבדים וממיין אותם בזיכרון. אם השרת מקבל בשלב כלשהו נקודה מובחנת שכבר התקבלה קודם לכן, הוא מחשב את הלוגריתם הבדיד ומסיים בהצלחה.

אם הפרופורציה של הנקודות המובחנות ב-{\displaystyle \langle P\rangle } היא {\displaystyle \theta } הסיכויים לקבל התנגשות הם בערך {\displaystyle 1/\theta } לכן מספר פעולות כפל נקודות בעקום הצפוי מכל מעבד עד שמתקבלת התנגשות אחת הוא

{\displaystyle {\frac {1}{M}}{\sqrt {\frac {\pi n}{2}}}+{\frac {1}{\theta }}}.
בכך מושגת האצה ליניארית במהירות הביצוע של האלגוריתם ביחס למספר המעבדים הזמינים. ההתקשרות עם השרת המרכזי היא מינימלית וכן אין צורך בתקשורת כלשהי של המחשבים בינם לבין עצמם מלבד עם השרת. אפשר לשלוט בכמות הזיכרון הנדרשת בשרת המרכזי על ידי בחירה נכונה של תכונת ההבחנה באופן כזה שמצד אחד לא תהיה נדירה ויהיה קשה למצוא נקודה כזו אך מצד שני שלא תהיה תדירה מדי ואז כמות הזיכרון עלולה להיות מופרזת.

דרך נוספת לשפר ביצועים היא על ידי שימוש באוטומורפיזם. יהי {\displaystyle \psi :\langle P\rangle \rightarrow \langle P\rangle } אוטומורפיזם של חבורה, כאשר {\displaystyle P} היא נקודה בעקום מסדר {\displaystyle n}. בהנחה שקל לחשב את {\displaystyle \psi } והיא מסדר {\displaystyle t}. כלומר {\displaystyle t} הוא השלם הקטן ביותר כך ש-{\displaystyle \psi ^{t}(R)=R} עבור כל {\displaystyle R} ב-{\displaystyle \langle P\rangle }. מגדירים יחס שקילות על {\displaystyle \langle P\rangle } המסומן {\displaystyle \sim } על ידי

{\displaystyle R\_{1}\sim R\_{2}} אם ורק אם {\displaystyle R\_{1}=\psi ^{j}(R\_{2})} עבור {\displaystyle j} בטווח {\displaystyle [0,t-1]}. מחלקת השקילות [R] היא
{\displaystyle [R]=\{R,\psi (R),\psi ^{2}(R),...\psi ^{l-1}(R)\}}
כאשר {\displaystyle l} הוא המחלק הקטן ביותר של {\displaystyle t} המקיים {\displaystyle \psi ^{l}(R)=R}.
הרעיון בהאצת האלגוריתם הוא לשנות את פונקציית האיטרציה {\displaystyle f} שתהיה מעל מחלקת השקילות {\displaystyle [R]}. כדי לעשות זאת מגדירים הצגה קנונית של {\displaystyle {\overline {R}}} של כל מחלקת שקילות {\displaystyle [R]}. למשל {\displaystyle {\overline {R}}} יכולה להיות הנקודה ב-{\displaystyle [R]} שהקואורדינטה {\displaystyle x} שלה היא השלם הקטן ביותר. או למשל העתקת השלילה {\displaystyle \psi (P)=-P}. שאז אפשר להגדיר את פונקציית האיטרציה {\displaystyle g} על ידי

{\displaystyle g(R)={\overline {f(R)}}}.
אם נניח שקיים שלם {\displaystyle \lambda } המקיים {\displaystyle \psi (P)=\lambda P} אז, היות ש-{\displaystyle \psi } היא אוטומורפית מתקבל {\displaystyle \psi (R)=\lambda R} עבור כל {\displaystyle R\in \langle P\rangle }. אם מוצאים שני שלמים {\displaystyle a,b} המקיימים {\displaystyle X=aP+bQ} אז אפשר לחשב בקלות את השלמים {\displaystyle a',b'} המקיימים {\displaystyle {\overline {X}}=a'P+b'Q}. אם {\displaystyle {\overline {X}}=\psi ^{j}(X)} אז {\displaystyle a'=\lambda ^{j}a{\text{ mod }}n} וכן {\displaystyle b'=\lambda ^{j}b{\text{ mod }}n}. הפונקציה {\displaystyle g} כאן משמשת כפונקציה איטרטיבית באלגוריתם רו בגרסה המקבילית שלו עם {\displaystyle M} מעבדים. הנקודה התחלתית של כל סדרה היא {\displaystyle X\_{0}'={\overline {X\_{0}}}} כאשר {\displaystyle X\_{0}=a\_{0}P+b\_{0}Q} ו-{\displaystyle a\_{0},b\_{0}} הם שלמים אקראיים הנמוכים מ-{\displaystyle n}. הנקודות הבאות בכל סדרה מחושבות על ידי {\displaystyle X\_{i}'=g(X\_{i-1}')}. אם רוב מחלקות השקילות של {\displaystyle \langle P\rangle } הן באורך {\displaystyle t} אז טווח החיפוש מצטמצם ל-{\displaystyle n/t} ולכן זמן הרצוי המשוער של האלגוריתם בגרסה משופרת זו הוא

{\displaystyle {\frac {1}{M}}{\sqrt {\frac {\pi n}{2t}}}+{\frac {1}{\theta }}}.
זהו שיפור בפקטור של {\displaystyle {\sqrt {t}}} במהירות הביצוע. אם משתמשים בהעתקת השלילה {\displaystyle \psi (P)=-P} כאוטומורפיזם, מושג שיפור בפקטור של {\displaystyle {\sqrt {2}}}.

במקרה של עקום קובליץ {\displaystyle E\_{a}} מעל {\displaystyle \mathbb {F} \_{2}} שהוא עקום פופולרי בתקנים של NIST וסרטיקום, העתקת פרובניוס {\displaystyle \tau :E\_{a}(\mathbb {F} \_{2^{m}})\rightarrow E\_{a}(\mathbb {F} \_{2^{m}})} המוגדרת על ידי {\displaystyle \tau ({\mathcal {O}})={\mathcal {O}}} וכן {\displaystyle \tau (x,y)=(x^{2},y^{2})} גם היא אוטומורפיזם של חבורה מסדר {\displaystyle m} והיא קלה לחישוב היות שהעלאה בריבוע היא פעולה קלה בשדה הבינארי (בהצגה פולינומית העלאה בריבוע מודולו 2 שקולה למעשה להכנסת אפסים בין כל הספרות לסירוגין). אם {\displaystyle P\in E\_{a}} הוא מסדר ראשוני {\displaystyle n} כך ש-{\displaystyle n^{2}} אינו מחלק של סדר העקום המסומן ב-{\displaystyle \#E\_{a}} אז {\displaystyle \tau (P)\in \langle P\rangle } ולכן {\displaystyle \tau } היא אוטומורפית. יהי {\displaystyle \mu =(-1)^{1-a}} אפשר להוכיח שאחד מהפתרונות {\displaystyle \lambda } של המשוואה המודולרית {\displaystyle \lambda ^{2}-\mu \lambda +2\equiv 0{\text{ (mod }}n)} מקיים {\displaystyle \tau (P)=\lambda P}. לכן באופן דומה, הגרסה המקבילית של אלגוריתם רו עם {\displaystyle M} מעבדים המשתמשת במחלקות השקילות תחת העתקת פרובניוסמגיעה לזמן ריצה של

{\displaystyle {\frac {1}{M}}{\sqrt {\frac {\pi n}{2m}}}+{\frac {1}{\theta }}}.
ואם מנצלים גם את העתקת השלילה מושג שיפור כולל בזמן הריצה בפקטור של {\displaystyle {\sqrt {2m}}}.

למשל ההערכה המקורית שניתנה ב-1996 הייתה שכדי לפתור את בעיית הלוגריתם הבדיד בעקום אליפטי מסדר 113 בהנחה שזמינים 10,000 מעבדים לצורך המשימה כשכל אחד מהם מסוגל לבצע איטרציה אחת בעשר מילישניות, אם {\displaystyle \theta =2^{-30}} אז מספר החזרות הצפוי בכל מעבד לפני שמוצאים לוגריתם הוא

{\displaystyle {\frac {\sqrt {\pi 2^{113}}}{2\cdot 10000}}+2^{30}\approx 9.03\times 10^{13}}.
שזה שקול בערך ל-1045 ימים או שלוש שנות עיבוד עם כמות של כארבע גיגה-בית זיכרון. הערכות יותר מעודכנות קצת יותר אופטימיות. לדוגמה ב-2002 הצליח צוות חוקרים בראשות קריס מוניקו לפצח את העקום האליפטי ECCp-109 עם 10,000 מחשבים שעבדו במקביל בסך הכול 549 ימים. הם השתמשו בגרסה משופרת של אלגוריתם רו של פולרד והצליחו לפתור את בעיית דיפי-הלמן בעקום זה.

לקריאה נוספת
------------

* Hankerson, Darrel, Menezes, Alfred J. Vanstone, Scott (2004) Guide to Elliptic Curve Cryptography

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

1. ↑  Pollard, J. M. (1978). Monte Carlo methods for index computation (mod p). "Mathematics of Computation". 32 (143): 918–924
2. ↑  Brent, Richard P. (1980), "An Improved Monte Carlo Factorization Algorithm", BIT, 20: 176–184
3. ↑  Menezes, Alfred J.; van Oorschot, Paul C.; Vanstone, Scott A. (2001). "Chapter 3 - Number-Theoretic Reference Problems" (PDF). "Handbook of Applied Cryptography".
4. ↑  Paul C. van Oorschot, Michael J. Wiener, "Parallel Collision Search with Cryptanalytic Applications" Journal of Cryptology January 1999, Volume 12, Issue 1, pp 1–28

| קריפטוגרפיה |
| --- |
| 

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

 |
| 

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

 |
| 

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

 |
| 

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

 |
| 

| צופן זרם |
| --- |
| RC4 • Salsa20 • SOSEMANUK • גריין • 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 • סיסמה חד-פעמית |

 |
| 

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

 |