BLAKE היא משפחה שלפונקציות גיבוב קריפטוגרפיות שהראשונה שבהן פותחה ב-2008 והייתה מועמדת לתחרות הגיבוב עבור תקןSHA-3 שאורגנה על ידיNIST ובסופה זכהKeccak. בהתאם לדרישות התקן האלגוריתם כולל ארבע פונקציות: BLAKE-224,‏ BLAKE-256,‏ BLAKE-384 ו-BLAKE-512 כשהמספר אחרי השם מייצג את גודל הפלט בסיביות. הן מחולקות לשתי קטגוריות; הראשונה BLAKE-256 מיועדת לפלטפורמת 32 סיביות או פחות, ממנה נגזרת BLAKE-224 הנבדלת ממנה בערכים ההתחלתיים וגודל הפלט וכן לגבי BLAKE-512 והפונקציה הנגזרת ממנה המיועדות לסביבת 64 סיביות. אף על פי ש-BLAKE לא זכתה בסופו של דבר, לפי הצהרת מארגני התחרות לאחרקריפטואנליזה מעמיקה, BLAKE כמו יתר האלגוריתמים שעלו לגמר בטוחה לשימוש ולא התגלו בה פגמים או בעיות רציניות. BLAKE2 פותחה בעקבות הלקחים והניסיון שהצטברו מקודמה. היא מהירה מאוד ונחשבת ל-'סטייט אוף דה ארט' בתפוקתה. היא מהירה פי שלושה בערך מ-SHA-3 ולטענת המפתחים עם ביטחון זהה. היא מגיעה בשתי גרסאות BLAKE2s עבורחומרה מוגבלת משאבים ו-BLAKE2b הפועלת על פלטפורמת 64 סיביות ונועדה לביצועים גבוהים.

BLAKE^[1] פותחה על ידי Jean-Philippe Aumasson,‏ Luca Henzen,‏ Willi Meier ו-Raphael C.-W. Phan. בתחילה נקראה BLAKE-xx כאשר xx הוא 28, 32, 48 או 64. ב-2010 שונה השם לקראת ההגשה לתחרות כדי להבדילו מהגרסה המקורית. BLAKE2^[2] שהוצעה בטיוטהRFC 7693 פותחה בדצמבר 2012 על ידי Jean-Philippe Aumasson,‏ Samuel Neves,‏ Zooko Wilcox-O’Hearn, ו-Christian Winnerlein.

שתיהן חופשיות לשימוש ואינן מוגנות בפטנט. לא ידוע על קריפטואנליזה מוצלחת שלהן והן נחשבות לבטוחות. כמו כן פורסמו מספר גרסאות מוחלשות של מועמד SHA-3 הנקראות "גרסאות צעצוע" לצורך קריפטואנליזה (BLOKE,‏ FLAKE,‏ BLAZE ו-BRAKE). קיימים מימושים חופשיים של הפונקציות השונות בשפתC,‏C++‎ ו-C#‎ בין היתר אפשר למצוא ב-GitHub^[3][4] וכן מימוש לשפתVHDL^[5].

פונקציית הגיבוב BLAKE מבוססת על מספר מרכיבים ידועים בביטחונם. היא דור המשך של פונקציית הגיבובLAKE המכילה מצב פנימי רחב (Wide pipe), פונקציית הדחיסה הפנימית היא וריאציה שלצופן הזרםChaCha והיא מגוונת באמצעות Salt שהוא ערך אקראי חד-פעמי שאינו סודי המתפקד כמווקטור אתחול והאיטרציה הפנימית פועלת לפי מבנהHAIFA שהוא גרסה משופרת שלמבנה מרקל-דמגרד. הגיוון הוא אופציונלי וכאשר הוא קיים הפונקציה נקראתפונקציית גיבוב אקראית.

פונקציית גיבוב אקראית היא פונקציית גיבוב המשלבת בנוסף לקלט הרגיל "גיוון" אקראי הנקרא Salt. מהיבט תאורטי המטרה של ה-Salt היא לאפשר הסתמכות על פונקציית גיבוב בעלת ביטחון חלש ממה שהוצהר. הרעיון הוצע במקור על ידי שי הלוי והוגו קרווציק לחיזוק אלגוריתםחתימה דיגיטליתDSA, המשלב בין היתר פונקציית גיבוב. השאיפה היא שאלגוריתם החתימה יישאר בטוח אפילו אם פונקציית הגיבוב בה הוא משתמש אינה טובה לגמרי, כלומר ביטחונה התרופף בעקבות קריפטואנליזה חדשה, בדיוק כמו שקרה עםMD5. אפשר להפוך פונקציית גיבוב דטרמיניסטית לאקראית על ידי ערבוב הקלט עם ערך אקראי לפי שמעבירים בפונקציית הגיבוב. למשל פונקציית הגיבוב מהצורה${\displaystyle H_r(x)=H(r\oplus x)}$ נקראת פונקציית גיבוב אקראית, כאשר${\displaystyle H}$ היא פונקציית גיבוב רגילה כמוSHA-2 ו-${\displaystyle r}$ יכול להיות ערך אקראי אפילו קצר ואינו נחשב למפתחהצפנה לכן אין צורך להסתירו. מבנה כזה יעיל ומבטיח קושי רב יותר במציאתהתנגשויות כלומר למצוא${\displaystyle y}$ המקיים${\displaystyle H_r(x)=H_r(y)}$ מאשר במודל הסטנדרטי של פונקציות גיבוב. כאןהתקפת יום הולדת אינה ישימה כיוון שהיא לא יכולה להיות אוף ליין, כלומר התוקף חייב לקבל בנוסף לתמצית הקלט את ה-Salt שמיוצר באופן אקראי עבור כל מסר, לכן אפשר להסתפק בפונקציית גיבוב הנקראת Target Collision Resistance (בקיצור TCR) שהיא גרסה חלשה יותר מפונקציה חסינת התנגשויות מלאה.

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

