RSA

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

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

בידיעת הגורמים הראשוניים חישוב המפתח הסודי <math>d</math> מתוך המפתח הציבורי <math>e</math> הוא מלאכה קלה, כפי שיתואר בהמשך ואילו ללא ידיעת הגורמים הראשוניים לא ידועה דרך יעילה לחישובו בזמן סביר. לכן "הקושי" נמדד במספר הפעולות האלמנטריות הנדרש כדי לפרק את המודולוס לגורמים. ההבדל בפקטור העבודה בין העלאה בחזקה מודולרית לבין חישוב שורש מודולרי שהן פעולות הופכיות, הוא המקור לפונקציה החד־כיוונית שבבסיס RSA. שבירת מערכת ההצפנה, דהיינו פענוח המידע ללא ידיעת הגורמים הראשוניים של <math>n</math> נקרא בעיית RSA. היא נחשבת לבעיה קשה אם כי אין הוכחה שהיא קשה לפחות כפירוק לגורמים. אלגוריתם RSA נחשב איטי יחסית ועל כן אינו מתאים להצפנה ישירה של מידע בכמות גדולה. במקום זאת, במערכת הצפנה היברידית, RSA משמש לשיתוף והעברה של מפתח להצפנה סימטרית, אשר בתורו משמש להצפנת המידע עצמו עם אלגוריתם מועדף כמו AES.

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

== היסטוריה ==
[[עדי שמיר בכנס בנושא המאגר הביומטרי, אפריל 2012]]
החיסרון העיקרי בצפנים סימטריים הוא שהמפתח הסודי נדרש הן להצפנה והן לפענוח ולכן יש צורך להעבירו לידי השולח בדרך כלשהי ובכך לסכנו בחשיפה. ב־1976 פרסמו ויטפילד דיפי ומרטין הלמן מאמר המתאר את התפיסה של ההצפנה האסימטרית, שבה הנמען מפרסם מפתח הצפנה פומבי בעזרתו מבוצעת הצפנת מסרים הנשלחים אליו, ואילו הפענוח מתבצע אך ורק באמצעות המפתח הפרטי שברשותו, שמעולם לא נחשף. כשנה לאחר מכן ב־1977, רונלד ריבסט, עדי שמיר ולאונרד אדלמן מ־MIT פרסמו לראשונה במגזין סיינטיפיק אמריקן את RSA, שיישם לראשונה את המודל של דיפי והלמן באופן מעשי. אלגוריתם RSA זיכה את ממציאיו בפרס טיורינג לשנת 2002.

=== זכויות יוצרים ===
RSA נרשם כפטנט בארצות הברית בשנת 1983 ותוקפו פג בספטמבר 2000. בדצמבר 1997 פרסם מטה התקשורת של המודיעין הבריטי GCHQ מסמך בו נטען כי רעיון המפתח הפומבי היה ידוע להם כעשור לפני שהתפרסם. הם גילו לטענתם גם את RSA וגם את דיפי־הלמן, אך שמרו את הדבר בסוד. גם ה־NSA טען שגילה את RSA הרבה לפני שנודע לציבור, אולם התגלית סווגה כסוד לאומי. המתמטיקאי הבריטי קליפורד קוקס שעבד בסוכנות הביון הבריטית, פרסם מסמך בו נטען כי ב־1973 המציא אלגוריתם הצפנה דומה ל־RSA. ייתכן שבקהיליית המודיעין המצאות אלו היו ידועות שנים רבות לפני שהציבור התוודע להן. בכל מקרה ספק אם לממצאים אלו הייתה תועלת מעשית כלשהי באותה עת.

== הכנה ==
בגרסת RSA הבסיסית, תחילה להכנה:
# בוחרים שני מספרים ראשוניים גדולים <math>\ p</math> ו־<math>\ q</math>
# מחשבים את <math>\ n = pq</math>
# מחשבים את <math>\ \phi(n)=(p-1)(q-1)</math>. הפונקציה <math>\phi</math> נקראת פונקציית אוילר המייצגת את סדר החבורה.
# בוחרים שלם <math>1 < e < \phi(n)</math> שהוא זר ל־<math>\phi(n)</math> (בעבר היה נהוג לבחור e=3, אך התגלו בו פרצות אבטחה. היום נהוג לבחור e=65537)
# מחשבים <math>\ d</math> המקיים את הקונגרואנציה: <math>de \equiv 1 \ (\mbox{mod }\phi(n))</math>. כלומר מקיים את: <math>de \ {mod} \ \phi(n) = 1</math>.

=== פירוט הפרמטרים ===
* <math>\ p</math> ו־<math>\ q</math> בשלב 1 צריכים להיות ראשוניים גדולים כדי להקשות על פירוק לגורמים ואקראיים כדי להקשות על ניחושם. האסטרטגיה המומלצת היא להגריל מספר אקראי אי־זוגי באורך הרצוי באמצעות מחולל פסאודו-אקראי ובדיקת ראשוניותו באמצעות אלגוריתם לבדיקת ראשוניות. אפשר להסתפק באלגוריתם הסתברותי כגון מילר־רבין אם הפרמטרים נבחרו כראוי. משפט המספרים הראשוניים מבטיח שתוך מספר קטן יחסית של הגרלות (בערך כמספר הספרות של המספר), נתקלים בראשוני.
* <math>n</math> נקרא מודולוס. החישובים מתבצעים בחוג <math>\ \mathbb{Z}_n</math> שבו מחושבת השארית של כל פעולה אריתמטית במספר n (ראו חשבון מודולרי). <math>n</math> משמש כמפתח פומבי ונדרש להצפנה ופענוח.
* <math>e</math> הוא מפתח פומבי המשמש להצפנה ויכול להיות כל שלם טבעי הנמוך מ־<math>n</math> ובלבד שיהיה זר ל־<math>\ \phi(n)</math> כלומר שאין לו מחלק משותף עם <math>\phi(n)</math> מלבד 1. מסמנים זאת: <math>\mbox{gcd}(\phi(n),e)=1</math> (הפונקציה gcd מציינת מחלק משותף מרבי). זאת כדי להבטיח כי ההצפנה תהיה תמורה ייחודית (כלומר עבור כל מסר מוצפן <math>\ c</math> יהיה מסר מפוענח יחיד <math>\ m</math> המתאים לו). רצוי לבחור <math>\ e</math> קטן ככל האפשר כדי להקל על תהליך ההצפנה.
* <math>d</math> הוא מפתח פרטי המשמש לפענוח וצריך להישמר בסוד. <math>d</math> הוא הופכי כפלי מודולרי של <math>e</math> (מודולו <math>\phi(n)</math>) וניתן לסמנו: <math>e^{-1}</math>. להכנת <math>\ d</math> אפשר להיעזר באלגוריתם אוקלידס המורחב (להלן)
* הראשוניים <math>p</math> ו־<math>q</math> לא נחוצים לתהליך ההצפנה והפענוח על כן רצוי להשמידם.

