בעיית RSA

בקריפטוגרפיה, בעיית RSA היא הבסיס התאורטי להצפנת RSA, שהומצאה על ידי שמיר, ריבסט ואדלמן ב-1977, ונמצאת מאז בשימוש מאסיבי בכמעט כל מערכת הצפנה מודרנית. בעיית RSA היא בעיה בתורת המספרים שאפשר לנסחה בקיצור: "מציאת שורש ממעלה <math>e</math> של <math>c</math> מודולו <math>n</math>".

==מודולוס RSA==

בהצפנת RSA אליס מצפינה את המסר הגלוי <math>M</math> עבור בוב באמצעות המפתח הציבורי של בוב <math>(n,e)</math> על ידי חישוב:
:<math>C\equiv M^e\text{ mod }n</math>
<math>n</math> נקרא מודולוס RSA והוא בדרך כלל כפולה של שני ראשוניים <math>p</math> ו-<math>q</math> אקראיים, גדולים ושווים בגודלם בקירוב. <math>e</math> נקרא מעריך ציבורי והוא שלם אי-זוגי <math>e\ge 3</math>, שצריך להיות זר ביחס ל-<math>\phi(n)</math> שהוא פונקציית אוילר המייצגת את הסדר של החבורה הכפלית <math>\mathbb{Z}_n^*</math>. היות שהסדר של <math>p</math> הוא <math>p-1</math> וכן לגבי <math>q</math> הרי ש-<math>\phi(n)=(p-1)(q-1)</math>. פונקציית RSA היא מהצורה <math>f(x)=x^e\text{ (mod }n)</math>. השלם <math>d</math> הוא הופכי כפלי של <math>e</math> ביחס לסדר <math>\phi</math> ונקרא גם דלת המלכודת. המפתח הפרטי הוא אם כן הצמד <math>(n,d)</math>.

בוב שברשותו המפתח הפרטי יכול לפענח את <math>C</math> כיוון ש-<math>de\equiv 1\text{ (mod }\phi(n))</math> ומזה נובע ש-<math>C^d\equiv M^{ed}\equiv M\text{ (mod }n)</math>.

יריב פוטנציאלי יכול לנסות לגלות מהו <math>C</math> על ידי ציתות לרשת וייתכן אף שהמפתח הציבורי של בוב ידוע לו. ההנחה היא שלמרות האמור יהיה קשה לו לחשוף את <math>M</math> או את <math>d</math>.

==ניסוח פורמלי של הבעיה==

:בהינתן שלם חיובי <math>\ n=pq</math>, כאשר <math>p</math> ו-<math>q</math> ראשוניים שווים בגודלם בקירוב ושלם אי-זוגי חיובי <math>e</math> הנמוך מ-<math>n</math> שמקיים <math>\mbox{gcd}((p-1)(q-1),e)=1</math> ונתון שלם <math>C</math>. מצא שלם <math>M</math> המקיים: <math>M^e \equiv C \ (\mbox{mod }n)</math>.

המגבלות שהוטלו על הפרמטרים מבטיחים שלכל <math>C</math> קיים אך ורק <math>M</math> יחיד המתאים לו, כלומר <math>\ f(x)=x^e \ \mbox{mod }n</math> היא תמורה ב-<math>\mathbb{Z}_n</math>. הפונקציה gcd היא מחלק משותף מקסימלי. היריב, שהמפתח הפרטי אינו ידוע לו, חייב להפוך את פונקציית RSA. חיפוש סדרתי של הפונקציה ההופכית <math>f^{-1}(C)\ \mbox{mod }n</math> מחייב בממוצע בדיקת כמעט כל המעריכים האפשריים. אם המעריך גדול המשימה תהיה בלתי מעשית.

==השערת RSA==
השערת RSA מניחה שבעיית RSA המתוארת קשה לפתרון במידה והתנאים הבאים מתקיימים: הגורמים הראשוניים של המודולוס אינם ידועים לתוקף, המודולוס גדול מאוד, המודולוס נוצר באקראי (הגורמים נבחרו באקראי) וכן המסר <math>M</math> (ומזה נובע גם הצופן <math>C</math>) ממופה לאלמנט אקראי ב-<math>\mathbb{Z}_n^*</math>, דהיינו בטווח <math>[0,n-1]</math>.

השערה זו זהה לטענה שפונקציית RSA היא חד-כיוונית עם דלת מלכודת כשהמפתח הפרטי הוא דלת המלכודת. דהיינו בעוד שקל לחשב חזקה ממעלה <math>e</math> של <math>x</math> (מודולו <math>n</math>), הרי שקשה לבצע את הפעולה ההפוכה, לחשב את השורש ממעלה <math>e</math> של <math>C</math> מודולו <math>n</math>. אלא אם כן יינתן רמז סודי שהוא במקרה זה <math>\phi(n)</math>.