עקרונות הפיתוח והתכנון של פונקציית הגיבוב BLAKE הם:

• פשטות ומהירות הן בחומרה והן בתוכנה.
• פרמטרים דומים ל-SHA-2.
• אורך מסר מקסימלי${\displaystyle 2^{64}-1}$ סיביות.
• תמיכה בתוספת גיוון (Salt) לאקראיות.
• תמיכה במקביליות.
• איזון גמיש בין תפוקה לדרישות זיכרון.
• התאמה לסביבה מוגבלת במשאבים.
• עמידות נגד "מציאת מקור נוסף" (Second preimage resistance).
• עמידות נגדהתקפת ערוץ צדדי.

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

הזיכרון הפנימי (Internal state) של פונקציית הגיבוב מיוצג על ידימטריצה של 4x4מילים באורך 32 סיביות כל אחד. הקלט נטען לתוך המצב הפנימי המורחב לפי התיאור בהמשך. הפונקציה הפנימית מורכבת מסדרה של שלוש פעולות פשוטותXOR,חיבור והזזה מעגלית. הפונקציה מופעלת על מילות המצב 14 פעמים במקרה של BLAKE-256 או 16 פעמים במקרה של BLAKE-512 ובכל סבב מעבדת את כניסות המטריצה תחילה בעמודות ולאחר מכן באלכסונים ומוסיפה ערכים קבועים שונים לפי טבלה בהתאם למספר הסבב. לאחר מכן המצב הפנימי נדחס לחצי מאורכו והפלט מופק יחד עם הגיוון (Salt).

BLAKE פועלת ברמה של מילים באורך 32 סיביות (או 64 סיביות במקרה של BLAKE-512). הסימונים המוסכמים הם: הקלט${\displaystyle m}$ באורך כלשהו מחולק ל-${\displaystyle N}$ בלוקים באורך 16 מילים כל אחד:${\displaystyle m^0,m^1,...,m^{N-1}}$. המילים מייצגים מספרים שלמים בלתי מסומנים כאשר ההמרה מבתים למילים היא לפיסדר בתים גדול. הביטוי${\displaystyle m^j}$ מתייחס לבלוק ה-${\displaystyle j}$ של${\displaystyle m}$ ואילו הביטוי${\displaystyle m_i}$ מתייחס למילה ה-${\displaystyle i}$ של בלוק כלשהו, לכן${\displaystyle m_i^j}$ מייצג את המילה ה-${\displaystyle i}$ של הבלוק${\displaystyle j}$ של${\displaystyle m}$. המילים בבלוק הראשון מיוצגות על ידי:${\displaystyle m_0^0,m_1^0,m_2^0,...,m_{15}^0}$, בבלוק הבא המספר העילי מתחלף ל-1 וכן הלאה.

הערכים ההתחלתיים של BLAKE לקוחים מתקןSHA-2:

${\displaystyle I{V}_0=\text{6a09e667}}$	,${\displaystyle I{V}_1=\text{bb67ae85}}$
${\displaystyle I{V}_2=\text{3c6ef372}}$	,${\displaystyle I{V}_3=\text{a54ff53a}}$
${\displaystyle I{V}_4=\text{510e527f}}$	,${\displaystyle I{V}_5=\text{9b05688c}}$
${\displaystyle I{V}_6=\text{1f83d9ab}}$	,${\displaystyle I{V}_7=\text{5be0cd19}}$

ב-BLAKE-256 יש 16 קבועים שהם ספרותפאי בנקודה כלשהי:

${\displaystyle c_0=\text{243f6a88}}$	,${\displaystyle c_1=\text{85a308d3}}$	,${\displaystyle c_2=\text{13198a2e},c_3=\text{03707344}}$,
${\displaystyle c_4=\text{a4093822}}$	,${\displaystyle c_5=\text{299f31d0}}$	,${\displaystyle c_6=\text{082efa98},c_7=\text{ec4e6c89}}$,
${\displaystyle c_8=\text{452821e6}}$	,${\displaystyle c_9=\text{38d01377}}$	,${\displaystyle c_{10}=\text{be5466cf},c_{11}=\text{34e90c6c}}$,
${\displaystyle c_{12}=\text{c0ac29b7}}$	,${\displaystyle c_{13}=\text{c97c50dd}}$	,${\displaystyle c_{14}=\text{3f84d5B5},c_{15}=\text{b5470917}}$

בנוסף כל פונקציות משפחת BLAKE משתמשות בטבלת התמורות הבאה:

${\displaystyle {\sigma }_0}$	0	1	2	3	4	5	6	7	8	9	10	11	12	13	14	15
${\displaystyle {\sigma }_1}$	14	10	4	8	9	15	13	6	1	12	0	2	11	7	5	3
${\displaystyle {\sigma }_2}$	11	8	12	0	5	2	15	13	10	14	3	6	7	1	9	4
${\displaystyle {\sigma }_3}$	7	9	3	1	13	12	11	14	2	6	5	10	4	0	15	8
${\displaystyle {\sigma }_4}$	9	0	5	7	2	4	10	15	14	1	11	12	6	8	3	13
${\displaystyle {\sigma }_5}$	2	12	6	10	0	11	8	3	4	13	7	5	15	14	1	9
${\displaystyle {\sigma }_6}$	12	5	1	15	14	13	4	10	0	7	6	3	9	2	8	11
${\displaystyle {\sigma }_7}$	13	11	7	14	12	1	3	9	5	0	15	4	8	6	2	10
${\displaystyle {\sigma }_8}$	6	15	14	9	11	3	0	8	12	2	13	7	1	4	10	5
${\displaystyle {\sigma }_9}$	10	2	8	4	7	6	1	5	15	11	9	14	3	12	13	0

הטבלה מכילה 10 שורות כשבכל שורה 16 בתים. השימוש בטבלה מתבצע על ידי שני אינדקסים, האחד מייצג את השורה והשני את הכניסה. למשל${\displaystyle {\sigma }_0(0)}$ מייצג את הכניסה הראשונה בשורה הראשונה ואילו${\displaystyle {\sigma }_9(15)}$ היא הכניסה האחרונה בשורה האחרונה. שתיהן אפס במקרה זה.

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

• ערך ביניים${\displaystyle h}$ שהוא מערך של 8 מילים${\displaystyle h_0,...,h_7}$.
• קלט${\displaystyle m}$ המכיל 16 מילים${\displaystyle m=m_0,...,m_{15}}$.
• גיוון${\displaystyle s}$ המכיל 4 מילים${\displaystyle s=s_0,...,s_3}$.
• מונה${\displaystyle t}$ המכיל שתי מילים${\displaystyle t_0,t_1}$.

בסך הכול מונים הפרמטרים 30 מילים (120 בתים). פלט הפונקציה הוא ערך ביניים חדש${\displaystyle h^{\prime }}$ המכיל 8 מילים, כלומר:

${\displaystyle {\mathit{h}}^{\mathbf{\prime }}\mathbf{=}\mathbf{C}\mathbf{o}\mathbf{m}\mathbf{p}\mathbf{r}\mathbf{e}\mathbf{s}\mathbf{s}\mathbf{(}\mathit{h}\mathbf{,}\mathit{m}\mathbf{,}\mathit{s}\mathbf{,}\mathit{t}\mathbf{)}}$.

המצב הפנימי${\displaystyle v}$ של פונקציית הגיבוב מורכב מ-16 מילים${\displaystyle v_0,...,v_{15}}$ המסודרים כמטריצה עם ארבע שורות וארבע עמודות ומאותחל על ידי הערכים${\displaystyle h,s,c}$ ו-${\displaystyle t}$ לפי הסדר הבא:

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

כלומר הפונקציה הפנימית מבוצעת בכל פעם על כניסות אחרות של${\displaystyle v}$ (כמתואר בתרשים). ארבע הקריאות הראשונות${\displaystyle G_0,...,G_3}$ לפונקציית הסבב הפנימית מעבדות את כניסות${\displaystyle v}$ בעמודות וכיוון שהן נפרדות זו מזו אפשר לבצען באופן מקבילי. כמו כן ארבע הקריאות האחרונות${\displaystyle G_4,...,G_7}$ מעבדות כניסות המטריצה באלכסונים וגם הן נפרדות ולכן גם הן ניתנות לביצוע מקבילי.

בכל סבב${\displaystyle r}$ הקריאה לפונקציה${\displaystyle G_i(a,b,c,d)}$ מבצעת את החישוב הבא:

כאשר הסימון${\displaystyle \oplus }$ מייצגXOR, הסימון${\displaystyle ⋙}$ מייצגהזזה מעגלית והביטוי${\displaystyle {\sigma }_r(2i)}$ מתייחס לכניסה המתאימה בטבלת התמורות. מספר הסבב${\displaystyle r}$ הוא אינדקס השורה מודולו 10. דהיינו בסבב ה-13 לוקחים את הערך בכניסה${\displaystyle 2i}$ בשורה${\displaystyle {\sigma }_{13\text{ mod }10}={\sigma }_3}$.

ערך הביניים${\displaystyle h^{\prime }}$ מועבר מסבב לסבב והוא מחולץ מהמצב הפנימי ונדחס ל-8 מילים כך:

אם נתון הקלט${\displaystyle m}$ באורך סיביות, הקלט תחילה מרופד לפי כלל הריפוד של HAIFA. תחילה מוודים שאורכו יהיה שקול ל-447 מודולו 512. תחילה מוסיפים '1' בסוף ומשלימים באפסים כמידת הצורך. לכל היותר נוספים 512 סיביות. לאחר מכן מוסיפים סיבית '1' נוספת ואחריהמספר שלם באורך 64 סיביות המייצג את${\displaystyle \ell }$. לסיכום:

כך מובטח שאורך הקלט בסיביות יהיה כפולה של 512.

