Hashning — vad är det, kryptografiska algoritmer och tillämpning

Vad är hashning?

Hashning — processen att beräkna en hashfunktion som omvandlar en godtycklig uppsättning indata till en bitsträng med fast längd, kallad digest eller hashvärde. Till skillnad från kryptering är hashning en envägsprocess: det är omöjligt att återställa originaldata från hashen.

Grundläggande egenskaper hos hashfunktioner

Kryptografiska hashfunktioner har fyra obligatoriska egenskaper: determinism (samma indata ger alltid samma hash), oåterkallelighet (det är beräkningsmässigt omöjligt att återställa indata från hashen), lavineffekt (ändring av en bit i indata ändrar i genomsnitt hälften av hashbitarna) och kollisionsresistens (det är beräkningsmässigt omöjligt att hitta två olika indata med samma hash).

Skillnad mellan hashning och kryptering

Det är viktigt att förstå skillnaden mellan hashning och kryptering. Kryptering är en tvåvägsprocess: krypterade data kan dekrypteras med en nyckel. Hashning är en envägsprocess: efter omvandling kan data inte återställas. Denna egenskap gör hashning idealisk för lagring av lösenord: systemet lagrar endast hashen, och även vid databasläckage förblir lösenorden skyddade.

Kryptografiska och icke-kryptografiska hashfunktioner

Alla hashfunktioner är inte lika lämpliga för säkerhetsuppgifter. Indelningen i kryptografiska och icke-kryptografiska kategorier är kritisk när man väljer en algoritm för en specifik uppgift inom mobil utveckling.

Kryptografiska hashfunktioner

Dessa funktioner är avsiktligt långsamma och komplexa för att försvåra brute-force-attacker. De måste vara resistenta mot kollisioner och preimage-attacker. Familien SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512) är certifierad av NIST och rekommenderas för användning i statliga system. För hashning av lösenord används dessutom algoritmerna bcrypt, scrypt och Argon2 med justerbar komplexitet.

Icke-kryptografiska hashfunktioner

Dessa funktioner är optimerade för hastighet, inte för säkerhet. Exempel: CityHash, MurmurHash, xxHash. De används i hashtabeller, datadeduplicering och kontrollsummor för snabb integritetskontroll av icke-kritisk data. Det är viktigt att aldrig använda dem för lagring av lösenord eller verifiering av digitala signaturer — hög hastighet gör dem sårbara för brute-force-attacker.

Populära hash-algoritmer

Låt oss titta på de vanligaste hash-algoritmerna som används inom modern mobil utveckling. Var och en har sina styrkor och svagheter.

SHA-256

SHA-256 — en symbol för modern kryptografi, rekommenderad av NIST inom ramen för standarden FIPS 180-4. Algoritmen producerar en 256-bitars digest och är huvudkomponenten i TLS-protokoll, blockkedjenätverk och versionshanteringssystem. Enligt NCC Group (2025) används SHA-256 i 96 % av TLS-certifikaten för att signera certificate transparency.

SHA-3 — efterföljare till SHA-2

SHA-3 — den senaste familjen hashfunktioner, standardiserad av NIST 2015 som FIPS 202. Till skillnad från SHA-2, som är byggd på Merkle–Damgård-strukturen, är SHA-3 baserad på en annorlunda Keccak-konstruktion med svampfunktion. Detta gör SHA-3 resistent mot attacker som kan uppstå i framtiden på SHA-2. För mobilutvecklare är SHA-3 tillgänglig via standardkryptografiska bibliotek från och med Android 7.0 och iOS 13.

import java.security.MessageDigest

fun hashWithSHA256(input: String): String {
    val digest = MessageDigest.getInstance("SHA-256")
    val hashBytes = digest.digest(input.toByteArray())
    return hashBytes.joinToString("") { String.format("%02x", it) }
}

bcrypt för lösenord

För lagring av lösenord räcker inte allmänna kryptografiska hash — de är för snabba. bcrypt är speciellt utformat för hashning av lösenord: det innehåller salt och en kostnadsparameter som reglerar beräkningstiden. En ökning av kostnaden med 2 gånger fördubblar hashningstiden, vilket gör brute-force-attacker ineffektiva även på kraftfull hårdvara.

import at.favre.lib.crypto.bcrypt.BCrypt