אקראיות <math>M</math> חשובה כיוון שאם ידוע ש-<math>M</math> נבחר מתוך טווח קצר, היריב יכול לנסות לפענח את <math>C</math> פשוט על ידי ניסוי כל האפשרויות (מבלי צורך להפוך את פונקציית RSA כלל).

גם אם <math>M</math> נבחר באקראי היריב יכול למפות את כל האלמנטים ב-<math>\mathbb{Z}_n^*</math> עד שהוא נתקל ב-<math>M</math> הנכון. אולם התקפת כוח גס מסוג זה היא מעריכית, עם זמן ריצה בסדר גודל של <math>\text{log}_2\ n</math>. בטכנולוגיה הנוכחית ועם מספרים גדולים (כמה אלפי ספרות) אלגוריתם כזה אינו יעיל.

==הקשר לפירוק לגורמים==
קל לראות שבעיית RSA אינה קשה יותר מפירוק לגורמים. כלומר, אם קיים אלגוריתם יעיל לפירוק לגורמים אזי RSA אינו בטוח כלל. היות שאם היריב יכול לפרק את המודולוס לגורמים קל לו לחשב את סדר החבורה <math>\phi</math>, למצוא את המפתח הפרטי <math>(n,d)</math> מתוך המפתח הציבורי <math>(n,e)</math> כך שמתקיים <math>d\equiv e^{-1}\text{ mod }\phi(n)</math> ואז לפענח את <math>C</math>.

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

אף על פי שקיימים אלגוריתמים טובים לפירוק לגורמים של מספרים שלמים, הם עדיין רחוקים מלהוות איום ממשי על מודולוס RSA שנבחר לפי התקן. האלגוריתם היעיל ביותר, "סטייט אוף דה ארט" הידוע כיום לפירוק לגורמים הוא נפת שדה מספרים הכללי עם זמן ריצה מסדר גודל של <math>\exp((c+o(1))n^{1/3}\text{log}^{2/3}n)</math> עבור קבוע <math>c<2</math>. שזהו בערך החסם התחתון הידוע לשבירת RSA באמצעות פירוק לגורמים.

מודולוס RSA שלא נבחר באקראי עלול להכיל חולשות שמאפשרות שבירתו בקלות. לדוגמה אם <math>n=pq</math> נבחר כך ש-<math>p-1</math> הוא כפולה של ראשוניים קטנים שאינם עולים על חסם כלשהו <math>B</math> אזי ניתן לפרקו לגורמים בזמן של <math>B^3</math> בערך.

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

:בהינתן מודלוס <math>n</math> ומעריך <math>e</math> שלם אי זגי, המקיימים <math>\text{gcd}(e,\phi(n))=1</math> והתמורה <math>f_{e,n}(x)=x^{1/e}\text{ mod }n</math> מהחבורה <math>\mathbb{Z}_n^*</math> על עצמה, האם קיים אלגוריתם שיכול חשב בזמן פולינומי את הגורמים הראשוניים של <math>n</math> בהינתן גישה לאורקל <math>f_{e,n}(x)</math>, כאשר האורקל יכול לחשב את <math>f(x)</math> בזמן קבוע.

בונה ו-Venkatesan ואחרים הוכיחו שאם <math>e</math> קטן כגון <math>e\le 17</math>, התשובה לשאלה האמורה היא "לא". במילים אחרות ייתכן שלא קיימת רדוקציה מבעיית RSA לפירוק לגורמים במקרה הפרטי של <math>e</math> קטן. אך אין בזה די כדי להוכיח באופן כללי שבעיית RSA קלה מפירוק לגורמים.

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

בנובמבר 2005 הצליח צוות מתמטיקאים לפרק לגורמים בעזרת אלגוריתם נפת שדה המספרים את המודולוס RSA-200 (200 ספרות עשרוניות) מתוך מספרי האתגר של מעבדות RSA. המאמץ נמשך כמעט שלוש שנים, תוך שימוש במספר גדול של מחשבים שעבדו במקביל. בדצמבר 2009 פרסם צוות מחקר ממוסדות אקדמאיים שונים, בראשות תורסטן קליינג'ונג כי הצליחו לפרק לגורמים את המספר RSA-768 (ממספרי האתגר של מעבדות RSA) בתהליך שנמשך כמעט שלוש שנים ונרתמו לצורכו אלפי מעבדים (אותו תהליך על מחשב בודד בעל עוצמת חישוב טובה, היה אורך כ-1500 שנה). האתגר הבא RSA-1024 (כ-300 ספרות עשרוניות) קשה פי כמה אלפים. בעבר הוצע פרס של כ-100,000 דולר למי שיצליח לפרקו.

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

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

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

