פרוטוקול פייגה-פיאט-שמיר

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

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

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

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

===תהליך הכנה חד פעמי===
במערכת אימות זהויות מעשית הלקוח A מגיש בקשת התחברות לשרת B ומנסה לאמת את זהותו מולו על ידי הוכחת ידיעת הסיסמה מבלי לחשוף את הסיסמה עצמה. לשם כך מסתייעים בצד שלישי נאמן (נקרא גם רשות מאשרת), הלקוח רושם מפתח פומבי מתאים אצל הצד השלישי בעזרתו השרת מסוגל לאמת את זהות הלקוח. על כן ההנחה היא שהמפתח הפומבי של הלקוח מאומת ומשויך לו באמצעים מקובלים כמו תעודת מפתח פומבי החתומה על ידי רשות מאשרת, כך שהשרת B יוכל להשיג את המידע הציבורי הדרוש לצורך הפרוטוקול, באופן בטוח. לצורך הכנה חד-פעמית:
*בוחרים שלם פריק <math>\ n</math> שהוא כפולה של שני מספרים ראשוניים גדולים <math>\ p</math> ו-<math>\ q</math> השקולים ל-3 (מודולו 4), עקב כך מספרים אילו מכונים מספרי בלום (Blum integer) וכן המספר <math>\ -1</math> אינו שארית ריבועית מודולו <math>\ n</math> כלומר שלו סימן יעקובי <math>\ \left( \frac{-1}{n} \right)=+1</math>. המודולוס <math>\ n</math> יהיה ציבורי ויירשם אצל הצד השלישי וכמו כן צריך להיות גדול דיו כדי לסכל ניסיון לפרקו לגורמים.
*בוחרים שלמים <math>\ t</math> ו-<math>\ k</math> המשמשים כפרמטרים של בטיחות (ראה בטיחות).

===בחירת סוד פרטי===
כחלק מתהליך ההכנה, כל משתמש פועל כדלהלן:
*בוחר <math>\ k</math> שלמים אקראיים <math>\ s_1,s_2,...,s_k</math> בטווח <math>\ [1,n-1]</math> וכן <math>\ k</math> סיביות אקראיות <math>\ b_1,b_2,...,b_k</math> (כמובן שצריך להתקיים <math>\ \mbox{gcd}(s_i,n)=1</math>, אולם כמעט בטוח שדרישה זו לא תופר לעולם כיוון שמשמעות הדבר שנמצא גורם ראשוני של המודולוס מה שלא סביר שיקרה).
*מחשב את <math>\ v_i=(-1)^{b_i}\cdot (s^2_i)^{-1}\mbox{ mod }n</math> עבור כל השלמים <math>\ s_i</math> (באופן זה מבטיחים ש-<math>\ v</math> משתרע על פני כל השלמים מודולו <math>\ n</math> וכן כל <math>\ v_i</math> זר ל-<math>\ n</math> ובעל סימן יעקובי 1, דרישה זו הכרחית כדי להבטיח שלא ייחשף כל מידע בנוגע לסוד).
*המפתח הציבורי יהיה הווקטור <math>\ v_1,v_2,...,v_k</math> אותו המשתמש רושם אצל הצד השלישי. המפתח הפרטי הוא הווקטור <math>\ s_1,s_2,...,s_k</math> ומשמש כסודו של A.

===מהלכי הפרוטוקול===
#<math>A \rarr B</math>: <math>\ x = \pm r^{2}\mbox{ mod }n</math>
#<math>A \larr B</math>: <math>\ e_1,e_2,...,e_k, (e \in \{0,1\})</math>
#<math>A \rarr B</math>: <math>\ y=r\cdot \prod_{e_{j=1}} s_j^{e_j} \mbox{ mod }n</math>

===פירוט המהלכים===
מהלכי הפרוטוקול מבוצעים <math>\ t</math> פעמים כדלהלן:
*A בוחר מספר אקראי <math>\ r</math> בטווח <math>\ [1,n-1]</math> וסיבית אקראית אחת <math>\ b</math> ומחשב את <math>\ x=(-1)^b\cdot r^2\mbox{ mod }n</math> ושולח את <math>\ x</math> הנקרא הוכחה ל-B.
*B שולח ל-A את האתגר שהוא וקטור סיביות אקראי <math>\ e_1,e_2,...,e_k</math>.
*A מחשב את <math>\ y=rs_1^{e_1}s_2^{e_2}\cdot\cdot\cdot s_k^{e_k} \mbox{ mod }n</math> (כלומר כפולה של <math>\ r</math> בכל השלמים <math>\ s_j</math> אשר מקבילים ל-1 בוקטור האתגר) ושולח את המענה <math>\ y</math> ל-B.
*B מחשב את <math>\ z=y^2\cdot \prod_{j=1}^k v_j^{e_j}\mbox{ mod }n</math> ומוודא ש-<math>\ z=\pm x</math> וכן ש-<math>\ z\ne 0</math>.
אם בכל <math>\ t</math> הסבבים <math>\ z=\pm x</math> כנדרש, B יכול לקבל את הוכחת הזהות של A ולא, ההוכחה תדחה.

