sha256

chaos | entropie | generátor | hash | mmBIP32-84 | adresy | transakce | blockchain | halving |

---

SHA-256 je jednoznačně deterministická hashovací (hašovací) funkce, která přijímá libovolně velká data jako vstup a produkuje 256bitový výstup. Tato funkce je navržena tak, aby byla velmi rychlá i při zpracování velkých objemů dat. Z principu není možné najít inverzní funkci, což znamená, že není možné zpětně rekonstruovat původní data z hash hodnoty.
SHA-256 slouží jako digitální otisk, který je využíván pro zajištění integrity dat a jejich autentizaci v mnoha kryptografických aplikacích.
Pokud se na vstupu změní jediný bit, hashovací funkce budu zcela jiná, než před změnou. Vstup může být libovolně velký, výstupem je vždy „pouze“ 256 bitů (s poměrně velkou entropí).

HMAC „varianta využití“: https://en.wikipedia.org/wiki/HMAC hash-based message authentication code.

SHA-256 (součást rodiny SHA-2) je komplexní algoritmus pro kryptografické hashování, který se skládá z několika kroků a operací.
Zde je přehled hlavních operací a fází, které se provádějí v SHA-256:

1. Inicializace:
   • SHA-256 používá několik „polí konstant“ – prvních osm 32bitových slov (h0 až h7) jako počáteční hodnoty. Tyto hodnoty jsou odvozeny z prvních 32 bitů zlomkových částí druhých odmocnin prvních osmi prvočísel.

import math

def compute_initial_hash_values(primes):
    def fractional_part_of_sqrt(n):
        sqrt_value = math.sqrt(n)
        fractional_part = sqrt_value - math.floor(sqrt_value)
        return fractional_part
    
    def first_32_bits_of_fractional_part(n):
        fractional_part = fractional_part_of_sqrt(n)
        return int(fractional_part * (2 ** 32))
    
    initial_hash_values = [first_32_bits_of_fractional_part(p) for p in primes]
    return initial_hash_values

# Prvních osm prvočísel
primes = [2, 3, 5, 7, 11, 13, 17, 19]

# Výpočet počátečních hodnot
initial_hash_values = compute_initial_hash_values(primes)

# Výpis počátečních hodnot v hexadecimálním formátu
for i, h in enumerate(initial_hash_values):
    print(f"h{i}: {h:08x}")

2. Předzpracování:

• Původní zpráva se rozdělí na bloky o délce 512 bitů. Pokud délka zprávy není násobkem 512, je nutné provést padding.
• Padding se provádí přidáním bitu 1 na konec zprávy, následovaným potřebným počtem bitů 0, a nakonec 64bitovou reprezentací délky původní zprávy.

3. Nastavení konstant:

• SHA-256 dále používá 64 konstant (k0 až k63) odvozených z prvních 32 bitů zlomkových částí třetích odmocnin prvních 64 prvočísel.

4. Zpracování bloků:

• Každý 512bitový blok zprávy se rozdělí na 16 32bitových slov. (16×32=512)
• Z těchto slov se vytvoří 64 slov pomocí specifických bitových operací a posunů.

V algoritmu SHA-256 (část rodiny SHA-2) osm bloků označených jako A až H představuje osm pracovních proměnných, které se používají během hashovacího procesu. Tyto proměnné jsou inicializovány počátečními hodnotami a jsou průběžně aktualizovány v každém z 64 kroků kompresní smyčky.

Počáteční hodnoty (Initial Hash Values)

Osm pracovních proměnných je inicializováno následujícími hodnotami, které jsou odvozeny z prvních 32 bitů zlomkových částí druhých odmocnin prvních osmi prvočísel (kód uveden výše):

1. A = h0 = 0x6a09e667
2. B = h1 = 0xbb67ae85
3. C = h2 = 0x3c6ef372
4. D = h3 = 0xa54ff53a
5. E = h4 = 0x510e527f
6. F = h5 = 0x9b05688c
7. G = h6 = 0x1f83d9ab
8. H = h7 = 0x5be0cd19

Průběh hashovacího procesu

Během zpracování každého 512bitového bloku zprávy jsou tyto pracovní proměnné A až H aktualizovány prostřednictvím 64 kroků kompresní smyčky. Každý krok používá specifické bitové operace, konstanty a části zprávy k aktualizaci těchto proměnných.

Funkce ror(x, y)

def ror(x, y): return ((x >> y) | (x << (32 - y))) & 0xFFFFFFFF

Popis: Tato funkce provádí bitovou rotaci doprava (right rotate).

• Jak funguje:
  x >> y: Posune bity v x doprava o y míst.
  x << (32 - y): Posune bity v x doleva o (32 - y) míst.
  |: Kombinuje výsledky obou operací pomocí bitového OR.
  & 0xFFFFFFFF: Omezí výsledek na 32 bitů.

Ma: Funkce maj(x, y, z)

def maj(x, y, z): return (x & y) ^ (x & z) ^ (y & z)

• Popis: Tato funkce implementuje bitovou majoritu (majority function).
• Jak funguje:
  1. (x & y): Bitově AND mezi x a y.
  2. (x & z): Bitově AND mezi x a z.
  3. (y & z): Bitově AND mezi y a z.
  4. ^: XOR mezi výsledky předchozích AND operací.

Funkce maj vrací bitový výsledek, kde každý bit je většinovým bitem mezi odpovídajícími bity x, y a z.

Ch: Funkce ch(x, y, z)

def ch(x, y, z): return (x & y) ^ ((~x) & z)

• Popis: Tato funkce implementuje bitovou volbu (choose function).
• Jak funguje:
  1. (x & y): Bitově AND mezi x a y.
  2. (~x & z): Bitově AND mezi negovaným x a z.
  3. ^: XOR mezi výsledky předchozích operací.

Funkce ch vrací bitový výsledek, kde každý bit je vybrán z y nebo z v závislosti na odpovídajícím bitu x.

5. Iterace hlavního cyklu:

• Pro každý blok se provede 64 kol hlavního cyklu. V každém kole se používají různé bitové operace, včetně rotací, posunů a logických operací AND, OR a XOR.
• Výsledky těchto operací se kombinují s předchozími hodnotami proměnných a konstantami.

6. Konečný hash:

• Po zpracování všech bloků se spojí osm pracovních proměnných, aby se vytvořil konečný 256bitový hash.
  

---

Kolik možností nám dává 256 bitů?

.
..
…

---

Python implementace SHA256, pro „porozumění“, jak to funguje
https://github.com/agama-point/agama_point_crypto/blob/main/crypto_agama/sha256py.py
.:.
Hash hraje důležitou roli i v komunikačním protokoluSSL/TLS (Secure Sockets Layer/Transport Layer Security)

Tabulka bezpečnosti a odhalených „kolizí“: https://valerieaurora.org/hash.html
https://developer.bitcoin.org/devguide/mining.html

---

github example:
https://github.com/agama-point/agama_point_crypto/blob/main/explanation%20_sha.py

Kryptografická hašovací funkce (Wiki)

.:.

…

…

---