===פרמטרים מתקדמים===
* בתקן PKCS (גרסה 2), שונה מעט תהליך הכנת המפתחות. במקום לחשב את <math>\ \phi(n)=(p-1)(q-1)</math> מחשבים את <math>\ \lambda(n)=\mbox{LCM}(q-1, p-1)</math>, שהוא האקספוננט של חבורת אוילר <math>\ U_n</math> (הפונקציה <math>\ \mbox{LCM}</math> היא הכפולה המשותפת המינימלית). במקרה זה <math>\ d</math> צריך לקיים את יחס השקילות <math>\ ed \equiv 1 \ (\mbox{mod } \lambda \left(n\right))</math>.
* תקן PKCS תומך בגרסה מתקדמת הנקראת RSA-CRT בה מנצלים את משפט השאריות הסיני כדי לחלק את מפתח הפענוח הסודי לשני מפתחות קטנים. מחשבים את <math>\ d_P</math> כך שמתקיים <math>\ e \cdot d_P \equiv 1 \ (\mbox{mod } (p-1))</math> ו־<math>\ d_Q</math> כאשר <math>\ e \cdot d_Q \equiv 1 \ (\mbox{mod } (q-1))</math> ובאופן דומה מחשבים את מקדם CRT שהוא ההופכי הכפלי של <math>\ q</math> מודולו <math>\ p</math> המסומן בקיצור <math>\ q^{-1}</math>. הראשוניים ומקדם ה־CRT נדרשים להצפנה ופענוח ועל כן יש לשומרם בסוד. כמו כן תהליך הפענוח שונה במעט (להלן).
*התקן תומך גם בגרסת "Multi-prime" שבה מספר הגורמים הראשוניים של המודולוס <math>\ n</math> גדול משניים. במקרה זה, עבור הראשוניים <math>\ r_1,r_2,...,r_u</math> כאשר <math>\ u \ge 3</math> מחשבים את המעריכים <math>\ d_i</math> כך שמתקיים <math>\ e \cdot d_i \equiv 1 \ (\mbox{mod } (r_i - 1))</math> וכן <math>\ t_i</math> הנקראים מקדמי <math>\ \mbox{CRT}</math> כך שמתקיים <math>\ R_i \cdot t_i \equiv 1 \ (\mbox{mod } r_i)</math> כאשר <math>\ R_i</math> הוא כפולה של כל הראשוניים למעט <math>\ r_i</math>. בשיטה זו יש לשמור את כל השלישיות <math>\ r_i,d_i,t_i</math>. וכן תהליך הפענוח שונה בהתאם (להלן).

== הצפנה ופענוח ==
אליס משדרת לבוב את מפתחות ההצפנה (<math>\ e, n</math>) ושומרת בסוד את המפתח <math>\ d</math>. אם בוב מעוניין לשלוח את המסר <math>\ m</math> לאליס תחילה עליו להפוך את <math>\ m</math> לערך מספרי הנמוך מ־<math>\ n</math> בדרך מוסכמת כלשהי.

===הצפנה===
: <math>\boldsymbol{c = m^e \mbox{ mod }n}</math>.
להצפנה בוב פשוט מעלה את <math>m</math> בחזקת <math>e</math> ונוטל את השארית מחילוק ב־<math>n</math>. את הטקסט המוצפן <math>c</math> הוא יוכל לשדר לאליס בערוץ פתוח ונגיש לכל.

===פענוח===
לפענוח אליס משחזרת את המסר <math>m</math> מתוך הטקסט המוצפן <math>c</math> בעזרת המפתח הסודי <math>d</math> בדרך זו:
: <math>\ \boldsymbol{m = c^d \mbox{ mod }n}</math>

===גרסאות מתקדמות===
====RSA-CRT====
בגרסת CRT המופיעה בתקן, תהליך ההצפנה נותר זהה אך תהליך הפענוח שונה והוא מורכב משלושה שלבים:
#משתמשים במפתחות הפענוח מתהליך ההכנה לעיל, כדי לחשב את <math>\ m_1 = c^{d_P} \mbox{ mod } p</math> וכן <math>\ m_2 = c^{d_Q} \mbox{ mod } q</math>.
#מחשבים את <math>\ h = (m_1 - m_2) \cdot q^{-1} \ \mbox{mod } p</math> כאשר <math>\ q^{- 1}</math> הוא הופכי כפלי מודולרי של <math>\ q</math> מודולו <math>\ p</math>
#התוצאה תהיה <math>\ m = m_2 + q \cdot h</math>
היות שפעולת העלאה בחזקה מודולרית היא הפעולה הארוכה והאיטית ביותר בכל התהליך. היתרון בשיטה זו כאמור שהיא נעשית מודולו <math>p</math> ו־<math>q</math> כל אחד בנפרד. היות שהם קטנים מהמודולוס בחצי מושג שיפור בפקטור של 2 בקירוב.