fun hashPassword(password: String): String {
    return BCrypt.create()
        .hashToString(BCrypt.MIN_COST, password.toCharArray())
}

fun verifyPassword(password: String, hash: String): Boolean {
    val result = BCrypt.verifyer().verify(password.toCharArray(), hash)
    return result.verified
}

Argon2 — modern standard

Argon2 — vinnare av Password Hashing Competition (2015), rekommenderad av OWASP som det bästa valet för hashning av lösenord. Argon2id — variant som är resistent mot sidokanalsattacker och time-memory trade-off-attacker. Till skillnad från bcrypt tillåter Argon2 separat konfiguration av exekveringstid, minnesanvändning och parallellismgrad, vilket ger flexibelt skydd mot olika typer av attacker.

Tillämpning av hashning i mobila appar

Hashning löser många praktiska uppgifter inom mobil utveckling — från användarautentisering till kontroll av integriteten hos nedladdade filer. Låt oss titta på de viktigaste användningsscenarierna.

Lagring av lösenord

Huvudscenariot — säker lagring av lösenord på serversidan. Vid registrering skickar appen lösenordet till servern, där det hashas med salt med bcrypt eller Argon2 och lagras i databasen. Vid inloggning hashar servern det angivna lösenordet och jämför det med den lagrade hashen. OWASP rekommenderar användning av Argon2id med parametrarna: tid 2 sekunder, minne 64 MB, parallellismgrad 4.

Kontroll av filintegritet

Vid nedladdning av stora filer, såsom OBB-paket eller innehållsuppdateringar, kan mobila appar kontrollera deras integritet genom hashning. Servern publicerar SHA-256-hashen av filen, och appen beräknar hashen av den nedladdade datan och jämför dem. Detta garanterar att filen inte har skadats eller bytts ut under överföringen. Enligt Google Play Console (2025) förebygger hashverifiering av certifierade appar upp till 99,9 % av attacker med skadade nedladdningar.

Cachning och deduplicering

Hashar används aktivt för att bygga effektiva cacheminnen och datadeduplicering. En bilds adress eller JSON-svar hashas och används som cache-nyckel: vid en upprepad begäran jämför systemet hasharna och returnerar det lagrade resultatet om datan inte har ändrats. För denna uppgift är icke-kryptografiska hashfunktioner som MurmurHash eller xxHash lämpliga, vilka ger maximal prestanda.

import java.security.MessageDigest

fun calculateFileHash(fileBytes: ByteArray): String {
    val digest = MessageDigest.getInstance("SHA-256")
    val hash = digest.digest(fileBytes)
    return hash.joinToString("") { String.format("%02x", it) }
}

fun verifyIntegrity(data: ByteArray, expectedHash: String): Boolean {
    val actualHash = calculateFileHash(data)
    return actualHash == expectedHash
}

Vanliga misstag vid användning av hash

Även erfarna utvecklare gör misstag när de arbetar med hashning. Låt oss titta på de vanligaste problemen som kan upphäva alla fördelar med kryptografiskt skydd.

Användning av MD5 eller SHA-1

MD5 och SHA-1 — föråldrade algoritmer för vilka det finns praktiska kollisionsattacker. MD5 knäcktes 2004 av en grupp kinesiska forskare (kollision inom en timme). SHA-1 knäcktes 2017 av teamet från Google och Centrum Wiskunde & Informatica (SHAttered-attacken). Användning av dessa algoritmer i nya projekt anses vara ett grovt säkerhetsfel enligt OWASP-klassificeringen.

Hashning utan salt

Hashning av lösenord utan salt — en kritisk sårbarhet. Salt är en slumpmässig sträng, unik för varje användare, som läggs till lösenordet före hashning. Utan salt ger två identiska lösenord samma hash, vilket möjliggör användning av regnbågstabeller för brute-force. OWASP rekommenderar användning av kryptografiskt starkt salt med en längd på minst 32 byte, genererat separat för varje användare.

Otillräckligt antal iterationer

Även vid användning av bcrypt eller Argon2 kan skyddet försvagas genom att välja en för låg kostnadsparameter. Enligt OWASP (2025) bör det minsta antalet bcrypt-iterationer vara 10 (2^10 = 1024 iterationer), och för Argon2id — beräkningstid på minst 1 sekund på målplattformen. För låga parametrar gör brute-force-attacker praktiskt genomförbara på GPU-farmer.