הצגת המקור של הדף "BLAKE"

'''BLAKE''' היא משפחה של [[פונקציית גיבוב קריפטוגרפית|פונקציות גיבוב קריפטוגרפיות]] שהראשונה שבהן פותחה ב-2008 והייתה מועמדת לתחרות הגיבוב עבור תקן [[SHA-3]] שאורגנה על ידי [[NIST]] ובסופה זכה [[SHA-3#Keccak|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{{הערה|[https://131002.net/blake/ SHA-3 proposal BLAKE]}} פותחה על ידי Jean-Philippe Aumasson,{{כ}} Luca Henzen,{{כ}} Willi Meier ו-Raphael C.-W. Phan. בתחילה נקראה BLAKE-xx כאשר xx הוא 28, 32, 48 או 64. ב-2010 שונה השם לקראת ההגשה לתחרות כדי להבדילו מהגרסה המקורית. BLAKE2{{הערה|[https://blake2.net/ BLAKE2 - fast secure hashing]}} שהוצעה בטיוטה {{RFC|7693}} פותחה בדצמבר 2012 על ידי Jean-Philippe Aumasson,{{כ}} Samuel Neves,{{כ}} Zooko Wilcox-O’Hearn, ו-Christian Winnerlein.

שתיהן חופשיות לשימוש ואינן מוגנות ב[[פטנט]]. לא ידוע על קריפטואנליזה מוצלחת שלהן והן נחשבות לבטוחות. כמו כן פורסמו מספר גרסאות מוחלשות של מועמד SHA-3 הנקראות "גרסאות צעצוע" לצורך קריפטואנליזה (BLOKE,{{כ}} FLAKE,{{כ}} BLAZE ו-BRAKE). קיימים מימושים חופשיים של הפונקציות השונות בשפת [[שפת C|C]],{{כ}} [[C++]]{{D}} ו-[[סי שארפ|C#]]{{D}} בין היתר אפשר למצוא ב-[[GitHub]]{{הערה|[https://github.com/veorq/BLAKE Reference implementation of the SHA-3 finalist BLAKE]}}{{הערה|[https://github.com/BLAKE2/BLAKE2 Reference source code package of BLAKE2]}} וכן מימוש לשפת [[VHDL]]{{הערה|[http://cryptography.gmu.edu/athena/index.php?id=source_codes HLS-ready C Source Code for the SHA-3 Round 3 Candidates - ARC 2015 Conference Release, April 2015]}}.

==BLAKE==
[[קובץ:BLAKE 01.png|460px|ממוזער|שמאל|תיאור הפונקציה הפנימית של BLAKE שהיא וריאציה של צופן הזרם [[Salsa20#ChaCha|ChaCha]]. הפונקציה מקבלת ארבע מילים ומחזירה ארבע מילים לאחר עיבוד מקבילי עם שילוב של שלוש פעולות אריתמטיות: חיבור, הזזה מעגלית ו-XOR הידוע בקיצור "ARX". שילוב זה הוכח כבטוח הן מפני [[קריפטואנליזה דיפרנציאלית]] והן מפני [[התקפת ערוץ צדדי|התקפות ערוץ צדדי]].]]
פונקציית הגיבוב BLAKE מבוססת על מספר מרכיבים ידועים בביטחונם. היא דור המשך של פונקציית הגיבוב [[LAKE]] המכילה מצב פנימי רחב (Wide pipe), פונקציית הדחיסה הפנימית היא וריאציה של [[צופן זרם|צופן הזרם]] [[Salsa20#ChaCha|ChaCha]] והיא מגוונת באמצעות Salt שהוא ערך אקראי חד-פעמי שאינו סודי המתפקד כמו [[וקטור אתחול]] והאיטרציה הפנימית פועלת לפי מבנה [[שיטת מרקל-דמגרד#HAIFA|HAIFA]] שהוא גרסה משופרת של [[שיטת מרקל-דמגרד|מבנה מרקל-דמגרד]]. הגיוון הוא אופציונלי וכאשר הוא קיים הפונקציה נקראת [[פונקציית גיבוב אקראית]].

===פונקציית גיבוב אקראית===
{{הפניה לערך מורחב|פונקציית גיבוב אקראית}}
פונקציית גיבוב אקראית היא פונקציית גיבוב המשלבת בנוסף לקלט הרגיל "גיוון" אקראי הנקרא Salt. מהיבט תאורטי המטרה של ה-Salt היא לאפשר הסתמכות על פונקציית גיבוב בעלת ביטחון חלש ממה שהוצהר. הרעיון הוצע במקור על ידי שי הלוי והוגו קרווציק לחיזוק אלגוריתם [[חתימה דיגיטלית]] [[Digital Signature Algorithm|DSA]], המשלב בין היתר פונקציית גיבוב. השאיפה היא שאלגוריתם החתימה יישאר בטוח אפילו אם פונקציית הגיבוב בה הוא משתמש אינה טובה לגמרי, כלומר ביטחונה התרופף בעקבות קריפטואנליזה חדשה, בדיוק כמו שקרה עם [[MD5]]. אפשר להפוך פונקציית גיבוב דטרמיניסטית לאקראית על ידי ערבוב הקלט עם ערך אקראי לפי שמעבירים בפונקציית הגיבוב. למשל פונקציית הגיבוב מהצורה <math>H_r(x)=H(r\oplus x)</math> נקראת פונקציית גיבוב אקראית, כאשר <math>H</math> היא פונקציית גיבוב רגילה כמו [[SHA-2]] ו-<math>r</math> יכול להיות ערך אקראי אפילו קצר ואינו נחשב למפתח [[הצפנה]] לכן אין צורך להסתירו. מבנה כזה יעיל ומבטיח קושי רב יותר במציאת [[התקפת התנגשויות|התנגשויות]] כלומר למצוא <math>y</math> המקיים <math>H_r(x)=H_r(y)</math> מאשר במודל הסטנדרטי של פונקציות גיבוב. כאן [[פונקציית גיבוב קריפטוגרפית#התקפת יום הולדת|התקפת יום הולדת]] אינה ישימה כיוון שהיא לא יכולה להיות אוף ליין, כלומר התוקף חייב לקבל בנוסף לתמצית הקלט את ה-Salt שמיוצר באופן אקראי עבור כל מסר, לכן אפשר להסתפק בפונקציית גיבוב הנקראת Target Collision Resistance (בקיצור TCR) שהיא גרסה חלשה יותר מפונקציה חסינת התנגשויות מלאה.

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

===תכונות===
עקרונות הפיתוח והתכנון של פונקציית הגיבוב BLAKE הם:
*פשטות ומהירות הן בחומרה והן בתוכנה.
*פרמטרים דומים ל-SHA-2.
*אורך מסר מקסימלי <math>2^{64}-1</math> סיביות.
*תמיכה בתוספת גיוון (Salt) לאקראיות.
*תמיכה במקביליות.
*איזון גמיש בין תפוקה לדרישות זיכרון.
*התאמה לסביבה מוגבלת במשאבים.
*עמידות נגד "מציאת מקור נוסף" (Second preimage resistance).
*עמידות נגד [[התקפת ערוץ צדדי]].

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

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

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

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

{| align="center" 
|- align="left"
|<math>IV_0 =\text{6a09e667}</math> ||, <math>\ \ \ IV_1 =\text{bb67ae85}</math>
|- align="left"
|<math>IV_2 =\text{3c6ef372}</math> ||, <math>\ \ \ IV_3 =\text{a54ff53a}</math>
|- align="left"
|<math>IV_4 =\text{510e527f}</math> ||, <math>\ \ \ IV_5 =\text{9b05688c}</math>
|- align="left"
|<math>IV_6 =\text{1f83d9ab}</math> ||, <math>\ \ \ IV_7 =\text{5be0cd19}</math>
|}

ב-BLAKE-256 יש 16 קבועים שהם ספרות [[פאי]] בנקודה כלשהי:
{| align="center"
|- align="left"
|<math>c_0 =\text{243f6a88}</math> ||, <math>\ \ \ c_1 =\text{85a308d3}</math> ||, <math>\ \ \ c_2 =\text{13198a2e}, c_3 =\text{03707344}</math>,
|- align="left"
|<math>c_4 =\text{a4093822}</math> ||, <math>\ \ \ c_5 =\text{299f31d0}</math> ||, <math>\ \ \ c_6 =\text{082efa98}, c_7 =\text{ec4e6c89}</math>,
|- align="left"
|<math>c_8 =\text{452821e6}</math> ||, <math>\ \ \ c_9 =\text{38d01377}</math> ||, <math>\ \ \ c_{10} =\text{be5466cf}, c_{11} = \text{34e90c6c}</math>,
|- align="left"
|<math>c_{12} =\text{c0ac29b7}</math> ||, <math>\ \ \ c_{13} =\text{c97c50dd}</math> ||, <math>\ \ \ c_{14} =\text{3f84d5B5}, c_{15} = \text{b5470917}</math>
|}

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

{| dir="ltr" align="center"
|- align="left"
! width="26px" | <math>\sigma_0</math> !! width="26px" | 0 !! width="26px" | 1 !! width="26px" | 2 !! width="26px" | 3 !! width="26px" | 4 !! width="26px" | 5 !! width="26px" | 6 !! width="26px" | 7 !! width="26px" | 8 !! width="26px" | 9 !! width="26px" | 10 !! width="26px" | 11 !! width="26px" | 12 !! width="26px" | 13 !! width="26px" | 14 !! width="26px" | 15
|- align="left"
! <math>\sigma_1</math> !! 14 !! 10 !! 4 !! 8 !! 9 !! 15 !! 13 !! 6 !! 1 !! 12 !! 0 !! 2 !! 11 !! 7 !! 5 !! 3
|- align="left"
! <math>\sigma_2</math> !! 11 !! 8 !! 12 !! 0 !! 5 !! 2 !! 15 !! 13 !! 10 !! 14 !! 3 !! 6 !! 7 !! 1 !! 9 !! 4
|- align="left"
! <math>\sigma_3</math> !! 7 !! 9 !! 3 !! 1 !! 13 !! 12 !! 11 !! 14 !! 2 !! 6 !! 5 !! 10 !! 4 !! 0 !! 15 !! 8
|- align="left"
! <math>\sigma_4</math> !! 9 !! 0 !! 5 !! 7 !! 2 !! 4 !! 10 !! 15 !! 14 !! 1 !! 11 !! 12 !! 6 !! 8 !! 3 !! 13
|- align="left"
! <math>\sigma_5</math> !! 2 !! 12 !! 6 !! 10 !! 0 !! 11 !! 8 !! 3 !! 4 !! 13 !! 7 !! 5 !! 15 !! 14 !! 1 !! 9
|- align="left"
! <math>\sigma_6</math> !! 12 !! 5 !! 1 !! 15 !! 14 !! 13 !! 4 !! 10 !! 0 !! 7 !! 6 !! 3 !! 9 !! 2 !! 8 !! 11
|- align="left"
! <math>\sigma_7</math> !! 13 !! 11 !! 7 !! 14 !! 12 !! 1 !! 3 !! 9 !! 5 !! 0 !! 15 !! 4 !! 8 !! 6 !! 2 !! 10
|- align="left"
! <math>\sigma_8</math> !! 6 !! 15 !! 14 !! 9 !! 11 !! 3 !! 0 !! 8 !! 12 !! 2 !! 13 !! 7 !! 1 !! 4 !! 10 !! 5
|- align="left"
! <math>\sigma_9</math> !! 10 !! 2 !! 8 !! 4 !! 7 !! 6 !! 1 !! 5 !! 15 !! 11 !! 9 !! 14 !! 3 !! 12 !! 13 !! 0
|}

הטבלה מכילה 10 שורות כשבכל שורה 16 בתים. השימוש בטבלה מתבצע על ידי שני אינדקסים, האחד מייצג את השורה והשני את הכניסה. למשל <math>\sigma_0(0)</math> מייצג את הכניסה הראשונה בשורה הראשונה ואילו <math>\sigma_9(15)</math> היא הכניסה האחרונה בשורה האחרונה. שתיהן אפס במקרה זה.

====פונקציית דחיסה====
[[קובץ:BLAKE 02.png|460px|ממוזער|שמאל|תיאור סדר הפעולות של הפונקציה הפנימית]]
פונקציית הדחיסה הפנימית של BLAKE-256 מקבלת ארבעה פרמטרים: 
*ערך ביניים <math>h</math> שהוא מערך של 8 מילים <math>h_0,...,h_7</math>.
*קלט <math>m</math> המכיל 16 מילים <math>m=m_0,...,m_{15}</math>.
*גיוון <math>s</math> המכיל 4 מילים <math>s=s_0,...,s_3</math>.
*מונה <math>t</math> המכיל שתי מילים <math>t_0,t_1</math>.
בסך הכול מונים הפרמטרים 30 מילים (120 בתים). פלט הפונקציה הוא ערך ביניים חדש <math>h'</math> המכיל 8 מילים, כלומר:
:<math>\boldsymbol{h'=\mathbf{Compress}(h,m,s,t)}</math>.

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

<center>
<math>\begin{pmatrix} v_0 & v_1 & v_2 & v_3 \\ v_4 & v_5 & v_6 & v_7 \\ v_8 & v_9 & v_{10} & v_{11} \\ v_{12} & v_{13} & v_{14} & v_{15} \end{pmatrix}\longleftarrow \begin{pmatrix} h_0 & h_1 & h_2 & h_3 \\ h_4 & h_5 & h_6 & h_7 \\ s_0 \oplus c_0 & s_1 \oplus c_1 & s_2 \oplus c_2 & s_3 \oplus c_3 \\ t_0 \oplus c_4 & t_0 \oplus c_5 & t_1 \oplus c_6 & t_1 \oplus c_7 \end{pmatrix}</math>
</center>

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

{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>G_0(v_0 ,v_4 ,v_8 ,v_{12}), G_1(v_1 ,v_5 ,v_9 ,v_{13}), G_2(v_2 ,v_6 ,v_{10},v_{14}), G_3(v_3 ,v_7 ,v_{11},v_{15})</math>
:<math>G_4(v_0 ,v_5 ,v_{10},v_{15}), G_5(v_1 ,v_6 ,v_{11},v_{12}), G_6(v_2 ,v_7 ,v_8 ,v_{13}), G_7(v_3 ,v_4 ,v_9 ,v_{14}) </math>
</div>
|}

כלומר הפונקציה הפנימית מבוצעת בכל פעם על כניסות אחרות של <math>v</math> (כמתואר בתרשים). ארבע הקריאות הראשונות <math>G_0,...,G_3</math> לפונקציית הסבב הפנימית מעבדות את כניסות <math>v</math> בעמודות וכיוון שהן נפרדות זו מזו אפשר לבצען באופן מקבילי. כמו כן ארבע הקריאות האחרונות <math>G_4,...,G_7</math> מעבדות כניסות המטריצה באלכסונים וגם הן נפרדות ולכן גם הן ניתנות לביצוע מקבילי.

בכל סבב <math>r</math> הקריאה לפונקציה <math>G_i(a,b,c,d)</math> מבצעת את החישוב הבא:
{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>a\leftarrow a + b + (m_{\sigma_r(2i)} \oplus c_{\sigma_r(2i+1)})</math>
:<math>d\leftarrow (d \oplus a) \ggg 16</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b \oplus c) \ggg 12</math>
:<math>a\leftarrow a + b + (m_{\sigma_r(2i+1)} \oplus c_{\sigma_r(2i)})</math>
:<math>d\leftarrow (d \oplus a) \ggg 8</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b \oplus c) \ggg 7</math>
</div>
|}

כאשר הסימון <math>\oplus</math> מייצג [[XOR]], הסימון <math>\ggg</math> מייצג [[פעולה על סיביות#סיבוב ללא סחיבה|הזזה מעגלית]] והביטוי <math>\sigma_r(2i)</math> מתייחס לכניסה המתאימה בטבלת התמורות. מספר הסבב <math>r</math> הוא אינדקס השורה מודולו 10. דהיינו בסבב ה-13 לוקחים את הערך בכניסה <math>2i</math> בשורה <math>\sigma_{13\text{ mod }10}=\sigma_3</math>.

====סיום====
ערך הביניים <math>h'</math> מועבר מסבב לסבב והוא מחולץ מהמצב הפנימי ונדחס ל-8 מילים כך:
{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>h_0^'\leftarrow h_0 \oplus s_0 \oplus v_0 \oplus v_8</math>
:<math>h_1^'\leftarrow h_1 \oplus s_1 \oplus v_1 \oplus v_9</math>
:<math>h_2^'\leftarrow h_2 \oplus s_2 \oplus v_2 \oplus v_{10}</math>
:<math>h_3^'\leftarrow h_3 \oplus s_3 \oplus v_3 \oplus v_{11}</math>
:<math>h_4^'\leftarrow h_4 \oplus s_0 \oplus v_4 \oplus v_{12}</math>
:<math>h_5^'\leftarrow h_5 \oplus s_1 \oplus v_5 \oplus v_{13}</math>
:<math>h_6^'\leftarrow h_6 \oplus s_2 \oplus v_6 \oplus v_{14}</math>
:<math>h_7^'\leftarrow h_7 \oplus s_3 \oplus v_7 \oplus v_{15}</math>
</div>
|}

====הכנת הקלט====
אם נתון הקלט <math>m</math> באורך <math>\ell<2^{64}</math> סיביות, הקלט תחילה מרופד לפי כלל הריפוד של HAIFA. תחילה מוודים שאורכו יהיה שקול ל-447 מודולו 512. תחילה מוסיפים '1' בסוף ומשלימים באפסים כמידת הצורך. לכל היותר נוספים 512 סיביות. לאחר מכן מוסיפים סיבית '1' נוספת ואחריה [[מספר שלם]] באורך 64 סיביות המייצג את <math>\ell</math>. לסיכום:
<center>
:<math>m\leftarrow m \ \| \ 1000...0001 \ \| \ <\ell>_{64}</math>.
</center>
כך מובטח שאורך הקלט בסיביות יהיה כפולה של 512.

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

{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>\boldsymbol{h^0=IV}</math>
:<math>\boldsymbol{\mathbf{For\ }i=0\mathbf{\ to\ }N-1\mathbf{\ do:}}</math>
::<math>\boldsymbol{h^{i+1}\leftarrow\mathbf{Compress}(h^i,m^i,s,\ell^i)}</math>
:<math>\boldsymbol{\mathbf{Return\ }h^N}</math>
</div>
|}

תמצית המסר היא <math>h^N</math> שהוא ערך הביניים האחרון.

===BLAKE-512===
BLAKE-512 דומה ל-BLAKE-256 למעט השינויים הבאים. הערכים ההתחלתיים הם מתוך SHA-512:
{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>IV_0 =\text{6a09e667f3bcc908},\ \ \ IV_1 =\text{bb67ae8584caa73b}</math>
:<math>IV_2 =\text{3c6ef372fe94f82b},\ \ \ IV_3 =\text{a54ff53a5f1d36f1}</math>
:<math>IV_4 =\text{510e527fade682d1},\ \ \ IV_5 =\text{9b05688c2b3e6c1f}</math>
:<math>IV_6 =\text{1f83d9abfb41bd6b},\ \ \ IV_7 =\text{5be0cd19137e2179}</math>
</div>
|}

הקבועים הם: 
{| align="center"
|- align="left"
| <math>c_0 =\text{243f6a8885a308d3}</math>,|| width="230px"| <math>c_1 =\text{13198a2e03707344}</math>
|- align="left"
|<math>c_2 =\text{a4093822299f31d0}</math>,|| <math>c_3 =\text{082efa98ec4e6c89}</math>
|- align="left"
|<math>c_4 =\text{452821e638d01377}</math>,|| <math>c_5 =\text{be5466cf34e90c6c}</math>
|- align="left"
|<math>c_6 =\text{c0ac29b7c97c50dd}</math>,|| <math>c_7 =\text{3f84d5b5b5470917}</math>
|- align="left"
|<math>c_8 =\text{9216d5d98979fb1b}</math>,|| <math>c_9 =\text{d1310ba698dfb5ac}</math>
|- align="left"
|<math>c_{10} =\text{2ffd72dbd01adfb7}</math>,|| <math>c_{11} =\text{b8e1afed6a267E96}</math>
|- align="left"
|<math>c_{12} =\text{ba7c9045f12c7f99}</math>,|| <math>c_{13} =\text{24a19947b3916cf7}</math>
|- align="left"
|<math>c_{14} =\text{0801f2e2858efc16}</math>,|| <math>c_{15} =\text{636920d871574e69}</math>
|}

פונקציית הדחיסה היא בסגנון פונקציית Quarter Round של צופן ChaCha אך בתוספת קבועים לפי הטבלה כדלהלן:
{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>a\leftarrow a + b + (m_{\sigma_r(2i)} \oplus c_{\sigma_r(2i+1)})</math>
:<math>d\leftarrow (d \oplus a) \ggg 32</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b \oplus c) \ggg 25</math>
:<math>a\leftarrow a + b + (m_{\sigma_r(2i+1)} \oplus c_{\sigma_r(2i)})</math>
:<math>d\leftarrow (d \oplus a) \ggg 16</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b \oplus c) \ggg 11</math>
</div>
|}

טבלת התמורה ופונקציות הסבב זהים ל-BLAKE-256. ההבדל היחידי הוא באורך המשתנים ומספר הסבבים. ב-BLAKE-512 מתבצעים 16 סבבים והמשתנים כולם באורך 64 סיביות. הכנת המסר היא לפי כלל ריפוד דומה. אורכו הכולל צריך להיות שקול ל-895 סיביות מודולו 1024, מוסיפים '1' בסוף המסר ואפסים לפי הצורך ולבסוף מוסיפים '1' נוסף ואחריו את אורך המסר המקודד כמספר שלם באורך 128 סיביות לפי סדר בתים גדול. כך שלבסוף יתקבל [[קלט]] באורך שהוא כפולה של 1024.
<center>
:<math>m\leftarrow m\ \| \ 1000...0001 \ \| \ <\ell>_{128}</math>
</center>

===BLAKE-224===
BLAKE-224 זהה ל-BLAKE-256 למעט שני שינויים. הערכים ההתחלתיים הם:
{| align="center"
|-
| 
<div class="mw-content-ltr">
:<math>IV_0 =\text{C1059ED8}, IV_1 =\text{367CD507}, IV_2 =\text{3070DD17}, IV_3 =\text{F70E5939}</math>
:<math>IV_4 =\text{FFC00B31}, IV_5 =\text{68581511}, IV_6 =\text{64F98FA7}, IV_7 =\text{BEFA4FA4}</math>
</div>
|}

משמיטים את ה-'1' הנוסף בריפוד המסר לפני קידוד האורך:
<center>
:<math>m\leftarrow m \ \| \ 1000...0000 \ \| \ <\ell>_{64}</math>.
</center>

===BLAKE-384===
BLAKE-384 מתאים ל-BLAKE-512 למעט השינויים הבאים. הערכים ההתחלתיים הם:
{| align="center"
|- align="left"
|<math>IV_0 =\text{CBBB9D5DC1059ED8}</math>,|| width="250" | <math>IV_1 =\text{629A292A367CD507}</math>
|- align="left"
|<math>IV_2 =\text{9159015A3070DD17}</math>,||<math>IV3 =\text{152FECD8F70E5939}</math>
|- align="left"
|<math>IV_4 =\text{67332667FFC00B31}</math>,||<math>IV5 =\text{8EB44A8768581511}</math>
|- align="left"
|<math>IV_6 =\text{DB0C2E0D64F98FA7}</math>,||<math>IV_7 =\text{47B5481DBEFA4FA4}</math>
|}

וכן בריפוד המסר משמיטים את ה-'1' הנוסף. כלומר:
<center>
:<math>m \leftarrow m \ \| \ 1000...0000 \ \| \ <\ell>_{128}</math>.
</center>

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

דרך אחרת יעילה יותר לבצע את הפעולה הפנימית של פונקציית הדחיסה היא תחילה לעבד את העמודות ולאחר מכן לסובב (Rotate) בהזזה מעגלית ברמה של מילים את מילות המצב לפי הכלל הבא: עבור העמודה ה-<math>i</math> מסובבים <math>i</math> פעמים. ואז מחשבים את שורות המטריצה (במקום אלכסונים). מיטוב דומה בוצע ב-[[Salsa20]], המטרה היא ליהנות מביצוע מקבילי מהיר באמצעות פקודות SIMD על וקטורים הנתמכות במעבדים המודרניים.

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

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

הפעולות האריתמטיות של הפונקציה הפנימית מסודרות לפי "ARX" שזה חיבור, הזזה ו-XOR לפי סדר מסוים. השילוב הזה נחקר היטב ב[[צופן זרם|צופן הזרם]] [[Salsa20]] ובצפנים אחרים והוכח שהוא בטוח נגד [[קריפטאנליזה דיפרנציאלית]]{{הערה|Jean-Philippe Aumasson, Simon Fischer, Shahram Khazaei, Willi Meier, and Christian Rechberger. New features of Latin dances: analysis of Salsa, ChaCha, and Rumba. In FSE, 2008}} וכן נגד [[התקפת ערוץ צדדי|התקפות ערוץ צדדי]]{{הערה|Thomas Peyrin. Security analysis of extended sponge functions. Talk at the workshop Hash functions in cryptology: theory and practice, 2008}}{{הערה|Erik Zenner. Cache timing analysis of HC-256. In SASC 2008 – The State of the Art of Stream Ciphers. ECRYPT, 2008}}.

HAIFA הוא מבנה משופר גנרי לפונקציית גיבוב הפועל כמו מבנה מרקל דמגרד אך עם Salt ומונה והוכח כבטוח יותר. המבנה מציע עמידות נגד התקפות ידועות על פונקציות גיבוב. מציאת התנגשויות, מציאת מקור שני, התקפת יום-הולדת, הטכניקה של Joux למציאת התנגשויות מרובות{{הערה|Antoine Joux. Multicollisions in iterated hash functions. application to cascaded constructions. In CRYPTO, 2004.}}{{הערה|Jean-Philippe Aumasson. [https://131002.net/data/papers/Aum08a.pdf Faster multicollisions]. In INDOCRYPT 2008, 2008.}}.

===קוד אימות מסרים ו-PRF===
אפשר לשלב את BLAKE ב[[קוד אימות מסרים]] כמו ב-HMAC או UMAC. למשל:
<center>
:<math>\text{HMAC}_k(m)=\text{BLAKE256}(k\oplus\text{opad}\ \| \ \text{BLAKE256}(k\oplus\text{ipad}\ \| \ m))</math>.
</center>

שימוש דומה ניתן לעשות ב-BLAKE כדי לבנות [[פונקציה פסבדו-אקראית קריפטוגרפית|פונקציה פסאודו אקראית]] או [[מחולל פסאודו אקראי קריפטוגרפי|מחולל פסאודו אקראי]], לדוגמה:
<center>
:<math>\text{BLAKE256}(m\ \| \ i)</math> או <math>\text{BLAKE256}(i\ \| \ m)</math>
</center>
כאשר <math>i</math> הוא מונה כלשהו המקודד בדרך מוסכמת ומשורשר למסר.

==BLAKE2==
אף על פי שפונקציית הגיבוב SHA-3 התקנית טובה היא אינה נותנת מענה לכל לצרכים. לפעמים יש צורך בפונקציית גיבוב מהירה בתוכנה ל[[סיכום ביקורת|בדיקת שלמות]] וסינון כפילויות ב[[מערכת קבצים]] ו[[אחסון ענן]], [[מערכת איתור פריצות]], [[ניהול גרסאות]] או שיטות [[אתחול (מחשוב)|אתחול]] (Boot) בטוח. יישומים אילו לרוב מגבבים קבצים קטנים מאוד בכמות רבה, מה שהתקן אינו מביא בחשבון ועשוי להשפיע על ביצועי המערכת וחוויית המשתמש. מסיבה זו מערכות רבות עדיין משתמשות באלגוריתמים ישנים ולא מומלצים כמו MD5 שהוא מהיר כמעט פי שלושה מ-SHA-2 אך ידוע כפגיע להתקפת התנגשויות{{הערה|Stevens, M., Sotirov, A., Appelbaum, J., Lenstra, A.K., Molnar, D., Osvik, D.A., de Weger, B.: Short chosen-preﬁx collisions for MD5 and the creation of a rogue CA certiﬁcate. In Halevi, S., ed.: CRYPTO. Volume 5677 of LNCS., Springer (2009)}} והוצא משימוש כל התקנים לצורך קריפטוגרפי. למרות זאת בגלל שיקולי יעילות מערכות ידועות עדיין משתמשות בו לבדיקת שלמות. דוגמאות הן: מערכת הקבצים [[ZFS]] של [[אורקל (חברה)|אורקל]], [[OpenStack]], ניהול גרסאות [[Perforce]] ואפילו מערכות חדשות כמו [[מערכת אחסון אובייקטים]] של [[אמריקה און ליין|AOL]]. כדי לתת מענה לבעיה זו פותחה BLAKE2 שהיא גרסה רזה וקלילה של BLAKE ממנה הוסרו מספר אלמנטים המכבידים על יעילותה ואין הוכחה שקיומם מחזק את ביטחון האלגוריתם. לפי [[בוחן ביצועים]] של eBACS{{הערה|[http://bench.cr.yp.to/impl-hash/blake2b.html Implementation comparison BLAKE2b]}} באופן כללי BLAKE מהירה יותר מ-SHA-3 אך איטית בהשוואה ל-MD5. החידוש ב-BLAKE2 הוא המהירות הרבה אף יותר מ-MD5 בעוד שהיא אינה נופלת בביטחונה מ-SHA3 (לפי הצהרת המפתחים). למשל בביצועי תוכנה על מעבד [[Sandy Bridge]] 3.1GHz של [[אינטל ישראל]], BLAKE2 מצליחה לגבב 890 מגה בית לשנייה לעומת רק 144 מגה לשנייה עם SHA3-512.

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

BLAKE2 מגיע בשתי גרסאות:
*BLAKE2b אופטימלי למעבדי 64 ביט ומעבדי [[ARM]] המייצר תמצית באורך של עד 64 בתים.
*BLAKE2s אופטימלי למעבדי 8 או 32 ביט המייצר תמצית באורך של עד 32 בתים.
שניהם מספיק פורטביליים ומתאימים לכל מעבד אך מותאמים במיוחד להשגת ביצועים טובים על פלטפורמות ספציפיות.

===ההבדלים בין BLAKE2 ל-BLAKE===
#'''פחות סבבים'''. הפונקציה הפנימית של BLAKE2s מבצועת רק 10 פעמים והפונקציה הפנימית של BLAKE2b מבוצעת רק 12 פעמים. הסיבה שבגרסאות הקודמות הוצע מספר סבבים גדול יותר (14 ו-16 בהתאמה) נבע רק מהרצון להיות שמרניים ולספק שולי ביטחון גבוהים ולא בגלל קריפטואנליזה מוצקה. השינוי הזה מהותי ומניב שיפור של בין 25 ל-29 אחוז בביצועים בעיקר על קלטים ארוכים לעומת הגרסאות הקודמות ואין סימנים המעידים שביטחון הפונקציה נחלש עקב כך.
#'''הזזות אופטימליות לצורך מהירות'''. הפונקציה הפנימית מבצעת הזזה מעגלית לשמאל בהיסטים הקבועים: 24, 11, 63. השינוי של ההזזה הראשונה מ-25 ל-24 נובע מסיבות טכניות כי נדרשות פחות [[פקודה (מחשב)|הוראות מעבד]]. השינוי מ-64 ל-63 מוסיף גם הוא במהירות במיוחד שאפשר לראות בהזזה זו כהזזה אחת ימינה במקום 63 שמאלה שהן למעשה שקולות על משתנה 64 סיביות ולכן עשויה להיות מהירה יותר.
#'''ריפוד מינימלי'''. הריפוד שונה כך שרק אם יש צורך מוסיפים בתים ריקים לסוף המסר. אם אורך הקלט מתחלק באורך הבלוק, לא מבוצע ריפוד כלל. כדי למנוע נקודות תורפה בעקבות השינוי (כי כעת אפשר לבצע התקפות מסוימות שמנצלות את העובדה שהמסר יכול להיות חלק ממסר אחר ארוך יותר), מוחלף כלל הריפוד בשני "דגלי סיום" <math>f_0</math> ו-<math>f_1</math> הנמצאים בבלוק הראשון. כאשר <math>f_0=0</math> עבור כל הבלוקים למעט האחרון שאז <math>f_0=1</math>. הדגל <math>f_1</math> נועד לאותת על הצומת האחרון בעץ הגיבוב במקרה של גיבוב בצורת עץ, כאשר מגיעים לבלוק האחרון <math>f_1=f_0</math>.
#'''פחות קבועים'''. BLAKE2 עושה שימוש בשמונה קבועים בלבד. שינוי זה חוסך ב-128 בתים הן ב-RAM והן ב-ROM ב-BLAKE2b ו-64 בתים ב-BLAKE2s.
#'''סדר בתים קטן'''. BLAKE2 מפרשת את הקלט לפי סדר בתים קטן כמו MD5 ולא כמו ב-SHA-3 זאת מפני שפלטפורמות רבות פועלות לפי סדר בתים קטן, בעיקר [[AMD]] ו[[אינטל]].
#'''מונה בתים ולא סיביות'''. המונה סופר את בתי המסר ולא סיביות המסר, הסיבה לכך טכנית היא מפשטת את היישום ומונעת באגים.
#'''הגיוון מעובד רק פעם אחת'''. בניגוד לקודמה BLAKE2 טוענת את ה-Salt רק פעם אחת בתחילת הגיבוב כמו וקטור אתחול במקום כקלט לפונקציית הדחיסה בכל סבב. עובדה שחוסכת מעט פעולות ומעט זיכרון. פונקציית דחיסה נטולת Salt מפחיתה בביטחון האלגוריתם באופן שולי.
#'''תוספת בלוק פרמטרים'''. כדי להתאים את BLAKE2 לשימוש ב-Salt מבלי הצורך להכניסו לפונקציית הדחיסה, נוסף "בלוק פרמטרים" או "בלוק קונפיגורציה" שמחובר תחילה ב-XOR עם ה-IV ומעובד ראשון. בתוך בלוק הפרמטרים מקודדים את כל הפרמטרים החיוניים לפעולת הפונקציה בתצורה הנדרשת; כגון Salt, מפתח הצפנה אם קיים, תמיכה בתצורת גיבוב עץ, אורך תמצית המסר, פרסונליזציה וכדומה.

אתחול פונקציית הדחיסה שונה בהתאם:
<center>
<math>\begin{pmatrix} v_0 & v_1 & v_2 & v_3 \\ v_4 & v_5 & v_6 & v_7 \\ v_8 & v_9 & v_{10} & v_{11} \\ v_{12} & v_{13} & v_{14} & v_{15} \end{pmatrix}\longleftarrow \begin{pmatrix} h_0 & h_1 & h_2 & h_3 \\ h_4 & h_5 & h_6 & h_7 \\ IV_0 & IV_1 & IV_2 & IV_3 \\ t_0 \oplus IV_4 & t_1 \oplus IV_5 & f_0 \oplus IV_6 & f_1 \oplus IV_7 \end{pmatrix}</math>
</center>
כאן בניגוד לגרסאות הקודמות נוספו הדגלים <math>f_0</math> ו-<math>f_1</math> בשתי הכניסות האחרונות במקום המונה <math>t</math> שהיה מיותר. שני הדגלים מתפקדים כמונה ומסייעים גם להחליף את פונקציית הריפוד, כך שהמסר אינו מתרחב.

הפונקציה הפנימית <math>G</math> של BLAKE2b (משמאל) ו-BLAKE2s מוצגת להלן:
<center>
{| dir="ltr"
|-
| 
<math>\boldsymbol{G_i(a,b,c,d)}</math>
:<math>a\leftarrow a + b + m_{\sigma_r(2i)}</math>
:<math>d\leftarrow (d\oplus a) \ggg 32</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b\oplus c) \ggg 24</math>
:<math>a\leftarrow a + b + m_{\sigma_r(2i+1)}</math>
:<math>d\leftarrow (d\oplus a) \ggg 16</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b\oplus c) \ggg 63</math>
|| 
<math>\boldsymbol{G_i(a,b,c,d)}</math>
:<math>a\leftarrow a + b + m_{\sigma_r(2i)}</math>
:<math>d\leftarrow (d\oplus a) \ggg 16</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b\oplus c) \ggg 12</math>
:<math>a\leftarrow a + b + m_{\sigma_r(2i+1)}</math>
:<math>d\leftarrow (d\oplus a) \ggg 8</math>
:<math>c\leftarrow c + d</math>
:<math>b\leftarrow (b\oplus c) \ggg 7</math>
|}
</center>

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

====בלוק פרמטרים====
בלוק הפרמטרים מכיל 32 בתים עבור BLAKE2s ו-50 בתים עבור BLAKE2b המחולקים למקטעים המייצגים את הנתונים הבאים:
*'''אורך התמצית בבתים''' (עד 32 בתים במקרה של BLAKE2s ועד 64 בתים במקרה של BLAKE2b).
*'''אורך מפתח הצפנה בבתים'''. בית אחד בטווח <math>[0, 255]</math> (נקבע ל-0 אם אין מפתח).
*'''Salt'''. מערך של 8 בתים אקראיים עבור BLAKE2s ו-16 בתים עבור BLAKE2b.
*'''פרסונליזציה'''. 8 או 16 בתים בהתאמה של פרטים ייחודיים למשתמש (יכול להיות ריק).
פרמטרים המתאימים לשימוש בתצורת עץ (אם לא משתמשים במצב עץ מאפסים את כל השדות):
*'''דרגת העץ''' (Fanout). בית אחד בטווח <math>[0, 255]</math> (הערך 0 מייצג רוחב בלתי מוגבל). 
*'''עומק העץ'''. בית אחד בטווח <math>[0, 255]</math>. (הערך 255 מייצג עומק בלתי מוגבל).
*'''אורך עלה בבתים'''. 4 בתים המייצגים מספר שלם בטווח <math>[0, 2^{32}-1]</math>.
*'''אופסט הצומת'''. 6 או 8 בתים המייצגים מספר שלם בטווח <math>[0, 2^{48}-1]</math> או <math>[0, 2^{64}-1]</math> במקרה של BLAKE2b. נקבע ל-0 במקרים הבאים: בעלים, בצומת הראשון, בצומת השמאלי ביותר או במצב סדרתי (לא בתצורת עץ).
*'''גובה הצומת'''. בית אחד המייצג מספר שלם בטווח <math>[0, 255]</math>. רלוונטי רק בתצורת עץ ושווה 0 בעלים.
*'''אורך הגיבוב הפנימי בבתים'''. בית שלם המייצג מספר בטווח <math>[0, 32]</math> או <math>[0, 64]</math> בהתאמה.

יתר הבתים הפנויים שמורים לשימוש עתידי. ערכים המתפרשים על פני מספר בתים נחשבים למספר שלם לפי סדר בתים קטן.
{|
|-
|
'''טבלת חלוקת בתים בבלוק הקונפיגורציה של BLAKE2b''':
{| class="wikitable"
|- align="center"
! אופסט בבתים !! 0 !! 1 !! 2 !! 3
|- align="center"
| 0 || אורך התמצית || אורך המפתח || רוחב העץ || עומק העץ
|- align="center"
| 4 || colspan="4" | אורך עלה
|- align="center"
| 8...12 || colspan="4" | אופסט צומת
|- align="center"
| 16 || עומק הצומת || אורך פנימי || colspan="2" | שמור לשימוש עתידי
|- align="center"
| 20 ... 28 || colspan="4" | שמור לשימוש עתידי
|- align="center"
| 32 ... 44 || colspan="4" | Salt
|- align="center"
| 48 ... 60 || colspan="4" | פרסונליזציה
|}
| width="20px;" | 
|
'''טבלת חלוקת בתים בבלוק הקונפיגורציה של BLAKE2s''':
{| class="wikitable"
|- align="center"
! אופסט בבתים !! 0 !! 1 !! 2 !! 3
|- align="center"
| 0 || אורך התמצית || אורך המפתח || רוחב העץ || עומק העץ
|- align="center"
| 4 || colspan="4" | אורך עלה
|- align="center"
| 8 || colspan="4" | אופסט צומת
|- align="center"
| 12 || colspan="2" | אופסט צומת (המשך) || עומק הצומת || אורך פנימי
|- align="center"
| 16 ... 20 || colspan="4" | Salt
|- align="center"
| 24 ... 28 || colspan="4" | פרסונליזציה
|- align="center"
| colspan="5" | {{D}}
|}
|}

למשל אם הקונפיגורציה כוללת אורך תמצית 64 בתים (40 בייצוג [[בסיס הקסדצימלי|הקסדצימלי]]) והיא כוללת מפתח הצפנה באורך 32 בתים (20 בייצוג הקסדיצמלי), גיוון (Salt) - מחרוזת המכילה את הספרה "5" בסך הכול 32 פעמים ופרסונליזציה המכילה את האות "e" בסך הכול 32 פעמים. כאמור היות שהתצורה אינה במבנה עץ רוחב ועומק שווים 1 וכל יתר הפרמטרים 0. הבלוק ייראה כך:
{|
|-
| <syntaxhighlight lang="text">
40200101 00000000 00000000 00000000 00000000 00000000 00000000 00000000
55555555 55555555 55555555 55555555 eeeeeeee eeeeeeee eeeeeeee eeeeeeee
</syntaxhighlight>
|}

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

====עץ גיבוב====
גיבוב בתצורת עץ מתאים במיוחד לגיבוב קבצים גדולים או מדיית אחסון גדולה ואפשרי בכמה דרכים. זה יכול להיות [[עץ בינארי]] מאוזן, עץ טרינארי, עץ בעומק משתנה או בעומק קבוע. המנגנון העיקרי הוא כדלהלן. עץ הגיבוב מעבד נתחים של מידע באורך המוגדר על ידי השדה "אורך העלה" המופיע בבלוק הפרמטרים. כל נתח מעובד בנפרד וללא תלות באחרים, מה שמאפשר לבצע את הגיבוב באופן מקבילי על ליבות שונות או ב[[תהליכון|תהליכונים]] שונים. לאחר מכן כל התוצאות נאספות לנתח חדש שמוזן שוב לפונקציית הגיבוב כאשר כל עלה מקבל כקלט שרשור של גיבובים לפי השדה "דרגת העץ". השדות אופסט הצומת וגובה הצומת מבטיחים שכל קריאה לפונקציית הגיבוב מקבלת קלט שונה ולכן תתקבל תוצאה אחרת ללא תלות במידע עצמו. דגל הסיום <math>f_1</math> מאותת כאשר מבצעים את הקריאה האחרונה בגובה נתון ביחס לאופסט הן של העלים והן של הצמתים. <math>f_1=1</math> רק בבלוק האחרון של כל קריאה לפונקציית הגיבוב, כך שבשורש העץ תמיד <math>f_1=1</math>.

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

====קוד לדוגמה====
להלן קוד שלם בשפת [[סי שארפ|C#]]{{D}} של פונקציית הגיבוב BLAKE2B-512 בתצורה רגילה לפי המלצת המפתחים בעמוד הבית של BLAKE{{הערה|[https://github.com/BLAKE2/BLAKE2/tree/master/csharp BLAKE2b]}}. לאחר מימוש המחלקה יש להשתמש בשלוש הפונקציות Initialize,{{כ}} HashCore ו-HashFinal. תחילה קוראים לפונקציה Initialize שצריכה לקבל כארגומנט את בלוק הפרמטרים המתואר לעיל שהוא מערך של 8 מילים באורך 64 ביט. הפונקציה המייצרת את בלוק הקונפיגורציה לא הובאה כאן מפאת חוסר מקום. לצורך הבדיקה אפשר להשתמש בערך [[ברירת מחדל|ברירת המחדל]] שהוא <math>\text{0x1010040}</math> בכניסה הראשונה, כל היתר אפסים. הפונקציה HashCore מקבלת את המידע לגיבוב ו-HashFinal מחזירה את תמצית המידע.
<syntaxhighlight lang="CSHARP">
class Blake2B
{
   ulong _counter0;
   ulong _counter1;
   ulong _finalizationFlag0;
   ulong _finalizationFlag1;
   int _bufferFilled = 0;
   byte[] _buf = new byte[128];
   ulong[] _m = new ulong[16];
   ulong[] _h = new ulong[8];
   ulong[] _v = new ulong[16];

   const ulong IV0 = 0x6A09E667F3BCC908UL;
   const ulong IV1 = 0xBB67AE8584CAA73BUL;
   const ulong IV2 = 0x3C6EF372FE94F82BUL;
   const ulong IV3 = 0xA54FF53A5F1D36F1UL;
   const ulong IV4 = 0x510E527FADE682D1UL;
   const ulong IV5 = 0x9B05688C2B3E6C1FUL;
   const ulong IV6 = 0x1F83D9ABFB41BD6BUL;
   const ulong IV7 = 0x5BE0CD19137E2179UL;

   private static readonly int[] Sigma = new int[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
   };

   ulong BytesToUInt64(byte[] buf, int offset)
   {
     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]));
   }

   void UInt64ToBytes(ulong value, byte[] buf, int offset)
   {
     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;
   }

   ulong RotateRight(ulong value, int nBits)
   {
     return (value >> nBits) | (value << (64 - nBits));
   }
 
   void G(int a, int b, int c, int d, int r, int i)
   {
     int p = (r << 4) + i;
     int p0 = Sigma[p];
     int p1 = Sigma[p + 1];
     var v = _v;
     var m = _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);
   }

   void Compress(byte[] block, int start)
   {
     var v = _v;
     var h = _h;
     var m = _m;

     for (int i = 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 (int r = 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 (int i = 0; i < 8; ++i)
       h[i] ^= v[i] ^ v[i + 8];
   }

   public void Initialize(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 (int i = 0; i < 8; i++)
       _h[i] ^= config[i];
   }

   public void HashCore(byte[] array, int start, int count)
   {
     int offset = start;
     int bufferRemaining = 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;
     }
   }

   public byte[] HashFinal()
   {
     _counter0 += (uint)_bufferFilled;
     _finalizationFlag0 = ulong.MaxValue;
     for (int i = _bufferFilled; i < _buf.Length; i++)
       _buf[i] = 0;
     Compress(_buf, 0);

     byte[] hash = new byte[64];
     for (int i = 0; i < 8; ++i)
       UInt64ToBytes(_h[i], hash, i << 3);
     return hash;
   }
}
</syntaxhighlight>

====וקטור בדיקה====
<syntaxhighlight lang="text">
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
</syntaxhighlight>

==ראו גם==
* [[SHA-3]]

==הערות שוליים==
{{הערות שוליים|יישור=שמאל}}

{{קריפטוגרפיה}}


[[קטגוריה:פונקציות גיבוב קריפטוגרפיות]]