====RSA Multi-primes====
בגרסת Multi-Prime שבה מספר הגורמים גדול משניים, שוב ההצפנה זהה לגרסה הבסיסית ואילו הפענוח מתבצע כדלהלן:
#תחילה עבור הגורמים <math>\ r_1,r_2,...,r_u</math> כאשר <math>\ u \ge 3</math> מחשבים את <math>\ m_i = c^{d_i}\mbox{ mod } r_i</math> כאשר <math>d_i</math> הם מפתחות הפענוח שהוכנו קודם (פרמטרים מתקדמים לעיל).
#מחשבים את <math>\ h = (m_1 - m_2) \cdot r_2^{-1} \ (\mbox{mod }r_1)</math>.
#מחשבים את <math>\ m = m_2 + r_2 \cdot h</math>.
#מציבים <math>\ R = r_1</math> ועבור <math>\ i=3</math> עד <math>\ u</math> מחשבים את:
##<math>\ R = R \cdot r_{i-1}</math> (כפולת כל הראשוניים למעט <math>\ r_i</math>)
##<math>\ h = (m_i - m) \cdot t_i \ (\mbox{mod }r_i)</math>
##<math>\ m = m + R \cdot h</math>
יש לזכור שכל הפעולות מבוצעות מודולו <math>\ n</math>.
מכיוון שהפרמטרים ביישום מעשי בדרך כלל גדולים, חישוב חזקות בסדר גודל כזה נעשה בשיטות לחישובים מודולריים מרובי ספרות (ראו חשבון מודולרי).

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

== בסיס מתמטי ==

ביטחון שיטת RSA מתבסס על בעיית RSA כדלקמן; נתון שלם חיובי <math>pq</math>, מכפלת שני ראשוניים שונים שווים בגודלם בקירוב, נתון שלם חיובי <math>e</math> הנמוך מ־<math>pq</math> המקיים <math>\ \mbox{gcd}((p-1)(q-1),e)=1</math> (פירושו ש־<math>e</math> זר ל־<math>(p-1)(q-1)</math>) ונתון שלם <math>c</math> כלשהו. מצא את <math>m</math> המקיים את המשוואה: <math>m^e \equiv c \ (\mbox{mod }pq)</math>. במילים אחרות הבעיה היא מציאת שורש ממעלה <math>e</math> של <math>c</math> (מודולו <math>pq</math>).

הרעיון מאחורי אלגוריתם הפענוח של RSA מבוסס על משפט אוילר הקובע: עבור כל <math>\ a</math> ו־<math>n</math> טבעיים הזרים זה לזה (שאין להם מחלק משותף מלבד 1) מתקיים:
<math>a^{\phi(n)} \equiv 1 \ (\mbox{mod }n)</math>. הפונקציה <math>\phi (n)</math> נקראת פונקציית אוילר ומייצגת את מספר הטבעיים הזרים ל־<math>n</math> וקטנים ממנו. אם מכפילים את שני אגפי השקילות האמורה ב־<math>a</math> מתקבל: <math>a^{\phi (n)+1}\equiv a^{\phi (n)} \cdot a\equiv a \ (\mbox{mod }n)</math>.

=== הוכחת נכונות ===
לפי האלגוריתם מפתח הפענוח <math>\ d</math> מקיים את השקילות <math>\ ed \equiv 1 \ (\mbox{mod } \phi)</math>,

כלומר <math>ed-1</math> הוא כפולה כלשהי של <math>\phi</math> שהוא בעצם <math>(p-1)(q-1)</math>, בניסוח אחר קיים שלם <math>\ k</math> המקיים <math>\ ed=1+k(p-1)(q-1)</math> לכן <math>c^d</math> הוא פתרון של המשוואה <math>m^e\equiv c\text{ (mod }pq)</math> כי עבור כל שלם <math>c</math> הנמוך מ־<math>pq</math> מתקיים:

{|
|-
|
<div class="mw-content-ltr">
:<math>(c^d)^e\equiv c^{de}\text{ (mod }pq)</math>,
:::<math>\equiv c^{1+k(p-1)(q-1)}\text{ (mod }pq)</math>,
:::<math>\equiv c\cdot (c^{(p-1)(q-1)})^k\text{ (mod }pq)</math>,
:::<math>\equiv c\cdot 1^k\text{ (mod }pq)</math>
:::<math>\equiv c\text{ (mod }pq)</math>
</div>
||
:לפי חוקי החזקות,
:היות שמתקיים <math>de=1+k(p-1)(q-1)</math>,
:חוקי החזקות שוב,
:נובע ממשפט אוילר
:
|}

והפתרון הוא יחיד כיוון שאם קיים פתרון אחר נניח <math>u</math> שגם הוא פתרון של <math>c\equiv m^e</math> אז:
{|
|-
|
<div class="mw-content-ltr">
:<math>u\ \equiv u^{de-k(p-1)(q-1)}\text{ (mod }pq)</math>,
::<math>\equiv (u^e)^d\cdot (u^{(p-1)(q-1)})^{-k}\text{ (mod }pq)</math>,
::<math>\equiv (u^e)^d\cdot 1^{-k}\text{ (mod }pq)</math>,
::<math>\equiv c^d\text{ (mod }pq)</math>
</div>
||
:היות ש־<math>de=1+k(p-1)(q-1)</math>,
:לפי חוקי החזקות
:לפי משפט אוילר
:היות ש־<math>u</math> הוא פתרון של <math>m^e\equiv c\text{ (mod }pq)</math>.
|}


=== דוגמה במספרים קטנים ===
נניח שאליס בוחרת את הראשוניים

