שידור מוצפן

בקריפטוגרפיה, סכימת שידור מוצפן (באנגלית: Broadcast Encryption) היא טכניקה לשידור יעיל של תוכן מוצפן לקבוצה דינאמית של משתמשים מורשים באופן שרק הם יוכלו לפענחו. כלומר כל המשתמשים שברשותם מקלט מתאים מסוגלים לקלוט את התוכן המשודר, אך רק קבוצה של משתמשים מורשים תוכל ליהנות ממנו, בעוד שהיתר אמורים לראות תוכן בלתי קריא. לעיתים נוח להתייחס לזה כאל 'סכימת ביטול' שמטפלת בצורך למנוע ממקלט אחד או יותר מלקלוט שידור מסוים. שידור מוצפן לעיתים משולב עם "מנגנון מעקב" שמאפשר להתחקות אחר חשיפת תוכן בלתי חוקית או הפרת זכויות. במיוחד איתור וזיהוי מקור החשיפה, כך שהמערכת תוכל להגיב בהתאם. בדרך זו אפשר להתגונן מפני העתקה בלתי חוקית או שימוש בהתקנים לא חוקיים כמו מפענח פיראטי. יישומים אפשריים של שידור מוצפן כוללים: שלם וצפה; שיטות שידור בתשלום של תוכן אחיד למשתמשים מרובים. רב-נתיב; פרוטוקול תקשורת לניתוב מידע יחיד לנקודות מרובות. וידאו על פי דרישה; שירות אינטראקטיבי להעברת תכנים לפי דרישה. הזרמת מדיה; טכניקות העברת מדיה רציפה ומתמשכת על ידי ספקי תוכן. זכויות יוצרים; הגבלת גישה והגנה מפני העתקה פיראטית של מדיה דיגיטלית כמו תקן Advanced Access Content System. שימוש אפשרי נוסף הוא אבטחת שיתוף מידע במחשוב ענן. היישומים השונים מכתיבים גישות שונות לניהול ועדכון רשימת המשתמשים הלגיטימיים. משתמשים מוסרים מהרשימה עקב אי תשלום, תפוגה של מנוי או שימוש בלתי הולם. מקרה מיוחד של הבעיה נקרא "State-less", כלומר משתמש לגיטימי לא יוכל להקליט את היסטוריית התכנים שקיבל כדי לשנות את מעמדו באופן שיאפשר לו לראות תכנים בלתי מורשים. במקרה זה ההחלטה האם משתמש רשאי לקבל תוכן מבוקש מתבססת רק על השידור הנוכחי והקונפיגורציה הראשונית שלו. 'משתמש חסר מעמד' נחוץ במקרים בהם השידור מופץ להתקנים שאינם בהכרח מקוונים, כגון נגן DVD במקרה זה ה"שידור" הוא בעצם התקליטור. הבעיה הכללית שנקראת בעיית שידור מוצפן מתעוררת בתרחישים שונים כמו העברת תכנים בסגנון שלם וצפה והיא כדלהלן: שרת מרכזי מעוניין לשדר תוכן רב לקבוצה גדולה של מקלטים, כך שרק תת-קבוצה מוגדרת מראש תוכל לפענח את התוכן המשודר. דרך נאיבית לפתור את הבעיה היא להפיץ מראש לכל המשתמשים הרשומים במערכת מפתחות הצפנה סודיים, כל משתמש מקבל מפתח שונה. את המפתח הסודי אפשר להעביר בדרך בטוחה כלשהי או להטמיעו בתוך חומרת המקלט באופן בטוח. זה לא מעשי להצפין ולשדר את התוכן עצמו מספר מרובה של פעמים עם מפתח אחר בכל פעם אלא במקום זאת, השרת מכין תחילה מפתח שיחה, מצפין את גוף התוכן, מצפין את המפתח איתו השתמש במספר הפעמים הדרוש עבור כל משתמש מורשה (עם המפתח הסודי המשותף לו ולשרת) ואז משדר את כל המפתחות המוצפנים יחד עם התוכן המוצפן, רק המשתמשים המחזיקים במפתחות המתאימים יוכלו לחלץ את מפתח ההצפנה מהמידע הנלווה ולפענח את התוכן. דרך זו אינה יעילה במיוחד בעיקר ברשת מרובת משתתפים כי נפח המידע שהשרת צריך לשדר מלבד התוכן גדל משמעותית, כלומר גודל המפתחות המוצפנים כפול מספר המשתמשים. אפשר לחלק את המשתמשים הרשומים לתת-קבוצות (למשל תת-קבוצה אפשרית היא כל המשתמשים שהזמינו תוכן מסוים) ולהקצות מראש לכל תת-קבוצה אפשרית מפתח הצפנה מתאים, כך שהשרת צריך להצפין ולשדר את התוכן רק פעם אחת עבור תת-הקבוצה המתאימה ואינו נדרש לשדר מלבד התוכן שום דבר. אולם במקרה כזה כל משתמש רשום יאלץ להחזיק בכמות עצומה של מפתחות (מפתח אחד עבור כל תת-קבוצה אפשרית שהוא עשוי להיות חבר בה). המטרות הן למצוא דרך מאוזנת שבה כמות המפתחות שמשתמש בודד צריך להחזיק תהיה המינימלית האפשרית, שתעבורת הרשת לא תגדל משמעותית עקב התרחבות המידע המוצפן וכן כמות העבודה שתידרש מכל משתמש כדי לפענח את התוכן שיקבל לא תהיה גבוהה. בכללות התכונות המינימליות הדרושות ממערכת שידור מוצפן הן: רוחב פס נמוך; כלומר התרחבות מינימלית של התוכן עקב ההצפנה. דרישות אחסון נמוכות; שכל משתמש יאלץ להחזיק בכמות נמוכה ביותר האפשרית של מידע פרטי כמו מפתחות הצפנה. זמינות; אפשרות למצב של שידור "חסר מעמד" כך שהמשתמש אינו נדרש להיות מקוון כמו תקליטור. עמידות; תכונה חשובה של שידור מוצפן היא היכולת להתנגד לשיתוף פעולה או "קואליציה" של מספר משתמשים כנגד המערכת על מנת לקבל מידע בלתי מורשה. בדרך כלל יש איזון בין הצורך בביטחון לעומת נוחות. לפעמים מתפשרים בביטחון השידור המוצפן על מנת להבטיח תעבורה גבוהה או תקורה נמוכה. על מנת להעריך או להשוות בין שיטות שידור מוצפן, צריך להגדיר מספר פרמטרים. קבוצת כל המשתמשים הרשומים במערכת מסומנת ב- N {\displaystyle {\mathcal {N}}} ומכילה N = | N | {\displaystyle N=|{\mathcal {N}}|} חברים. הקבוצה R ⊂ N {\displaystyle {\mathcal {R}}\subset {\mathcal {N}}} היא תת-קבוצה המכילה r = | R | {\displaystyle r=|{\mathcal {R}}|} משתמשים בלתי מורשים (Revoked) שיש לבטל את תקפות מפתחות ההצפנה שלהם ולא לאפשר להם ליהנות מהתוכן (כגון, אם לא שילמו עבורו). M {\displaystyle M} מייצג את התוכן המיועד לשידור במצבו הגלוי, אותו השרת צריך להצפין ולשדר באופן כזה שרק תת-הקבוצה u ∈ N ∖ R {\displaystyle u\in {\mathcal {N}}\setminus {\mathcal {R}}} (המורשים פחות המבוטלים) תוכל לפענחו, בעוד שקואליציה של t {\displaystyle t} או פחות משתמשים החברים ב- R {\displaystyle {\mathcal {R}}} לא תוכל. אם אחד מהמשתמשים המורשים משתתף בקואליציה לא ניתן להגן על סודיות התוכן. מקרה כזה מוגדר כ'בגידה' והטיפול בה נעשה באמצעות מנגנון מעקב (Traitor tracing) להלן. מערכת שידור מוצפן כוללת שלושה מרכיבים עיקריים: סכימת הקצאת מפתח. שהיא שיטת אתחול המייצרת ומפיצה מפתחות הצפנה סודיים לכל המשתמשים הרשומים. אלגוריתם שידור. בהינתן תוכן M {\displaystyle M} וקבוצה בלתי מורשית R {\displaystyle {\mathcal {R}}} מפיק ומשדר את M ′ {\displaystyle M'} לכל N {\displaystyle N} המשתמשים הרשומים. אלגוריתם פענוח. משתמש לגיטימי שאינו נכלל בקבוצה R {\displaystyle {\mathcal {R}}} המקבל את M ′ {\displaystyle M'} משחזר את התוכן המקורי M {\displaystyle M} באמצעות המפתח הסודי שברשותו משלב 1. נושא הצפנה משודרת הועלה כבר ב-1991 על ידי שמשון ברקוביץ שהציע שימוש בחלוקת סוד כדי לפתור את הבעיה. הגדרה הפורמלית ראשונה וניתוח יסודי של הבעיה ניתנו ב-1993 על ידי עמוס פיאט ומוני נאור. הם הציעו אלגוריתם המבוסס על עץ בינארי שמאפשר למנוע מכל מספר של משתמשים מלקבל תוכן כל עוד לא יותר מ- k {\displaystyle k} מהם משתפים פעולה נגד המערכת. כמות המפתחות המוצפנים היא בסדר גודל של O ( k  log 2 k ) {\displaystyle O(k{\text{ log}}^{2}k)} וכל משתמש צריך לאחסן מספר מפתחות שהוא ביחס לוגריתמי ל- k {\displaystyle k} . כמות העבודה הנדרשת מכל משתמש היא O ( r / k ) {\displaystyle O(r/k)} פענוחים. כמו כן הפרוטוקול תומך בסביבת Stateless ואינו דורש נוכחות (בלתי מקוון). רעיון השימוש בלוגיקה של עץ היררכי הומצא בנפרד ב-1990 על ידי וולנר (Wallner) וונג (Wong) שפיתחו שיטות לתקשורת בטוחה בתרחיש רב-נתיב (multicast) במצב מקוון. בשיטה זו שנקראת בקיצור LKH (להלן) יש צורך לשדר 2  log  N {\displaystyle 2{\text{ log }}N} מפתחות בכל פעם שמעדכנים את הרשימה (מבטלים משתמש), כל משתמש נדרש לאחסן log  N {\displaystyle {\text{log }}N} מפתחות וכן כמות העבודה שכל משתמש נדרש לבצע היא log  N {\displaystyle {\text{log }}N} פעולות פענוח (בממוצע רק 1). הפרוטוקול בטוח ללא תלות ב- k {\displaystyle k} אך כמות המידע המשודר היא r  log  N {\displaystyle r{\text{ log }}N} שזה יחסית גבוה אלא אם כן כל משתמש יאחסן יותר מידע. הנושא נחקר על ידי רבים אחרים. השיטה subset difference (להלן) שהוצעה ב-2002 על ידי נאור ולוצפיץ' היא הטובה ביותר למצב Statesless. לפי שיטה זו התוכן המשודר דורש רק 1.38 r {\displaystyle 1.38r} הצפנות במקרה הממוצע כדי לבטל r {\displaystyle r} משתמשים, כמות האחסון של כל מקבל היא 1 2  log 2 N {\displaystyle \textstyle {\frac {1}{2}}{\text{ log}}^{2}N} מפתחות. אין הגבלה על r {\displaystyle r} וכן תהליך הקצאת המפתח הוא חישובי ולא מסתמך על תורת האינפורמציה. שמיר הלוי ואחרים הציעו שיפור לשיטה זו שנקרא LSD כמות האחסון מצטמצמת לפיה ל- log 1 + ϵ N {\displaystyle {\text{log}}^{1+\epsilon }N} וכמות התוכן היא בפקטור r / ϵ {\displaystyle r/\epsilon } , כאשר ϵ {\displaystyle \epsilon } יכול 2. להלן פירוט שלוש שיטות בסיסיות לפתרון בעיית שידור מוצפן שהמכנה המשותף שלהן בתהליך הקצאת המפתחות הוא השימוש במבנה דמוי עץ. מקצים מפתח ראשי לשורש העץ ולכל יתר הצמתים והעלים מקצים מפתחות בשיטת GGM שהוצעה על ידי גולדרייך, גולדווסר ומיקאלי שהיא סוג של פונקציה פסאודו-אקראית. הבסיס התאורטי למשפחת האלגוריתמים Subset-Cover מתחיל במושג שהגו לראשונה פיאט ונאור שנקרא סכימת ביטול "k-resilient" הפועלת כך שבהינתן קבוצה U {\displaystyle U} של n {\displaystyle n} חברים, הסכימה תהיה עמידה כנגד קואליציה S {\displaystyle S} של עד k {\displaystyle k} חברים. לשם כך מקצים מפתחות הצפנה סודיים ונפרדים K B {\displaystyle K_{B}} עבור כל תת-קבוצה B ⊂ U {\displaystyle B\subset U} אפשרית כאשר 0 ≤ | B | ≤ k {\displaystyle 0\leq |B|\leq k} , אותו מעבירים לכל משתמש u ∈ U − B {\displaystyle u\in U-B} (לכל המשתמשים החברים ב- U {\displaystyle U} אך אינם נמנים עם B {\displaystyle B} ). אפשר לדמות זאת באנלוגיה למצב שבו המפתחות נרשמים על גבי מצחם של כל המשתמשים, כל אחד יכול לראות את המפתחות של כולם למעט המפתח הרשום על מצחו. אם הקבוצה T {\displaystyle T} היא אוסף חברים מורשים, מפתח ההצפנה הסודי עבורם הוא XOR של כל המפתחות K B {\displaystyle K_{B}} כאשר B ⊂ U − T {\displaystyle B\subset U-T} . כל קואליציה של S ≤ k {\displaystyle S\leq k} חברים תחסר את המפתח K S {\displaystyle K_{S}} (המשויך להם) ולכן לא תוכל לחלץ את המפתח של T {\displaystyle T} בתנאי שמתקיים S ∩ T = ∅ {\displaystyle S\cap T=\emptyset } . הסכימה המתוארת הוכחה בטוחה מהיבט תאורטי אך אינה יעילה, כדי לכסות את כל האפשרויות, כל משתמש נדרש לאחסן ∑ i = 0 k ( n k ) {\displaystyle \textstyle \sum _{i=0}^{k}{\binom {n}{k}}} מפתחות (לדוגמה; עבור עשרה משתמשים שמתוכם חמישה מבוטלים, כל משתמש נדרש לאחסן 638 מפתחות). במקרה הפרטי שבו k = 1 {\displaystyle k=1} (כלומר רק משתמש אחד מבוטל) מספר המפתחות שכל אחד נדרש לשמור הוא n + 1 {\displaystyle n+1} . אפשר לשפר את הסכימה על ידי הסתמכות על פונקציה חד-כיוונית ואז הביטחון אינו אבסולוטי אלא חישובי. מדמים את רשימת המשתמשים לעץ בינארי שכל עלה בו מתאים למשתמש אחד. מקצים מפתח אקראי לשורש העץ ולכל צומת מקצים רקורסיבית מפתח מתאים על ידי פונקציה פסאודו-אקראית f : { 0 , 1 } ℓ ↦ { 0 , 1 } 2 ℓ {\displaystyle f:\{0,1\}^{\ell }\mapsto \{0,1\}^{2\ell }} שמקבלת קלט מפתח של צומת אב ומפיקה פלט כפול באורכו, מחצית אחת מקצים לבן השמאלי והמחצית השנייה לבן הימני. היתרון שבשיטת בנייה זו הוא שכעת כל משתמש נדרש לדעת בעיקרון רק מפתח של אב קדום כלשהו שלו, כי המפתח שלו הוא תוצאה של הפעלת הפונקציה הפסאודו-אקראית באופן רקורסיבי במסלול מהשורש ועד לעלה שלו. כעת כדי לבטל עלים מסוימים מסירים את המסלולים המקשרים ביניהם לבין שורש העץ, כך למעשה נוצר "יער" של ⌈ log  n ⌉ {\displaystyle \lceil {\text{log }}n\rceil } תת-עצים, כל משתמש צריך לקבל כעת את מפתחות של כל שורשי תת-העצים. כעת אם המדיה מוצפנת עם XOR של כל המפתחות המשויכים למשתמשים שהוסרו, כל משתמש x {\displaystyle x} יכול לחשב כל מפתח מלבד המפתח המשויך אליו ולכן אינו יכול לחלץ את המפתח לתוכן. המשתמשים המורשים לעומת זאת מקבלים את המפתח כשהוא מוצפן עם המפתח הפרטי שהם משתפים עם השרת. דרך אחרת היא לבסס את הסכימה על בעיה מתורת המספרים דוגמת RSA. השרת מכין מפתח שורש שהוא n = p q {\displaystyle n=pq} , כפולה של שני ראשוניים גדולים, בוחר יוצר g {\displaystyle g} מסדר גבוה וכל משתמש i {\displaystyle i} מקבל את g i = g p i {\displaystyle g_{i}=g^{p_{i}}} כאשר כל p i {\displaystyle p_{i}} זרים הדדית. המפתח המשותף לקבוצה T {\displaystyle T} הוא g T = g p T  mod  n {\displaystyle g_{T}=g^{p_{T}}{\text{ mod }}n} כאשר p T = ∏ i ∈ T p i {\displaystyle \textstyle p_{T}=\prod _{i\in T}p_{i}} ואז המשתמש i {\displaystyle i} מחלץ את המפתח המשותף על ידי g T = g i ∏ j ∈ T − { i } p j  mod  n {\displaystyle \textstyle g_{T}=g_{i}^{\prod _{j\in T-\{i\}}p_{j}}{\text{ mod }}n} כלומר חזקה של כל המפתחות למעט המפתח שלו. הוכח שהסכימה הזו בטוחה בהנחה שפירוק לגורמים היא בעיה קשה וכל מה שנדרש לאחסן הוא רק מפתח אחד. בשתי הסכימות השרת אינו נדרש לשדר כלל מידע נלווה לתוכן המוצפן, כיוון שהמפתחות הוקצו מראש ובידי המשתמשים המידע הדרוש לחילוץ מפתח השיחה. אולם שיתוף פעולה של שני משתמשים מאפשר להם לשבור בקלות את המערכת. אלגוריתם Complete Subset Cover מרחיב את הרעיון הבסיסי לעמידות כנגד k > 1 {\displaystyle k>1} מבוטלים וכן מצמצם את דרישות האחסון ברמת משתמש במחיר שהשרת ישדר לפני כל תוכן מוצפן מידע מסוים שנקרא "כותר". בכללות הוא מגדיר אוסף של תת-קבוצות S 1 , . . . , S w {\displaystyle S_{1},...,S_{w}} כאשר S j ⊆ N {\displaystyle S_{j}\subseteq {\mathcal {N}}} . מקצים מפתח סודי ארוך טווח (קבוע) L j {\displaystyle L_{j}} לכל S j {\displaystyle S_{j}} ולכל u ∈ S j {\displaystyle u\in S_{j}} מקצים מידע פרטי I u {\displaystyle I_{u}} איתו הוא אמור לשחזר את L j {\displaystyle L_{j}} . בהינתן קבוצה R {\displaystyle {\mathcal {R}}} של משתמשים מבוטלים יתר המשתמשים N ∖ R {\displaystyle {\mathcal {N}}\setminus {\mathcal {R}}} מחולקים לתת-קבוצות זרות S i 1 , . . . , S i m {\displaystyle S_{i_{1}},...,S_{i_{m}}} כך שמתקיים: N ∖ R = ⋃ j = 1 m S i j {\displaystyle {\mathcal {N}}\setminus {\mathcal {R}}=\bigcup _{j=1}^{m}S_{i_{j}}} . K {\displaystyle K} מוצפן m {\displaystyle m} פעמים עם המפתחות L i 1 , . . . , L i m {\displaystyle L_{i_{1}},...,L_{i_{m}}} בהתאמה. לצורך כך יש להגדיר שני פרימיטיבים קריפטוגרפיים: (1) צופן מהצורה F K : { 0 , 1 } ∗ ↦ { 0 , 1 } ∗ {\displaystyle F_{K}:\{0,1\}^{*}\mapsto \{0,1\}^{*}} להצפנת התוכן M {\displaystyle M} עם K {\displaystyle K} שצריך להיות חדש עבור כל תוכן. הצופן צריך להיות מהיר ולא אמור לגרום להתנפחות התוכן עקב ההצפנה. הוא יכול להיות צופן זרם בטוח כמו Salsa20. וכן (2) צופן מהצורה E L { 0 , 1 } ℓ ↦ { 0 , 1 } ℓ {\displaystyle E_{L}\{0,1\}^{\ell }\mapsto \{0,1\}^{\ell }} עם מפתח ארוך-טווח L {\displaystyle L} שהמרכז משתף עם כל משתמש בנפרד. יכול להיות צופן בלוקים כמו AES. מסיבות של יעילות רצוי ש- K {\displaystyle K} יהיה קצר (להגנה על זכויות יוצרים אין צורך בהצפנה כבדה) ורק המפתח ארוך הטווח צריך להיות באורך מלא (בדרך כלל 128 סיביות). מפני שאורך הכותר תלוי בגודל הבלוק של צופן הבלוקים, אפשר להשתמש בחלופה חסכונית כך; [ Prefix | K | E L ( U ) ] ⊕ K {\displaystyle [{\text{Prefix}}_{|K|}E_{L}({\mathcal {U}})]\oplus K} במקום בלוק מלא. כאשר הביטוי Prefix i ( S ) {\displaystyle {\text{Prefix}}_{i}(S)} פירושו i {\displaystyle i} הסיביות הראשונות של הערך S {\displaystyle S} וכן U {\displaystyle {\mathcal {U}}} הוא מחרוזת אקראית כלשהי באורך בלוק מלא. כל משמש u {\displaystyle u} מקבל מידע סודי I u {\displaystyle I_{u}} באופן כזה שעבור כל 1 ≤ i ≤ w {\displaystyle 1\leq i\leq w} כאשר u ∈ S i {\displaystyle u\in S_{i}} , מאפשר לו לחלץ את המפתח L i {\displaystyle L_{i}} לקבוצה שלו S i {\displaystyle S_{i}} . את L i {\displaystyle L_{i}} אפשר להכין בשתי דרכים, בחירה אקראית (אמיתית) ונפרדת עבור כל מפתח, מה שמספק ביטחון אבסולוטי מהיבט של תורת האינפורמציה כמו פנקס חד-פעמי או כפונקציה של מידע סודי אחר שאז ביטחונו נשען על הפונקציה הפסאודו-אקראית מה שמספק ביטחון חישובי. מרכז שמעוניין לשדר או להפיץ תוכן מוצפן פועל כדלהלן; 1. בוחר מפתח שיחה אקראי K {\displaystyle K} . 2. בהינתן קבוצה R {\displaystyle {\mathcal {R}}} של משתמשים מבוטלים, המרכז מפריד את כל המשתמשים הבלתי מבוטלים ל- m {\displaystyle m} תת-קבוצות זרות S i 1 , . . . , S i m {\displaystyle S_{i_{1}},...,S_{i_{m}}} ומקצה להם מפתחות סודיים L i 1 , . . . , L i m {\displaystyle L_{i_{1}},...,L_{i_{m}}} בהתאמה. 3. המרכז מצפין את מפתח השיחה m {\displaystyle m} פעמים עם כל המפתחות L i {\displaystyle L_{i}} ומשדר את התוכן כדלהלן: ⟨ [ i 1 , i 2 , . . . , i m , E L i 1 ( K ) , . . . , E L i m ( K ) ] , F K ( M ) ⟩ {\displaystyle \langle [i_{1},i_{2},...,i_{m},E_{L_{i_{1}}}(K),...,E_{L_{i_{m}}}(K)],F_{K}(M)\rangle } החלק שמופיע בסוגריים המרובעות נקרא "כותר" והחלק האחרון הוא גוף התוכן. מקבל מורשה u {\displaystyle u} הקולט את השידור: [ ⟨ i 1 , i 2 , . . . , i m , C 1 , C 2 , C m ] , M ′ ⟩ {\displaystyle [\langle i_{1},i_{2},...,i_{m},C_{1},C_{2},C_{m}],M'\rangle } פועל כדלהלן: 1. מוצא את i j {\displaystyle i_{j}} כך שמתקיים u ∈ S i j {\displaystyle u\in S_{i_{j}}} (תת-הקבוצה אליה הוא שייך) במקרה שהוא נמנה עם הקבוצה R {\displaystyle {\mathcal {R}}} התוצאה היא null. 2. מחלץ את המפתח המתאים L j {\displaystyle L_{j}} באמצעות I u {\displaystyle I_{u}} . 3. מפענח את מפתח השיחה: K = D L i j ( C j ) {\displaystyle K=D_{L_{i_{j}}}(C_{j})} . 4. מפענח את התוכן: D K ( M ′ ) {\displaystyle D_{K}(M')} . עיקר העבודה ביישום הסכימה האמורה היא (1) הכנת אוסף של כל תת-הקבוצות האפשריות של המשתמשים הרשומים (2) הקצאת מפתח לכל תת-קבוצה אפשרית באוסף, (3) "כיסוי" כל המשתמשים הלגיטימיים פחות המבוטלים בתת-קבוצות נפרדות ו-(4) הגדרת שיטה שבה כל משתמש יוכל למצוא את המפתח המתאים לקבוצה שלו. אלגוריתם Subset-Cover ניתן למימוש באופן הבא: אוסף הקבוצות מתאים לכל תת-העצים בעץ בינארי מלא בעל N {\displaystyle N} עלים, כל עלה כנגד משתמש אחד. סך הכול עלים וצמתים הוא 2 N − 1 {\displaystyle 2N-1} . כל צומת v i {\displaystyle v_{i}} מייצג תת-עץ בעץ הכללי, כל משתמש u {\displaystyle u} נמנה עם תת-הקבוצה S i {\displaystyle S_{i}} אך ורק אם שורש תת-הקבוצה v i {\displaystyle v_{i}} הוא אב קדום שלו. לכל צומת מוקצה מפתח L i {\displaystyle L_{i}} וכל משתמש u {\displaystyle u} מקבל log  N + 1 {\displaystyle {\text{log }}N+1} מפתחות המשויכים לכל הצמתים במסלול המקשר מהעלה שלו לשורש העץ. אם אוסף המשתמשים u 1 , . . . , u r {\displaystyle u_{1},...,u_{r}} שייכים לקבוצה R {\displaystyle {\mathcal {R}}} , מפרידים את יתר העלים בעץ לתת-קבוצות נפרדות על ידי הכנת "עץ שטיינר" מכוון, בקיצור ( S T ( R {\displaystyle ST({\mathcal {R}}} שהוא עץ פורש מינימלי הנוצר על ידי r {\displaystyle r} העלים u i {\displaystyle u_{i}} המקושרים לשורש העץ באמצעות תוספת קשתות המינימלית האפשרית. כעת תת-הקבוצות האחרות הן למעשה כל תת-העצים "התלויים", כלומר העצים אשר שורשיהם סמוכים לצמתים בעץ S T ( R ) {\displaystyle ST({\mathcal {R}})} בעלי דרגה 1, אך אינם נמצאים בו. אוסף הקבוצות הללו נקרא "כיסוי" ומספרם הוא בערך r ⋅ ( i − log  r ) + 1 {\displaystyle r\cdot (i-{\text{log }}r)+1} . ישנן כמה דרכים כדי למצוא במהירות וביעילות חברות באחת מהקבוצות של משתמש נתון u {\displaystyle u} , אפשר להשתמש למשל בטבלת גיבוב או בקוד תיקון שגיאות. רצוי שהמידע בכותר יהיה דחוס ככל האפשר. עם אופטימיזציה אפשר להגיע לתצורה שבה החיפוש נעשה בסיבוכיות של log log  N {\displaystyle {\text{log log }}N} השוואות. כמות המפתחות שכל משתמש יאחסן תעמוד על log  N {\displaystyle {\text{log }}N} , מספר המפתחות המוצפנים שהשרת משדר r  log  N r {\displaystyle \textstyle r{\text{ log }}{\frac {N}{r}}} ואילו התוכן מוצפן רק פעם אחת. 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. הוא מגדיר טבלה עם A {\displaystyle A} שורות ו- C {\displaystyle C} עמודות, ומתייחסים לכל התקן (מקלט) כאל אוסף של C {\displaystyle C} כניסות בטבלה, אחת בכל עמודה, כלומר u = [ u 1 , . . . , u C ] {\displaystyle u=[u_{1},...,u_{C}]} כאשר u i ∈ { 0 , 1 , . . . , A − 1 } {\displaystyle u_{i}\in \{0,1,...,A-1\}} . אוסף כל תת-הקבוצות האפשריות S 1 , . . . , S w {\displaystyle S_{1},...,S_{w}} המוגדר על ידי האלגוריתם מתאים לאוסף התקנים שנמצאים באותה כניסה בעמודה נתונה. למשל S r , i {\displaystyle S_{r,i}} כולל את כל ההתקנים u = [ u 1 , . . . , u C ] {\displaystyle u=[u_{1},...,u_{C}]} כך ש- u i = r {\displaystyle u_{i}=r} . עבור כל שורה i {\displaystyle i} ועמודה j {\displaystyle j} הסכימה מקצה מפתח המיוצג על ידי L i , j {\displaystyle L_{i,j}} . בכל התקן u = [ u 1 , . . . , u C ] {\displaystyle u=[u_{1},...,u_{C}]} מוטמע מידע פרטי (סודי) I u {\displaystyle I_{u}} הכולל C {\displaystyle C} מפתחות L u 1 , 1 , L u 2 , 2 , . . . , L u C , C {\displaystyle L_{u_{1},1},L_{u_{2},2},...,L_{u_{C},C}} . עבור קבוצה R {\displaystyle {\mathcal {R}}} של התקנים "מבוטלים" (Revoked), האלגוריתם מחלק את N ∖ R {\displaystyle {\mathcal {N}}\setminus {\mathcal {R}}} כך שכל תת-קבוצה S i , j {\displaystyle S_{i,j}} מכוסה רק אם S i , j ∩ R = ∅ {\displaystyle S_{i,j}\cap {\mathcal {R}}=\emptyset } . בעוד שהסכימה מבטיחה שהתקן לא מאושר לא ייכלל בכיסוי, יש סיכוי נמוך שהתקן מאושר לא ייכלל גם הוא. כלומר ייתכן התקן לגיטימי שייחשב כלא תקף. בניגוד לשיטת נאור, תת-הקבוצות בסכימת CPRM/CPPM אינן זרות לגמרי ולכן הכיסוי אינו משולם. יתרה מזו הסיכוי שהתקן מאושר יפסל גדל ככל ש- r {\displaystyle r} גדל (מספר ההתקנים המבוטלים). לשם השוואה לשיטת נאור אם C = log  N {\displaystyle C={\text{log }}N} ו- A = r {\displaystyle A=r} אזי מנגנון CPRM/CPPM דורש r  log  N {\displaystyle r{\text{ log }}N} הצפנות, כמות האחסון במקלט או התקן עומדת על log  N {\displaystyle {\text{log }}N} מפתחות, וכמות החישוב הדרושה בצד ההתקן היא רק פעולת פענוח אחת. למשל ב-DVD בלוק המפתח MKB מכיל 3MB. חיסרון נוסף הוא בעובדה ש- r {\displaystyle r} מוגבל, כלומר מספר המכשירים המבוטלים המקסימלי שאפשר להגדיר בשיטה זו הוא בערך 10,000. בשיטת נאור אפשר להגיע ל-250,000. שיטת Logical-tree-hierarchy פותחה בעיקר לרב-נתיב במצב מקוון ונכללה בהצעה לתקן RFC-2627. המערכת מנהלת מפתח הצפנה משותף יחיד עבור קבוצת כל המשתתפים הפעילים N {\displaystyle {\mathcal {N}}} שנקרא Net Key שמועבר אליהם באמצעות פרוטוקול העברת מפתח קריפטוגרפי כמו דיפי-הלמן. המערכת מוסיפה או מסירה משתתף (אחד בכל מהלך) על ידי אלגוריתם הקצאת מפתח שבו המערכת מחשבת ומקצה מפתחות הצפנה לכל המשתתפים הלגיטימיים. התהליך מנוהל על ידי שרת שמדווח לכל משתתפים על המהלכים שבוצעו. המשתתפים מיוצגים על ידי העלים בעץ בינארי מאוזן בגובה log  N {\displaystyle {\text{log }}N} , לכל צומת v i {\displaystyle v_{i}} מוקצה מפתח K i {\displaystyle K_{i}} . כל משתתף u i {\displaystyle u_{i}} מקבל (בתהליך שנקרא Rekeying באמצעות המפתח הראשי) את כל המפתחות המשויכים לכל הצמתים במסלול המקשר משורש העץ לעלה שלו (לדוגמה בתרשים משתתף מספר 3 מקבל את המפתחות B,I,M). כדי להסיר את העלה u {\displaystyle u} מקצים מפתחות חדשים K i ′ {\displaystyle K_{i}'} לכל הצמתים v i {\displaystyle v_{i}} לאורך המסלול המקשר מהעלה שהוסר ועד שורש העץ. כעת אם v i {\displaystyle v_{i}} הוא צומת הנמצא על המסלול, v j {\displaystyle v_{j}} צומת בן הנמצא על המסלול ו- v l {\displaystyle v_{l}} הוא צומת בן שאינו על מסלול. את המפתח K i ′ {\displaystyle K_{i}'} של הצומת v i {\displaystyle v_{i}} מצפינים על ידי המפתחות K j ′ {\displaystyle K_{j}'} ו- K l {\displaystyle K_{l}} (שימו לב שהאחרון לא התעדכן) כלומר ⟨ E K j ′ ( K i ′ ) , E K l ( K i ′ ) ⟩ {\displaystyle \langle E_{K_{j}'}(K_{i}'),E_{K_{l}}(K_{i}')\rangle } . במקרה ש- v i {\displaystyle v_{i}} הוא צומת אב של העלה u {\displaystyle u} מבצעים רק הצפנה אחת עם הצאצא של u {\displaystyle u} . המפתחות החדשים המוצפנים משודרים לכל המשתתפים הפעילים. האלגוריתם מחייב העברה של 2  log  N {\displaystyle 2{\text{ log }}N} מפתחות בכל פעולה כזו, כל משתתף נדרש לאחסן log  N {\displaystyle {\text{log }}N} מפתחות וכמות העבודה המקסימלית הנדרשת מכל משתתף היא log  N {\displaystyle {\text{log }}N} הצפנות (בממוצע נדרשת רק הצפנה אחת). להלן טבלה להמחשה של תהליך הפצת מפתחות (Rekeying) של פרוטוקול LKH שתי העמודות האחרונות מתייחסות למספר המשתתפים שצריכים לקבל שידור בכל פעם שנוסף או מבוטל משתתף אחד בשידור. מבנה subset difference מגדיר אוסף של תת-קבוצות של משתמשים S 1 , . . . , S w {\displaystyle S_{1},...,S_{w}} כאשר S j ∈ N {\displaystyle S_{j}\in {\mathcal {N}}} . לכל תת-קבוצה מקצים מפתח הצפנה L j {\displaystyle L_{j}} , לכל משתמש u {\displaystyle u} משייכים מידע סודי I u {\displaystyle I_{u}} איתו הוא יכול לחלץ את המפתחות של תת-הקבוצות אליהן הוא משויך. בהינתן הקבוצה R {\displaystyle {\mathcal {R}}} של משתמשים מבוטלים, יתר המשתמשים מחולקים לקבוצות זרות S i 1 , . . . , S i m {\displaystyle S_{i_{1}},...,S_{i_{m}}} מהאוסף אשר 'מכסות' לגמרי את כל המשתמשים, כלומר כל משתמש חבר בלפחות קבוצה אחת כזו. מפתח שיחה K {\displaystyle K} מוצפן m {\displaystyle m} פעמים עם L i 1 , . . . , L i m {\displaystyle L_{i_{1}},...,L_{i_{m}}} והתוכן מוצפן עם K {\displaystyle K} . כל המשתמשים משויכים לעלים בעץ בינארי מאוזן בגובה log  N {\displaystyle {\text{log }}N} אוסף הקבוצות S 1 , . . . , S w {\displaystyle S_{1},...,S_{w}} בהגדרה הוא מהצורה "קבוצה G 1 {\displaystyle G_{1}} פחות הקבוצה G 2 {\displaystyle G_{2}} " כאשר G 2 ⊂ G 1 {\displaystyle G_{2}\subset G_{1}} . שתי הקבוצות מתאימות לעלים של שני תת-עצים בינאריים בהתאמה. לכן תת-קבוצה S {\displaystyle S} כלשהי מיוצגת על ידי שני צמתים בעץ הראשי v i , v j {\displaystyle v_{i},v_{j}} כך ש- v i {\displaystyle v_{i}} הוא אב קדום של v j {\displaystyle v_{j}} מסמנים זאת על ידי S i , j {\displaystyle S_{i,j}} (כמתואר בתרשים). העלה u {\displaystyle u} הוא בתת-קבוצה S i , j {\displaystyle S_{i,j}} אם ורק אם הוא בתת-העץ שהשורש שלו הוא v j {\displaystyle v_{j}} . במילים אחרות u ∈ S i , j {\displaystyle u\in S_{i,j}} אם v i {\displaystyle v_{i}} הוא אב קדום שלו אך לא v j {\displaystyle v_{j}} . הרעיון הוא שעבור כל תת-קבוצה R {\displaystyle {\mathcal {R}}} של משתמשים מבוטלים אפשר למצוא קבוצה של לכל היותר s 2 − 1 {\displaystyle s2-1} תת-קבוצות מהאוסף אשר מכסה את כל המשתמשים ב- N ∖ R {\displaystyle {\mathcal {N}}\setminus {\mathcal {R}}} . אם יוקצה עבור כל משתמש מפתחות קבועים עבור אוסף כל הקבוצות מספר המפתחות עבור כל משתמש יהיה N {\displaystyle N} . במקום זאת אפשר לצמצם את המידע הזה באופן כזה שרק 1 2  log 2 N {\displaystyle \textstyle {\frac {1}{2}}{\text{ log}}^{2}N} מפתחות יאוחסנו, את המפתח הנכון המשתמש מחלץ באמצעות מבנה עץ דמוי GGM. לכל צומת מקצים שלושה מספרים אקראיים באמצעות מחולל פסאודו-אקראי בטוח, לכל צומת מצמידים תוויות המכילות את המספרים האקראיים G L {\displaystyle G_{L}} תווית עבור צד שמאל, G R {\displaystyle G_{R}} תווית עבור צד ימין ו- G M {\displaystyle G_{M}} תווית המייצגת את המפתח הסודי המשויך לעלה (כמתואר בתרשים). שימו לב שלא ניתן לשחזר את המפתח של צומת נתון ללא ידיעת צומת האב. בעת הפענוח המשתמש u {\displaystyle u} מקבל את המחרוזת הבאה: ⟨ [ i 1 , . . . , i m , E L i 1 ( K ) , E L i 2 ( K ) , . . . , E L i m ( K ) ] , F K ( M ) ⟩ {\displaystyle \langle [i_{1},...,i_{m},E_{L_{i_{1}}}(K),E_{L_{i_{2}}}(K),...,E_{L_{i_{m}}}(K)],F_{K}(M)\rangle } תחילה מוצא את תת-הקבוצה S i , j {\displaystyle S_{i,j}} אליה הוא משויך ומחשב את המפתח המתאים L i , j {\displaystyle L_{i,j}} באמצעות הפעלת הפונקציה הפסאודו רנדומלית על צומתי האב log  N {\displaystyle {\text{log }}N} פעמים. באמצעות טבלת גיבוב אפשר לצמצם את פעולת החיפוש של המשתמש ל- O ( loglog  N ) {\displaystyle O({\text{loglog }}N)} . לאחר מכן כל מה שנדרש הוא פעולת פענוח אחת כדי לחלץ את התוכן המוצפן. הפונקציות F K {\displaystyle F_{K}} ו- E L {\displaystyle E_{L}} מייצגות אלגוריתמים להצפנה כאשר הראשון מומלץ שיהיה צופן זרם והאחרון צופן בלוקים כמו AES. Berkovits, S. (1991). "How to Broadcast a Secret". Advances in Cryptology—EUROCRYPT'91, Lecture Notes in Computer Science, vol. 547, ed. D.W. Davies. Springer, Berlin, 535–541. Fiat, A. and M. Naor (1994). "Broadcast encryption". Advances in Cryptology—CRYPTO’93, Lecture Notes in Computer Science, vol. 773, ed. D.R. Stinson. Springer, Berlin, 480–491. Wallner, D.M., E.J. Harder, and R.C. Agee (1999). "Key management for multicast: Issues and architectures". Internet Request for Comments 2627. Available: ftp.ietf.org/rfc/rfc2627.txt Naor, D., M. Naor and J. Lotspiech (2001). "Revocation and tracing schemes for stateless receivers". Advances in Cryptology—CRYPTO 2001, Lecture Notes in Computer Science, vol. 2139, ed. J. Killian. Springer, Berlin, 41–62. Full version: ECCC Report 43, 2002 Amos Fiat; Moni Naor (1994). "Broadcast encryption". Proc. Advances in Cryptology – CRYPTO '93 (Extended abstract). Lecture Notes in Computer Science 773: 480–491. Key Management for Multicast: Issues and Architectures