הקלט המרופד מחולק ל-${\displaystyle N}$ בלוקים באורך 16 מילים כל אחד${\displaystyle m^0,...,m^{N-1}}$. ויהי${\displaystyle \ell }$ מערך שלמים המייצגים את מספר סיביות המצטבר של הקלט לא כולל הריפוד. למשל אם המסר המקורי הוא באורך 600 סיביות, יתקבלו שני בלוקים כאשר הבלוק הראשון באורך 512 לכן${\displaystyle {\ell }^0=512}$ הבלוק הנותר חלקי ואורכו הוא רק 88 סיביות לכן${\displaystyle {\ell }^1={\ell }^0+88=600}$. אם המסר הוא כפולה של 512 או שהבלוק האחרון גדול מ-447 סיביות, יש צורך להוסיף בלוק ריק לצורך הריפוד והמספר המייצג את אורך המסר, לכן יוצא שהשלם האחרון הוא${\displaystyle {\ell }^{N-1}=0}$. כלומר הבלוק האחרון אינו כולל סיביות מהמסר כלל אלא רק ריפוד וקידוד האורך. ה-Salt הוא אופציונלי ואם אין שימוש בו${\displaystyle s=0}$. גיבוב המסר מתבצע כך:

תמצית המסר היא${\displaystyle h^N}$ שהוא ערך הביניים האחרון.

BLAKE-512 דומה ל-BLAKE-256 למעט השינויים הבאים. הערכים ההתחלתיים הם מתוך SHA-512:

הקבועים הם:

${\displaystyle c_0=\text{243f6a8885a308d3}}$,	${\displaystyle c_1=\text{13198a2e03707344}}$
${\displaystyle c_2=\text{a4093822299f31d0}}$,	${\displaystyle c_3=\text{082efa98ec4e6c89}}$
${\displaystyle c_4=\text{452821e638d01377}}$,	${\displaystyle c_5=\text{be5466cf34e90c6c}}$
${\displaystyle c_6=\text{c0ac29b7c97c50dd}}$,	${\displaystyle c_7=\text{3f84d5b5b5470917}}$
${\displaystyle c_8=\text{9216d5d98979fb1b}}$,	${\displaystyle c_9=\text{d1310ba698dfb5ac}}$
${\displaystyle c_{10}=\text{2ffd72dbd01adfb7}}$,	${\displaystyle c_{11}=\text{b8e1afed6a267E96}}$
${\displaystyle c_{12}=\text{ba7c9045f12c7f99}}$,	${\displaystyle c_{13}=\text{24a19947b3916cf7}}$
${\displaystyle c_{14}=\text{0801f2e2858efc16}}$,	${\displaystyle c_{15}=\text{636920d871574e69}}$

פונקציית הדחיסה היא בסגנון פונקציית Quarter Round של צופן ChaCha אך בתוספת קבועים לפי הטבלה כדלהלן:

טבלת התמורה ופונקציות הסבב זהים ל-BLAKE-256. ההבדל היחידי הוא באורך המשתנים ומספר הסבבים. ב-BLAKE-512 מתבצעים 16 סבבים והמשתנים כולם באורך 64 סיביות. הכנת המסר היא לפי כלל ריפוד דומה. אורכו הכולל צריך להיות שקול ל-895 סיביות מודולו 1024, מוסיפים '1' בסוף המסר ואפסים לפי הצורך ולבסוף מוסיפים '1' נוסף ואחריו את אורך המסר המקודד כמספר שלם באורך 128 סיביות לפי סדר בתים גדול. כך שלבסוף יתקבלקלט באורך שהוא כפולה של 1024.

BLAKE-224 זהה ל-BLAKE-256 למעט שני שינויים. הערכים ההתחלתיים הם:

משמיטים את ה-'1' הנוסף בריפוד המסר לפני קידוד האורך:

BLAKE-384 מתאים ל-BLAKE-512 למעט השינויים הבאים. הערכים ההתחלתיים הם:

${\displaystyle I{V}_0=\text{CBBB9D5DC1059ED8}}$,	${\displaystyle I{V}_1=\text{629A292A367CD507}}$
${\displaystyle I{V}_2=\text{9159015A3070DD17}}$,	${\displaystyle IV3=\text{152FECD8F70E5939}}$
${\displaystyle I{V}_4=\text{67332667FFC00B31}}$,	${\displaystyle IV5=\text{8EB44A8768581511}}$
${\displaystyle I{V}_6=\text{DB0C2E0D64F98FA7}}$,	${\displaystyle I{V}_7=\text{47B5481DBEFA4FA4}}$

וכן בריפוד המסר משמיטים את ה-'1' הנוסף. כלומר:

מספר הפעולות של BLAKE-256 הן 672 פעולות חיבור, 700 פעולות XOR ו-448 הזזות, בסך הכול 1,820 פעולות בסיסיות. לא כולל תקורה נוספת הנובעת מריפוד והכנת המסר. צריכת הזיכרון היא 144 בתים ב-ROM ו-184 בתים ב-RAM לא כולל תקורה נוספת הנובעת מטיפול במצביעים. BLAKE-512 מבצע בסך הכול 2,076 פעולות.

דרך אחרת יעילה יותר לבצע את הפעולה הפנימית של פונקציית הדחיסה היא תחילה לעבד את העמודות ולאחר מכן לסובב (Rotate) בהזזה מעגלית ברמה של מילים את מילות המצב לפי הכלל הבא: עבור העמודה ה-${\displaystyle i}$ מסובבים${\displaystyle i}$ פעמים. ואז מחשבים את שורות המטריצה (במקום אלכסונים). מיטוב דומה בוצע ב-Salsa20, המטרה היא ליהנות מביצוע מקבילי מהיר באמצעות פקודות SIMD על וקטורים הנתמכות במעבדים המודרניים.

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