<math>p=5581 ,q=8059</math> ומחשבת את: <math>n=5581\cdot 8059=44977279</math>

ואת פונקציית אוילר: <math>\phi=\mbox{lcm}(5580,8058)=7493940</math>

וכן בוחרת את <math>e=257</math>, שימו לב שמתקיים <math>\ \mbox{gcd}(7493940,257)=1</math> כנדרש.

בעזרת אלגוריתם אוקלידס המורחב מתקבל

<math>(291593 \cdot 257) \equiv 1 \ (\mbox{mod } 7493940)</math>

לכן <math>d=291593</math> יהיה מפתח הפענוח המתאים. אליס שולחת את

<math>\ 44977279</math> ואת <math>\ 257</math> לבוב ושומרת בסוד את <math>291593</math>.

אם בוב מעוניין להצפין את המסר <math>\ m=123456</math> עבור אליס הוא מחשב את:
: <math>c=123456^{257} \mbox{ mod }44977279=10526715</math>
: ושולח את <math>\ c</math> לאליס.

כשאליס מקבלת את <math>\ c</math> היא משחזרת את <math>\ m</math> בעזרת המפתח הסודי:

: <math>m=10526715^{291593} \mbox{ mod }44977279=123456</math>.

בגרסת CRT מחשבים תחילה את מפתחות הפענוח <math>d_P=1433</math> כי מתקיים <math>1433 \cdot 257 \equiv 1 \ (\mbox{mod }5580)</math> באופן דומה מוצאים את <math>d_Q=1505</math>.

ואז לפענוח מחשבים את <math>m_1=10526715^{1433}\mbox{ mod }5581=674</math> וכן <math>m_2=10526715^{1505}\mbox{ mod }8059=2571</math>

מחשבים את ההופכי הכפלי של <math>q</math> מודולו <math>p</math> שהוא <math>q^{-1}=1268</math> ואז <math>h=3684\cdot 1268 \ (\mbox{mod }5581)=15</math>. שימו לב שהיות ש־<math>m_1-m_2=-1897</math> הוא מספר שלילי לכן לפי הכלל בחשבון מודולרי (מודולו <math>p</math> במקרה זה) הוא שקול למעשה ל־<math>p-1897=3684</math>.

מה שנותר הוא לחשב את <math>m=15\cdot 8059 + 2571</math>.

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

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

אם אליס מעוניינת לשלוח את המסר <math>m</math> כשהוא חתום על ידה לבוב, היא מבצעת:

: <math>\ \bar{m} = R(m)</math>
: <math>\ s = \bar{m}^d \mbox{ mod }n</math> (בדיוק כמו בתהליך הפענוח לעיל).

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

לאימות החתימה, בוב מחשב את:

: <math>\ \bar{m} = s^e \mbox{ mod }n</math> (בדיוק כמו תהליך ההצפנה לעיל)
: <math>m = R^{-1}(\bar{m})</math>

בוב משיג עותק אותנטי של מפתח האימות של אליס (המקביל למפתח ההצפנה <math>\ e</math>) באמצעותו מפענח את <math>\ \bar{m}</math> ובהפעלת הפונקציה ההופכית <math>\ R^{-1}</math> משחזר את המסר המקורי. בוב יכול להיות משוכנע כי רק אליס שהיא בעלת המפתח הפרטי המתאים, יכולה הייתה להיות המקור למסר ובמיוחד שלא שונה על ידי גורם כלשהו במהלך המשלוח.

פונקציית היתירות הכרחית כיוון שללא השימוש בה יהיה קל למצוא מסר אחר שעבורו החתימה של אליס תהיה תקפה ללא ידיעת המפתח הפרטי שלה. זאת בשל הכיפליות של RSA. כדי לראות מדוע נניח כי <math>R(m)=m</math> (פונקציית הזהות), אם אליס חתמה על שני מסמכים שונים <math>\ m_1</math> ו־<math>\ m_2</math> אזי כפולה של החתימות: <math>\ s_1 = m^d_1 \mbox{ mod }n</math> ו־<math>\ s_2 = m^d_2 \mbox{ mod }n</math> על המסרים הנ"ל תהיה חתימה תקפה עבור המסר <math>\ m = m_1m_2</math>. פונקציית היתירות מבטלת את האסוציאטיביות של החתימות ועל כן מונעת בעיה זו.

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

; RSA-CRT : ב־1982 פותחה גרסת RSA-CRT בה תהליך הכנת המפתחות והפענוח דורשים מספר התאמות: מחשבים שני מפתחות פענוח <math>\ d_p</math> ו־<math>\ d_q</math> באופן שמתקיים <math>\ e \cdot d_p \equiv 1 \ (\mbox{mod }(p-1))</math> וכן <math>\ e \cdot d_q \equiv 1 \ (\mbox{mod }(q-1))</math>. לפענוח תחילה מחשבים את <math>\ m_1=c^{d_p} \mbox{ mod }p</math> ואת <math>\ m_2=c^{d_q} \mbox{ mod }q</math>. נעזרים באלגוריתם של הרווי גארנר לחישוב CRT, כדי לחלץ את <math>\ m</math> מתוך מערכת השקילויות כך: <math>\ h=(m_1-m_2) \cdot q^{-1} \mbox{ mod }p</math> (כאשר <math>\ q^{-1}</math> הוא הופכי כפלי של <math>\ q</math> מודולו <math>\ p</math>). המסר <math>\ m</math> יהיה <math>\ m_2+q \cdot h</math>. כיוון שהמפתחות <math>\ d_p</math> ו־<math>\ d_q</math> קטנים בחצי מהמודולוס זמן הפענוח מתקצר בפקטור של 2 כמעט, זאת מבלי לאבד מביטחון האלגוריתם.