===דוגמה להמחשה===
נתון המודולוס <math>\ n=631\cdot 983=620273</math> והפרמטרים <math>\ t=1,k=4</math>.
להכנה המשתמש A בוחר 4 שלמים אקראיים <math>\ s_1=5586,s_2=12546,s_3=1819,s_4=11777</math> המשמשים כמפתח פרטי וכן וקטור סיביות <math>\ b_1=0,b_2=0,b_3=0,b_4=1</math> ומחשב את המפתח הפומבי: <math>\ v_1=587652,v_2=370139,v_3=537354,v_4=109516</math>

לצורך אימות מול B המשתמש A בחר מספר אקראי <math>\ 5506</math> וסיבית אחת, נניח <math>\ 0</math> ומחשב את ההוכחה: <math>\ 5506^2\mbox{ mod }620273=542932</math> ושולח את <math>\ 542932</math> לשרת. השרת מייצר רצף סיביות אתגר אקראי <math>\ (0,0,1,0)</math> ושולח למשתמש. המשתמש בתורו מחשב את <math>\ 5506\cdot 1819\mbox{ mod }620273=91046</math> (רק הסיבית <math>\ e_3=1</math> לכן <math>\ s_3</math> נכלל בחישוב) ושולח בחזרה לשרת את המענה <math>\ 91046</math>. מה שנותר לשרת כדי לאמת את זהותו זה לבדוק האם <math>\ 91046^2\cdot 537354\mbox{ mod }620273=542932</math> כיוון שזהו אכן המקרה ההוכחה מתקבלת.

אם A מתחזה ואין לו שמץ של מושג לגבי הסוד <math>\ s</math>. הוא יכול לרמות רק אם ידע מראש מה תהיה מחרוזת סיביות האתגר שהשרת ישלח לו. במקרה כזה הוא יכול פשוט לקבוע את: <math>\ x = r^2\cdot \prod_{i=1}^k v_i^{e_i}</math> ואז המענה יהיה תמיד <math>\ y=r</math>. עבור כל סיבית סיכוייו לרמות הם חצי ובסך הכול סיכוייו הם <math>\ 2^{-k}</math> עבור סבב בודד.

קל יותר להבין את הרעיון עם סיבית אתגר בודדת. אם נתייחס רק לסיבית הראשונה המקבילה ל-<math>\ v_1=587652</math>, נניח שהמתחזה ישלח לשרת את <math>\ x=r^2\cdot v_1</math> הוא יצליח לענות תשובה נכונה רק אם סיבית האתגר שיקבל תהיה 1 כיוון שאז <math>\ y^2\cdot v_1 \equiv x\mbox{ (mod }n)</math> אולם תהיה לו בעיה עם סיבית 0 כי אז יהיה עליו לחשב את השורש הריבועי של <math>\ r^2\cdot v_1\mbox{ mod }n</math>. ולפי הדוגמה המובאת לעיל, אם המתחזה יבחר מספר אקראי <math>\ r=1234</math> למשל וישלח לשרת את <math>x=1234^2\cdot v_1\mbox{ mod }620273=119456</math>, קל לראות שאם סיבית האתגר היא 1 המענה הנכון הוא <math>\ y=1234</math> אולם אם סיבית האתגר תהיה 0 המענה צריך להיות השורש הריבועי של <math>\ 119456</math> כיוון ש: <math>\ 149683^2\equiv 119456\mbox{ (mod }620273)</math> הרי שהמענה הנכון הוא <math>\ y=149683</math>. מכיוון שהדוגמה המובאת כאן היא במספרים קטנים, קל כמובן למצוא שורש ריבועי בסדר גודל כזה, במיוחד אם הגורמים הראשוניים ידועים. אולם במספרים גדולים חישוב שורש ריבועי ללא ידיעת הגורמים הראשוניים הופך לבעיה מאוד קשה, על כן המתחזה יכשל.