פונקציית הגיבוב BLAKE על גרסאותיה נוסתה על מספר פלטפורמות כמו מעבדי 64 ביט, 32 ביט,מיקרו בקר 8 ביט ו-FPGA. והיא הציגה ביצועים טובים בהשוואה למתחרים.

הפעולות האריתמטיות של הפונקציה הפנימית מסודרות לפי "ARX" שזה חיבור, הזזה ו-XOR לפי סדר מסוים. השילוב הזה נחקר היטב בצופן הזרםSalsa20 ובצפנים אחרים והוכח שהוא בטוח נגדקריפטאנליזה דיפרנציאלית^[6] וכן נגדהתקפות ערוץ צדדי^[7][8].

HAIFA הוא מבנה משופר גנרי לפונקציית גיבוב הפועל כמו מבנה מרקל דמגרד אך עם Salt ומונה והוכח כבטוח יותר. המבנה מציע עמידות נגד התקפות ידועות על פונקציות גיבוב. מציאת התנגשויות, מציאת מקור שני, התקפת יום-הולדת, הטכניקה של Joux למציאת התנגשויות מרובות^[9][10].

אפשר לשלב את BLAKE בקוד אימות מסרים כמו ב-HMAC או UMAC. למשל:

שימוש דומה ניתן לעשות ב-BLAKE כדי לבנותפונקציה פסאודו אקראית אומחולל פסאודו אקראי, לדוגמה:

כאשר${\displaystyle i}$ הוא מונה כלשהו המקודד בדרך מוסכמת ומשורשר למסר.

אף על פי שפונקציית הגיבוב SHA-3 התקנית טובה היא אינה נותנת מענה לכל לצרכים. לפעמים יש צורך בפונקציית גיבוב מהירה בתוכנה לבדיקת שלמות וסינון כפילויות במערכת קבצים ואחסון ענן,מערכת איתור פריצות,ניהול גרסאות או שיטותאתחול (Boot) בטוח. יישומים אילו לרוב מגבבים קבצים קטנים מאוד בכמות רבה, מה שהתקן אינו מביא בחשבון ועשוי להשפיע על ביצועי המערכת וחוויית המשתמש. מסיבה זו מערכות רבות עדיין משתמשות באלגוריתמים ישנים ולא מומלצים כמו MD5 שהוא מהיר כמעט פי שלושה מ-SHA-2 אך ידוע כפגיע להתקפת התנגשויות^[11] והוצא משימוש כל התקנים לצורך קריפטוגרפי. למרות זאת בגלל שיקולי יעילות מערכות ידועות עדיין משתמשות בו לבדיקת שלמות. דוגמאות הן: מערכת הקבציםZFS שלאורקל,OpenStack, ניהול גרסאותPerforce ואפילו מערכות חדשות כמומערכת אחסון אובייקטים שלAOL. כדי לתת מענה לבעיה זו פותחה BLAKE2 שהיא גרסה רזה וקלילה של BLAKE ממנה הוסרו מספר אלמנטים המכבידים על יעילותה ואין הוכחה שקיומם מחזק את ביטחון האלגוריתם. לפיבוחן ביצועים של eBACS^[12] באופן כללי BLAKE מהירה יותר מ-SHA-3 אך איטית בהשוואה ל-MD5. החידוש ב-BLAKE2 הוא המהירות הרבה אף יותר מ-MD5 בעוד שהיא אינה נופלת בביטחונה מ-SHA3 (לפי הצהרת המפתחים). למשל בביצועי תוכנה על מעבדSandy Bridge 3.1GHz שלאינטל ישראל, BLAKE2 מצליחה לגבב 890 מגה בית לשנייה לעומת רק 144 מגה לשנייה עם SHA3-512.

להלן תקציר החידושים והשיפורים ב-BLAKE2 לעומת הפונקציות הקודמות באותה משפחה:

• מהירות גבוהה על פלטפורמת 64 ביט (אף יותר מ-MD5).
• מקביליות גבוהה יותר על מעבדים מרובי ליבות תוך ניצולסט פקודות SIMD חדשות.
• גיבוב בתצורת עץ לאימות קבצים גדולים.
• PrefixMAC שהוא קוד אימות מסרים מבוסס BLAKE2 המהיר מ-HMAC.
• פרסונליזציה. לצורך מתן ייחודיות ברמת משתמש.
• ריפוד מינימלי.

BLAKE2 מגיע בשתי גרסאות:

• BLAKE2b אופטימלי למעבדי 64 ביט ומעבדיARM המייצר תמצית באורך של עד 64 בתים.
• BLAKE2s אופטימלי למעבדי 8 או 32 ביט המייצר תמצית באורך של עד 32 בתים.

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