; Batch RSA : גרסת RSA של עמוס פיאט שבה, אם המפתח הפומבי קטן מאוד, ניתן לפענח מספר מסרים שהוצפנו תחת אותו מודולוס בבת אחת. רעיון זה שימושי במערכות דוגמת שרת SSL המבצע פעולות Handshake בתדירות גבוהה. במקרה כזה ניתן לשנות את ארכיטקטורת השרת כך שימתין לקבלת מספר בקשות פענוח ואז יפענח את כל המסרים במחיר של פעולת פענוח אחת, בתנאי שהמודולוס זהה ומפתחות ההצפנה קטנים (ושונים). שיטה זו משפרת את יעילות אלגוריתם RSA בפקטור של כמעט 3.5 אם מבצעים שמונה פענוחים בבת אחת. כדי להסביר כיצד זה פועל, ידוע שבעיית RSA היא מציאת שורש ממעלה כלשהי מודולו שלם פריק <math>\ N</math>. כלומר:
: <math>\ M^d \ (\mbox{mod }N) = M^{1/e} \ (\mbox{mod }N)</math>.
: בתהליכי הפענוח והכנת החתימה המתוארים לעיל, יש צורך להעלות את <math>\ M</math> בחזקת <math>\ d</math> כלומר לחשב את <math>\ M^{1/e}</math>. אם למשל <math>\ e_1=3, e_2=5</math>, ונתונים <math>\ M_1, M_2</math> שעבורם צריך לחשב את <math>\ m^{1/3}_1</math> ואת <math>\ M^{1/5}_2</math>, אפשר לחשב תחילה את:
:: <math>\ M = M^5_1 \cdot M^3_2 \ (\mbox{mod }N)</math> ואת,
:: <math>\ I=M^{1/15} \ (\mbox{mod }N)</math>.
: ואז לפתור את המשוואות הנ"ל כדלהלן:
:: <math>\ \frac{I^6}{M^2_1 \cdot M_2}=M^{1/5}_2 \ (\mbox{mod }N)</math>,
:: <math>\ \frac{I}{M^{1/5}_2}=M^{1/3}_1 \ (\mbox{mod }N)</math>.
: יוצא שרק בחישוב <math>\ I=M^{1/15}</math> נדרשת העלאה בחזקה מודולרית מלאה, בנוסף למספר קבוע קטן של פעולות כפל וחילוק מודולריים. החסכון הוא ששתי העלאות בחזקה מודולו <math>\ N</math> בוצעו כמעט במחיר של העלאה בחזקה מודולרית אחת. הטריק המתואר מסתמך על העובדה שהמעריכים זרים זה לזה. אפשר להוסיף שיפורים לשיטה זו כמו CRT האמור. החסרון העיקרי הוא בצורך במפתחות הצפנה קטנים מאוד. כאשר מפתח הצפנה גדול, Batch RSA לא תהיה יעילה בשל התקורה הרבה הנוספת.

; Multi-prime RSA : גרסה זו מבוססת על שינוי מבנה המודולוס. מיישמים את RSA עם מודולוס במבנה <math>\ n=pqr</math> או <math>\ n=r_1\cdot r_2\cdots r_u</math> כאשר <math>\ u \ge 3</math>. מכינים מפתחות פענוח מתאימים כמספר הגורמים, מפענחים עם כל מפתח במפרד ואז מחשבים את מערכת הקונגרואנציות באמצעות אלגוריתם CRT. במקרה של שלושה גורמים, אם המודולוס בגודל 2048 סיביות, כל גורם ראשוני יהיה בערך בגודל 683 סיביות. חישוב חזקה מודולרית בסדר גודל כזה מהיר במידה ניכרת מאשר חישוב החזקה עם המודלוס עצמו. משיקולי ביטחון במקרה שהמודולוס בגודל 1024 סיביות מספר הגורמים המקסימלי יכול להיות 3. RSA multi-prime מהירה יותר מהגרסה הבסיסית בפקטור של 2 בקירוב. תקן PKCS #1 תומך בגרסה זו.

; Multi-power RSA : בגרסה זו המודולוס הוא מהצורה: <math>\ N=p^{b-1}q</math> כאשר <math>\ p</math> ו־<math>\ q</math> הם בגודל <math>\ n/b</math> סיביות (n הוא מספר סיביות המודולוס). במקרה של 1024 סיביות משיקולי ביטחון, לכל היותר <math>\ b=3</math>. בפענוח משתמשים בשיטת למת הנזל (Hensel lifting) שהיא יעילה יותר מהעלאה בחזקה מודולרית רגילה. בשיפורים קלים multi-power יעילה יותר מהשיטה הבסיסית בפקטור של 2.3 לפחות.

; Rebalanced RSA : הרעיון בשיטה זו הוא לפתור את חוסר האיזון הקיים בגרסה הבסיסית של RSA בין גודל מפתח ההצפנה לבין גודל מפתח הפענוח. משיקולי יעילות מפתח ההצפנה בדרך כלל קטן משמעותית. עובדה שלא תמיד רצויה היות שעלול להיווצר עומס יתר בצד המפענח לעומת הצד המצפין. במיוחד הדבר חשוב במכשיר נייד שאמור לייצר חתימת RSA שלאחר מכן תאומת על ידי שרת מהיר. כאן דווקא תהליך יצירת החתימה (המקביל לפענוח) צריך להיות קל יותר כיוון שנעשה בסביבה מוגבלת במשאבים. גרסת Rebalanced RSA דומה ל־RSA-CRT המתוארת לעיל, מלבד זאת שבגרסה זו מקזזים מגודל מפתח הפענוח על חשבון מפתח ההצפנה. השוני הוא בעיקר באלגוריתם הכנת המפתחות. אם השיטה מיושמת נכון ניתן להגיע למפתחות פענוח בסדר גודל של 160 סיביות כל אחד (במקרה של מודולוס בגודל 1024 סיביות). התקורה הנוספת מתהליך הכנת המפתחות וכן חישוב CRT בשלב הסופי של הפענוח נמוכה ביותר. חסרונה של השיטה הוא בעיקר בעובדה שהמפתח הפומבי גדול יותר, עקב כך לא בכל המערכות ניתן לישמה. יש מערכות המגבילות את גודל מפתח ההצפנה משיקולי יעילות. שיטה זו יעילה יותר מהגרסה הבסיסית של RSA בפקטור של 3 לפחות.

