שידור מוצפן

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

שידור מוצפן לעיתים משולב עם "מנגנון מעקב" שמאפשר להתחקות אחר חשיפת תוכן בלתי חוקית או הפרת זכויות. במיוחד איתור וזיהוי מקור החשיפה, כך שהמערכת תוכל להגיב בהתאם. בדרך זו אפשר להתגונן מפני העתקה בלתי חוקית או שימוש בהתקנים לא חוקיים כמו מפענח פיראטי. יישומים אפשריים של שידור מוצפן כוללים:
* שלם וצפה; שיטות שידור בתשלום של תוכן אחיד למשתמשים מרובים.
* רב-נתיב; פרוטוקול תקשורת לניתוב מידע יחיד לנקודות מרובות.
* וידאו על פי דרישה; שירות אינטראקטיבי להעברת תכנים לפי דרישה.
* הזרמת מדיה; טכניקות העברת מדיה רציפה ומתמשכת על ידי ספקי תוכן.
* זכויות יוצרים; הגבלת גישה והגנה מפני העתקה פיראטית של מדיה דיגיטלית כמו תקן Advanced Access Content System.
* שימוש אפשרי נוסף הוא אבטחת שיתוף מידע במחשוב ענן.

היישומים השונים מכתיבים גישות שונות לניהול ועדכון רשימת המשתמשים הלגיטימיים. משתמשים מוסרים מהרשימה עקב אי תשלום, תפוגה של מנוי או שימוש בלתי הולם. מקרה מיוחד של הבעיה נקרא "State-less", כלומר משתמש לגיטימי לא יוכל להקליט את היסטוריית התכנים שקיבל כדי לשנות את מעמדו באופן שיאפשר לו לראות תכנים בלתי מורשים. במקרה זה ההחלטה האם משתמש רשאי לקבל תוכן מבוקש מתבססת רק על השידור הנוכחי והקונפיגורציה הראשונית שלו. 'משתמש חסר מעמד' נחוץ במקרים בהם השידור מופץ להתקנים שאינם בהכרח מקוונים, כגון נגן DVD במקרה זה ה"שידור" הוא בעצם התקליטור.

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

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

בדרך כלל יש איזון בין הצורך בביטחון לעומת נוחות. לפעמים מתפשרים בביטחון השידור המוצפן על מנת להבטיח תעבורה גבוהה או תקורה נמוכה. על מנת להעריך או להשוות בין שיטות שידור מוצפן, צריך להגדיר מספר פרמטרים. קבוצת כל המשתמשים הרשומים במערכת מסומנת ב-<math>\mathcal{N}</math> ומכילה <math>N=|\mathcal{N}|</math> חברים. הקבוצה <math>\mathcal{R}\subset\mathcal{N}</math> היא תת-קבוצה המכילה <math>r=|\mathcal{R}|</math> משתמשים בלתי מורשים (Revoked) שיש לבטל את תקפות מפתחות ההצפנה שלהם ולא לאפשר להם ליהנות מהתוכן (כגון, אם לא שילמו עבורו). <math>M</math> מייצג את התוכן המיועד לשידור במצבו הגלוי, אותו השרת צריך להצפין ולשדר באופן כזה שרק תת-הקבוצה <math>u\in \mathcal{N}\setminus \mathcal{R}</math> (המורשים פחות המבוטלים) תוכל לפענחו, בעוד שקואליציה של <math>t</math> או פחות משתמשים החברים ב-<math>\mathcal{R}</math> לא תוכל. אם אחד מהמשתמשים המורשים משתתף בקואליציה לא ניתן להגן על סודיות התוכן. מקרה כזה מוגדר כ'בגידה' והטיפול בה נעשה באמצעות מנגנון מעקב (Traitor tracing) להלן. מערכת שידור מוצפן כוללת שלושה מרכיבים עיקריים: 
#סכימת הקצאת מפתח. שהיא שיטת אתחול המייצרת ומפיצה מפתחות הצפנה סודיים לכל המשתמשים הרשומים.
#אלגוריתם שידור. בהינתן תוכן <math>M</math> וקבוצה בלתי מורשית <math>\mathcal{R}</math> מפיק ומשדר את <math>M'</math> לכל <math>N</math> המשתמשים הרשומים.
#אלגוריתם פענוח. משתמש לגיטימי שאינו נכלל בקבוצה <math>\mathcal{R}</math> המקבל את <math>M'</math> משחזר את התוכן המקורי <math>M</math> באמצעות המפתח הסודי שברשותו משלב 1.