1. פחות סבבים. הפונקציה הפנימית של BLAKE2s מבצועת רק 10 פעמים והפונקציה הפנימית של BLAKE2b מבוצעת רק 12 פעמים. הסיבה שבגרסאות הקודמות הוצע מספר סבבים גדול יותר (14 ו-16 בהתאמה) נבע רק מהרצון להיות שמרניים ולספק שולי ביטחון גבוהים ולא בגלל קריפטואנליזה מוצקה. השינוי הזה מהותי ומניב שיפור של בין 25 ל-29 אחוז בביצועים בעיקר על קלטים ארוכים לעומת הגרסאות הקודמות ואין סימנים המעידים שביטחון הפונקציה נחלש עקב כך.
2. הזזות אופטימליות לצורך מהירות. הפונקציה הפנימית מבצעת הזזה מעגלית לשמאל בהיסטים הקבועים: 24, 11, 63. השינוי של ההזזה הראשונה מ-25 ל-24 נובע מסיבות טכניות כי נדרשות פחותהוראות מעבד. השינוי מ-64 ל-63 מוסיף גם הוא במהירות במיוחד שאפשר לראות בהזזה זו כהזזה אחת ימינה במקום 63 שמאלה שהן למעשה שקולות על משתנה 64 סיביות ולכן עשויה להיות מהירה יותר.
3. ריפוד מינימלי. הריפוד שונה כך שרק אם יש צורך מוסיפים בתים ריקים לסוף המסר. אם אורך הקלט מתחלק באורך הבלוק, לא מבוצע ריפוד כלל. כדי למנוע נקודות תורפה בעקבות השינוי (כי כעת אפשר לבצע התקפות מסוימות שמנצלות את העובדה שהמסר יכול להיות חלק ממסר אחר ארוך יותר), מוחלף כלל הריפוד בשני "דגלי סיום"${\displaystyle f_0}$ ו-${\displaystyle f_1}$ הנמצאים בבלוק הראשון. כאשר${\displaystyle f_0=0}$ עבור כל הבלוקים למעט האחרון שאז${\displaystyle f_0=1}$. הדגל${\displaystyle f_1}$ נועד לאותת על הצומת האחרון בעץ הגיבוב במקרה של גיבוב בצורת עץ, כאשר מגיעים לבלוק האחרון${\displaystyle f_1=f_0}$.
4. פחות קבועים. BLAKE2 עושה שימוש בשמונה קבועים בלבד. שינוי זה חוסך ב-128 בתים הן ב-RAM והן ב-ROM ב-BLAKE2b ו-64 בתים ב-BLAKE2s.
5. סדר בתים קטן. BLAKE2 מפרשת את הקלט לפי סדר בתים קטן כמו MD5 ולא כמו ב-SHA-3 זאת מפני שפלטפורמות רבות פועלות לפי סדר בתים קטן, בעיקרAMD ואינטל.
6. מונה בתים ולא סיביות. המונה סופר את בתי המסר ולא סיביות המסר, הסיבה לכך טכנית היא מפשטת את היישום ומונעת באגים.
7. הגיוון מעובד רק פעם אחת. בניגוד לקודמה BLAKE2 טוענת את ה-Salt רק פעם אחת בתחילת הגיבוב כמו וקטור אתחול במקום כקלט לפונקציית הדחיסה בכל סבב. עובדה שחוסכת מעט פעולות ומעט זיכרון. פונקציית דחיסה נטולת Salt מפחיתה בביטחון האלגוריתם באופן שולי.
8. תוספת בלוק פרמטרים. כדי להתאים את BLAKE2 לשימוש ב-Salt מבלי הצורך להכניסו לפונקציית הדחיסה, נוסף "בלוק פרמטרים" או "בלוק קונפיגורציה" שמחובר תחילה ב-XOR עם ה-IV ומעובד ראשון. בתוך בלוק הפרמטרים מקודדים את כל הפרמטרים החיוניים לפעולת הפונקציה בתצורה הנדרשת; כגון Salt, מפתח הצפנה אם קיים, תמיכה בתצורת גיבוב עץ, אורך תמצית המסר, פרסונליזציה וכדומה.

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

כאן בניגוד לגרסאות הקודמות נוספו הדגלים${\displaystyle f_0}$ ו-${\displaystyle f_1}$ בשתי הכניסות האחרונות במקום המונה${\displaystyle t}$ שהיה מיותר. שני הדגלים מתפקדים כמונה ומסייעים גם להחליף את פונקציית הריפוד, כך שהמסר אינו מתרחב.

הפונקציה הפנימית${\displaystyle G}$ של BLAKE2b (משמאל) ו-BLAKE2s מוצגת להלן:

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

בלוק הפרמטרים מכיל 32 בתים עבור BLAKE2s ו-50 בתים עבור BLAKE2b המחולקים למקטעים המייצגים את הנתונים הבאים:

• אורך התמצית בבתים (עד 32 בתים במקרה של BLAKE2s ועד 64 בתים במקרה של BLAKE2b).
• אורך מפתח הצפנה בבתים. בית אחד בטווח${\displaystyle [0,255]}$ (נקבע ל-0 אם אין מפתח).
• Salt. מערך של 8 בתים אקראיים עבור BLAKE2s ו-16 בתים עבור BLAKE2b.
• פרסונליזציה. 8 או 16 בתים בהתאמה של פרטים ייחודיים למשתמש (יכול להיות ריק).

פרמטרים המתאימים לשימוש בתצורת עץ (אם לא משתמשים במצב עץ מאפסים את כל השדות):