; Unbalanced RSA : הצעה של עדי שמיר שבה הגורמים הראשוניים אינם שווים בגודלם (מכאן השם). הרעיון הוא שכדי להקשות על שבירת RSA בדרך של פירוק לגורמים רצוי שהמודולוס יהיה גדול ככל האפשר, אולם זה פוגע ביעילות השיטה במיוחד בסביבה מוגבלת במשאבים. אולם אם <math>\ p</math> קטן, נניח 1000 סיביות ו־<math>\ q</math> גדול פי חמישה, אזי משיגים שיפור בביטחון השיטה ועדיין תהליכי ההצפנה והפענוח נותרים באותה רמת סיבוכיות (בתנאי שהמסר קטן מ־<math>\ p</math>). זאת כיוון שיעילות אלגוריתמים המנצלים קיומם של גורמים קטנים אינה גבוהה והאלגוריתמים הכלליים פחות יעילים כאשר המודולוס גדול. בשיטה זו ההצפנה זהה, כל עוד המעריך <math>\ e</math> גדול מספיק כדי ש־<math>\ m^e</math> מספיק גדול. לפענוח מנצלים את CRT כדי לחשב את: <math>\ c^d\ \mbox{mod }n</math> כך: תחילה מצמצמים <math>\ d'\equiv d\ \mbox{mod }\phi(p)</math> ואת <math>\ r\equiv c\ \mbox{mod }p</math> ואז מחשבים את <math>\ m = r^{d'}\ \mbox{mod }p</math>. אך יש להיזהר מפני התקפת מוצפן־נבחר שבה התוקף מצליח לחלץ מידע מסוים לגבי סיביות המפתח, כאשר מנסים לפענח את <math>\ m > p</math> התוצאה תהיה <math>\ \tilde m \ne m</math> במקרה זה מתקבלת הודעת שגיאה מהמערכת. באמצעות חישוב CRT וחיפוש בינארי ניתן למקד את החיפוש עד כדי חשיפת המפתח כולו במספר קטן של ניסיונות.

סוגיית ביטחון גרסאות אילו היא שאלה פתוחה. לא ברור לגמרי האם טכניקות אילו מחלישות או מחזקות את ביטחון אלגוריתם RSA. אם כי לא ידוע על דרכים יעילות לשבירת האלגוריתם בשל שינויים אילו. ראו המאמר של דן בונה וחובב שחם Fast Variants of RSA שפורסם במגזין Cryptobytes של RSA, קיץ 2002.

== ריפוד ==

הצפנת RSA מכונה דטרמיניסטית משום שהאלגוריתם אינו מערב שימוש במספרים אקראיים בניגוד לשיטות הצפנה הסתברותיות (כמו אל־גמאל). משמעות הדבר היא שבהצפנת אותו מסר פעמים נוספות (עם מפתח הצפנה זהה) תתקבל תמיד תוצאה זהה. הצפנה דטרמיניסטית פגיעה מעצם טבעה להתקפת מוצפן־נבחר, בה מניחים שהתוקף מסוגל לבחור טקסטים אותם הוא מעוניין להצפין ולנתח את תוצאת הצפנתם, אך אין לו גישה למפתח הפענוח עצמו. כתוצאה מכך, ייתכן מצב שהתוקף יוכל לנחש או לחשוף מידע חלקי או מלא אודות הצופן. כמו כן ישנם מקרי קצה שבהם המסר המיועד להצפנה עלול להוות נקודת תורפה כגון אם הוא קטן מאוד או בעל מבנה ייחודי. במקרה כזה הטקסט נקרא "חלש" כי הוא מסכן את ביטחון ההצפנה. למשל:
* כאשר <math>m = 1</math> או <math>m = 0</math> או <math>m=n-1</math> תוצאת ההצפנה תהיה תמיד <math>m</math> עצמו.
* כאשר מצפינים עם מעריך קטן כגון <math>e=3</math> ערכים קטנים של <math>m</math> עלולים להניב תוצאות קטנות הנמוכות מהמודולוס מה שמאפשר חישוב שורש ממעלה שלישית ללא תלות במודולוס.
אקראי (בטוח) לצורך פונקציית המיסוך 3) ערך אופציונלי <math>L</math> המשמש כקלט לפונקציית הגיבוב שהפלט שלה משורשר לגוש המידע (ערך ברירת המחדל של <math>L</math> הוא מחרוזת אפסים). הסימן <math>\oplus</math> מייצג XOR והפונקציה MGF היא קיצור של Mask Generation Function והיא בעיקרון פלט חלקי של פונקציית גיבוב כמו SHA-2. השיטה מפורטת בתקן PKCS#1 v2.2.]]
* כשהמסר קטן ניתן לתקוף את ההצפנה בהתקפת מוצפן־נבחר, שבה התוקף מצפין מראש את כל האפשרויות של <math>m</math> ואז בחיפוש קל ימצא את <math>c</math> המתאים ובכך יפענח את הטקסט המוצפן מבלי לתקוף את השיטה עצמה.