==היסטוריה==
נושא הצפנה משודרת הועלה כבר ב-1991 על ידי שמשון ברקוביץ שהציע שימוש בחלוקת סוד כדי לפתור את הבעיה. הגדרה הפורמלית ראשונה וניתוח יסודי של הבעיה ניתנו ב-1993 על ידי עמוס פיאט ומוני נאור. הם הציעו אלגוריתם המבוסס על עץ בינארי שמאפשר למנוע מכל מספר של משתמשים מלקבל תוכן כל עוד לא יותר מ-<math>k</math> מהם משתפים פעולה נגד המערכת. כמות המפתחות המוצפנים היא בסדר גודל של <math>O(k\text{ log}^2k)</math> וכל משתמש צריך לאחסן מספר מפתחות שהוא ביחס לוגריתמי ל-<math>k</math>. כמות העבודה הנדרשת מכל משתמש היא <math>O(r/k)</math> פענוחים. כמו כן הפרוטוקול תומך בסביבת Stateless ואינו דורש נוכחות (בלתי מקוון). 

רעיון השימוש בלוגיקה של עץ היררכי הומצא בנפרד ב-1990 על ידי וולנר (Wallner) וונג (Wong) שפיתחו שיטות לתקשורת בטוחה בתרחיש רב-נתיב (multicast) במצב מקוון. בשיטה זו שנקראת בקיצור LKH (להלן) יש צורך לשדר <math>2\text{ log }N</math> מפתחות בכל פעם שמעדכנים את הרשימה (מבטלים משתמש), כל משתמש נדרש לאחסן <math>\text{log }N</math> מפתחות וכן כמות העבודה שכל משתמש נדרש לבצע היא <math>\text{log }N</math> פעולות פענוח (בממוצע רק 1). הפרוטוקול בטוח ללא תלות ב-<math>k</math> אך כמות המידע המשודר היא <math>r\text{ log }N</math> שזה יחסית גבוה אלא אם כן כל משתמש יאחסן יותר מידע. הנושא נחקר על ידי רבים אחרים.

השיטה subset difference (להלן) שהוצעה ב-2002 על ידי נאור ולוצפיץ' היא הטובה ביותר למצב Statesless. לפי שיטה זו התוכן המשודר דורש רק <math>1.38r</math> הצפנות במקרה הממוצע כדי לבטל <math>r</math> משתמשים, כמות האחסון של כל מקבל היא <math>\textstyle\frac{1}{2}\text{ log}^2N</math> מפתחות. אין הגבלה על <math>r</math> וכן תהליך הקצאת המפתח הוא חישובי ולא מסתמך על תורת האינפורמציה. שמיר הלוי ואחרים הציעו שיפור לשיטה זו שנקרא LSD כמות האחסון מצטמצמת לפיה ל-<math>\text{log}^{1+\epsilon}N</math> וכמות התוכן היא בפקטור <math>r/\epsilon</math>, כאשר <math>\epsilon </math> יכול 2.

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

==Subset Cover==
הבסיס התאורטי למשפחת האלגוריתמים Subset-Cover מתחיל במושג שהגו לראשונה פיאט ונאור שנקרא סכימת ביטול "k-resilient" הפועלת כך שבהינתן קבוצה <math>U</math> של <math>n</math> חברים, הסכימה תהיה עמידה כנגד קואליציה <math>S</math> של עד <math>k</math> חברים. לשם כך מקצים מפתחות הצפנה סודיים ונפרדים <math>K_B</math> עבור כל תת-קבוצה <math>B\subset U</math> אפשרית כאשר <math>0\le |B| \le k</math>, אותו מעבירים לכל משתמש <math>u\in U-B</math> (לכל המשתמשים החברים ב-<math>U</math> אך אינם נמנים עם <math>B</math>). אפשר לדמות זאת באנלוגיה למצב שבו המפתחות נרשמים על גבי מצחם של כל המשתמשים, כל אחד יכול לראות את המפתחות של כולם למעט המפתח הרשום על מצחו. אם הקבוצה <math>T</math> היא אוסף חברים מורשים, מפתח ההצפנה הסודי עבורם הוא XOR של כל המפתחות <math>K_B</math> כאשר <math>B\subset U-T</math>. כל קואליציה של <math>S\le k</math> חברים תחסר את המפתח <math>K_S</math> (המשויך להם) ולכן לא תוכל לחלץ את המפתח של <math>T</math> בתנאי שמתקיים <math>S\cap T=\emptyset</math>. 

