Хеширане — какво е това, криптографски алгоритми и приложение

Какво е хеширане?

Хеширането — процес на изчисляване на хеш функция, която преобразува произволен набор от входни данни в битов низ с фиксирана дължина, наричан дайджест или хеш стойност. За разлика от криптирането, хеширането е еднопосочен процес: възстановяването на оригиналните данни от хеша е невъзможно.

Основни свойства на хеш функциите

Криптографските хеш функции имат четири задължителни свойства: детерминизъм (еднакъв вход винаги дава еднакъв хеш), необратимост (изчислително е невъзможно да се възстанови входът от хеша), лавинен ефект (промяната на един бит на входа променя средно половината от битовете на хеша) и устойчивост на колизии (изчислително е невъзможно да се намерят два различни входа с еднакъв хеш).

Разлика между хеширане и криптиране

Важно е да се разбере разликата между хеширане и криптиране. Криптирането е двупосочен процес: криптираните данни могат да бъдат декриптирани с помощта на ключ. Хеширането е еднопосочен процес: след преобразуване данните не могат да бъдат възстановени. Това свойство прави хеширането идеално за съхранение на пароли: системата съхранява само хеша, а дори при изтичане на базата данни паролите остават защитени.

Криптографски и некриптографски хеш функции

Не всички хеш функции са еднакво подходящи за задачи по сигурността. Разделянето на криптографски и некриптографски категории е критично важно при избора на алгоритъм за конкретна задача в мобилната разработка.

Криптографски хеш функции

Тези функции са умишлено бавни и сложни, за да затруднят атаките с груба сила. Те трябва да бъдат устойчиви на колизии и атаки върху прообраза. Семейството SHA-2 (SHA-224, SHA-256, SHA-384, SHA-512) е сертифицирано от NIST и се препоръчва за използване в държавни системи. За хеширане на пароли допълнително се прилагат алгоритмите bcrypt, scrypt и Argon2 с настройваема сложност.

Некриптографски хеш функции

Тези функции са оптимизирани за скорост, а не за сигурност. Примери: CityHash, MurmurHash, xxHash. Те се използват в хеш таблици, дедупликация на данни и контролни суми за бърза проверка на целостта на некритични данни. Важно е никога да не ги използвате за съхранение на пароли или проверка на цифрови подписи — високата скорост ги прави уязвими на атаки с груба сила.

Популярни алгоритми за хеширане

Нека разгледаме най-често използваните алгоритми за хеширане в съвременната мобилна разработка. Всеки от тях има своите силни и слаби страни.

SHA-256

SHA-256 — символ на съвременната криптография, препоръчан от NIST в рамките на стандарта FIPS 180-4. Алгоритъмът създава 256-битов дайджест и е основен компонент на TLS протоколите, блокчейн мрежите и системите за контрол на версиите. Според доклада на NCC Group (2025), SHA-256 се използва в 96% от TLS сертификатите за подписване на certificate transparency.

SHA-3 — наследник на SHA-2

SHA-3 — най-новото семейство хеш функции, стандартизирано от NIST през 2015 г. като FIPS 202. За разлика от SHA-2, изграден върху структурата на Merkle–Damgård, SHA-3 се основава на различна конструкция Keccak с гъбена функция. Това прави SHA-3 устойчив на атаки, които могат да се появят в бъдеще върху SHA-2. За мобилни разработчици SHA-3 е достъпен чрез стандартни криптографски библиотеки, започвайки от Android 7.0 и 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 за пароли

За съхранение на пароли общите криптографски хешове не са достатъчни — те са твърде бързи. bcrypt е специално проектиран за хеширане на пароли: включва сол и параметър на разходите, който регулира времето за изчисление. Увеличаването на разходите 2 пъти удвоява времето за хеширане, което прави атаките с груба сила неефективни дори на мощно оборудване.

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 — съвременен стандарт

Argon2 — победител в Password Hashing Competition (2015), препоръчан от OWASP като най-добър избор за хеширане на пароли. Argon2id — вариант, устойчив на атаки по странични канали и атаки time-memory trade-off. За разлика от bcrypt, Argon2 позволява отделно конфигуриране на времето за изпълнение, използването на памет и степента на паралелизъм, което осигурява гъвкава защита срещу различни видове атаки.

Приложение на хеширането в мобилни приложения

Хеширането решава много практически задачи в мобилната разработка — от удостоверяване на потребители до проверка на целостта на изтеглени файлове. Нека разгледаме ключовите сценарии за използване.

Съхранение на пароли

Основният сценарий — сигурно съхранение на пароли от страна на сървъра. При регистрация приложението изпраща паролата на сървъра, където тя се хешира със сол с алгоритъм bcrypt или Argon2 и се съхранява в базата данни. При влизане сървърът хешира въведената парола и я сравнява със съхранения хеш. OWASP препоръчва използването на Argon2id с параметри: време 2 секунди, памет 64 MB, степен на паралелизъм 4.

Проверка на целостта на файлове

При изтегляне на големи файлове, като OBB пакети или актуализации на съдържание, мобилните приложения могат да проверяват тяхната цялост чрез хеширане. Сървърът публикува SHA-256 хеша на файла, а приложението изчислява хеша на изтеглените данни и ги сравнява. Това гарантира, че файлът не е бил повреден или заменен по време на предаване. Според Google Play Console (2025), проверката на хешове на сертифицирани приложения предотвратява до 99,9% от атаките с повредени изтегляния.

Кеширане и дедупликация

Хешовете се използват активно за изграждане на ефективни кешове и дедупликация на данни. Адресът на изображение или JSON отговор се хешира и се използва като ключ за кеш: при повторна заявка системата сравнява хешовете и връща съхранения резултат, ако данните не са се променили. За тази задача са подходящи некриптографски хеш функции, като MurmurHash или xxHash, които осигуряват максимална производителност.

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
}

Типични грешки при използване на хешове

Дори опитни разработчици правят грешки, когато работят с хеширане. Нека разгледаме най-честите проблеми, които могат да анулират всички предимства на криптографската защита.

Използване на MD5 или SHA-1

MD5 и SHA-1 — остарели алгоритми, за които съществуват практически атаки за колизии. MD5 беше разбит през 2004 г. от група китайски изследователи (колизия за час). SHA-1 беше разбит през 2017 г. от екипа на Google и Centrum Wiskunde & Informatica (атака SHAttered). Използването на тези алгоритми в нови проекти се счита за груба грешка в сигурността според класификацията на OWASP.

Хеширане без сол

Хеширането на пароли без сол — критична уязвимост. Солта е случаен низ, уникален за всеки потребител, който се добавя към паролата преди хеширане. Без сол две идентични пароли ще дадат еднакъв хеш, което позволява използването на дъгови таблици за атака с груба сила. OWASP препоръчва използването на криптографски силна сол с дължина най-малко 32 байта, генерирана отделно за всеки потребител.

Недостатъчен брой итерации

Дори при използване на bcrypt или Argon2, защитата може да бъде отслабена чрез избор на твърде нисък параметър на разходите. Според OWASP (2025), минималният брой итерации на bcrypt трябва да бъде 10 (2^10 = 1024 итерации), а за Argon2id — време за изчисление най-малко 1 секунда на целевата платформа. Твърде ниските параметри правят атаките с груба сила практически осъществими на GPU ферми.