===תכונת המעגליות===
בשל העובדה שהצפנת RSA הנה תמורה ב-<math>\ \mathbb{Z}_n</math>, אם <math>C=M^e \mbox{ mod }n</math> קיים שלם <math>k</math> המקיים <math>C^{e^k} \equiv C \ (\mbox{mod }n)</math>. מאותה סיבה <math>C^{e^{k-1}} \equiv M \ (\mbox{mod }n)</math>. אם <math>\ n</math> קטן חיפוש סדרתי של <math>k</math> כזה אפשרי. אפשר להתחיל בערך נמוך ולקדם את <math>k</math> עד שהמשוואה האמורה מתקיימת. יתרה מזו, ניתן לייעל את ההתקפה על ידי מציאת השלם <math>\ u</math> העונה על הדרישה <math>\mbox{gcd}(C^{e^u} - C, n) > 1</math>. יש סיכוי טוב למצוא את <math>\ u</math> בפחות מהזמן הדרוש למצוא את <math>\ k</math>. אם <math>C^{e^u} \equiv C</math> מודולו אחד מהגורמים הראשוניים של <math>\ n</math>, אזי <math>\mbox{gcd}(C^{e^u} - C, n)</math> הוא גורם ראשוני של <math>n</math> וכאמור ידיעת הגורמים הראשוניים מספקת לחילוץ מפתח הפענוח. במקרה ש-<math>\mbox{gcd}(C^{e^u} - C, n)=n</math> אזי מתקיים בהכרח <math>u=k</math> וכאמור <math>C^{e^{u-1}} \equiv M</math>, במקרה כזה מתקבל <math>\ m</math> בלא צורך במפתח הפענוח כלל. למעשה אפשר לראות בשיטה זו כדרך שונה לפירוק <math>n</math> לגורמים. כאמור, פירוק לגורמים היא בעיה קשה כך שתכונה זו אינה מהווה איום משמעותי על אלגוריתם RSA.

==מספרים ראשוניים==
כאמור חשוב שהמספרים הראשוניים ייבחרו באקראי. לא מומלץ למשל להשתמש ברשימת מספרים ראשוניים מפורסמת, כיוון שבדרך זו מועבר מידע ליריב פוטנציאלי. בבחירת מספרים ראשוניים רצוי שיהיו לא רק אקראיים אלא גם קשים לניחוש. אילו הגדרות שונות, כיוון שאקראיות לבדה אינה מבטיחה קושי בניחוש. על כן השיטה המקובלת היא הפעלת מחולל אקראי בטוח ליצירת מספר אי-זוגי אקראי באורך הרצוי ובדיקת ראשוניותו, מכיוון שבדיקת ראשוניות קלה יותר מפירוק לגורמים, אם המספר מתגלה כפריק מנסים שוב עם מספר אחר. הסיכויים הם שתוך מספר ניסיונות קצר בערך כמספר הספרות, יימצא ראשוני. כמו כן רצוי ש-<math>p</math> ו-<math>q</math> יהיו בגודל זהה בקירוב, כלומר שלמודולוס <math>n</math> לא יהיו גורמים קטנים כלשהם. זאת כדי לסכל אפשרות שימוש באלגוריתם פירוק שמנצל את קיומם של גורמים קטנים. מצד שני רצוי שההפרש ביניהם לא יהיה קטן מדי. כי אם <math>p \approx q</math>, אזי גם <math>p \approx \sqrt{n}</math> ואז ניתן למצוא אותם בחיפוש קל, קרוב לשורש.

יש הממליצים להשתמש במספרים ראשוניים חזקים. <math>\ p</math> הוא מספר ראשוני חזק אם הוא מקיים את ההגדרות הבאות:
:* <math>\ p-1</math> מכיל גורם ראשוני גדול <math>\ r</math>.
:* <math>\ p+1</math> מכיל גורם ראשוני גדול כלשהו.
:* <math>\ r</math> האמור גם הוא, מכיל גורם ראשוני גדול כלשהו.

: ניתן להכין מספרים כאלו בעזרת אלגוריתם גורדון (Gordon) למשל. הסיבות לתנאים אלו הם: הראשון והשני נועדו לסכל שימוש באלגוריתם פירוק לגורמים על המודולוס כמו אלגוריתם rho של פולרד או אלגוריתמים אחרים (של פולרד) המנצלים את <math>p \pm 1</math>. השלישי נועד לסכל את מתקפת מחזוריות (ראו להלן).

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