הסכימה המתוארת הוכחה בטוחה מהיבט תאורטי אך אינה יעילה, כדי לכסות את כל האפשרויות, כל משתמש נדרש לאחסן <math>\textstyle\sum_{i=0}^k \binom{n}{k}</math> מפתחות (לדוגמה; עבור עשרה משתמשים שמתוכם חמישה מבוטלים, כל משתמש נדרש לאחסן 638 מפתחות). במקרה הפרטי שבו <math>k=1</math> (כלומר רק משתמש אחד מבוטל) מספר המפתחות שכל אחד נדרש לשמור הוא <math>n+1</math>. אפשר לשפר את הסכימה על ידי הסתמכות על פונקציה חד-כיוונית ואז הביטחון אינו אבסולוטי אלא חישובי. מדמים את רשימת המשתמשים לעץ בינארי שכל עלה בו מתאים למשתמש אחד. מקצים מפתח אקראי לשורש העץ ולכל צומת מקצים רקורסיבית מפתח מתאים על ידי פונקציה פסאודו-אקראית <math>f:\{0,1\}^\ell\mapsto\{0,1\}^{2\ell}</math> שמקבלת קלט מפתח של צומת אב ומפיקה פלט כפול באורכו, מחצית אחת מקצים לבן השמאלי והמחצית השנייה לבן הימני. היתרון שבשיטת בנייה זו הוא שכעת כל משתמש נדרש לדעת בעיקרון רק מפתח של אב קדום כלשהו שלו, כי המפתח שלו הוא תוצאה של הפעלת הפונקציה הפסאודו-אקראית באופן רקורסיבי במסלול מהשורש ועד לעלה שלו. כעת כדי לבטל עלים מסוימים מסירים את המסלולים המקשרים ביניהם לבין שורש העץ, כך למעשה נוצר "יער" של <math>\lceil\text{log }n\rceil</math> תת-עצים, כל משתמש צריך לקבל כעת את מפתחות של כל שורשי תת-העצים. כעת אם המדיה מוצפנת עם XOR של כל המפתחות המשויכים למשתמשים שהוסרו, כל משתמש <math>x</math> יכול לחשב כל מפתח מלבד המפתח המשויך אליו ולכן אינו יכול לחלץ את המפתח לתוכן. המשתמשים המורשים לעומת זאת מקבלים את המפתח כשהוא מוצפן עם המפתח הפרטי שהם משתפים עם השרת.

דרך אחרת היא לבסס את הסכימה על בעיה מתורת המספרים דוגמת RSA. השרת מכין מפתח שורש שהוא <math>n=pq</math>, כפולה של שני ראשוניים גדולים, בוחר יוצר <math>g</math> מסדר גבוה וכל משתמש <math>i</math> מקבל את <math>g_i=g^{p_i}</math> כאשר כל <math>p_i</math> זרים הדדית. המפתח המשותף לקבוצה <math>T</math> הוא <math>g_T=g^{p_T}\text{ mod }n</math> כאשר <math>\textstyle p_T=\prod_{i\in T}p_i</math> ואז המשתמש <math>i</math> מחלץ את המפתח המשותף על ידי <math>\textstyle g_T=g_i^{\prod_{j\in T-\{i\}}p_j}\text{ mod }n</math> כלומר חזקה של כל המפתחות למעט המפתח שלו. הוכח שהסכימה הזו בטוחה בהנחה שפירוק לגורמים היא בעיה קשה וכל מה שנדרש לאחסן הוא רק מפתח אחד. 