כדי להימנע ממסר חלש וכדי לסכל התקפת טקסט מוצפן נבחר שמנצלת חולשה זו, מקובל לרפד את המסר באמצעות אלגוריתם ריפוד מוסכם לפני ההצפנה. שיטת הריפוד עצמה לא חייבת להיות סודית. אפשר לשרשר מחרוזת אקראית למסר לפני ההצפנה כך שמבנהו המקורי מיטשטש ובזמן הפענוח פשוט מסירים את המחרוזת האקראית. תקן PKCS #1 יישם שיטת ריפוד פשוטה כזו. לפני ההצפנה המסר רופד באפסים ובמספר אקראי באורך מוגדר כלשהו. ב־1998 הראה דניאל בלייכבכר ממעבדות בל ששיטת ריפוד כזו אינה בטוחה כלל ואפשר לפרוץ אותה בקלות. ב־1995 ניסחו מיהיר בלייר ופיליפ רוגווי את רעיון מודל אורקל אקראי והראו שבאמצעותו אפשר ליישם כל שיטת הצפנה אסימטרית (דטרמיניסטית) באופן שתהיה בעלת ביטחון סמנטי. על בסיס רעיון זה פותח אלגוריתם OAEP המשתמש במחולל מספרים אקראיים בטוח ופונקציית גיבוב קריפטוגרפית בשילוב עם RSA להצפנה בטוחה. ב־1998 תקן הצפנת מפתח־פומבי PKCS #1 תוקן ואלגוריתם OAEP שולב בתקן כשיטת הריפוד התקנית להצפנת מפתח פומבי הנקראת RSA-OAEP (ראו תרשים).

== אלגוריתמים ==
כדי ליישם את RSA במחשב אין די בדרך הרגילה באמצעות יחידת החישוב במעבד, כיוון שאורך מקסימלי של מספר שניתן לעיבוד בדרך קונבנציונלית אינו עולה על גודלו של האוגר הגדול ביותר. ככל שהמחשבים השתפרו, הצורך באריתמטיקה מודולרית במספרים גדולים בהרבה רק הלך וגדל. משום כך הפתרון הוא אריתמטיקה מרובת ספרות (Multi-precision), כלומר חישוב ספרה אחר ספרה בנפרד כאשר כל ספרה תופסת קרוב לאוגר שלם. בדרך זו החישוב יותר איטי, אך אורך המספרים אינו מוגבל (בגבולות הזיכרון הזמין במחשב). קיימות ספריות לחישובים אריתמטיים מרובי ספרות לשפות התכנות הנפוצות כמו FreeLIP לשפת C של ארג'ן לנסטרה, שסייעה באתגר הראשון כנגד RSA, פירוק RSA-129 ב־1994 או המחלקה BigInteger של Java.

מרכיב חשוב בהכנת RSA הוא יצירת מפתח הפענוח <math>\ d</math> שנקרא הופכי כפלי מודולרי של <math>\ e</math> (מודולו <math>\ n</math>). כדי למצוא מספר כזה צריך לפתור את משוואת אוקלידס <math>\ de + k \phi(n) = 1</math> עבור שלם <math>\ k</math> כלשהו. אפשר לבצע זאת באמצעות אלגוריתם אוקלידס המורחב. להלן הגרסה הבסיסית:

<syntaxhighlight lang="cpp">
MultiplicativeInverse(a, b)
{
 y1 = 1, y2 = 0;

 While (b > 0)
 {
 q = a/b;
 y = y2 –(q * y1);
 r = a % b;
 a = b, b = r;
 y2 = y1, y1 = y;
 }
 return y2; 
}
</syntaxhighlight>

הצפנה ופענוח דורשים פעולות העלאה בחזקה עם מעריך גדול. הדרך הנאיבית לחישוב חזקה אינה יעילה במקרה זה. קיימים מספר אלגוריתמים לחישוב חזקות גדולות באריתמטיקה מודולרית. להלן תיאור שיטה רקורסיבית בסיסית שנקראת Square and Multiply או "העלאה בחזקה משמאל לימין". הרעיון הוא שאפשר לחשב את <math>\ a^k\ \mbox{mod}\ n</math> באמצעות סדרת הריבועים <math>\ a, a^2, a^4, a^8,...</math> עד <math>\ a^k</math>, אפשר להכין סדרה כזו באופן רקורסיבי על ידי העלאות חוזרות בריבוע: <math>a_i=a_{i-1}^2\text{ mod }n</math>. לפי חוקי האריתמטיקה מודולו <math>n</math> אפשר לבצע את הצמצום המודולרי לאחר כל העלאה בריבוע במקום לבצע את הצמצום בסוף ובכך להימנע מהתנפחות התוצאה. לפי חוקי החזקות אפשר לקבל את <math>a^k</math> כמכפלה של ערכים מתוך הסדרה האמורה, אותם אפשר לקבל על ידי הייצוג הבינארי של המעריך, דהיינו כאשר הסיבית הנוכחית היא אחד יש לכלול את האיבר המתאים במכפלה. הטבלה הבאה מדגימה את <math>245^{3125}\mbox{ mod } 10237</math>. הפרמטר <math>k</math> בטבלה מכיל את הייצוג הבינארי של המעריך: <math>\{1,1,0,0,0,0,1,1,0,1,0,1\}_2</math> כאשר הסיבית הימנית היא הסיבית הכי פחות משמעותית והסיבית השמאלית היא הסיבית המשמעותית ביותר. התוצאה תהיה מכפלת ערכי <math>a</math> בעמודות בהן <math>k_i=1</math> כלומר
<center>
:<math>245^{3125}\equiv (a_1\cdot a_3\cdot a_5 \cdot a_6 \cdot a_{11} \cdot a_{12}) \mbox{ mod } 10237\equiv (245\cdot 6579\cdot 8608\cdot 2258\cdot 9942\cdot 5129)\text{ mod }10237\equiv 9737</math>
</center>
{| class="wikitable" cellpadding="4" dir="rtl" width="300" style="text-align: right; margin: auto;"
|-
!<math>i</math> !! 1 !! 2 !! 3 !! 4 !! 5 !! 6 !! 7 !! 8 !! 9 !! 10 !! 11 !! 12
|- align="center"
|<math>\boldsymbol{k}</math> || 1 || 0 || 1 || 0 || 1 || 1 || 0 || 0 || 0 || 0 || 1 || 1
|- align="center"
|<math>\boldsymbol{a}</math> || <span style="color:#0F0">245 || 8840 || <span style="color:#0F0">6579 || 1205 || <span style="color:#0F0">8608 || <span style="color:#0F0">2258 || 538 || 2808 || 2374 || 5526 || <span style="color:#0F0">9942 || <span style="color:#0F0">5129
|- align="center"
|<math>\boldsymbol{b}</math>|| 245 || 245 || 4646 || 4646 || 7046 || 1570 || 1570 || 1570 || 1570 || 1570 || 7752 || <span style="color:blue">9737
|}