==חשיפת המפתח הפרטי לעומת פירוק לגורמים==
:בהינתן המפתח הפרטי <math>(n,d)</math> אפשר לבנות אלגוריתם יעיל לפירוק לגורמים של <math>n=pq</math>.
:וכן להפך; בהינתן הגורמים הראשוניים של <math>n</math>, אפשר לחלץ את <math>d</math> בקלות.

ההוכחה פשוטה. אם <math>d</math> ידוע אפשר לחשב את <math>k=de-1</math>. ידוע ש-<math>k</math> צריך להיות כפולה של הסדר <math>\phi</math>. היות ש-<math>\phi</math> זוגי, אם כותבים את <math>k</math> כ-<math>2^tr</math> כאשר <math>r</math> אי-זוגי ו-<math>t\ge 1</math>, מתקיים <math>g^k\equiv 1</math> עבור כל <math>g\in\mathbb{Z}_n^*</math> ולכן <math>g^{k/2}</math> הוא שורש ריבועי של <math>1</math> מודולו <math>n</math>. לפי משפט השאריות הסיני ל-<math>1</math> ארבעה שורשים ריבועיים מודולו <math>n=pq</math>. שניים הם <math>\pm 1</math> האחרים הם <math>\pm x</math> כאשר <math>x</math> מקיים <math>x\equiv 1\text{ mod }p</math> וכן <math>x\equiv -1\text{ mod }q</math>. בעזרת אחד משני השורשים האחרונים אפשר לגלות את הגורמים של <math>n</math> על ידי חישוב <math>\text{gcd}(x-1,n)</math> (gcd היא מחלק משותף מקסימלי). אפשר לראות שאם <math>g</math> נבחר באקראי, אחד מהאלמנטים ברצף <math>g^{k/2},g^{k/4},...,g^{k/2^t}</math> מודולו <math>n</math> הוא שורש ריבועי של <math>1</math> בהסתברות של לפחות חצי. כל האלמנטים ברצף האמור ניתנים לחישוב בזמן של <math>\text{log}_2\ n</math>.

הטענה ההפוכה נובעת ישירות מהעובדה שבהינתן הגורמים הראשוניים אפשר לחשב את <math>\phi</math> ואת <math>d</math>. מזה נובע שבעיית פירוק לגורמים שקולה לחשיפת המפתח הפרטי, כך שאין טעם להסתיר את המפתח הפרטי ממי שהגורמים ידועים לו וכן להפך. מסיבה זו לא יהיה חכם לשתף מודולוס אחד לכמה משתמשים (כך שרק המפתחות הפרטיים והציבוריים שלהם שונים). כי בידי כל אחד מהם מספיק מידע כדי לפרק את <math>n</math> לגורמים ואז הוא יכול לחלץ את המפתחות הפרטיים של כל האחרים מתוך המפתחות הציבוריים שלהם.

==מעריך d קטן==
בפענוח סיבוכיות פעולת ההעלאה בחזקה המודולרית, ליניארית ביחס לאורכו של <math>d</math> בסיביות, מסיבה זו אם המפתח הפרטי קטן משיגים שיפור ביעילות הפענוח בפקטור משמעותי. התקפה מתוחכמת של מייקל ויינר מראה שעם מפתח פענוח קטן אפשר לשבור את המערכת כולה בקלות. הטענה היא:

:בהינתן <math>n=pq</math>, כאשר <math>q<p<2q</math> וכן השלמים <math>e,d</math> כך שמתקיים <math>ed\equiv 1\text{ mod }\phi(n)</math>, אם <math>d<n^{1/4}/3</math> אפשר לחלץ את <math>d</math> ביעילות.

ההתקפה של ויינר מבוססת על קירוב שברים משולבים. היות ש-<math>ed</math> שקול ל-<math>1</math> מודולו <math>\phi</math> קיים <math>k</math> המקיים <math>ed-k\phi=1</math>. מתקיים יחס הקירוב:

:<math>\left |\frac{e}{n}-\frac{k}{d} \right | \le\frac{1}{dn^{1/4}}<\frac{1}{2d^2}</math>

השברים <math>k/d</math> נותנים קירוב טוב של <math>e/n</math> על ידי התכנסות השבר המשולב. התוקף יכול לחשב את ההתכנסויות עבור <math>e/n</math>. אחד מהם יהיה שווה ל-<math>k/d</math> ולאור האמור צריך להיות <math>\text{gcd}(k,d)=1</math> ולכן <math>k/d</math> הוא שבר מצומצם. האלגוריתם של ויינר מאפשר חילוץ <math>d</math> בזמן ליניארי. אם <math>n</math> באורך 1024 סיביות <math>d</math> חייב להיות לפחות 256 סיביות כדי לסכל התקפה זו. לחלופין אפשר להגדיל את <math>e</math> על חשבון <math>d</math>. ויינר הראה שאם <math>e>n^{1.5}</math> ההתקפה שלו לא תצלח. על כל פנים הגדלת <math>e</math> אינה פותרת את בעיית היעילות אלא מעבירה אותה להצפנה. ייתכן ושיטה זו תהיה יעילה במקרים בהם המחיר שווה את התועלת, אם אין חשיבות לגודל מפתח ההצפנה לעומת מפתח הפענוח.