• דרגת העץ (Fanout). בית אחד בטווח${\displaystyle [0,255]}$ (הערך 0 מייצג רוחב בלתי מוגבל).
• עומק העץ. בית אחד בטווח${\displaystyle [0,255]}$. (הערך 255 מייצג עומק בלתי מוגבל).
• אורך עלה בבתים. 4 בתים המייצגים מספר שלם בטווח${\displaystyle [0,2^{32}-1]}$.
• אופסט הצומת. 6 או 8 בתים המייצגים מספר שלם בטווח${\displaystyle [0,2^{48}-1]}$ או${\displaystyle [0,2^{64}-1]}$ במקרה של BLAKE2b. נקבע ל-0 במקרים הבאים: בעלים, בצומת הראשון, בצומת השמאלי ביותר או במצב סדרתי (לא בתצורת עץ).
• גובה הצומת. בית אחד המייצג מספר שלם בטווח${\displaystyle [0,255]}$. רלוונטי רק בתצורת עץ ושווה 0 בעלים.
• אורך הגיבוב הפנימי בבתים. בית שלם המייצג מספר בטווח${\displaystyle [0,32]}$ או${\displaystyle [0,64]}$ בהתאמה.

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

למשל אם הקונפיגורציה כוללת אורך תמצית 64 בתים (40 בייצוגהקסדצימלי) והיא כוללת מפתח הצפנה באורך 32 בתים (20 בייצוג הקסדיצמלי), גיוון (Salt) - מחרוזת המכילה את הספרה "5" בסך הכול 32 פעמים ופרסונליזציה המכילה את האות "e" בסך הכול 32 פעמים. כאמור היות שהתצורה אינה במבנה עץ רוחב ועומק שווים 1 וכל יתר הפרמטרים 0. הבלוק ייראה כך:

40200101 00000000 00000000 00000000 00000000 00000000 00000000 0000000055555555 55555555 55555555 55555555 eeeeeeee eeeeeeee eeeeeeee eeeeeeee

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

גיבוב בתצורת עץ מתאים במיוחד לגיבוב קבצים גדולים או מדיית אחסון גדולה ואפשרי בכמה דרכים. זה יכול להיותעץ בינארי מאוזן, עץ טרינארי, עץ בעומק משתנה או בעומק קבוע. המנגנון העיקרי הוא כדלהלן. עץ הגיבוב מעבד נתחים של מידע באורך המוגדר על ידי השדה "אורך העלה" המופיע בבלוק הפרמטרים. כל נתח מעובד בנפרד וללא תלות באחרים, מה שמאפשר לבצע את הגיבוב באופן מקבילי על ליבות שונות או בתהליכונים שונים. לאחר מכן כל התוצאות נאספות לנתח חדש שמוזן שוב לפונקציית הגיבוב כאשר כל עלה מקבל כקלט שרשור של גיבובים לפי השדה "דרגת העץ". השדות אופסט הצומת וגובה הצומת מבטיחים שכל קריאה לפונקציית הגיבוב מקבלת קלט שונה ולכן תתקבל תוצאה אחרת ללא תלות במידע עצמו. דגל הסיום${\displaystyle f_1}$ מאותת כאשר מבצעים את הקריאה האחרונה בגובה נתון ביחס לאופסט הן של העלים והן של הצמתים.${\displaystyle f_1=1}$ רק בבלוק האחרון של כל קריאה לפונקציית הגיבוב, כך שבשורש העץ תמיד${\displaystyle f_1=1}$.

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

להלן קוד שלם בשפתC#‎ של פונקציית הגיבוב BLAKE2B-512 בתצורה רגילה לפי המלצת המפתחים בעמוד הבית של BLAKE^[13]. לאחר מימוש המחלקה יש להשתמש בשלוש הפונקציות Initialize,‏ HashCore ו-HashFinal. תחילה קוראים לפונקציה Initialize שצריכה לקבל כארגומנט את בלוק הפרמטרים המתואר לעיל שהוא מערך של 8 מילים באורך 64 ביט. הפונקציה המייצרת את בלוק הקונפיגורציה לא הובאה כאן מפאת חוסר מקום. לצורך הבדיקה אפשר להשתמש בערךברירת המחדל שהוא${\displaystyle \text{0x1010040}}$ בכניסה הראשונה, כל היתר אפסים. הפונקציה HashCore מקבלת את המידע לגיבוב ו-HashFinal מחזירה את תמצית המידע.