את החישוב הזה קשה לעשות בדרך הישירה כמו באמצעות מחשבון כי תוצאת הביניים של ההעלאה בחזקה לפני החילוק היא באורך כאלף ספרות עשרוניות שזה מספר ארוך מדי מכדי להכילו במשתנה אחד. להלן פסאודו קוד של האלגוריתם:
<syntaxhighlight lang="C">
Square_and_multiply(a, k, n)
{
 b = 1;
 while (k > 0)
 {
 if ((k & 1) == 1)
 b = ((b * a) % n);
 a = ((a * a) % n);
 k >>= 1;
 }
 return b;
}
</syntaxhighlight>

<math>\ k</math> המייצג את <math>\ t</math> סיביות המעריך <math>\ k_1,k_2,...,k_t</math>. בלולאה הראשית סורקים את סיביות <math>\ k</math> מימין לשמאל (מהספרה הכי פחות משמעותית לספרה הכי משמעותית), מעלים את <math>\ a</math> בריבוע בכל סבב וכל פעם שהסיבית הנוכחית היא 1 בנוסף מכפילים ב־<math>\ b</math>. התוצאה הסופית נשמרת ב־<math>\ b</math>.

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

== התקפות ==
=== התקפת ערוץ צדדי ===

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

ישנן דרכים להתמודד עם זה. למשל להבטיח שתהליך הפענוח יתרחש בזמן קבוע על ידי השהיה מכוונת. אולם בדרך זו יעילות המערכת נפגעת. גישה אחרת הנקראת Blinding מנצלת את תכונת הכפליות של RSA (להלן). במקום לפענח את הטקסט המוצפן ישירות, בוחרים <math>\ r</math> אקראי כלשהו ואז מחשבים את: <math>\ (cr^e)^d \mbox{ mod }n</math> והתוצאה תהיה <math>\ mr \mbox{ mod }n</math>. ניתן להסיר את הערך האקראי מהמסר על ידי הכפלה ב־<math>\ r^{-1}</math> (ההופכי של <math>\ r</math> מודולו <math>\ n</math>). בצורה זו הפענוח אינו תלוי בטקסט המוצפן המתקבל ועל כן התקפת תזמון תכשל במקרה כזה. כמו כן יש לוודא תמיד שהודעות השגיאה של המערכת לא יסגירו מידע פנימי, על ידי בדיקה תמידית של תקפות ערכים וכן לוודא שהזמן הדרוש לכל פעולה יהיה קבוע ללא תלות בשגיאה או בנקודת הזמן בו ארעה.

=== התקפת האדם שבתווך ===

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

== ראו גם ==
* פונקציה חד־כיוונית
* בעיית RSA

== קישורים חיצוניים ==
* המאמר המקורי של ריבסט, שמיר ואדלמן [http://people.csail.mit.edu/rivest/Rsapaper.pdf A Method for Obtaining Digital Signatures and Public-Key Cryptosystems], המכון הטכנולוגי של מסצ'וסטס, קיימברידג' מסצ'וסטס, אפריל 1977
* [https://web.archive.org/web/20051029040347/http://rsasecurity.com/rsalabs/node.asp?id=2125 תקן PKCS #1 להצפנת RSA], באתר [http://www.rsasecurity.com/rsalabs/ מעבדות RSA]
* [https://web.archive.org/web/20031009004754/http://www.acm.org/announcements/turing_2002.html נימוקי הוועדה, להענקת פרס טיורינג ל־RSA]
* תמי לפידות וד"ר דלית לוי, [https://web.archive.org/web/20040116081720/http://cse.proj.ac.il/hebetim/june2003/rsa.htm#î÷åøåú הסבר תמציתי ובהיר (עברית) על שיטת RSA, הצפנה בכלל, ומקבלי פרס טיורינג]
* [https://web.archive.org/web/20061016190100/http://www.rsasecurity.com/rsalabs/node.asp?id=2213 סדרת מאמרים של מעבדות RSA], המסבירים את עקרונות אלגוריתם RSA, הבסיס המתמטי, היתרונות והתועלת שבשיטה
* נצה מובשוביץ־הדר, [https://web.archive.org/web/20180122072045/http://video.cet.ac.il/VideoPlayerHTML5.aspx?xmlConfigPath=math%2F2014%2Fprop_niza_movshovich_hadar_mdi.xml הרצאה על מספרים ראשוניים והצפנה], יסודות ה־RSA
* עודד בראש, [http://www.underwar.co.il/document-details.asp?id=311 התקפות על מערכת ההצפנה RSA], באתר פרויקט UnderWarrior
* [https://web.archive.org/web/20061020211126/http://www.rsasecurity.com/rsalabs/cryptobytes/CryptoBytes_January_2002_final.pdf גרסאות מהירות של RSA], מגזין CryptoBytes (כרך 5) ינואר 2002
* 
* 

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

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