ייעול ההצפנה והפענוח מבלי להסתכן בהתקפה של ויינר, אפשרי באמצעות משפט השאריות הסיני כפי שמובא בתקן PKCS. אם מחלקים את <math>d</math> לשני מפתחות פענוח כך שמתקיים <math>d_p\equiv d\text{ mod }(p-1)</math> וכן <math>d_q\equiv d\text{ mod }(q-1)</math> ואורך כל אחד מהם מחצית מאורך המודולוס. אזי הפענוח מתייעל בפקטור של שניים בקירוב. בפענוח משתמשים במשפט השאריות הסיני כדי לפתור את מערכת השקילויות <math>M_p\equiv c^{d_p}\text{ mod }p</math> וכן <math>M_q\equiv c^{d_q}\text{ mod }q</math> כדי לחשב את <math>M</math>. והרעיון הוא שהמפתחות <math>d_p</math> ו-<math>d_q</math> קטנים לכן העלאה בחזקה עם מפתחות אילו יעילה יותר. לא ברור האם השיטה הזו מחזקת או מחלישה את RSA.

החסם שהציע ויינר אינו מדויק. בונה ואחרים הוכיחו שכל עוד <math>d<n^{0.292}</math> אפשר לשחזר את <math>d</math> מתוך <math>(n,e)</math>. בכל אופן החסם המדויק הוא שאלה פתוחה.

==מעריך e קטן==
משיקולי יעילות מקובל שהמעריך הציבורי יהיה קטן, זאת מבלי לפגוע בביטחון המערכת. הדבר חשוב במיוחד כאשר מיישמים את RSA בחומרה כמו כרטיס חכם. <math>e=2^{16}+1</math> נפוץ ביישומים מעשיים, יתרונו במשקלו הבינארי הנמוך. יש לשים לב שאם המסר עצמו קטן גם הוא, ייתכן שיהיה אפשר פשוט לחשב את השורש ממעלה <math>e</math> של המסר ללא המודולוס (אם <math>M<\sqrt[e]{n}</math>). משפט קופרשמידט אומר:

:בהינתן מודולוס <math>n</math> ופולינום <math>f\in \mathbb{Z}[x]</math> ממעלה <math>d</math>. יהי <math>X=n^{1/d-\epsilon}</math> עבור <math>\epsilon\ge0</math>, קיים אלגוריתם לחישוב כל השלמים <math>|x_0|<X</math> המקיימים <math>f(x_0)=0\text{ mod }n</math>.

כלומר אפשר לחשב כל השורשים של <math>f</math> מודולו <math>n</math> הנמוכים מ-<math>X=n^{1/d}</math>. ככל ש-<math>X</math> קטן זמן הריצה קטן בהתאם. הרעיון של קופרשמידט מבוסס על LLL (אלגוריתם לצמצום סריגים) וזמן הריצה שלו נשלט בידי הזמן שלוקח ל-LLL לרוץ על סריג בעל מימד <math>O(w)</math> כאשר <math>w=\text{min}(1/\epsilon,\text{log}_2\ n)</math>. הוא טוב במקרה שמנסים למצוא שורשים קטנים מודולו מספר פריק ויש לו השלכות גם בתחומים אחרים (במקרה של מספר ראשוני אין צורך בכך כי קיימות שיטות יותר טובות). על כל פנים ההשלכה של משפט זה שניתן לפתח התקפה על RSA כאשר המעריך הציבורי <math>e</math> קטן, כדלהלן.

אם השולח מצפין מסר <math>m</math> מספר פעמים עבור <math>i</math> משתמשים, כל אחד עם המפתחות המתאימים <math>(n_i,e_i)</math> שלהם, אם כל <math>e_i</math> שווים ל-<math>e</math> שלם קטן (נניח <math>e=3</math>), הרי שיריב שמסוגל ליירט את המסרים המוצפנים יכול לחלץ את המסר המקורי על ידי משפט השאריות הסיני ברגע שיצליח להניח ידו על לפחות <math>e</math> מהם. משום שעבור המסרים <math>C_1,C_2,C_3,...</math> קיים שלם <math>C'\in \mathbb{Z}_{n_1\cdot n_2\cdot n_3\cdots}</math> כך ש-<math>C'\equiv M^e\text{ mod }n_1n_2n_3\cdots</math>. לפי משפט קופרשימדט <math>M</math> יהיה השורש ממעלה <math>e</math> (מעל השלמים) של <math>C'</math>. גם אם השולח ייפרד את <math>M</math> על ידי סכימת ריפוד ידועה כלשהי (אם הריפוד הוא ערך קבוע עבור כל משתמש) ההתקפה עדיין ישימה. לכן הריפוד חייב להיות אקראי כדי לסכל את ההתקפה האמורה.