==ביטחון==
*בעיית מציאת שורש ריבועי של שלם פריק שקולה לבעיית פירוק לגורמים, לא ידוע על דרך יעילה לחישוב שורש ריבועי מודולרי ללא הגורמים הראשוניים. לכן ביטחון האלגוריתם נשען על הקושי שבפירוק לגורמים. כדי שהפרוטוקול יהיה בטוח כמובן יש צורך להבטיח שלא ניתן יהיה לפרק את המודולוס לגורמים עם מיטב האלגוריתמים הידועים. ההנחה היא כיום שמודולוס בגודל 2048 סיביות רחוק מהישג יד של היכולת הטכנולוגית הנוכחית.
*הפרמטרים <math>\ k</math> ו-<math>\ t</math> מספקים מדד יעילות וביטחון של הפרוטוקול. <math>\ k</math> גדול משפיע על סיבוכיות הפרוטוקול (כמות העבודה) ואילו <math>\ t</math> גדול משפיע על התקשורת (היקף התעבורה). מצד המוכיח עדיף <math>\ t</math> קטן יותר כי הוא חושף פחות מידע, בעוד שהמאמת לעומת זאת מעדיף <math>\ t</math> גדול. אם <math>\ t=1</math> (כלומר הפרוטוקול מבוצע בסבב אחד) ו-<math>\ k</math> גדול יותר ניתן להגיע לביצועים טובים יותר על חשבון ביטחון, במקרה כזה הפרוטוקול לא יקרא הוכחה באפס ידיעה כיוון שאינו נאות לפי ההגדרה. אולם מבחינה מעשית לנאותות יש חשיבות מועטה. כיוון שהמושג אפס ידיעה תאורטי במהותו, כשזה נוגע להיבטים פרקטיים לעיתים מסתפקים ב-<math>\ t=1</math>.
*בהנחה שפירוק לגורמים היא בעיה קשה, ההתקפה הטובה ביותר כנגד הפרוטוקול - התקפת טקסט-מוצפן-נבחר היא בעלת סיבוכיות <math>\ 2^{-kt}</math> כך שמהיבט של ביטחון רצוי ש-<math>\ kt</math> יהיה גדול כדי לסכל התקפה כזו, אולם מהיבט של יעילות רצוי שלא יהיה גדול מדי. במקרים בהם קיימת הגנה נוספת (כגון אם תהליך אימות מצריך נוכחות פיזית של המאמת או במקרים בהם קיימת הגבלה של מספר ניסיונות האימות האפשריים בפרק זמן נתון) <math>\ k=6, t=5</math> מספקים רמת ביטחון טובה (<math>\ 2^{-30}</math>).

==שיפורים==
*בהתאם לצורך או לדרישות בטיחות, ניתן לממש את הפרוטוקול עם מודולוס נפרד לכל משתמש כשהגורמים הראשוניים ידועים רק לו. או באמצעות מודולוס משותף למספר משתתפים שגורמיו הראשוניים ידועים רק לשרת הצד-השלישי והוא אחראי להפקת מפתח פומבי ומפתח פרטי מתאים לכל משתמש.
*במקום לשלוח את <math>\ x</math> במהלך הראשון לעיל, המשתתף A יכול לשלוח ערך גיבוב שלו <math>\ h(x)</math> בכך ניתן לצמצם מעט את היקף התעבורה.
*ניתן ליישם את הפרוטוקול באופן שהוא יקרא מבוסס זהות. פרוטוקול אימות מבוסס זהות הוא פרוטוקול שבו המפתח הפומבי של המוכיח הוא פונקציה של פרטי זהותו הפומביים כמו שם פרטי, מספר תעודת זהות, כתובת וכדומה. במקרה כזה הצד השלישי, אחראי להפקת מפתחות פומביים עבור כל המשתמשים באמצעות פונקציה מוסכמת ומתוכם הוא מפיק את המפתחות הפרטיים המתאימים על ידי חישוב השורשים הריבועיים שלהם ושולח אותם לכל המשתמשים (כאמור חישוב השורשים הריבועיים אפשרי רק בידיעת הגורמים הראשוניים).
*ניתן ליישם את מהלכי הפרוטוקול באופן מקבילי, כלומר במקום שהפרוטוקול יבוצע <math>\ t</math> פעמים, המוכיח והמאמת יכולים לשלוח זה לזה את כל האתגרים וההוכחות בו זמנית. אף על פי שהפרוטוקול במקרה כזה לא ייקרא הוכחה באפס ידיעה, יש בו תועלת להפחתת הסיכוי כנגד זיוף וניתן להוכיח כי הוא בטוח. למעשה שיטת חתימה דיגיטלית של פייגה-פיאט-שמיר פועלת על עיקרון זה כאשר במקום וקטור אתגר אקראי החותם משתמש בערך הגיבוב של המסר המיועד לחתימה.

==מקורות==
הספר [http://www.cacr.math.uwaterloo.ca/hac Handbook of Applied Cryptography] פרק 10.

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

קטגוריה:אבטחת מחשבים
קטגוריה:קריפטוגרפיה