בשתי הסכימות השרת אינו נדרש לשדר כלל מידע נלווה לתוכן המוצפן, כיוון שהמפתחות הוקצו מראש ובידי המשתמשים המידע הדרוש לחילוץ מפתח השיחה. אולם שיתוף פעולה של שני משתמשים מאפשר להם לשבור בקלות את המערכת. אלגוריתם Complete Subset Cover מרחיב את הרעיון הבסיסי לעמידות כנגד <math>k>1</math> מבוטלים וכן מצמצם את דרישות האחסון ברמת משתמש במחיר שהשרת ישדר לפני כל תוכן מוצפן מידע מסוים שנקרא "כותר". בכללות הוא מגדיר אוסף של תת-קבוצות <math>S_1,...,S_w</math> כאשר <math>S_j\subseteq\mathcal{N}</math>. מקצים מפתח סודי ארוך טווח (קבוע) <math>L_j</math> לכל <math>S_j</math> ולכל <math>u\in S_j</math> מקצים מידע פרטי <math>I_u</math> איתו הוא אמור לשחזר את <math>L_j</math>. בהינתן קבוצה <math>\mathcal{R}</math> של משתמשים מבוטלים יתר המשתמשים <math>\mathcal{N}\setminus\mathcal{R}</math> מחולקים לתת-קבוצות זרות <math>S_{i_1},...,S_{i_m}</math> כך שמתקיים: 
:<math>\mathcal{N}\setminus\mathcal{R}=\bigcup_{j=1}^m S_{i_j}</math>.
<math>K</math> מוצפן <math>m</math> פעמים עם המפתחות <math>L_{i_1},...,L_{i_m}</math> בהתאמה. 

לצורך כך יש להגדיר שני פרימיטיבים קריפטוגרפיים: (1) צופן מהצורה <math>F_K:\{0,1\}^*\mapsto \{0,1\}^*</math> להצפנת התוכן <math>M</math> עם <math>K</math> שצריך להיות חדש עבור כל תוכן. הצופן צריך להיות מהיר ולא אמור לגרום להתנפחות התוכן עקב ההצפנה. הוא יכול להיות צופן זרם בטוח כמו Salsa20. וכן (2) צופן מהצורה <math>E_L\{0,1\}^\ell\mapsto\{0,1\}^\ell</math> עם מפתח ארוך-טווח <math>L</math> שהמרכז משתף עם כל משתמש בנפרד. יכול להיות צופן בלוקים כמו AES. מסיבות של יעילות רצוי ש-<math>K</math> יהיה קצר (להגנה על זכויות יוצרים אין צורך בהצפנה כבדה) ורק המפתח ארוך הטווח צריך להיות באורך מלא (בדרך כלל 128 סיביות). מפני שאורך הכותר תלוי בגודל הבלוק של צופן הבלוקים, אפשר להשתמש בחלופה חסכונית כך; <math>[\text{Prefix}_{|K|}E_L(\mathcal{U})]\oplus K</math> במקום בלוק מלא. כאשר הביטוי <math>\text{Prefix}_i(S)</math> פירושו <math>i</math> הסיביות הראשונות של הערך <math>S</math> וכן <math>\mathcal{U}</math> הוא מחרוזת אקראית כלשהי באורך בלוק מלא.

===תיאור הסכימה===
====1. אלגוריתם אתחול====
כל משמש <math>u</math> מקבל מידע סודי <math>I_u</math> באופן כזה שעבור כל <math>1\le i\le w</math> כאשר <math>u\in S_i</math>, מאפשר לו לחלץ את המפתח <math>L_i</math> לקבוצה שלו <math>S_i</math>. את <math>L_i</math> אפשר להכין בשתי דרכים, בחירה אקראית (אמיתית) ונפרדת עבור כל מפתח, מה שמספק ביטחון אבסולוטי מהיבט של תורת האינפורמציה כמו פנקס חד-פעמי או כפונקציה של מידע סודי אחר שאז ביטחונו נשען על הפונקציה הפסאודו-אקראית מה שמספק ביטחון חישובי.