התקפה אחרת של פרנקלין וריטר על RSA עם מעריך <math>e</math> קטן, מנצלת קשר או יחס בין מסרים. כלומר אם לדוגמה השולח מצפין שני מסרים <math>m_1,m_2</math> כאשר <math>m_2</math> הוא פונקציה ידועה כלשהי מהצורה <math>f=ax+b</math> של <math>m_1</math>. וכן <math>c_1=m_1^e\text{ mod }n</math>. ידוע ש-<math>m_1</math> הוא שורש של הפולינום <math>g_1(x)=f(x)^e-c_1</math> וכן <math>m_2</math> הוא שורש של <math>g_2(x)=x^e-c_2</math>. הגורם הליניארי <math>x-m_2</math> מחלק של שני הפולינומים. לאור זאת אפשר להשתמש באלגוריתם אוקלידס כדי לחשב את <math>m_2=\text{gcd}(g_1,g_2)</math>. ההשלכה של התקפה זו הפכת חמורה יותר אם סכימת הריפוד אינה בטוחה. אם השולח מרפד את המסר <math>m</math> לפני המשלוח על ידי הוספת מספר אקראי קצר <math>r</math> לסוף המסר הרי שאם יעלה בידי התוקף להשיג מסר <math>M</math> כלשהו שנשלח פעמיים (עם ריפוד שונה, דהיינו <math>m_1=2^zM+r_1</math> וכן <math>m_2=2^zM+r_2</math> כאשר <math>z</math> הוא אורך הריפוד בסיביות), הוא יכול לבצע את ההתקפה האמורה ולחלץ את <math>M</math>. כיוון שאם מגדירים את הפולינומים <math>g_1(x,y)=x^e-c_1</math> וכן <math>g_2(x,y)=(x+y)^e-c_2</math>, ידוע שאם <math>y=r_1-r_2</math> הרי ש-<math>m_1</math> יהיה שורש משותף של שניהם שאותו אפשר למצוא בעזרת אלגוריתם קופרשמידט אם הוא קטן.

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

===חשיפה חלקית של d כאשר e קטן===
בונה ואחרים הוכיחו שאם עלה בידי התוקף לגלות חלק (למשל רבע) מסיביות המפתח הסודי <math>d</math> הרי שהוא יכול באמצעותם לגלות את המפתח הסודי כולו בתנאי שמפתח ההצפנה מקיים <math>e<\sqrt{n}</math>. עובדה זו נובעת ממשפט קופרשמידט שהוכיח שאם יעלה בידי התוקף לנחש נכונה כרבע מסיביות אחד הגורמים הראשוניים של המודולוס, ביכולתו לפרק את המודולוס כולו לגורמים בזמן של <math>e\text{ log}_2\ e</math> ניסיונות.

בנוסף אפשר לראות שאם המעריך <math>e</math> קטן מערכת RSA מדליפה כמחצית מהסיביות המשמעותיות של המפתח הפרטי <math>d</math>. הסיבה היא בשל המשוואה <math>ed-k(n-p-q+1)=1</math> עבור <math>0<k\le e</math>. בהינתן <math>k</math> כאמור התוקף יכול לחשב את <math>\hat d=\lfloor (kn+1)/ e\rfloor</math> ואז את
:<math>|\hat d-d|\le k(p+q)/ e \le 3k\sqrt{n}/e<3\sqrt{n}</math>
לכן <math>\hat d</math> הוא קירוב טוב של <math>d</math>. דהיינו ברוב המקרים מחצית הסיביות המשמעותיות של <math>\hat d</math> זהות לסיביות של <math>d</math>. היות שקיימים רק <math>e</math> ערכים אפשריים של <math>k</math> אפשר לבנות טבלה קטנה של <math>e</math> כניסות כך שאחד מהאלמנטים בה שווה למחצית השמשעותית של סיביות <math>d</math>.

== כפליות (Multiplicative) ==
אם <math>m_1, m_2</math> הם מסרים כלשהם שהטקסטים המוצפנים המקבילים להם הם <math>c_1, c_2</math> בהתאמה. אזי מתקיימת הזהות הבאה:

: <math>(m_1 \cdot m_2)^e \equiv m^e_1 \cdot m^e_2 \equiv c_1 \cdot c_2 (\mbox{mod }n)</math>

