PHP предоставляет много криптографических возможностей: от встроенных функций хеширования до полноценных библиотек шифрования — арсенал средств довольно обширен. Но всё это бесполезно без понимания правильного применения.
Знаете ли вы, что недостаточно просто зашифровать данные? Без правильного управления ключами и понимания основных принципов криптографии, даже самые сложные алгоритмы могут оказаться бесполезными. Многие разработчики допускают фатальные ошибки при внедрении криптографических решений: используют устаревшие алгоритмы, неправильно генерируют ключи, игнорируют векторы инициализации. С выходом PHP 7.2 в стандартную библиотеку языка была включена поддержка libsodium — современной библиотеки, значительно упрощающей использование криптографических примитивов. Это революционное изменение открыло новую эру безопасности в экосистеме PHP, позволяя разработчикам использовать доказуемо надёжные методы защиты данных.
Основы криптографии в PHP
Криптография — это целая наука о защите информации через её преобразование. В контексте PHP-разработки нам понадобится четкое понимание таких понятий как хеширование, шифрование, генерация случайных чисел и работа с ключами.
Хеширование и его реализация
Хеширование — это преобразование данных произвольной длины в строку фиксированной длины. Важно понимать, что хеширование — необратимая операция. Вы не сможете получить исходные данные из хеша. Именно поэтому хеширование идеально подходит для хранения паролей. В PHP существует целый ряд функций для хеширования:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Использование md5 (устарело, не рекомендуется для паролей)
$md5Hash = md5("мой_пароль"); // 32-символьная строка
// Использование SHA-256 (лучше, но все еще недостаточно для паролей)
$shaHash = hash('sha256', "мой_пароль");
// Современный способ хеширования паролей
$passwordHash = password_hash("мой_пароль", PASSWORD_BCRYPT);
// Проверка пароля
if (password_verify("мой_пароль", $passwordHash)) {
echo "Пароль верный!";
} |
|
password_hash() и password_verify(), которые автоматически добавляют "соль" и применяют медленные алгоритмы типа Bcrypt.
Шифрование: симметричное и асимметричное
Шифрование, в отличие от хеширования, позволяет восстановить исходные данные. Существует два основных типа шифрования:
1. Симметричное шифрование — использует один и тот же ключ для шифрования и дешифрования. Быстрое, но требует безопасного обмена ключом.
2. Асимметричное шифрование — использует пару ключей: открытый (для шифрования) и закрытый (для дешифрования). Медленнее симметричного, но решает проблему передачи ключа.
В PHP симметричное шифрование можно реализовать с помощью функций OpenSSL:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
| $plaintext = "Секретное сообщение";
$cipher = "aes-256-cbc";
$key = openssl_random_pseudo_bytes(32); // 256 бит
$iv = openssl_random_pseudo_bytes(openssl_cipher_iv_length($cipher));
// Шифрование
$encrypted = openssl_encrypt($plaintext, $cipher, $key, 0, $iv);
// Дешифрование
$decrypted = openssl_decrypt($encrypted, $cipher, $key, 0, $iv);
echo $decrypted; // Выведет "Секретное сообщение" |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // Генерация пары ключей
$config = [
"digest_alg" => "sha512",
"private_key_bits" => 4096,
"private_key_type" => OPENSSL_KEYTYPE_RSA,
];
$res = openssl_pkey_new($config);
// Получение приватного ключа
openssl_pkey_export($res, $privateKey);
// Получение публичного ключа
$publicKey = openssl_pkey_get_details($res)["key"];
$data = "Данные для шифрования";
// Шифрование публичным ключом
openssl_public_encrypt($data, $encrypted, $publicKey);
// Дешифрование приватным ключом
openssl_private_decrypt($encrypted, $decrypted, $privateKey);
echo $decrypted; // Выведет "Данные для шифрования" |
|
Современные библиотеки и функции PHP
В PHP 7.2 и выше встроена поддержка библиотеки Sodium, которая предоставляет современные криптографические примитивы высокого уровня. Она значительно упрощает работу с криптографией и минимизирует риск ошибок при реализации:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
| // Шифрование с использованием Sodium
$message = "Сверхсекретные данные";
// Генерация ключа
$key = sodium_crypto_secretbox_keygen();
// Генерация nonce (аналог IV)
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
// Шифрование
$ciphertext = sodium_crypto_secretbox($message, $nonce, $key);
// Дешифрование
$plaintext = sodium_crypto_secretbox_open($ciphertext, $nonce, $key);
echo $plaintext; // Выведет "Сверхсекретные данные" |
|
Если вы работаете с PHP версии ниже 7.2, можно использовать библиотеку paragonie/sodium_compat, которая обеспечивает совместимость с более старыми версиями PHP:
| PHP | 1
2
3
4
| // Установка через Composer
// composer require paragonie/sodium_compat
// Теперь вы можете использовать функции Sodium даже на PHP 5.2.4+ |
|
Генерация криптографически стойких псевдослучайных чисел в PHP
Основа любой криптографической системы — это качественные случайные числа. Насколько бы хорошим ни был алгоритм шифрования, слабый генератор случайных чисел может все испортить. В отличие от обычных случайных чисел, криптографически стойкие случайные числа должны быть непредсказуемыми. До PHP 7 многие разработчики использовали функцию mt_rand() даже для криптографических целей. Это серьезная ошибка! Функция mt_rand() генерирует предсказуемые псевдослучайные числа по алгоритму Mersenne Twister, который НЕ предназначен для криптографии.
| PHP | 1
2
| // НЕ ИСПОЛЬЗУЙТЕ для криптографии!
$key = mt_rand(10000, 99999); // Это катастрофически небезопасно |
|
random_bytes(), появившуюся в PHP 7, или openssl_random_pseudo_bytes() для более старых версий:
| PHP | 1
2
3
4
5
6
7
8
| // Правильный способ генерации случайного ключа
try {
$key = random_bytes(32); // 256-битный ключ
$hexKey = bin2hex($key); // Преобразование в шестнадцатеричный формат для хранения
} catch (Exception $e) {
// Обработка ошибки
die("Не удалось сгенерировать случайное число: " . $e->getMessage());
} |
|
random_int():
| PHP | 1
2
3
4
5
6
| // Генерация случайного числа от 1 до 1000
try {
$number = random_int(1, 1000);
} catch (Exception $e) {
die("Не удалось сгенерировать случайное число: " . $e->getMessage());
} |
|
/dev/urandom (источник энтропии в Unix-системах). В таких случаях можно использовать обертку от paragonie/random_compat, которая эмулирует поведение random_bytes() и random_int() на старых версиях PHP:
| PHP | 1
2
| // composer require paragonie/random_compat
// Теперь функции random_bytes() и random_int() доступны даже в PHP 5.x |
|
| PHP | 1
2
3
4
5
6
7
| // Генерация ключевой пары Ed25519 с использованием Sodium
$seed = random_bytes(SODIUM_CRYPTO_SIGN_SEEDBYTES); // Генерация сида
$keyPair = sodium_crypto_sign_seed_keypair($seed); // Генерация ключевой пары из сида
// Извлечение публичного и приватного ключей
$privateKey = sodium_crypto_sign_secretkey($keyPair);
$publicKey = sodium_crypto_sign_publickey($keyPair); |
|
Сравнение времени выполнения: защита от атак по времени
Особое внимание стоит уделить сравнению хешей или зашифрованных данных. Классическое сравнение строк в PHP (== или ===) может быть уязвимо к атакам по времени (timing attacks). При таких атаках злоумышленник измеряет время, которое требуется для сравнения строк, и по этим данным может определить часть секретного значения. Для защиты от этого используйте функцию hash_equals(), появившуюся в PHP 5.6:
| PHP | 1
2
3
4
5
6
7
8
9
| $storedHash = 'e3b0c44298fc1c149afbf4c8996fb92427ae41e4649b934ca495991b7852b855';
$userInputHash = hash('sha256', $userInput);
// Безопасное сравнение хешей с защитой от атак по времени
if (hash_equals($storedHash, $userInputHash)) {
echo "Хеши совпадают!";
} else {
echo "Хеши не совпадают!";
} |
|
Понять что за шифр
Помогите понять что за шифр используется? Дешифровать шифр виженера
«ЮЛМВЕУ ЦУТГСЩ –
ВРЗУЖШЖНЯЪСФЬ ЯЛ ПТАУЪМ ГЕВРГХ РЦЦИ ДОЭОИ Д
ЦЦЩТТАЭЗНРМ ВЛЙРНЦ ООТОХЛ ВРЛФЪГТАХЛ, ГЁЕ УЪ ВТЕЮК
СФАЭФНЕРСПСМОЫ МИФВМ... Дисковый шифр
Здравствуйте! Помогите, пожалуйста, мне нужно программно реализовать дисковый шифр. Есть реализация шифра Виженера, необходимо как-то свести к нему... шифр, тип и архив
Приветствую.
Сразу три вопроса (не создавать же 3 темы).
1. Есть ли в природе некий код, которым можно было бы воспользоваться для шифрации...
Практическое применение
Здесь мы рассмотрим реальные сценарии использования криптографических методов в веб-приложениях.
Защита паролей и чувствительных данных
Защита паролей — одна из самых распространенных задач, с которой сталкивались многие. Современный подход предполагает использование специализированных алгоритмов хеширования с "солью" и факторами замедления.
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
| // Регистрация нового пользователя
function registerUser($username, $password) {
$options = [
'cost' => 12 // Фактор замедления, оптимальное значение зависит от сервера
];
// Генерация хеша с автоматической солью
$passwordHash = password_hash($password, PASSWORD_BCRYPT, $options);
// Сохранение в базу данных
saveUserToDatabase($username, $passwordHash);
}
// Проверка при входе
function loginUser($username, $password) {
// Получение хеша из базы
$storedHash = getUserPasswordHash($username);
if ($storedHash && password_verify($password, $storedHash)) {
// Успешный вход
return true;
}
// Неверный логин или пароль
return false;
} |
|
password_hash() автоматически генерирует уникальную соль для каждого пароля и сохраняет её в результирующей строке. Поэтому нам не нужно хранить соль отдельно.
Интересный момент из личной практики: в одном из проектов мы столкнулись с тем, что хеширование паролей с высоким фактором замедления создавало серьезную нагрузку на сервер во время пиковой активности регистраций. Решение было найдено в асинхронной обработке регистраций:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
| // Асинхронное хеширование пароля с использованием очередей
function registerUserAsync($username, $password) {
// Временно храним пароль в защищенном виде для последующей обработки
$tempToken = bin2hex(random_bytes(32));
$tempEncrypted = sodium_crypto_secretbox(
$password,
$nonce,
$serverKey
);
// Добавляем задачу в очередь
addToProcessingQueue([
'action' => 'hash_password',
'username' => $username,
'temp_token' => $tempToken,
'encrypted' => base64_encode($tempEncrypted),
'nonce' => base64_encode($nonce)
]);
// Отправляем пользователю сообщение о необходимости активации
return $tempToken;
} |
|
Реализация шифрования в веб-приложениях
В веб-приложениях часто требуется хранить чувствительную информацию, такую как персональные данные, финансовая информация или конфиденциальные документы. Для этих целей оптимально подходит симметричное шифрование. Вот пример класса для работы с шифрованием данных с использованием libsodium:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
| class Encryptor {
private $key;
public function __construct($key = null) {
if ($key === null) {
$this->key = sodium_crypto_secretbox_keygen();
} else {
$this->key = $key;
}
}
public function encrypt($data) {
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$cipher = sodium_crypto_secretbox($data, $nonce, $this->key);
// Сохраняем nonce вместе с шифртекстом
$encrypted = base64_encode($nonce . $cipher);
// Очищаем память для безопасности
sodium_memzero($data);
sodium_memzero($this->key);
return $encrypted;
}
public function decrypt($encrypted) {
$decoded = base64_decode($encrypted);
// Извлекаем nonce
$nonce = mb_substr($decoded, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
// Извлекаем шифртекст
$cipher = mb_substr($decoded, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
// Расшифровываем
$data = sodium_crypto_secretbox_open($cipher, $nonce, $this->key);
if ($data === false) {
throw new Exception('Ошибка расшифровки: данные повреждены или ключ неверный');
}
// Очищаем память
sodium_memzero($this->key);
return $data;
}
public function getKey() {
return base64_encode($this->key);
}
}
// Использование
$encryptor = new Encryptor();
$key = $encryptor->getKey(); // Сохраните этот ключ в безопасном месте!
$encrypted = $encryptor->encrypt("Конфиденциальные данные");
echo $encryptor->decrypt($encrypted); // Выведет "Конфиденциальные данные" |
|
sodium_memzero() — это важная мера безопасности, которая очищает память после использования чувствительных данных. В классических реализациях с OpenSSL этот шаг часто пропускают, что может привести к утечке ключей через дамп памяти.
Важный нюанс: класс выше может быть использован для шифрования данных в базе данных, но не подходит для шифрования файлов большого размера из-за ограничений памяти. Для файлов следует использовать потоковое шифрование:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
| function encryptFile($inputFile, $outputFile, $key) {
// Открываем файлы
$if = fopen($inputFile, 'rb');
$of = fopen($outputFile, 'wb');
// Записываем заголовок для хранения nonce
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
fwrite($of, $nonce);
// Шифруем по частям
$chunkSize = 8192; // 8KB
$readBytes = 0;
while (!feof($if)) {
$chunk = fread($if, $chunkSize);
$cipher = sodium_crypto_secretbox($chunk, $nonce . pack('P', $readBytes), $key);
fwrite($of, pack('n', strlen($cipher)));
fwrite($of, $cipher);
$readBytes += strlen($chunk);
}
fclose($if);
fclose($of);
} |
|
Примеры кода с libsodium
Libsodium предоставляет не только функции шифрования, но и множество других криптографических примитивов. Например, для создания цифровой подписи:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| // Генерируем ключевую пару для подписи
$keypair = sodium_crypto_sign_keypair();
$secretKey = sodium_crypto_sign_secretkey($keypair);
$publicKey = sodium_crypto_sign_publickey($keypair);
// Подписываем сообщение
$message = 'Это сообщение будет подписано';
$signature = sodium_crypto_sign_detached($message, $secretKey);
// Проверяем подпись
$isValid = sodium_crypto_sign_verify_detached($signature, $message, $publicKey);
if ($isValid) {
echo "Подпись верна!";
} else {
echo "Подпись недействительна!";
} |
|
Другой полезный пример — аутентифицированное шифрование с дополнительными данными (AEAD), которое позволяет включить незашифрованные, но защищенные от изменений данные вместе с шифртекстом:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Данные для шифрования
$message = 'Секретный текст';
// Дополнительные данные, которые будут защищены, но не зашифрованы
$additionalData = 'user_id=12345&level=admin';
// Ключ и nonce
$key = sodium_crypto_aead_xchacha20poly1305_ietf_keygen();
$nonce = random_bytes(SODIUM_CRYPTO_AEAD_XCHACHA20POLY1305_IETF_NPUBBYTES);
// Шифрование
$ciphertext = sodium_crypto_aead_xchacha20poly1305_ietf_encrypt(
$message,
$additionalData,
$nonce,
$key
);
// Дешифрование
$plaintext = sodium_crypto_aead_xchacha20poly1305_ietf_decrypt(
$ciphertext,
$additionalData,
$nonce,
$key
);
echo $plaintext; // Выведет "Секретный текст" |
|
Безопасное хранение API-токенов и других ключей доступа
Один из самых болезненных вопросов в разработке — где хранить API-ключи, токены доступа и другие секретные данные. Встраивать их напрямую в код — крайне плохая практика. Лучше использовать систему управления секретами, такую как Vault от HashiCorp, или хотя бы переменные окружения:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
| // Загрузка API-ключа из переменной окружения
$apiKey = getenv('API_SECRET_KEY');
if ($apiKey === false) {
// Ключ не найден в окружении, используем запасной вариант
$encryptedKeyFile = '/path/to/encrypted/key.dat';
$masterKey = getServerMasterKey(); // Функция получения мастер-ключа сервера
// Расшифровываем ключ API
$encryptedKey = file_get_contents($encryptedKeyFile);
$apiKey = decryptWithMasterKey($encryptedKey, $masterKey);
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
| class SecretManager {
private $masterKey;
private $secretsFile;
public function __construct($masterKey, $secretsFile = 'secrets.enc') {
$this->masterKey = sodium_crypto_generichash($masterKey, '', 32);
$this->secretsFile = $secretsFile;
}
public function storeSecret($name, $value) {
$secrets = $this->loadSecrets();
$secrets[$name] = $value;
$this->saveSecrets($secrets);
}
public function getSecret($name) {
$secrets = $this->loadSecrets();
return $secrets[$name] ?? null;
}
private function loadSecrets() {
if (!file_exists($this->secretsFile)) {
return [];
}
$data = file_get_contents($this->secretsFile);
if (empty($data)) {
return [];
}
$nonce = mb_substr($data, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
$encrypted = mb_substr($data, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
$json = sodium_crypto_secretbox_open($encrypted, $nonce, $this->masterKey);
if ($json === false) {
throw new Exception('Не удалось расшифровать секреты');
}
return json_decode($json, true) ?: [];
}
private function saveSecrets(array $secrets) {
$json = json_encode($secrets);
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encrypted = sodium_crypto_secretbox($json, $nonce, $this->masterKey);
file_put_contents($this->secretsFile, $nonce . $encrypted);
}
}
// Использование
$manager = new SecretManager('очень-сложный-пароль');
$manager->storeSecret('aws_key', 'AKIAIOSFODNN7EXAMPLE');
$manager->storeSecret('payment_gateway_token', 'live_12345token');
// Позже в коде
$awsKey = $manager->getSecret('aws_key'); |
|
Реализация end-to-end шифрования в PHP-приложениях
End-to-end шифрование (E2EE) обеспечивает защиту данных на всем пути от отправителя к получателю, не позволяя даже серверу просматривать содержимое сообщений. Это особенно важно для приложений обмена сообщениями и других систем, где конфиденциальность критична. Реализация E2EE обычно включает асимметричное шифрование с обменом ключами. Вот упрощенный пример:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
| class E2EEChat {
// Генерация пары ключей для нового пользователя
public static function generateUserKeys() {
$keyPair = sodium_crypto_box_keypair();
return [
'public' => sodium_crypto_box_publickey($keyPair),
'private' => sodium_crypto_box_secretkey($keyPair)
];
}
// Шифрование сообщения для определенного получателя
public static function encryptMessage($message, $senderPrivateKey, $recipientPublicKey) {
// Создаем общий секрет из ключей отправителя и получателя
$keypair = sodium_crypto_box_keypair_from_secretkey_and_publickey(
$senderPrivateKey,
$recipientPublicKey
);
$nonce = random_bytes(SODIUM_CRYPTO_BOX_NONCEBYTES);
$encrypted = sodium_crypto_box(
$message,
$nonce,
$keypair
);
// Возвращаем nonce и зашифрованное сообщение
return [
'nonce' => base64_encode($nonce),
'data' => base64_encode($encrypted)
];
}
// Дешифрование сообщения
public static function decryptMessage($encryptedData, $recipientPrivateKey, $senderPublicKey) {
$nonce = base64_decode($encryptedData['nonce']);
$encrypted = base64_decode($encryptedData['data']);
// Воссоздаем общий секрет
$keypair = sodium_crypto_box_keypair_from_secretkey_and_publickey(
$recipientPrivateKey,
$senderPublicKey
);
$decrypted = sodium_crypto_box_open(
$encrypted,
$nonce,
$keypair
);
if ($decrypted === false) {
throw new Exception('Не удалось расшифровать сообщение');
}
return $decrypted;
}
}
// Пример использования
// Алиса создаёт пару ключей
$aliceKeys = E2EEChat::generateUserKeys();
// Боб создаёт пару ключей
$bobKeys = E2EEChat::generateUserKeys();
// Алиса шифрует сообщение для Боба
$message = "Привет, Боб! Это секретное сообщение.";
$encrypted = E2EEChat::encryptMessage(
$message,
$aliceKeys['private'],
$bobKeys['public']
);
// Боб расшифровывает сообщение от Алисы
$decrypted = E2EEChat::decryptMessage(
$encrypted,
$bobKeys['private'],
$aliceKeys['public']
);
echo $decrypted; // Выведет исходное сообщение |
|
Для более сложных сценариев, таких как групповой чат с end-to-end шифрованием, потребуется реализация дополнительных механизмов управления ключами и их распространения. В таких случаях обычно используют подход Signal Protocol, который сочетает алгоритмы Double Ratchet, предварительное согласование ключей и тройной Diffie-Hellman.
Помните, что безопасность E2EE зависит не только от криптографии, но и от защиты приватных ключей на устройствах пользователей. В веб-приложениях это особенно сложно, так как код JavaScript может быть скомпрометирован через XSS или другие атаки на клиентской стороне. Для серьёзных приложений рекомендую рассмотреть комбинацию PHP-бэкенда и нативных клиентов для максимальной безопасности. Чтобы обеспечить дополнительную защиту приватных ключей на стороне клиента, можно шифровать их паролем пользователя:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
| function protectPrivateKey($privateKey, $password) {
$salt = random_bytes(16);
$key = sodium_crypto_pwhash(
32,
$password,
$salt,
SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE,
SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE
);
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encrypted = sodium_crypto_secretbox($privateKey, $nonce, $key);
// Возвращаем защищенный ключ в формате, подходящем для хранения
return base64_encode($salt . $nonce . $encrypted);
}
function unlockPrivateKey($protectedKey, $password) {
$data = base64_decode($protectedKey);
$salt = substr($data, 0, 16);
$nonce = substr($data, 16, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encrypted = substr($data, 16 + SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$key = sodium_crypto_pwhash(
32,
$password,
$salt,
SODIUM_CRYPTO_PWHASH_OPSLIMIT_INTERACTIVE,
SODIUM_CRYPTO_PWHASH_MEMLIMIT_INTERACTIVE
);
$privateKey = sodium_crypto_secretbox_open($encrypted, $nonce, $key);
if ($privateKey === false) {
throw new Exception('Неверный пароль или поврежденные данные');
}
return $privateKey;
} |
|
Продвинутые техники
Теперь, когда мы освоили основы криптографии в PHP и разобрались с практическими сценариями применения, настало время погрузиться в более сложные и специализированные техники. Эти подходы особенно полезны для высоконагруженных систем, критически важных приложений и проектов с повышенными требованиями к безопасности.
Управление ключами и сертификатами
Управление криптографическими ключами — один из наиболее сложных аспектов безопасности. Недостаточно просто генерировать качественные ключи — их нужно безопасно хранить, распределять и периодически обновлять. Возможно, самый надёжный подход — это использование специализированных сервисов для управления ключами, таких как AWS KMS, Azure Key Vault или HashiCorp Vault. Они позволяют делегировать генерацию, хранение и управление ключами внешним сервисам, разработанным специально для этой задачи. Вот пример интеграции с AWS KMS для шифрования данных без хранения ключей в самом приложении:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| // Требует aws/aws-sdk-php
use Aws\Kms\KmsClient;
class KmsEncryptor {
private $kms;
private $keyId;
public function __construct($keyId, $region = 'us-east-1') {
$this->kms = new KmsClient([
'region' => $region,
'version' => 'latest'
]);
$this->keyId = $keyId;
}
public function encrypt($data) {
$result = $this->kms->encrypt([
'KeyId' => $this->keyId,
'Plaintext' => $data
]);
return base64_encode($result['CiphertextBlob']);
}
public function decrypt($encrypted) {
$result = $this->kms->decrypt([
'CiphertextBlob' => base64_decode($encrypted)
]);
return $result['Plaintext'];
}
} |
|
1. Корневой ключ — используется только для генерации и обновления промежуточных ключей.
2. Промежуточные ключи — используются для шифрования ключей данных.
3. Ключи данных — используются непосредственно для шифрования данных.
Такая система позволяет минимизировать риски и упростить ротацию ключей:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
| class KeyManager {
private $rootKeyFile;
private $intermediateKeyFile;
private $dataKeysFile;
private $password;
public function __construct($rootKeyFile, $intermediateKeyFile, $dataKeysFile, $password) {
$this->rootKeyFile = $rootKeyFile;
$this->intermediateKeyFile = $intermediateKeyFile;
$this->dataKeysFile = $dataKeysFile;
$this->password = $password;
}
// Инициализация системы ключей
public function initialize() {
// Генерируем корневой ключ и защищаем паролем
$rootKey = sodium_crypto_secretbox_keygen();
$this->saveEncryptedKey($this->rootKeyFile, $rootKey, $this->password);
// Генерируем промежуточный ключ и шифруем его корневым
$intermediateKey = sodium_crypto_secretbox_keygen();
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encryptedIntermediate = $nonce . sodium_crypto_secretbox(
$intermediateKey,
$nonce,
$rootKey
);
file_put_contents($this->intermediateKeyFile, $encryptedIntermediate);
// Инициализируем пустой файл для ключей данных
file_put_contents($this->dataKeysFile, json_encode([]));
return [
'root' => bin2hex($rootKey),
'intermediate' => bin2hex($intermediateKey)
];
}
// Создание нового ключа для данных
public function createDataKey($keyName) {
$intermediateKey = $this->loadIntermediateKey();
$dataKey = sodium_crypto_secretbox_keygen();
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encryptedDataKey = $nonce . sodium_crypto_secretbox(
$dataKey,
$nonce,
$intermediateKey
);
$dataKeys = json_decode(file_get_contents($this->dataKeysFile), true);
$dataKeys[$keyName] = base64_encode($encryptedDataKey);
file_put_contents($this->dataKeysFile, json_encode($dataKeys));
return bin2hex($dataKey);
}
// Получение ключа данных по имени
public function getDataKey($keyName) {
$intermediateKey = $this->loadIntermediateKey();
$dataKeys = json_decode(file_get_contents($this->dataKeysFile), true);
if (!isset($dataKeys[$keyName])) {
throw new Exception("Ключ не найден: $keyName");
}
$encryptedDataKey = base64_decode($dataKeys[$keyName]);
$nonce = mb_substr($encryptedDataKey, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
$ciphertext = mb_substr($encryptedDataKey, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
$dataKey = sodium_crypto_secretbox_open($ciphertext, $nonce, $intermediateKey);
if ($dataKey === false) {
throw new Exception("Не удалось расшифровать ключ: $keyName");
}
return $dataKey;
}
// Вспомогательные функции
private function saveEncryptedKey($file, $key, $password) {
$salt = random_bytes(16);
$derivedKey = sodium_crypto_pwhash(
32,
$password,
$salt,
SODIUM_CRYPTO_PWHASH_OPSLIMIT_MODERATE,
SODIUM_CRYPTO_PWHASH_MEMLIMIT_MODERATE
);
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encrypted = sodium_crypto_secretbox($key, $nonce, $derivedKey);
file_put_contents($file, $salt . $nonce . $encrypted);
}
private function loadRootKey() {
$data = file_get_contents($this->rootKeyFile);
$salt = mb_substr($data, 0, 16, '8bit');
$nonce = mb_substr($data, 16, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
$encrypted = mb_substr($data, 16 + SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
$derivedKey = sodium_crypto_pwhash(
32,
$this->password,
$salt,
SODIUM_CRYPTO_PWHASH_OPSLIMIT_MODERATE,
SODIUM_CRYPTO_PWHASH_MEMLIMIT_MODERATE
);
$rootKey = sodium_crypto_secretbox_open($encrypted, $nonce, $derivedKey);
if ($rootKey === false) {
throw new Exception('Не удалось расшифровать корневой ключ. Возможно, неверный пароль.');
}
return $rootKey;
}
private function loadIntermediateKey() {
$rootKey = $this->loadRootKey();
$data = file_get_contents($this->intermediateKeyFile);
$nonce = mb_substr($data, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
$encrypted = mb_substr($data, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
$intermediateKey = sodium_crypto_secretbox_open($encrypted, $nonce, $rootKey);
if ($intermediateKey === false) {
throw new Exception('Не удалось расшифровать промежуточный ключ.');
}
return $intermediateKey;
}
} |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
| function createSelfSignedCertificate($dn, $privateKeyFile, $certificateFile, $days = 365) {
// Создаем приватный ключ
$privateKey = openssl_pkey_new([
"private_key_bits" => 2048,
"private_key_type" => OPENSSL_KEYTYPE_RSA,
]);
// Создаем CSR (запрос на подпись сертификата)
$csr = openssl_csr_new($dn, $privateKey, ['digest_alg' => 'sha256']);
// Подписываем CSR и создаем сертификат
$certificate = openssl_csr_sign($csr, null, $privateKey, $days, ['digest_alg' => 'sha256']);
// Экспортируем приватный ключ в файл
openssl_pkey_export_to_file($privateKey, $privateKeyFile);
// Экспортируем сертификат в файл
openssl_x509_export_to_file($certificate, $certificateFile);
return true;
}
// Пример использования
$dn = [
"countryName" => "RU",
"stateOrProvinceName" => "Moscow",
"localityName" => "Moscow",
"organizationName" => "My Company",
"organizationalUnitName" => "IT Department",
"commonName" => "example.com",
"emailAddress" => "admin@example.com"
];
createSelfSignedCertificate($dn, 'private.key', 'certificate.crt'); |
|
Защита от типичных уязвимостей
Даже с правильно реализованной криптографией, приложение может быть уязвимо из-за ошибок в реализации или недостаточной защиты окружающей инфраструктуры.
Одна из распространенных проблем — это повторное использование одноразовых значений (nonce, IV). Для защиты от этого можно создать сервис, отслеживающий использованные nonce:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
| class NonceManager {
private $db; // PDO или другое подключение к БД
private $tableName;
public function __construct($db, $tableName = 'used_nonces') {
$this->db = $db;
$this->tableName = $tableName;
// Создаем таблицу, если она не существует
$this->db->exec("CREATE TABLE IF NOT EXISTS {$this->tableName} (
nonce_hash CHAR(64) PRIMARY KEY,
context VARCHAR(255) NOT NULL,
created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
)");
}
// Регистрация нового nonce
public function register($nonce, $context = 'default') {
// Хешируем nonce, чтобы избежать проблем с бинарными данными
$nonceHash = hash('sha256', $nonce);
try {
$stmt = $this->db->prepare("INSERT INTO {$this->tableName} (nonce_hash, context) VALUES (?, ?)");
$stmt->execute([$nonceHash, $context]);
return true;
} catch (\PDOException $e) {
// Ошибка может возникнуть, если nonce уже использовался (нарушение уникальности)
return false;
}
}
// Проверка, использовался ли nonce ранее
public function isUsed($nonce, $context = 'default') {
$nonceHash = hash('sha256', $nonce);
$stmt = $this->db->prepare("SELECT 1 FROM {$this->tableName} WHERE nonce_hash = ? AND context = ?");
$stmt->execute([$nonceHash, $context]);
return $stmt->fetchColumn() !== false;
}
// Очистка старых nonce (можно вызывать периодически)
public function cleanup($olderThan = '-30 days') {
$timestamp = date('Y-m-d H:i:s', strtotime($olderThan));
$stmt = $this->db->prepare("DELETE FROM {$this->tableName} WHERE created_at < ?");
$stmt->execute([$timestamp]);
return $stmt->rowCount();
}
}
// Пример использования
$pdo = new PDO('mysql:host=localhost;dbname=myapp', 'username', 'password');
$nonceManager = new NonceManager($pdo);
// При шифровании
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
if (!$nonceManager->register($nonce, 'user_data_encryption')) {
// Невероятно редкая коллизия, генерируем новый nonce
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$nonceManager->register($nonce, 'user_data_encryption');
}
// Шифруем данные с этим nonce |
|
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
| // Небезопасное сравнение строк
function insecureCompare($a, $b) {
return $a === $b; // Зависит от длины строк и различия символов
}
// Безопасное сравнение с постоянным временем
function secureCompare($a, $b) {
if (function_exists('hash_equals')) {
return hash_equals($a, $b); // Доступно с PHP 5.6
}
// Реализация для более старых версий PHP
if (strlen($a) !== strlen($b)) {
return false; // Избегаем утечки информации через различия в длине
}
$result = 0;
for ($i = 0; $i < strlen($a); $i++) {
$result |= ord($a[$i]) ^ ord($b[$i]);
}
return $result === 0;
} |
|
Нестандартные решения для сложных задач
В некоторых ситуациях стандартных криптографических примитивов может быть недостаточно. Например, при работе с большими наборами данных или при необходимости обеспечить специфические свойства.
Шифрование с возможностью поиска
Одна из сложных задач — это создание системы, которая позволяет искать по зашифрованным данным без их расшифровки. Вот упрощенный пример такой системы:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
| class SearchableEncryption {
private $encryptionKey;
private $macKey;
public function __construct($masterKey) {
// Разделяем мастер-ключ на ключ шифрования и ключ HMAC
$this->encryptionKey = sodium_crypto_generichash($masterKey, '', 32);
$this->macKey = sodium_crypto_generichash($masterKey . 'mac', '', 32);
}
// Шифрование данных с созданием поисковых индексов
public function encrypt($data, array $searchableFields) {
$nonce = random_bytes(SODIUM_CRYPTO_SECRETBOX_NONCEBYTES);
$encrypted = sodium_crypto_secretbox(
json_encode($data),
$nonce,
$this->encryptionKey
);
$searchTokens = [];
foreach ($searchableFields as $field) {
if (isset($data[$field])) {
$searchTokens[$field] = $this->generateSearchTokens($data[$field], $field);
}
}
return [
'data' => base64_encode($nonce . $encrypted),
'tokens' => $searchTokens
];
}
// Дешифрование данных
public function decrypt($encryptedData) {
$raw = base64_decode($encryptedData);
$nonce = mb_substr($raw, 0, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, '8bit');
$ciphertext = mb_substr($raw, SODIUM_CRYPTO_SECRETBOX_NONCEBYTES, null, '8bit');
$json = sodium_crypto_secretbox_open($ciphertext, $nonce, $this->encryptionKey);
if ($json === false) {
throw new Exception('Не удалось расшифровать данные');
}
return json_decode($json, true);
}
// Генерация поискового токена для конкретного значения
public function getSearchToken($value, $field) {
return hash_hmac('sha256', strtolower($value) . $field, $this->macKey);
}
// Генерация поисковых токенов для значения
private function generateSearchTokens($value, $field) {
$tokens = [];
$value = strtolower((string)$value);
// Токен для точного совпадения
$tokens[] = $this->getSearchToken($value, $field);
// Токены для префиксного поиска
for ($i = 3; $i <= min(strlen($value), 15); $i++) {
$prefix = substr($value, 0, $i);
$tokens[] = $this->getSearchToken("prefix:{$prefix}", $field);
}
return $tokens;
}
// Поиск записей (реализация зависит от хранилища данных)
public function search($field, $value, $records) {
$token = $this->getSearchToken($value, $field);
$results = [];
foreach ($records as $id => $record) {
if (isset($record['tokens'][$field]) && in_array($token, $record['tokens'][$field])) {
$results[$id] = $record;
}
}
return $results;
}
// Префиксный поиск
public function searchPrefix($field, $prefix, $records) {
$prefix = strtolower($prefix);
$token = $this->getSearchToken("prefix:{$prefix}", $field);
$results = [];
foreach ($records as $id => $record) {
if (isset($record['tokens'][$field]) && in_array($token, $record['tokens'][$field])) {
$results[$id] = $record;
}
}
return $results;
}
} |
|
Интеграция с аппаратными модулями безопасности (HSM)
Для особо критичных систем имеет смысл использовать аппаратные модули безопасности (HSM). Эти устройства специализируются на криптографических операциях и защите ключей. PHP может интегрироваться с HSM через PKCS#11 или специальные API:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
| // Примечание: Этот код является схематичным и требует реальной библиотеки
// для работы с PKCS#11, такой как yubico/php-pkcs11
class HSMIntegration {
private $pkcs11;
private $session;
private $keyHandle;
public function __construct($module, $pin, $slotId = 0) {
// Инициализация PKCS#11
$this->pkcs11 = new PKCS11($module);
$this->pkcs11->initialize();
// Открываем сессию
$this->session = $this->pkcs11->openSession($slotId, PKCS11_SESSFLAG_RW);
$this->session->login(PKCS11_CKU_USER, $pin);
// Находим или создаем ключ
$this->keyHandle = $this->findKey();
}
private function findKey() {
// Поиск ключа по метке
$template = [
'label' => 'MyAppEncryptionKey',
'class' => PKCS11_CKO_SECRET_KEY
];
$objects = $this->session->findObjects($template);
if (count($objects) > 0) {
return $objects[0];
}
// Создаем новый ключ, если не нашли
$keyTemplate = [
'class' => PKCS11_CKO_SECRET_KEY,
'key_type' => PKCS11_CKK_AES,
'label' => 'MyAppEncryptionKey',
'token' => true,
'private' => true,
'sensitive' => true,
'extractable' => false,
'value_len' => 32
];
return $this->session->generateKey(PKCS11_CKM_AES_KEY_GEN, $keyTemplate);
}
public function encrypt($data) {
$mechanism = [
'mechanism' => PKCS11_CKM_AES_CBC_PAD,
'parameter' => str_repeat("\0", 16) // IV
];
// HSM выполняет операцию шифрования
return $this->session->encrypt($this->keyHandle, $mechanism, $data);
}
public function decrypt($encrypted) {
$mechanism = [
'mechanism' => PKCS11_CKM_AES_CBC_PAD,
'parameter' => str_repeat("\0", 16) // IV
];
// HSM выполняет операцию расшифровки
return $this->session->decrypt($this->keyHandle, $mechanism, $encrypted);
}
public function __destruct() {
$this->session->logout();
$this->pkcs11->finalize();
}
} |
|
Использование эллиптических кривых в PHP-криптографии
Алгоритмы на основе эллиптических кривых (ECC) становятся всё более популярными благодаря их высокой стойкости при меньшей длине ключа по сравнению с RSA. В PHP работа с ECC возможна через libsodium и OpenSSL.
Вот пример генерации ключевой пары и подписи с использованием Ed25519 (реализация Edwards-curve Digital Signature Algorithm):
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
| // Генерация ключевой пары Ed25519
$keyPair = sodium_crypto_sign_keypair();
$secretKey = sodium_crypto_sign_secretkey($keyPair);
$publicKey = sodium_crypto_sign_publickey($keyPair);
// Подписание данных
$message = 'Данные, требующие подтверждения целостности';
$signature = sodium_crypto_sign_detached($message, $secretKey);
// Проверка подписи
$isValid = sodium_crypto_sign_verify_detached($signature, $message, $publicKey);
echo $isValid ? "Подпись валидна" : "Подпись недействительна"; |
|
Для шифрования с использованием эллиптических кривых можно применить алгоритм X25519:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
| // Генерация ключевых пар Алисы и Боба
$aliceKeyPair = sodium_crypto_box_keypair();
$aliceSecretKey = sodium_crypto_box_secretkey($aliceKeyPair);
$alicePublicKey = sodium_crypto_box_publickey($aliceKeyPair);
$bobKeyPair = sodium_crypto_box_keypair();
$bobSecretKey = sodium_crypto_box_secretkey($bobKeyPair);
$bobPublicKey = sodium_crypto_box_publickey($bobKeyPair);
// Алиса шифрует сообщение с помощью своего секретного и публичного ключа Боба
$message = 'Секретное сообщение для Боба';
$nonce = random_bytes(SODIUM_CRYPTO_BOX_NONCEBYTES);
$encryptedMessage = sodium_crypto_box(
$message,
$nonce,
sodium_crypto_box_keypair_from_secretkey_and_publickey($aliceSecretKey, $bobPublicKey)
);
// Боб расшифровывает сообщение с помощью своего секретного и публичного ключа Алисы
$decryptedMessage = sodium_crypto_box_open(
$encryptedMessage,
$nonce,
sodium_crypto_box_keypair_from_secretkey_and_publickey($bobSecretKey, $alicePublicKey)
);
echo $decryptedMessage ? $decryptedMessage : "Не удалось расшифровать сообщение"; |
|
Защита от квантовых вычислений
С развитием квантовых компьютеров многие традиционные алгоритмы, включая RSA и ECC, станут уязвимыми. Постквантовая криптография призвана решить эту проблему.
Хотя PHP пока не имеет встроенной поддержки постквантовых алгоритмов, можно использовать расширения или внешние библиотеки. Вот пример интеграции с открытой библиотекой для постквантовой криптографии:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
| // Пример абстракции для постквантовой криптографии
// Обратите внимание: это схематичный код, требующий реальной библиотеки
class PQCrypto {
// Алгоритм CRYSTALS-Kyber для обмена ключами
public static function kyberKeyGen() {
// Генерация ключевой пары Kyber
// В реальности это вызов библиотеки с поддержкой Kyber
$publicKey = '...'; // Результат генерации публичного ключа
$secretKey = '...'; // Результат генерации секретного ключа
return [
'public' => $publicKey,
'secret' => $secretKey
];
}
public static function kyberEncrypt($publicKey, $message) {
// Шифрование с помощью Kyber
$ciphertext = '...'; // Результат шифрования
$sharedSecret = '...'; // Общий секрет для симметричного шифрования
return [
'ciphertext' => $ciphertext,
'shared_secret' => $sharedSecret
];
}
public static function kyberDecrypt($secretKey, $ciphertext) {
// Расшифровка с помощью Kyber
return '...'; // Полученный общий секрет
}
} |
|
Гомоморфное шифрование
Гомоморфное шифрование позволяет выполнять вычисления над зашифрованными данными без их расшифровки. Хотя полное гомоморфное шифрование пока вычислительно дорого, частично гомоморфные схемы уже применяются в некоторых задачах.
Представим простую реализацию частично гомоморфного шифрования на основе алгоритма Пайя:
| PHP | 1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
| class PaillierCrypto {
private $n; // модуль
private $g; // генератор
private $lambda; // функция Кармайкла
private $mu; // обратный элемент
public function generateKeys($bits = 1024) {
// Генерация двух простых чисел p и q
$p = gmp_nextprime(gmp_random_bits($bits / 2));
$q = gmp_nextprime(gmp_random_bits($bits / 2));
// Вычисление n = p * q
$this->n = gmp_mul($p, $q);
// Вычисление lambda(n) = lcm(p-1, q-1)
$p_1 = gmp_sub($p, 1);
$q_1 = gmp_sub($q, 1);
$this->lambda = gmp_div_q(gmp_mul($p_1, $q_1), gmp_gcd($p_1, $q_1));
// Выбор генератора g
$this->g = gmp_add($this->n, 1);
// Вычисление mu = lambda^-1 mod n
$this->mu = gmp_invert($this->lambda, $this->n);
return [
'public' => [
'n' => gmp_strval($this->n),
'g' => gmp_strval($this->g)
],
'private' => [
'lambda' => gmp_strval($this->lambda),
'mu' => gmp_strval($this->mu)
]
];
}
public function encrypt($m, $publicKey) {
$n = gmp_init($publicKey['n']);
$g = gmp_init($publicKey['g']);
$n_squared = gmp_pow($n, 2);
// Выбираем случайное r такое, что 0 < r < n и gcd(r, n) = 1
do {
$r = gmp_random_range(1, gmp_sub($n, 1));
} while (gmp_cmp(gmp_gcd($r, $n), 1) != 0);
// c = g^m * r^n mod n^2
$gm = gmp_powm($g, $m, $n_squared);
$rn = gmp_powm($r, $n, $n_squared);
return gmp_strval(gmp_mod(gmp_mul($gm, $rn), $n_squared));
}
public function decrypt($c, $privateKey) {
$c = gmp_init($c);
$n = $this->n;
$lambda = gmp_init($privateKey['lambda']);
$mu = gmp_init($privateKey['mu']);
$n_squared = gmp_pow($n, 2);
// m = L(c^lambda mod n^2) * mu mod n
$c_lambda = gmp_powm($c, $lambda, $n_squared);
$L = gmp_div_q(gmp_sub($c_lambda, 1), $n);
return gmp_strval(gmp_mod(gmp_mul($L, $mu), $n));
}
// Гомоморфное сложение: E(a) * E(b) = E(a + b mod n)
public function homomorphicAdd($ca, $cb, $publicKey) {
$n = gmp_init($publicKey['n']);
$n_squared = gmp_pow($n, 2);
return gmp_strval(gmp_mod(gmp_mul(gmp_init($ca), gmp_init($cb)), $n_squared));
}
// Гомоморфное умножение на константу: E(a)^b = E(a * b mod n)
public function homomorphicMultiplyConstant($ca, $b, $publicKey) {
$n = gmp_init($publicKey['n']);
$n_squared = gmp_pow($n, 2);
return gmp_strval(gmp_powm(gmp_init($ca), $b, $n_squared));
}
} |
|
Выводы
Хочу выделить ключевые моменты, которые следует учитывать при внедрении криптографических решений в PHP-приложения:
1. Используйте современные библиотеки. Libsodium, встроенная в PHP начиная с версии 7.2, предоставляет высокоуровневый API, который минимизирует вероятность ошибок реализации. Откажитесь от устаревших функций вроде md5() и sha1() в пользу современных алгоритмов.
2. Правильно генерируйте случайные числа. Основа любой криптографической системы — качественные случайные данные. Используйте функции random_bytes() и random_int() вместо небезопасных rand() и mt_rand().
3. Тщательно управляйте ключами. Даже самый стойкий алгоритм будет скомпрометирован при утечке ключа. Разделяйте ключи по функциональности, контролируйте их жизненный цикл, используйте иерархический подход к управлению ключами.
4. Не изобретайте велосипед. Криптография — это та область, где эксперименты обычно заканчиваются провалом. Полагайтесь на проверенные решения и стандартизированные алгоритмы.
5. Защищайтесь от атак по времени. Используйте функции с постоянным временем выполнения, такие как hash_equals(), для сравнения хешей и других криптографических значений.
При работе над проектами я часто сталкиваюсь с попытками создать "собственную" криптографию или оптимизировать существующие алгоритмы. Это почти всегда приводит к уязвимостям. Лучше тратить время на изучение и правильное применение существующих решений. Я также заметил, что многие разработчики уделяют слишком мало внимания процессам управления ключами. Нередко ключи хранятся в репозиториях кода, передаются небезопасно или не обновляются годами. Создание надёжной системы управления ключами должно быть приоритетом при внедрении криптографии.
Шифр Бофора
Кто нибудь расскажите пож-та про Шифр Бофора, как она работает, простыми словами, в интернете ничего толком не нашел, и если можно то код в си подобрать шифр с 1 ключом
Всем привет, помогите с подбором шифра.
Нужен такой шифр чтобы можно было шифровать запись с использованием одного ключа.
Но запись должна быть... Шифр Атбаш
Здравствуйте. Помогите пожалуйста. Задание расшифровать сообщение зашифрованное шифром Атбаш.
ЧАКЫXОАЬОИ_ЦЫЪШПААЧАПУXОАШАСОЧШАТСШЦУЪ_ПРБ где знак... Шифр Виженера
проблемы с шифром Виженера, конкретнее с функцией расшифровки, не могу понять что делаю не так, но вместо расшифрованной записи выводиться просто... Шифр Цезаря
Доброй ночи!
Сижу уже второй час. Подскажите хоть каким макаром эта хрен декодируется?!
... Шифр Вернама(С русскими и английскими символами)
<?php
function shifrVernam($oStr,$key='')
{
$len = mb_strlen($oStr, 'utf-8');
$shStr = '';
if($key == '')
... Опознать шифр
Помогите, пожалуйста, узнать каким шифром кодируется строка.
Вот, выловил несколько штук предположительно одного и того же сообщения, но... Шифр простой замены
Лфыанщвффижиыщецажштфрмлфыаншфбжщнамупцбдтпбфбтфшбнтуоабынцбджюфеефифафшнбьщехжыфбфуефюужтореаещнажшбфецджюфезеифбтждшжбануупцфчнщжааыфюыщбнуупцюотеам... Шифр подстановки
Есть открытый текст сообщения и зашифрованное одноалфавитным подстановочным шифром сообщение. Нужно вычислить алфавит замены, при котором... Шифр
как расшифровать "ЮЯЙЪО Г НЫХЭЭШЪ ДОАУИ ЭЪШСАЛЖЦ ЩФЯЁАМХ"??? Шифр Хасегава
Помогите реализовать этот шифр... Языки: Дельфи, С++, С шарп... или хотя бы подробно объясните алгоритм... Очень надо... Шифр Цезаря
Доброго времени суток!
Есть задание, пользователь вводит текст в текстовое поле и необходимо зашифровать его используя шифр Цезаря с ключом 3....
|