classBlake2B{ulong_counter0;ulong_counter1;ulong_finalizationFlag0;ulong_finalizationFlag1;int_bufferFilled=0;byte[]_buf=newbyte[128];ulong[]_m=newulong[16];ulong[]_h=newulong[8];ulong[]_v=newulong[16];constulongIV0=0x6A09E667F3BCC908UL;constulongIV1=0xBB67AE8584CAA73BUL;constulongIV2=0x3C6EF372FE94F82BUL;constulongIV3=0xA54FF53A5F1D36F1UL;constulongIV4=0x510E527FADE682D1UL;constulongIV5=0x9B05688C2B3E6C1FUL;constulongIV6=0x1F83D9ABFB41BD6BUL;constulongIV7=0x5BE0CD19137E2179UL;privatestaticreadonlyint[]Sigma=newint[192]{0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,14,10,4,8,9,15,13,6,1,12,0,2,11,7,5,3,11,8,12,0,5,2,15,13,10,14,3,6,7,1,9,4,7,9,3,1,13,12,11,14,2,6,5,10,4,0,15,8,9,0,5,7,2,4,10,15,14,1,11,12,6,8,3,13,2,12,6,10,0,11,8,3,4,13,7,5,15,14,1,9,12,5,1,15,14,13,4,10,0,7,6,3,9,2,8,11,13,11,7,14,12,1,3,9,5,0,15,4,8,6,2,10,6,15,14,9,11,3,0,8,12,2,13,7,1,4,10,5,10,2,8,4,7,6,1,5,15,11,9,14,3,12,13,0,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,14,10,4,8,9,15,13,6,1,12,0,2,11,7,5,3};ulongBytesToUInt64(byte[]buf,intoffset){return((ulong)buf[offset+7]<<7*8|((ulong)buf[offset+6]<<6*8)|((ulong)buf[offset+5]<<5*8)|((ulong)buf[offset+4]<<4*8)|((ulong)buf[offset+3]<<3*8)|((ulong)buf[offset+2]<<2*8)|((ulong)buf[offset+1]<<1*8)|((ulong)buf[offset]));}voidUInt64ToBytes(ulongvalue,byte[]buf,intoffset){buf[offset+7]=(byte)(value>>7*8);buf[offset+6]=(byte)(value>>6*8);buf[offset+5]=(byte)(value>>5*8);buf[offset+4]=(byte)(value>>4*8);buf[offset+3]=(byte)(value>>3*8);buf[offset+2]=(byte)(value>>2*8);buf[offset+1]=(byte)(value>>1*8);buf[offset]=(byte)value;}ulongRotateRight(ulongvalue,intnBits){return(value>>nBits)|(value<<(64-nBits));}voidG(inta,intb,intc,intd,intr,inti){intp=(r<<4)+i;intp0=Sigma[p];intp1=Sigma[p+1];varv=_v;varm=_m;v[a]+=v[b]+m[p0];v[d]=RotateRight(v[d]^v[a],32);v[c]+=v[d];v[b]=RotateRight(v[b]^v[c],24);v[a]+=v[b]+m[p1];v[d]=RotateRight(v[d]^v[a],16);v[c]+=v[d];v[b]=RotateRight(v[b]^v[c],63);}voidCompress(byte[]block,intstart){varv=_v;varh=_h;varm=_m;for(inti=0;i<16;++i)m[i]=BytesToUInt64(block,start+(i<<3));v[0]=h[0];v[1]=h[1];v[2]=h[2];v[3]=h[3];v[4]=h[4];v[5]=h[5];v[6]=h[6];v[7]=h[7];v[8]=IV0;v[9]=IV1;v[10]=IV2;v[11]=IV3;v[12]=IV4^_counter0;v[13]=IV5^_counter1;v[14]=IV6^_finalizationFlag0;v[15]=IV7^_finalizationFlag1;for(intr=0;r<12;++r){G(0,4,8,12,r,0);G(1,5,9,13,r,2);G(2,6,10,14,r,4);G(3,7,11,15,r,6);G(3,4,9,14,r,14);G(2,7,8,13,r,12);G(0,5,10,15,r,8);G(1,6,11,12,r,10);}for(inti=0;i<8;++i)h[i]^=v[i]^v[i+8];}publicvoidInitialize(ulong[]config){_h[0]=IV0;_h[1]=IV1;_h[2]=IV2;_h[3]=IV3;_h[4]=IV4;_h[5]=IV5;_h[6]=IV6;_h[7]=IV7;_counter0=0;_counter1=0;_finalizationFlag0=0;_finalizationFlag1=0;_bufferFilled=0;Array.Clear(_buf,0,_buf.Length);for(inti=0;i<8;i++)_h[i]^=config[i];}publicvoidHashCore(byte[]array,intstart,intcount){intoffset=start;intbufferRemaining=128-_bufferFilled;if((_bufferFilled>0)&&(count>bufferRemaining)){Array.Copy(array,offset,_buf,_bufferFilled,bufferRemaining);_counter0+=128;if(_counter0==0)_counter1++;Compress(_buf,0);offset+=bufferRemaining;count-=bufferRemaining;_bufferFilled=0;}while(count>128){_counter0+=128;if(_counter0==0)_counter1++;Compress(array,offset);offset+=128;count-=128;}if(count>0){Array.Copy(array,offset,_buf,_bufferFilled,count);_bufferFilled+=count;}}publicbyte[]HashFinal(){_counter0+=(uint)_bufferFilled;_finalizationFlag0=ulong.MaxValue;for(inti=_bufferFilled;i<_buf.Length;i++)_buf[i]=0;Compress(_buf,0);byte[]hash=newbyte[64];for(inti=0;i<8;++i)UInt64ToBytes(_h[i],hash,i<<3);returnhash;}}

BLAKE2b-512("abc") = BA 80 A5 3F 98 1C 4D 0D 6A 27 97 B6 9F 12 F6 E9                     4C 21 2F 14 68 5A C4 B7 4B 12 BB 6F DB FF A2 D1                     7D 87 C5 39 2A AB 79 2D C2 52 D5 DE 45 33 CC 95                     18 D3 8A A8 DB F1 92 5A B9 23 86 ED D4 00 99 23

• SHA-3

• פונקציות גיבוב קריפטוגרפיות

• דפים עם תבנית הפניה לערך מורחב ותבנית להשלים