תכונה זו נקראת גם הומומורפיזם והיא מאפשרת במצב מסוים התקפה שבה לתוקף גישה חלקית למערכת ההצפנה (אין לו גישה למפתח ההצפנה) אם <math>c = M^e \mbox{ mod }n</math> וברצונו לחשוף את <math>C</math> ביכולתו להסתירו על ידי הכפלת הטקסט המוצפן ב-<math>x^e</math> כלשהו כך: <math>s = Cx^e \mbox{ mod }n</math>, אם המערכת תפענח עבורו את <math>s</math> בלא ידיעת הקשר שבינו לבין <math>C</math> הוא יקבל את: <math>t = s^d \mbox{ mod }n</math>. תוצאה זו מאפשרת חילוץ <math>C</math> בשל הזהות הבאה:

: <math>t \equiv s^d \equiv C^d(x^e)^d \equiv Mx \ (\mbox{mod }n)</math>

ולכן <math>M=tx^{-1} \mbox{ mod }n</math>. כלומר מסירים את <math>x</math> על ידי הכפלה בהופכי שלו כדי לקבל את הטקסט מקורי. תכונה זו שימושית גם לטכניקת הסינוור להלן כנגד התקפת ערוץ צדדי. הדרך הטובה ביותר למנוע חולשות עקב תכונת הכיפליות היא לרפד את המסר באמצעות סכימת ריפוד בטוחה.

==פריקות עצמית==
לאור תכונת הכפליות, לפונקציית RSA תכונת "פריקות עצמית" (Self-reducibility) או רדוקציה עצמית, כלומר תמיד מתקיים:

:<math>(MR)^e \equiv M^eR^e\text{ (mod }n)</math>.

כך שאפשר למעשה להמיר טקסט מוצפן נתון <math>M^e</math> לטקסט מוצפן אחר <math>(MR)^e</math> כאשר<math>R</math> אקראי. כעת היות שיש סיכוי שהתוצאה תהיה "חלשה" במובן שייתכן שתהיה דרך קלה לפענחה, הרי שהתוקף יכול לנצל עובדה זו כדי לפענח כל טקסט מוצפן. הוכח שאם קיים אלגוריתם <math>\text{A}</math> שיכול לפענח חלקיק קטן <math>\epsilon</math> מסך כל ההצפנות האפשריות, הרי שקיים אלגוריתם אקראי אחר <math>\text{A}'</math> שיכול לפענח את כל המסרים המוצפנים באותה סיבוכיות זמן בערך.

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

==השערת RSA החזקה==
באריץ' ופיצמן ואחרים המציאו ב-1997 את השערת RSA החזקה (Strong RSA Assumption) שמאז מהווה בסיס למספר מערכות הצפנה וחתימה דיגיטלית בין היתר חתימה דיגיטלית של קריימר ושופ. השערה זו שונה מההשערה הרגילה בכך שהתוקף יכול לבחור גם את המפתח הציבורי, כדלהלן:
:בהינתן מודולוס אקראי <math>n</math> ושלם אקראי <math>C\in\mathbb{Z}_n^*</math>, מצא <math>e>1</math> ו-<math>M\in\mathbb{Z}_n^*</math> המקיימים <math>C=M^e</math>.
כלומר היריב מקבל מודולוס וטקסט מוצפן ועליו למצוא כל מעריך ובסיס כך שהמשוואה האמורה תתקיים. ייתכן שמשימה זו תהיה קלה יותר מפתרון בעיית RSA הרגילה ולכן ההשערה נקראת חזקה במובן הזה, שאם היא קשה, הרי שהיא משיגה ביטחון גבוה יותר מ-RSA הרגיל.

==סיבית קשה ב-RSA==

אף על פי ש-RSA בטוח בהנחה שהשערת RSA נכונה ובהנחה שפירוק לגורמים היא משימה קשה. בכל זאת בתנאים מסוימים RSA מדליף מעט מידע על הטקסט המקורי, כלומר קל לנחש סיביות מסוימות של המסר המקורי מתוך הטקסט המוצפן. גולדווסר ומיקאלי הראו שאם היריב יכול לנחש את הסיבית הכי פחות משמעותית של הטקסט המקורי, הוא יכול עם מידע זה לבצע התקפה שבה יצליח יחלץ את כל סיביות המקור בזמן פולינומי. ואזירני וכן שור, גולדרייך, אלקסי פישלין, שנור ואחרים הוכיחו ש-<math>\text{log}(\text{log}(n))</math> הסיביות הפחות משמעותיות של הטקסט המוצפן של הצפנת RSA בטוחות, דהיינו ההסתברות לניחוש מוצלח שלהן הוא לא יותר מאשר <math>1/2+\epsilon</math> כאשר <math>\epsilon=1/\text{poly}(\text{log}(n))</math>.

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

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

