sha256

chaos | entropie | generátor | hash | mmBIP32-84 | 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í).


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:
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í:

3. Nastavení konstant:

4. Zpracování bloků:

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).

Ma: Funkce maj(x, y, z)

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

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)

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:

6. Konečný 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)

.:.