====2. אלגוריתם שידור====
מרכז שמעוניין לשדר או להפיץ תוכן מוצפן פועל כדלהלן;
::1. בוחר מפתח שיחה אקראי <math>K</math>.
::2. בהינתן קבוצה <math>\mathcal{R}</math> של משתמשים מבוטלים, המרכז מפריד את כל המשתמשים הבלתי מבוטלים ל-<math>m</math> תת-קבוצות זרות <math>S_{i_1},...,S_{i_m}</math> ומקצה להם מפתחות סודיים <math>L_{i_1},...,L_{i_m}</math> בהתאמה.
::3. המרכז מצפין את מפתח השיחה <math>m</math> פעמים עם כל המפתחות <math>L_i</math> ומשדר את התוכן כדלהלן:
:::<math>\langle [i_1,i_2,...,i_m,E_{L_{i_1}}(K),...,E_{L_{i_m}}(K)],F_K(M)\rangle</math>
::החלק שמופיע בסוגריים המרובעות נקרא "כותר" והחלק האחרון הוא גוף התוכן.

====3. אלגוריתם פענוח====
מקבל מורשה <math>u</math> הקולט את השידור: <math>[\langle i_1,i_2,...,i_m,C_1,C_2,C_m],M'\rangle</math> פועל כדלהלן:
::1. מוצא את <math>i_j</math> כך שמתקיים <math>u\in S_{i_j}</math> (תת-הקבוצה אליה הוא שייך) במקרה שהוא נמנה עם הקבוצה <math>\mathcal{R}</math> התוצאה היא null.
::2. מחלץ את המפתח המתאים <math>L_j</math> באמצעות <math>I_u</math>.
::3. מפענח את מפתח השיחה: <math>K = D_{L_{i_j}}(C_j)</math>.
::4. מפענח את התוכן: <math>D_K(M')</math>.

עיקר העבודה ביישום הסכימה האמורה היא (1) הכנת אוסף של כל תת-הקבוצות האפשריות של המשתמשים הרשומים (2) הקצאת מפתח לכל תת-קבוצה אפשרית באוסף, (3) "כיסוי" כל המשתמשים הלגיטימיים פחות המבוטלים בתת-קבוצות נפרדות ו-(4) הגדרת שיטה שבה כל משתמש יוכל למצוא את המפתח המתאים לקבוצה שלו. אלגוריתם Subset-Cover ניתן למימוש באופן הבא: אוסף הקבוצות מתאים לכל תת-העצים בעץ בינארי מלא בעל <math>N</math> עלים, כל עלה כנגד משתמש אחד. סך הכול עלים וצמתים הוא <math>2N-1</math>. כל צומת <math>v_i</math> מייצג תת-עץ בעץ הכללי, כל משתמש <math>u</math> נמנה עם תת-הקבוצה <math>S_i</math> אך ורק אם שורש תת-הקבוצה <math>v_i</math> הוא אב קדום שלו. לכל צומת מוקצה מפתח <math>L_i</math> וכל משתמש <math>u</math> מקבל <math>\text{log }N+1</math> מפתחות המשויכים לכל הצמתים במסלול המקשר מהעלה שלו לשורש העץ. אם אוסף המשתמשים <math>u_1,...,u_r</math> שייכים לקבוצה <math>\mathcal{R}</math>, מפרידים את יתר העלים בעץ לתת-קבוצות נפרדות על ידי הכנת "עץ שטיינר" מכוון, בקיצור (<math>ST(\mathcal{R}</math> שהוא עץ פורש מינימלי הנוצר על ידי <math>r</math> העלים <math>u_i</math> המקושרים לשורש העץ באמצעות תוספת קשתות המינימלית האפשרית. כעת תת-הקבוצות האחרות הן למעשה כל תת-העצים "התלויים", כלומר העצים אשר שורשיהם סמוכים לצמתים בעץ <math>ST(\mathcal{R})</math> בעלי דרגה 1, אך אינם נמצאים בו. אוסף הקבוצות הללו נקרא "כיסוי" ומספרם הוא בערך <math>r\cdot(i-\text{log }r)+1</math>. ישנן כמה דרכים כדי למצוא במהירות וביעילות חברות באחת מהקבוצות של משתמש נתון <math>u</math>, אפשר להשתמש למשל בטבלת גיבוב או בקוד תיקון שגיאות. רצוי שהמידע בכותר יהיה דחוס ככל האפשר. עם אופטימיזציה אפשר להגיע לתצורה שבה החיפוש נעשה בסיבוכיות של <math>\text{log log }N</math> השוואות. כמות המפתחות שכל משתמש יאחסן תעמוד על <math>\text{log }N</math>, מספר המפתחות המוצפנים שהשרת משדר <math>\textstyle r\text{ log }\frac{N}{r}</math> ואילו התוכן מוצפן רק פעם אחת.

==CPRM/CPPM==

Content Protection for Recordable Media and Pre-Recorded Media היא טכנולוגית ניהול זכויות דיגיטלי שפותחה ב-2001 על ידי 4C Entity (התאגדות של ארבעה ענקי אלקטרוניקה; IBM, אינטל, פנסוניק וטושיבה). CPRM/CPPM נועד בעיקר למצב 'חסר מעמד' (statelss). זהו מנגנון הכולל שיטות להגבלה ושליטה על מדיה דיגיטלית פיזית כמו תקליטורי DVD, כרטיסי זיכרון כמו SD או זיכרון הבזק בהתקן מארח (מחשב אישי או נגן). 

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

האלגוריתם שמיישם CPRM הוא למעשה וריאציה של שיטת פיאט-נאור שנקראת סכימת Subset-Cover. הוא מגדיר טבלה עם <math>A</math> שורות ו-<math>C</math> עמודות, ומתייחסים לכל התקן (מקלט) כאל אוסף של <math>C</math> כניסות בטבלה, אחת בכל עמודה, כלומר <math>u=[u_1,...,u_C]</math> כאשר <math>u_i\in \{0,1,...,A-1\}</math>. אוסף כל תת-הקבוצות האפשריות <math>S_1,...,S_w</math> המוגדר על ידי האלגוריתם מתאים לאוסף התקנים שנמצאים באותה כניסה בעמודה נתונה. למשל <math>S_{r,i}</math> כולל את כל ההתקנים <math>u=[u_1,...,u_C]</math> כך ש-<math>u_i=r</math>. עבור כל שורה <math>i</math> ועמודה <math>j</math> הסכימה מקצה מפתח המיוצג על ידי <math>L_{i,j}</math>. בכל התקן <math>u=[u_1,...,u_C]</math> מוטמע מידע פרטי (סודי) <math>I_u</math> הכולל <math>C</math> מפתחות <math>L_{u_1,1},L_{u_2,2},...,L_{u_C,C}</math>.

עבור קבוצה <math>\mathcal{R}</math> של התקנים "מבוטלים" (Revoked), האלגוריתם מחלק את <math>\mathcal{N}\setminus\mathcal{R}</math> כך שכל תת-קבוצה <math>S_{i,j}</math> מכוסה רק אם <math>S_{i,j}\cap\mathcal{R}=\emptyset</math>. בעוד שהסכימה מבטיחה שהתקן לא מאושר לא ייכלל בכיסוי, יש סיכוי נמוך שהתקן מאושר לא ייכלל גם הוא. כלומר ייתכן התקן לגיטימי שייחשב כלא תקף. בניגוד לשיטת נאור, תת-הקבוצות בסכימת CPRM/CPPM אינן זרות לגמרי ולכן הכיסוי אינו משולם. יתרה מזו הסיכוי שהתקן מאושר יפסל גדל ככל ש-<math>r</math> גדל (מספר ההתקנים המבוטלים).

לשם השוואה לשיטת נאור אם <math>C=\text{log }N</math> ו-<math>A=r</math> אזי מנגנון CPRM/CPPM דורש <math>r\text{ log }N</math> הצפנות, כמות האחסון במקלט או התקן עומדת על <math>\text{log }N</math> מפתחות, וכמות החישוב הדרושה בצד ההתקן היא רק פעולת פענוח אחת. למשל ב-DVD בלוק המפתח MKB מכיל 3MB. חיסרון נוסף הוא בעובדה ש-<math>r</math> מוגבל, כלומר מספר המכשירים המבוטלים המקסימלי שאפשר להגדיר בשיטה זו הוא בערך 10,000. בשיטת נאור אפשר להגיע ל-250,000.

==LKH==
תיאור עץ LKH
שיטת Logical-tree-hierarchy פותחה בעיקר לרב-נתיב במצב מקוון ונכללה בהצעה לתקן RFC-2627. המערכת מנהלת מפתח הצפנה משותף יחיד עבור קבוצת כל המשתתפים הפעילים <math>\mathcal{N}</math> שנקרא Net Key שמועבר אליהם באמצעות פרוטוקול העברת מפתח קריפטוגרפי כמו דיפי-הלמן. המערכת מוסיפה או מסירה משתתף (אחד בכל מהלך) על ידי אלגוריתם הקצאת מפתח שבו המערכת מחשבת ומקצה מפתחות הצפנה לכל המשתתפים הלגיטימיים. התהליך מנוהל על ידי שרת שמדווח לכל משתתפים על המהלכים שבוצעו. המשתתפים מיוצגים על ידי העלים בעץ בינארי מאוזן בגובה <math>\text{log }N</math>, לכל צומת <math>v_i</math> מוקצה מפתח <math>K_i</math>. כל משתתף <math>u_i</math> מקבל (בתהליך שנקרא Rekeying באמצעות המפתח הראשי) את כל המפתחות המשויכים לכל הצמתים במסלול המקשר משורש העץ לעלה שלו (לדוגמה בתרשים משתתף מספר 3 מקבל את המפתחות B,I,M). כדי להסיר את העלה <math>u</math> מקצים מפתחות חדשים <math>K_i'</math> לכל הצמתים <math>v_i</math> לאורך המסלול המקשר מהעלה שהוסר ועד שורש העץ. כעת אם <math>v_i</math> הוא צומת הנמצא על המסלול, <math>v_j</math> צומת בן הנמצא על המסלול ו-<math>v_l</math> הוא צומת בן שאינו על מסלול. את המפתח <math>K_i'</math> של הצומת <math>v_i</math> מצפינים על ידי המפתחות <math>K_j'</math> ו-<math>K_l</math> (שימו לב שהאחרון לא התעדכן) כלומר <math>\langle E_{K_j'}(K_i'),E_{K_l}(K_i')\rangle</math>. במקרה ש-<math>v_i</math> הוא צומת אב של העלה <math>u</math> מבצעים רק הצפנה אחת עם הצאצא של <math>u</math>. המפתחות החדשים המוצפנים משודרים לכל המשתתפים הפעילים. האלגוריתם מחייב העברה של <math>2\text{ log }N</math> מפתחות בכל פעולה כזו, כל משתתף נדרש לאחסן <math>\text{log }N </math> מפתחות וכמות העבודה המקסימלית הנדרשת מכל משתתף היא <math>\text{log }N</math> הצפנות (בממוצע נדרשת רק הצפנה אחת).

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

{| class="wikitable"
|-
! מספר משתתפים !! מעלה (<math>k</math>) !! אחסון פר משתתף !! שידורי מפתח יחיד (<math>kd-1</math>) !! שידורי מפתחות מרובים <math>d(k-1)</math>
|-
| 8 || 2 || 4 || 5 || 8
|-
| 16 || 2 || 5 || 7 || 16
|-
| 2048 || 2 || 12 || 21 || 2048
|-
| 131072 || 2 || 18 || 33 || 131072
|}

==Subset Difference==
תיאור עץ משתמשים בשיטת Subset Difference
מבנה subset difference מגדיר אוסף של תת-קבוצות של משתמשים <math>S_1,...,S_w</math> כאשר <math>S_j\in \mathcal{N}</math>. לכל תת-קבוצה מקצים מפתח הצפנה <math>L_j</math>, לכל משתמש <math>u</math> משייכים מידע סודי <math>I_u</math> איתו הוא יכול לחלץ את המפתחות של תת-הקבוצות אליהן הוא משויך. בהינתן הקבוצה <math>\mathcal{R} </math> של משתמשים מבוטלים, יתר המשתמשים מחולקים לקבוצות זרות <math>S_{i_1},...,S_{i_m}</math> מהאוסף אשר 'מכסות' לגמרי את כל המשתמשים, כלומר כל משתמש חבר בלפחות קבוצה אחת כזו. מפתח שיחה <math>K</math> מוצפן <math>m</math> פעמים עם <math>L_{i_1},...,L_{i_m}</math> והתוכן מוצפן עם <math>K</math>. כל המשתמשים משויכים לעלים בעץ בינארי מאוזן בגובה <math>\text{log }N</math> אוסף הקבוצות <math>S_1,...,S_w</math> בהגדרה הוא מהצורה "קבוצה <math>G_1</math> פחות הקבוצה <math>G_2</math>" כאשר <math>G_2\subset G_1</math>. שתי הקבוצות מתאימות לעלים של שני תת-עצים בינאריים בהתאמה. לכן תת-קבוצה <math>S</math> כלשהי מיוצגת על ידי שני צמתים בעץ הראשי <math>v_i,v_j</math> כך ש-<math>v_i</math> הוא אב קדום של <math>v_j</math> מסמנים זאת על ידי <math>S_{i,j}</math> (כמתואר בתרשים). העלה <math>u</math> הוא בתת-קבוצה <math>S_{i,j}</math> אם ורק אם הוא בתת-העץ שהשורש שלו הוא <math>v_j</math>. במילים אחרות <math>u\in S_{i,j}</math> אם <math>v_i</math> הוא אב קדום שלו אך לא <math>v_j</math>. הרעיון הוא שעבור כל תת-קבוצה <math>\mathcal{R}</math> של משתמשים מבוטלים אפשר למצוא קבוצה של לכל היותר <math>s2-1</math> תת-קבוצות מהאוסף אשר מכסה את כל המשתמשים ב-<math>\mathcal{N} \setminus \mathcal{R}</math>.

אם יוקצה עבור כל משתמש מפתחות קבועים עבור אוסף כל הקבוצות מספר המפתחות עבור כל משתמש יהיה <math>N</math>. במקום זאת אפשר לצמצם את המידע הזה באופן כזה שרק <math>\textstyle\frac{1}{2}\text{ log}^2N</math> מפתחות יאוחסנו, את המפתח הנכון המשתמש מחלץ באמצעות מבנה עץ דמוי GGM. לכל צומת מקצים שלושה מספרים אקראיים באמצעות מחולל פסאודו-אקראי בטוח, לכל צומת מצמידים תוויות המכילות את המספרים האקראיים <math>G_L</math> תווית עבור צד שמאל, <math>G_R</math> תווית עבור צד ימין ו-<math>G_M</math> תווית המייצגת את המפתח הסודי המשויך לעלה (כמתואר בתרשים). שימו לב שלא ניתן לשחזר את המפתח של צומת נתון ללא ידיעת צומת האב.

בעת הפענוח המשתמש <math>u</math> מקבל את המחרוזת הבאה:
:<math>\langle[i_1,...,i_m,E_{L_{i_1}}(K),E_{L_{i_2}}(K),...,E_{L_{i_m}}(K)],F_K(M)\rangle</math> 
תחילה מוצא את תת-הקבוצה <math>S_{i,j}</math> אליה הוא משויך ומחשב את המפתח המתאים <math>L_{i,j}</math> באמצעות הפעלת הפונקציה הפסאודו רנדומלית על צומתי האב <math>\text{log }N</math> פעמים. באמצעות טבלת גיבוב אפשר לצמצם את פעולת החיפוש של המשתמש ל-<math>O(\text{loglog }N)</math>. לאחר מכן כל מה שנדרש הוא פעולת פענוח אחת כדי לחלץ את התוכן המוצפן. 

הפונקציות <math>F_K</math> ו-<math>E_L</math> מייצגות אלגוריתמים להצפנה כאשר הראשון מומלץ שיהיה צופן זרם והאחרון צופן בלוקים כמו AES.

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

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