==התקפת מוצפן נבחר==

התקפת מוצפן נבחר על RSA מוגדרת כדלהלן: לתוקף גישה לאורקל אשר מבצע עבורו עם מפתח הצפנה זהה, <math>k</math> פענוחים של <math>k</math> טקסטים מוצפנים <math>c_1,c_2,...,c_k</math> (לא בהכרח קשורים זה בזה) ומתוך מידע זה עליו לגלות <math>C</math> אחר שאינו נמנה כמובן עליהם. ההתקפה מתחלקת לשני סוגים CCA1 ו-CCA2 כאשר השנייה מאפשרת שיהיה קשר בין <math>C</math> שאותו התוקף מעוניין לגלות לבין הפענוחים שקיבל, במילים אחרות הוא יכול לבחור את הפענוחים שברצונו לקבל לפי <math>C</math> בהתאם לתוצאות קודמות כלשהן.

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

==התקפת תיזמון==

RSA הבסיסי פגיע להתקפת ערוץ צדדי המודדת במדויק את הזמן הדרוש לביצוע פענוח. למשל בהינתן כרטיס חכם שבו מוטמע מפתח הצפנה סודי שכמובן לא ניתן לראות באמצעים רגילים. בגלל שהמספרים העצומים לא מאפשרים חישוב ישיר של העלאה בחזקה פעולת הפענוח מנצלת את "אלגוריתם ריבוע וכפל" כדי לחשב את <math>C</math> בחזקת <math>d</math> ברקורסיה של העלאות בריבוע. העיקרון הוא להקצות משתנה זמני שמתחיל ב-1, סורקים את הייצוג הבינארי של המעריך מימין לשמאל (מהסיבית הכי פחות משמעותית לסיבית העליונה). אם הסיבית היא "1" מכפילים את המשתנה הזמני ב-<math>C</math> ומעלים בריבוע ואילו אם הסיבית היא "0" מבצעים רק העלאה בריבוע, מצמצמים את התוצאה במודולוס וממשיכים כאשר התוצאה האחרונה היא במשתנה הזמני. היות ש-<math>d</math> אי זוגי, אנחנו יודעים שבסבב הראשון מתבצעת העלאה בריבוע וכפל מלא ב-<math>C</math> אם מודדים את הזמן הדרוש לפעולה זו ומשווים עם הפעולה של האלגוריתם בסבב הבא ונמצא הבדל אפילו כלשהו אפשר להעריך שהסיבית השנייה היא "0". בדרך זו ניתן לעלות על כל הסיביות. באותה מידה אפשר לבצע את ההתקפה על ידי מדידת הפרשי צריכת החשמל בזמן ביצוע פעולות ההעלאה בריבוע וכפל.

דרך אחת לסכל התקפה זו היא באמצעות טכניקת "סינוור" (blinding) המנצלת את תכונת ההומומורפיות של RSA. לפני הפענוח מכפילים את המסר במספר אקראי כלשהו ולאחר הפענוח מחלקים בו שוב. בדרך זו מדידת התזמון אינה מועילה לתוקף כי המסר אקראי.

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

ב-2011 פרסמה חברת D-Wave הקנדית שהצליחה לייצר מעבד קוונטי המכיל 128 קיוביטים שנועד בעיקר לפתרון בעיות כמו אופטימיזציה, מדגמים, ביואינפורמטיקה וכדומה. מומחי החברה הדגישו שהמעבד אינו מסוג מעבד לשימוש כללי ולכן לא מתאים לכל מטרה ועוד הם מצפים לכל היותר לשיפור ריבועי ביכולת החישובית לעומת מחשב קונבנציונלי בפתרון בעיות מסוימות בתורת המספרים. במאי 2013 הכריזה החברה על מחשב קוונטי מדור שני בעל 512 קיוביטים. המעבד של D-Wave כפי שהוצג אינו מתאים לפירוק לגורמים משום שלא ניתן להריץ עליו את אלגוריתם שור. המחשבים הקוונטיים הדיגיטליים שפותחו נכון להיות אינם מסוגלים לפרק לגורמים מספרים גדולים לפי התקן העולמי הנוכחי. בנוסף כל מספר שניתן לטעון ב-512 קיוביטים אפשר לפרק לגורמים על מחשב קונבנציונלי.

==ראו גם==
* RSA
* הצפנת פאיי
* הצפנת קריימר-שופ
* הצפנת רבין
* התקפת שיבוש (קריפטוגרפיה)

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

קטגוריה:קריפטוגרפיה