F.38. pgcrypto — функции защитного преобразования #

Модуль pgcrypto предоставляет функции защитного преобразования для Postgres Pro.

Данный модуль считается «доверенным», то есть его могут устанавливать обычные пользователи, имеющие право CREATE в текущей базе данных.

Для работы pgcrypto требуется OpenSSL — модуль не будет установлен, если Postgres Pro был собран без OpenSSL.

F.38.1. Стандартные функции хеширования #

F.38.1.1. digest() #

digest(data text, type text) returns bytea
digest(data bytea, type text) returns bytea

Вычисляет двоичный хеш данных (data). Параметр type выбирает используемый алгоритм. Поддерживаются стандартные алгоритмы: md5, sha1, sha224, sha256, sha384 и sha512. Кроме того, эта функция автоматически поддерживает любые другие алгоритмы хеширования, которые поддерживает OpenSSL.

Если вы хотите получить дайджест в виде шестнадцатеричной строки, примените encode() к результату. Например:

CREATE OR REPLACE FUNCTION sha1(bytea) returns text AS $$
    SELECT encode(digest($1, 'sha1'), 'hex')
$$ LANGUAGE SQL STRICT IMMUTABLE;

F.38.1.2. hmac() #

hmac(data text, key text, type text) returns bytea
hmac(data bytea, key bytea, type text) returns bytea

Вычисляет имитовставку на основе хеша для данных data с ключом key. Параметр type имеет то же значение, что и для digest().

Эта функция похожа на digest(), но вычислить хеш с ней можно, только зная ключ. Это защищает от сценария подмены данных и хеша вместе с ними.

Если размер ключа больше размера блока хеша, он сначала хешируется, а затем используется в качестве ключа хеширования данных.

F.38.2. Функции хеширования пароля #

Функции crypt() и gen_salt() разработаны специально для хеширования паролей. Функция crypt() выполняет хеширование, а gen_salt() подготавливает параметры алгоритма для неё.

Алгоритмы в crypt() отличаются от обычных алгоритмов хеширования MD5 и SHA-1 в следующих аспектах:

  1. Они медленные. Так как объём данных невелик, это единственный способ усложнить перебор паролей.

  2. Они используют случайное значение, называемое солью, чтобы у пользователей с одинаковыми паролями защищённые пароли оказывались разными. Это также обеспечивает дополнительную защиту от получения обратного алгоритма.

  3. Они включают в результат тип алгоритма, что допускает сосуществование паролей, хешированных разными алгоритмами.

  4. Некоторые из них являются адаптируемыми — то есть с ростом производительности компьютеров эти алгоритмы можно настроить так, чтобы они стали медленнее, при этом сохраняя совместимость с существующими паролями.

В Таблице F.23 перечислены алгоритмы, поддерживаемые функцией crypt().

Таблица F.23. Алгоритмы, которые поддерживает crypt()

АлгоритмМакс. длина пароляАдаптивный?Размер соли (бит)Размер результатаОписание
bf72да12860На базе Blowfish, вариация 2a
md5без ограниченийнет4834crypt на базе MD5
xdes8да2420Расширенный DES
des8нет1213Изначальный crypt из UNIX
sha256cryptбез ограниченийдадо 3280Взят из примера реализации crypt из Unix с применением SHA-256 и SHA-512, который находится в открытом доступе
sha512cryptбез ограниченийдадо 32123Взят из примера реализации crypt из Unix с применением SHA-256 и SHA-512, который находится в открытом доступе

F.38.2.1. crypt() #

crypt(password text, salt text) returns text

Вычисляет хеш пароля (password) в стиле crypt(3). Для сохранения нового пароля необходимо вызвать gen_salt(), чтобы сгенерировать новое значение соли (salt). Для проверки пароля нужно передать сохранённое значение хеша в параметре salt и проверить, соответствует ли результат сохранённому значению.

Пример установки нового пароля:

UPDATE ... SET pswhash = crypt('new password', gen_salt('md5'));

Пример проверки пароля:

SELECT (pswhash = crypt('entered password', pswhash)) AS pswmatch FROM ... ;

Этот запрос возвращает true, если введённый пароль правильный.

F.38.2.2. gen_salt() #

gen_salt(type text [, iter_count integer ]) returns text

Вычисляет новое случайное значение соли для функции crypt(). Строка соли также говорит crypt(), какой алгоритм использовать.

Параметр type задаёт алгоритм хеширования. Принимаются следующие варианты: des, xdes, md5, bf, sha256crypt и sha512crypt. Последние два варианта, sha256crypt и sha512crypt, — это современные хеши паролей из семейства SHA-2.

Параметр iter_count позволяет пользователю указать счётчик итераций для алгоритма, который его принимает. Чем больше это число, тем больше времени уйдёт на вычисление хеша пароля, а значит, тем больше времени понадобится, чтобы взломать его. Хотя со слишком большим значением время вычисления хеша может вырасти до нескольких лет — это вряд ли практично. Когда параметр iter_count опускается, применяется количество итераций по умолчанию. Множество допустимых значений для iter_count зависит от алгоритма, как показано в Таблице F.24.

Таблица F.24. Счётчики итераций для crypt()

АлгоритмПо умолчаниюМин.Макс.
xdes725116777215
bf6431
sha256crypt, sha512crypt50001000999999999

Для xdes есть дополнительное ограничение: счётчик итераций должен быть нечётным.

При выборе подходящего числа итераций учтите, что оригинальный алгоритм DES crypt был рассчитан так, чтобы выдавать 4 хеша в секунду на компьютерах того времени. Если за секунду будет вычисляться меньше 4 хешей, скорее всего, возникнут определённые неудобства при пользовании. С другой стороны, скорость больше, чем 100 хешей в секунду, вероятно, будет слишком высокой.

В Таблице F.25 дана сводка относительной скорости различных алгоритмов хеширования. В таблице показано, сколько времени уйдёт на перебор всех комбинацией символов в восьмисимвольном пароле, в предположении, что пароль содержит только буквы в нижнем регистре, либо буквы в верхнем и нижнем регистре, а также цифры. В строках crypt-bf числа после косой черты показывают значение параметра iter_count функции gen_salt.

Значение по умолчанию параметра iter_count для sha256crypt и sha512crypt, равное 5000, считается слишком маленьким для современного аппаратного обеспечения, но параметр можно настроить для генерации более надёжных хешей паролей. В остальных случаях оба хеша, sha256crypt и sha512crypt, считаются безопасными.

Таблица F.25. Скорости алгоритмов хеширования

АлгоритмХешей/сек.Для [a-z]Для [A-Za-z0-9]Длительность относительно md5
crypt-bf/817924 года3927 лет100k
crypt-bf/736482 года1929 лет50k
crypt-bf/671681 год982 лет25k
crypt-bf/513504188 дней521 лет12.5k
crypt-md517158415 дней41 год1k
crypt-des23221568157.5 минут108 дней7
sha13777427290 минут68 дней4
md5 (хеш)15008550422.5 минут17 дней1

Замечания:

  • Для расчётов использовался процессор Intel Mobile Core i3.

  • Показатели алгоритмов crypt-des и crypt-md5 взяты из вывода теста программы John the Ripper v1.6.38.

  • Показатели md5 получены программой mdcrack 1.2.

  • Показатели sha1 получены программой lcrack-20031130-beta.

  • Показатели crypt-bf получены простой программой, обрабатывающей в цикле 1000 паролей из 8 символов. Таким способом можно показать скорость с разным числом итераций. Для справки: john -test показывает 13506 циклов/с для crypt-bf/5. (Это очень небольшое различие в результатах согласуется с тем фактом, что реализация crypt-bf в pgcrypto не отличается от применяемой в программе John the Ripper.)

Заметьте, что вариант «перепробовать все комбинации» не вполне реалистичен. Обычно перебор паролей производится с применением словарей, которые содержат и обычные слова, и их различные видоизменения. Поэтому даже похожие на слова пароли обычно можно подобрать быстрее, чем за указанное время, тогда как 6-символьный несловесный пароль может избежать взлома. А может и не избежать.

F.38.3. Функции защитного преобразования на базе PGP #

Функции, описанные здесь, реализуют часть стандарта OpenPGP (RFC 4880), относящуюся к защитным преобразованиям. Они поддерживают защитные преобразования как с симметричным, так и с открытым ключом.

Защищённое PGP сообщение состоит из 2 частей или пакетов:

  • Пакет, содержащий сеансовый ключ — либо симметричный, либо открытый (в защищённом виде).

  • Пакет, содержащий данные, защищённые сеансовым ключом.

При защитном преобразовании с симметричным ключом (то есть, паролем):

  1. Заданный пароль хешируется по алгоритму String2Key (S2K). Этот алгоритм подобен алгоритмам crypt() — специально замедлен и добавляет случайную соль — но на выход выдаёт двоичный ключ полной длины.

  2. Если требуется отдельный сеансовый ключ, генерируется новый случайный ключ. В противном случае в качестве сеансового будет использоваться непосредственно ключ S2K.

  3. Когда используется непосредственно ключ S2K, в пакет сеансового ключа помещаются только параметры S2K. В противном случае сеансовый ключ защищается ключом S2K и помещается в пакет сеансового ключа.

При защитном преобразовании с открытым ключом:

  1. Генерируется новый случайный сеансовый ключ.

  2. Он защищается открытым ключом и помещается в пакет сеансового ключа.

В любом случае данные, которые должны быть защищены, обрабатываются так:

  1. Необязательная подготовка данных: сжатие, перекодировка в UTF-8 и/или преобразование концов строк.

  2. Перед данными добавляется блок случайных байт. Это равносильно использованию случайного вектора инициализации.

  3. В конце добавляется хеш SHA-1 случайного префикса и данных.

  4. Всё это защищается сеансовым ключом и помещается в пакет данных.

F.38.3.1. pgp_sym_encrypt() #

pgp_sym_encrypt(data text, psw text [, options text ]) returns bytea
pgp_sym_encrypt_bytea(data bytea, psw text [, options text ]) returns bytea

Защищает данные (data) симметричным ключом PGP psw. В options могут передаваться параметры защитного преобразования, описанные ниже.

F.38.3.2. pgp_sym_decrypt() #

pgp_sym_decrypt(msg bytea, psw text [, options text ]) returns text
pgp_sym_decrypt_bytea(msg bytea, psw text [, options text ]) returns bytea

Делает обратное преобразование сообщения, защищённого симметричным ключом PGP.

Обратно преобразовывать данные bytea функцией pgp_sym_decrypt запрещено. Это ограничение введено, чтобы не допустить вывода некорректных символьных данных. Обратно преобразовывать изначально текстовые данные с помощью pgp_sym_decrypt_bytea можно без ограничений.

Аргумент options может содержать параметры защитного преобразования, описанные ниже.

F.38.3.3. pgp_pub_encrypt() #

pgp_pub_encrypt(data text, key bytea [, options text ]) returns bytea
pgp_pub_encrypt_bytea(data bytea, key bytea [, options text ]) returns bytea

Защищает данные (data) открытым ключом PGP (key). Если передать этой функции закрытый ключ, она выдаст ошибку.

Аргумент options может содержать параметры защитного преобразования, описанные ниже.

F.38.3.4. pgp_pub_decrypt() #

pgp_pub_decrypt(msg bytea, key bytea [, psw text [, options text ]]) returns text
pgp_pub_decrypt_bytea(msg bytea, key bytea [, psw text [, options text ]]) returns bytea

Обратно преобразовывает сообщение, защищённое открытым ключом. В key должен передаваться закрытый ключ, соответствующий открытому ключу, применяющемуся при защитном преобразовании. Если секретный ключ защищён паролем, этот пароль нужно передать в параметре psw. Если пароля нет, но необходимо передать параметры, вы должны передать пустой пароль.

Обратно преобразовывать данные bytea функцией pgp_pub_decrypt запрещено. Это ограничение введено, чтобы исключить вывод недопустимых символьных данных. Обратно преобразовывать изначально текстовые данные с помощью pgp_pub_decrypt_bytea можно без ограничений.

Аргумент options может содержать параметры защитного преобразования, описанные ниже.

F.38.3.5. pgp_key_id() #

pgp_key_id(bytea) returns text

pgp_key_id извлекает идентификатор ключа из открытого или закрытого ключа PGP. Она также может выдать идентификатор ключа, которым были защищены данные, если ей передаётся защищённое сообщение.

Она может выдать два специальных идентификатора ключа:

  • SYMKEY

    Сообщение защищено симметричным ключом.

  • ANYKEY

    Сообщение защищено открытом ключом, но идентификатор ключа был удалён. Это означает, что вам надо будет перепробовать ключи, чтобы подобрать подходящий. Сама библиотека pgcrypto не генерирует такие сообщения.

Заметьте, что разные ключи могут иметь одинаковый идентификатор. Это редкое, но не невероятное явление. В таком случае клиентское приложение должно пытаться обратно преобразовать данные с каждым ключом, пока не найдёт подходящий — примерно так же, как и с ANYKEY.

F.38.3.6. armor(), dearmor() #

armor(data bytea [ , keys text[], values text[] ]) returns text
dearmor(data text) returns bytea

Эти функции переводят двоичные данные в/из формата PGP «ASCII Armor», по сути представляющий собой кодировку Base64 с контрольными суммами и дополнительным форматированием.

Если задаются массивы keys и values, для каждой пары ключ/значения в формат Armor добавляется заголовок Armor. Оба массива должны быть одномерными и иметь одинаковую длину. Задаваемые ключи и значения могут содержать только символы ASCII.

F.38.3.7. pgp_armor_headers #

pgp_armor_headers(data text, key out text, value out text) returns setof record

Функция pgp_armor_headers() извлекает заголовки Armor из параметра data. Она возвращает набор строк с двумя столбцами, key и value. Если в ключах или значениях оказываются символы не ASCII, они воспринимаются как UTF-8.

F.38.3.8. Параметры функций PGP #

Имена параметров подобны принятым в GnuPG. Значение параметра должно задаваться после знака равно; друг от друга параметры отделяются запятыми. Например:

pgp_sym_encrypt(data, psw, 'compress-algo=1, cipher-algo=aes256')

Все эти параметры, кроме convert-crlf, применяются только к функциям защитного преобразования. Функции защитного преобразования получают параметры из данных PGP.

Вероятно, самые интересные параметры — это compress-algo и unicode-mode. Остальные должны иметь достаточно адекватные значения по умолчанию.

F.38.3.8.1. cipher-algo #

Выбирает алгоритм защитного преобразования.

Значения: bf, aes128, aes192, aes256, 3des, cast5
По умолчанию: aes128
Применим к: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.2. compress-algo #

Выбирает алгоритм сжатия. Принимается, только если Postgres Pro собран с zlib.

Значения:
  0 — без сжатия
  1 — сжатие ZIP
  2 — сжатие ZLIB (= ZIP плюс метаданные и CRC блоков)
По умолчанию: 0
Применим к: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.3. compress-level #

Определяет уровень сжатия. Чем больше уровень, тем меньшего объёма результат, но длительнее процесс. Значение 0 отключает сжатие.

Значения: 0, 1-9
По умолчанию: 6
Применим к: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.4. convert-crlf #

Определяет, преобразовывать ли \n в \r\n при защитном преобразовании и \r\n в \n при обратном преобразовании. В RFC 4880 требуется, чтобы текстовые данные хранились с переводами строк в виде \r\n. Воспользуйтесь этим параметром, чтобы поведение полностью соответствовало RFC.

Значения: 0, 1
По умолчанию: 0
Применим к: pgp_sym_encrypt, pgp_pub_encrypt, pgp_sym_decrypt, pgp_pub_decrypt

F.38.3.8.5. disable-mdc #

Не защищать данные хешем SHA-1. Единственная разумная причина использовать этот параметр — добиться совместимости с древними программами PGP, вышедшими до того, как в RFC 4880 была предусмотрена защита пакетов с SHA-1. Все последние реализации с gnupg.org и pgp.com прекрасно поддерживают это.

Значения: 0, 1
По умолчанию: 0
Применим к: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.6. sess-key #

Использовать отдельный сеансовый ключ. Для защитного преобразования с открытым ключом всегда используется отдельный сеансовый ключ; этот параметр предназначен для защитного преобразования с симметричным ключом, которое по умолчанию использует непосредственно ключ S2K.

Значения: 0, 1
По умолчанию: 0
Применим к: pgp_sym_encrypt

F.38.3.8.7. s2k-mode #

Режим алгоритма S2K.

Значения:
  0 — Без соли. Опасно!
  1 — С солью, но с фиксированным числом итераций.
  3 — С переменным числом итераций.
По умолчанию: 3
Применим к: pgp_sym_encrypt

F.38.3.8.8. s2k-count #

Число итераций для алгоритма S2K. Оно должно быть не меньше 1024 и не больше 65011712.

По умолчанию: случайное значение между 65536 и 253952
Применим к: pgp_sym_encrypt, только с s2k-mode=3

F.38.3.8.9. s2k-digest-algo #

Выбирает алгоритм хеширования, который будет использоваться для вычисления S2K.

Значения: md5, sha1
По умолчанию: sha1
Применим к: pgp_sym_encrypt

F.38.3.8.10. s2k-cipher-algo #

Выбирает защитное преобразование, который будет использоваться для отдельного сеансового ключа.

Значения: bf, aes, aes128, aes192, aes256
По умолчанию: используется cipher-algo
Применим к: pgp_sym_encrypt

F.38.3.8.11. unicode-mode #

Определяет, преобразовывать ли текстовые данные из внутренней кодировки базы данных в UTF-8 и обратно. Если кодировка базы уже UTF-8, перекодировка не производится, но сообщение помечается как UTF-8. Без данного параметра этого не происходит.

Значения: 0, 1
По умолчанию: 0
Применим к: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.12. ignore-cipher-failure #

Опасно! Указывает pgcrypto использовать алгоритм расшифрования, который соответствует некорректному поведению, существовавшему до исправления CVE-2026-14663, и полностью игнорировать ошибки, возникающие при работе с шифром OpenSSL. Данный режим предназначен исключительно для пользователей, которым необходимо восстановить некорректно зашифрованные сообщения, созданные в условиях, когда алгоритм cipher-algo не был доступен в текущей конфигурации OpenSSL. При включённом параметре ignore-cipher-failure такие сообщения могут быть расшифрованы без корректного ключа, поэтому нет гарантии, что полученный расшифрованный текст действительно был создан владельцем ключа.

Для сравнение рассмотрим случай сообщения, которое было корректно зашифровано, но шифр, использованный для его создания, недоступен в текущей конфигурации OpenSSL. Чтобы восстановить такой обычный текст через pgcrypto, необходимо сделать фактический шифр доступным для OpenSSL, например, включив соответствующий провайдер. Параметр ignore-cipher-failure не требуется и не полезен для этого сценария. Если «расшифровка» корректно зашифрованного сообщения с этой опцией случайно проходит проверку целостности PGP, этот результат является совпадением и не делает восстановленный обычный текст заслуживающим доверия.

Values: 0, 1
Default: 0
Applies to: pgp_sym_decrypt, pgp_pub_decrypt

F.38.3.9. Формирование ключей PGP с применением GnuPG #

Формирование нового ключа:

gpg --gen-key

Предпочитаемый тип ключей: «DSA and Elgamal».

Для защитного преобразования RSA вы должны создать главный ключ либо DSA, либо RSA только для подписания, а затем добавить подключ для защитного преобразования, выполнив команду gpg --edit-key.

Просмотр списка ключей:

gpg --list-secret-keys

Экспорт открытого ключа в формате «ASCII Armor»:

gpg -a --export KEYID > public.key

Экспорт закрытого ключа в формате «ASCII Armor»:

gpg -a --export-secret-keys KEYID > secret.key

Прежде чем передавать эти ключи функциям PGP, вы должны применить функцию dearmor() к этим ключам. Либо, если вы можете обработать двоичные данные, уберите -a из команды.

Дополнительную информацию вы можете получить в руководстве man gpg, The GNU Privacy Handbook (Руководство GNU по обеспечению конфиденциальности) и другой документации на сайте https://www.gnupg.org/.

F.38.3.10. Ограничения кода PGP #

  • Не поддерживается подписывание. Это также означает, что принадлежность подключа защитного преобразования главному ключу не проверяется.

  • Не поддерживается использование ключа защитного преобразования в качестве главного ключа. Так как подобная практика обычно не приветствуется, это не должно быть проблемой.

  • Нет поддержки нескольких подключей. Это может представляться проблемой, так как такие ключи не редкость. С другой стороны, вы всё равно не должны использовать обычные ключи GPG/PGP с pgcrypto, а должны создать новые, учитывая, что это другой сценарий использования.

F.38.4. Низкоуровневые функции защитного преобразования #

Эти функции выполняют только защитное преобразование данных; они не предоставляют расширенные возможности защитного преобразования PGP. Таким образом, с ними связаны следующие проблемы:

  1. Они используют ключ пользователя непосредственно в качестве ключа защитного преобразования.

  2. Они не обеспечивают проверку целостности, которая должна выявлять модификацию защищённых данных.

  3. Они рассчитаны на то, что пользователи будут управлять всеми параметрами защитного преобразования самостоятельно, даже вектором инициализации.

  4. Они не рассчитаны на текст.

Поэтому с появлением поддержки защитного преобразования PGP использовать низкоуровневые функции защитного преобразования не рекомендуется.

encrypt(data bytea, key bytea, type text) returns bytea
decrypt(data bytea, key bytea, type text) returns bytea

encrypt_iv(data bytea, key bytea, iv bytea, type text) returns bytea
decrypt_iv(data bytea, key bytea, iv bytea, type text) returns bytea

Эти функции производят прямое и обратное защитное преобразование данных, применяя метод, заданный параметром type. Строка type имеет следующий формат:

алгоритм [ - режим ] [ /pad: дозаполнение ]

где допустимый алгоритм:

  • bf — Blowfish

  • aes — AES (Rijndael-128, -192 или -256)

допустимый режим:

  • cbc — следующий блок зависит от предыдущего (по умолчанию)

  • cfb — следующий блок зависит от предыдущего защищённого блока

  • ecb — каждый блок защищается отдельно (только для тестирования)

и допустимое дозаполнение:

  • pkcs — данные могут быть любой длины (по умолчанию)

  • none — размер данных должен быть кратен размеру блока защитного преобразования

Так что, например, эти вызовы равнозначны:

encrypt(data, 'fooz', 'bf')
encrypt(data, 'fooz', 'bf-cbc/pad:pkcs')

Для функций encrypt_iv и decrypt_iv параметр iv задаёт начальное значение для режимов CBC и CFB; для ECB он игнорируется. Оно обрезается или дополняется нулями, если его размер не равен ровно размеру блока. В функциях без этого параметра оно по умолчанию заполняется нулями.

F.38.5. Функции получения случайных данных #

gen_random_bytes(count integer) returns bytea

Возвращает защищённые стойкие случайные байты в количестве count. За один вызов можно получить максимум 1024 байт. Это ограничение предотвращает исчерпание пула энтропии.

gen_random_uuid() returns uuid

Возвращает UUID версии 4 (случайный). (Эта функция в данном модуле считается устаревшей, она вызывает одноимённую функцию ядра.)

F.38.6. Вспомогательные функции OpenSSL #

fips_mode() returns boolean

Возвращает true, если OpenSSL работает в режиме FIPS, в противном случае — false.

F.38.7. Параметры конфигурации #

Есть один параметр конфигурации, который управляет поведением pgcrypto.

pgcrypto.builtin_crypto_enabled (enum) #

Параметр pgcrypto.builtin_crypto_enabled определяет, доступны ли для использования встроенные криптографические функции gen_salt() и crypt(). Чтобы отключить эти функции, задайте параметру значение off. Значение on (значение по умолчанию) показывает, что функции работают в обычном режиме. fips отключает эти функции, если обнаруживается, что OpenSSL работает в режиме FIPS.

Функции pgp_sym_encrypt() и pgp_pub_encrypt() не используют встроенное шифрование, поэтому на них это не влияет.

В обычной ситуации этот параметр задаётся в postgresql.conf, хотя суперпользователи могут изменить его «на лету» в рамках своих сеансов.

F.38.8. Примечания #

F.38.8.1. Конфигурирование #

Модуль pgcrypto настраивается согласно установкам, полученным в главном скрипте configure Postgres Pro. На его конфигурацию влияют аргументы --with-zlib и --with-ssl=openssl.

При компиляции с zlib функции защитного преобразования PGP могут сжимать данные перед применением преобразования.

Для работы pgcrypto требуется OpenSSL. Без этой библиотеки модуль не будет собран и установлен.

Чтобы использовать устаревшие алгоритмы защитного преобразования, такие как DES или Blowfish, при компиляции с OpenSSL версии 3.0.0 и выше, нужно активировать поставщиков этих алгоритмов в файле конфигурации openssl.cnf.

F.38.8.2. Обработка NULL #

Как и положено по стандарту SQL, все эти функции возвращают NULL, если один из аргументов — NULL. Это может угрожать безопасности при неаккуратном использовании.

F.38.8.3. Ограничения безопасности #

Все функции pgcrypto выполняются внутри сервера баз данных. Это означает, что все данные и пароли передаются между функциями pgcrypto и клиентскими приложениями открытым текстом. Поэтому вы должны:

  1. Подключаться локально или использовать подключения SSL.

  2. Доверять и системе, и администратору баз данных.

Если это невозможно, лучше произвести защитное преобразование в клиентском приложении.

Эта реализация не противостоит атакам по сторонним каналам. Например, время, требующееся для выполнения функции дешифрования pgcrypto, будет разным для разного шифротекста заданного размера.

F.38.9. Автор #

Марко Крин

Модуль pgcrypto заимствует код из следующих источников:

АлгоритмАвторИсточник исходного кода
Защитное преобразование DESДэвид Буррен и другиеFreeBSD, libcrypt
Хеширование MD5Пол-Хеннинг КампFreeBSD, libcrypt
Защитное преобразование BlowfishSolar Designerwww.openwall.com

F.38. pgcrypto — cryptographic functions #

The pgcrypto module provides cryptographic functions for Postgres Pro.

This module is considered trusted, that is, it can be installed by non-superusers who have CREATE privilege on the current database.

pgcrypto requires OpenSSL and won't be installed if OpenSSL support was not selected when Postgres Pro was built.

F.38.1. General Hashing Functions #

F.38.1.1. digest() #

digest(data text, type text) returns bytea
digest(data bytea, type text) returns bytea

Computes a binary hash of the given data. type is the algorithm to use. Standard algorithms are md5, sha1, sha224, sha256, sha384 and sha512. Moreover, any digest algorithm OpenSSL supports is automatically picked up.

If you want the digest as a hexadecimal string, use encode() on the result. For example:

CREATE OR REPLACE FUNCTION sha1(bytea) returns text AS $$
    SELECT encode(digest($1, 'sha1'), 'hex')
$$ LANGUAGE SQL STRICT IMMUTABLE;

F.38.1.2. hmac() #

hmac(data text, key text, type text) returns bytea
hmac(data bytea, key bytea, type text) returns bytea

Calculates hashed MAC for data with key key. type is the same as in digest().

This is similar to digest() but the hash can only be recalculated knowing the key. This prevents the scenario of someone altering data and also changing the hash to match.

If the key is larger than the hash block size it will first be hashed and the result will be used as key.

F.38.2. Password Hashing Functions #

The functions crypt() and gen_salt() are specifically designed for hashing passwords. crypt() does the hashing and gen_salt() prepares algorithm parameters for it.

The algorithms in crypt() differ from the usual MD5 or SHA-1 hashing algorithms in the following respects:

  1. They are slow. As the amount of data is so small, this is the only way to make brute-forcing passwords hard.

  2. They use a random value, called the salt, so that users having the same password will have different encrypted passwords. This is also an additional defense against reversing the algorithm.

  3. They include the algorithm type in the result, so passwords hashed with different algorithms can co-exist.

  4. Some of them are adaptive — that means when computers get faster, you can tune the algorithm to be slower, without introducing incompatibility with existing passwords.

Table F.23 lists the algorithms supported by the crypt() function.

Table F.23. Supported Algorithms for crypt()

AlgorithmMax Password LengthAdaptive?Salt BitsOutput LengthDescription
bf72yes12860Blowfish-based, variant 2a
md5unlimitedno4834MD5-based crypt
xdes8yes2420Extended DES
des8no1213Original UNIX crypt
sha256cryptunlimitedyesup to 3280Adapted from publicly available reference implementation Unix crypt using SHA-256 and SHA-512
sha512cryptunlimitedyesup to 32123Adapted from publicly available reference implementation Unix crypt using SHA-256 and SHA-512

F.38.2.1. crypt() #

crypt(password text, salt text) returns text

Calculates a crypt(3)-style hash of password. When storing a new password, you need to use gen_salt() to generate a new salt value. To check a password, pass the stored hash value as salt, and test whether the result matches the stored value.

Example of setting a new password:

UPDATE ... SET pswhash = crypt('new password', gen_salt('md5'));

Example of authentication:

SELECT (pswhash = crypt('entered password', pswhash)) AS pswmatch FROM ... ;

This returns true if the entered password is correct.

F.38.2.2. gen_salt() #

gen_salt(type text [, iter_count integer ]) returns text

Generates a new random salt string for use in crypt(). The salt string also tells crypt() which algorithm to use.

The type parameter specifies the hashing algorithm. The accepted types are: des, xdes, md5, bf, sha256crypt and sha512crypt. The last two, sha256crypt and sha512crypt are modern SHA-2 based password hashes.

The iter_count parameter lets the user specify the iteration count, for algorithms that have one. The higher the count, the more time it takes to hash the password and therefore the more time to break it. Although with too high a count the time to calculate a hash may be several years — which is somewhat impractical. If the iter_count parameter is omitted, the default iteration count is used. Allowed values for iter_count depend on the algorithm and are shown in Table F.24.

Table F.24. Iteration Counts for crypt()

AlgorithmDefaultMinMax
xdes725116777215
bf6431
sha256crypt, sha512crypt50001000999999999

For xdes there is an additional limitation that the iteration count must be an odd number.

To pick an appropriate iteration count, consider that the original DES crypt was designed to have the speed of 4 hashes per second on the hardware of that time. Slower than 4 hashes per second would probably dampen usability. Faster than 100 hashes per second is probably too fast.

Table F.25 gives an overview of the relative slowness of different hashing algorithms. The table shows how much time it would take to try all combinations of characters in an 8-character password, assuming that the password contains either only lower case letters, or upper- and lower-case letters and numbers. In the crypt-bf entries, the number after a slash is the iter_count parameter of gen_salt.

The default iter_count for sha256crypt and sha512crypt of 5000 is considered too low for modern hardware, but can be adjusted to generate stronger password hashes. Otherwise both hashes, sha256crypt and sha512crypt are considered safe.

Table F.25. Hash Algorithm Speeds

AlgorithmHashes/secFor [a-z]For [A-Za-z0-9]Duration relative to md5 hash
crypt-bf/817924 years3927 years100k
crypt-bf/736482 years1929 years50k
crypt-bf/671681 year982 years25k
crypt-bf/513504188 days521 years12.5k
crypt-md517158415 days41 years1k
crypt-des23221568157.5 minutes108 days7
sha13777427290 minutes68 days4
md5 (hash)15008550422.5 minutes17 days1

Notes:

  • The machine used is an Intel Mobile Core i3.

  • crypt-des and crypt-md5 algorithm numbers are taken from John the Ripper v1.6.38 -test output.

  • md5 hash numbers are from mdcrack 1.2.

  • sha1 numbers are from lcrack-20031130-beta.

  • crypt-bf numbers are taken using a simple program that loops over 1000 8-character passwords. That way the speed with different numbers of iterations can be shown. For reference: john -test shows 13506 loops/sec for crypt-bf/5. (The very small difference in results is in accordance with the fact that the crypt-bf implementation in pgcrypto is the same one used in John the Ripper.)

Note that try all combinations is not a realistic exercise. Usually password cracking is done with the help of dictionaries, which contain both regular words and various mutations of them. So, even somewhat word-like passwords could be cracked much faster than the above numbers suggest, while a 6-character non-word-like password may escape cracking. Or not.

F.38.3. PGP Encryption Functions #

The functions here implement the encryption part of the OpenPGP (RFC 4880) standard. Supported are both symmetric-key and public-key encryption.

An encrypted PGP message consists of 2 parts, or packets:

  • Packet containing a session key — either symmetric-key or public-key encrypted.

  • Packet containing data encrypted with the session key.

When encrypting with a symmetric key (i.e., a password):

  1. The given password is hashed using a String2Key (S2K) algorithm. This is rather similar to crypt() algorithms — purposefully slow and with random salt — but it produces a full-length binary key.

  2. If a separate session key is requested, a new random key will be generated. Otherwise the S2K key will be used directly as the session key.

  3. If the S2K key is to be used directly, then only S2K settings will be put into the session key packet. Otherwise the session key will be encrypted with the S2K key and put into the session key packet.

When encrypting with a public key:

  1. A new random session key is generated.

  2. It is encrypted using the public key and put into the session key packet.

In either case the data to be encrypted is processed as follows:

  1. Optional data-manipulation: compression, conversion to UTF-8, and/or conversion of line-endings.

  2. The data is prefixed with a block of random bytes. This is equivalent to using a random IV.

  3. A SHA-1 hash of the random prefix and data is appended.

  4. All this is encrypted with the session key and placed in the data packet.

F.38.3.1. pgp_sym_encrypt() #

pgp_sym_encrypt(data text, psw text [, options text ]) returns bytea
pgp_sym_encrypt_bytea(data bytea, psw text [, options text ]) returns bytea

Encrypt data with a symmetric PGP key psw. The options parameter can contain option settings, as described below.

F.38.3.2. pgp_sym_decrypt() #

pgp_sym_decrypt(msg bytea, psw text [, options text ]) returns text
pgp_sym_decrypt_bytea(msg bytea, psw text [, options text ]) returns bytea

Decrypt a symmetric-key-encrypted PGP message.

Decrypting bytea data with pgp_sym_decrypt is disallowed. This is to avoid outputting invalid character data. Decrypting originally textual data with pgp_sym_decrypt_bytea is fine.

The options parameter can contain option settings, as described below.

F.38.3.3. pgp_pub_encrypt() #

pgp_pub_encrypt(data text, key bytea [, options text ]) returns bytea
pgp_pub_encrypt_bytea(data bytea, key bytea [, options text ]) returns bytea

Encrypt data with a public PGP key key. Giving this function a secret key will produce an error.

The options parameter can contain option settings, as described below.

F.38.3.4. pgp_pub_decrypt() #

pgp_pub_decrypt(msg bytea, key bytea [, psw text [, options text ]]) returns text
pgp_pub_decrypt_bytea(msg bytea, key bytea [, psw text [, options text ]]) returns bytea

Decrypt a public-key-encrypted message. key must be the secret key corresponding to the public key that was used to encrypt. If the secret key is password-protected, you must give the password in psw. If there is no password, but you want to specify options, you need to give an empty password.

Decrypting bytea data with pgp_pub_decrypt is disallowed. This is to avoid outputting invalid character data. Decrypting originally textual data with pgp_pub_decrypt_bytea is fine.

The options parameter can contain option settings, as described below.

F.38.3.5. pgp_key_id() #

pgp_key_id(bytea) returns text

pgp_key_id extracts the key ID of a PGP public or secret key. Or it gives the key ID that was used for encrypting the data, if given an encrypted message.

It can return 2 special key IDs:

  • SYMKEY

    The message is encrypted with a symmetric key.

  • ANYKEY

    The message is public-key encrypted, but the key ID has been removed. That means you will need to try all your secret keys on it to see which one decrypts it. pgcrypto itself does not produce such messages.

Note that different keys may have the same ID. This is rare but a normal event. The client application should then try to decrypt with each one, to see which fits — like handling ANYKEY.

F.38.3.6. armor(), dearmor() #

armor(data bytea [ , keys text[], values text[] ]) returns text
dearmor(data text) returns bytea

These functions wrap/unwrap binary data into PGP ASCII-armor format, which is basically Base64 with CRC and additional formatting.

If the keys and values arrays are specified, an armor header is added to the armored format for each key/value pair. Both arrays must be single-dimensional, and they must be of the same length. The keys and values cannot contain any non-ASCII characters.

F.38.3.7. pgp_armor_headers #

pgp_armor_headers(data text, key out text, value out text) returns setof record

pgp_armor_headers() extracts the armor headers from data. The return value is a set of rows with two columns, key and value. If the keys or values contain any non-ASCII characters, they are treated as UTF-8.

F.38.3.8. Options for PGP Functions #

Options are named to be similar to GnuPG. An option's value should be given after an equal sign; separate options from each other with commas. For example:

pgp_sym_encrypt(data, psw, 'compress-algo=1, cipher-algo=aes256')

All of the options except convert-crlf apply only to encrypt functions. Decrypt functions get the parameters from the PGP data.

The most interesting options are probably compress-algo and unicode-mode. The rest should have reasonable defaults.

F.38.3.8.1. cipher-algo #

Which cipher algorithm to use.


Values: bf, aes128, aes192, aes256, 3des, cast5
Default: aes128
Applies to: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.2. compress-algo #

Which compression algorithm to use. Only available if Postgres Pro was built with zlib.


Values:
  0 - no compression
  1 - ZIP compression
  2 - ZLIB compression (= ZIP plus meta-data and block CRCs)
Default: 0
Applies to: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.3. compress-level #

How much to compress. Higher levels compress smaller but are slower. 0 disables compression.


Values: 0, 1-9
Default: 6
Applies to: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.4. convert-crlf #

Whether to convert \n into \r\n when encrypting and \r\n to \n when decrypting. RFC 4880 specifies that text data should be stored using \r\n line-feeds. Use this to get fully RFC-compliant behavior.


Values: 0, 1
Default: 0
Applies to: pgp_sym_encrypt, pgp_pub_encrypt, pgp_sym_decrypt, pgp_pub_decrypt

F.38.3.8.5. disable-mdc #

Do not protect data with SHA-1. The only good reason to use this option is to achieve compatibility with ancient PGP products, predating the addition of SHA-1 protected packets to RFC 4880. Recent gnupg.org and pgp.com software supports it fine.


Values: 0, 1
Default: 0
Applies to: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.6. sess-key #

Use separate session key. Public-key encryption always uses a separate session key; this option is for symmetric-key encryption, which by default uses the S2K key directly.


Values: 0, 1
Default: 0
Applies to: pgp_sym_encrypt

F.38.3.8.7. s2k-mode #

Which S2K algorithm to use.


Values:
  0 - Without salt.  Dangerous!
  1 - With salt but with fixed iteration count.
  3 - Variable iteration count.
Default: 3
Applies to: pgp_sym_encrypt

F.38.3.8.8. s2k-count #

The number of iterations of the S2K algorithm to use. It must be a value between 1024 and 65011712, inclusive.


Default: A random value between 65536 and 253952
Applies to: pgp_sym_encrypt, only with s2k-mode=3

F.38.3.8.9. s2k-digest-algo #

Which digest algorithm to use in S2K calculation.


Values: md5, sha1
Default: sha1
Applies to: pgp_sym_encrypt

F.38.3.8.10. s2k-cipher-algo #

Which cipher to use for encrypting separate session key.


Values: bf, aes, aes128, aes192, aes256
Default: use cipher-algo
Applies to: pgp_sym_encrypt

F.38.3.8.11. unicode-mode #

Whether to convert textual data from database internal encoding to UTF-8 and back. If your database already is UTF-8, no conversion will be done, but the message will be tagged as UTF-8. Without this option it will not be.


Values: 0, 1
Default: 0
Applies to: pgp_sym_encrypt, pgp_pub_encrypt

F.38.3.8.12. ignore-cipher-failure #

Dangerous! Instructs pgcrypto to use an incorrect decryption algorithm matching the historical behavior prior to the fix for CVE-2026-14663, by completely ignoring failures from the OpenSSL cipher in use. This is intended only for users who need to recover incorrectly-encrypted messages created when the cipher-algo was unavailable under the OpenSSL configuration in use. Such faulty messages do not require the correct decryption key when ignore-cipher-failure is enabled, so there is no guarantee that the decrypted plaintext actually originated from a holder of the key.

Contrast the case of a message which was correctly encrypted, but the cipher that produced it is unavailable under the current OpenSSL configuration. Recovering such plaintext via pgcrypto requires making the actual cipher available to OpenSSL by, for example, enabling the appropriate provider. ignore-cipher-failure is not necessary or helpful for that scenario. If decryption of a correctly encrypted message with this option happens to pass PGP integrity checks, that result is coincidental and does not make the recovered plaintext trustworthy.


Values: 0, 1
Default: 0
Applies to: pgp_sym_decrypt, pgp_pub_decrypt

F.38.3.9. Generating PGP Keys with GnuPG #

To generate a new key:

gpg --gen-key

The preferred key type is DSA and Elgamal.

For RSA encryption you must create either DSA or RSA sign-only key as master and then add an RSA encryption subkey with gpg --edit-key.

To list keys:

gpg --list-secret-keys

To export a public key in ASCII-armor format:

gpg -a --export KEYID > public.key

To export a secret key in ASCII-armor format:

gpg -a --export-secret-keys KEYID > secret.key

You need to use dearmor() on these keys before giving them to the PGP functions. Or if you can handle binary data, you can drop -a from the command.

For more details see man gpg, The GNU Privacy Handbook and other documentation on https://www.gnupg.org/.

F.38.3.10. Limitations of PGP Code #

  • No support for signing. That also means that it is not checked whether the encryption subkey belongs to the master key.

  • No support for encryption key as master key. As such practice is generally discouraged, this should not be a problem.

  • No support for several subkeys. This may seem like a problem, as this is common practice. On the other hand, you should not use your regular GPG/PGP keys with pgcrypto, but create new ones, as the usage scenario is rather different.

F.38.4. Raw Encryption Functions #

These functions only run a cipher over data; they don't have any advanced features of PGP encryption. Therefore they have some major problems:

  1. They use user key directly as cipher key.

  2. They don't provide any integrity checking, to see if the encrypted data was modified.

  3. They expect that users manage all encryption parameters themselves, even IV.

  4. They don't handle text.

So, with the introduction of PGP encryption, usage of raw encryption functions is discouraged.

encrypt(data bytea, key bytea, type text) returns bytea
decrypt(data bytea, key bytea, type text) returns bytea

encrypt_iv(data bytea, key bytea, iv bytea, type text) returns bytea
decrypt_iv(data bytea, key bytea, iv bytea, type text) returns bytea

Encrypt/decrypt data using the cipher method specified by type. The syntax of the type string is:

algorithm [ - mode ] [ /pad: padding ]

where algorithm is one of:

  • bf — Blowfish

  • aes — AES (Rijndael-128, -192 or -256)

and mode is one of:

  • cbc — next block depends on previous (default)

  • cfb — next block depends on previous encrypted block

  • ecb — each block is encrypted separately (for testing only)

and padding is one of:

  • pkcs — data may be any length (default)

  • none — data must be multiple of cipher block size

So, for example, these are equivalent:

encrypt(data, 'fooz', 'bf')
encrypt(data, 'fooz', 'bf-cbc/pad:pkcs')

In encrypt_iv and decrypt_iv, the iv parameter is the initial value for the CBC and CFB mode; it is ignored for ECB. It is clipped or padded with zeroes if not exactly block size. It defaults to all zeroes in the functions without this parameter.

F.38.5. Random-Data Functions #

gen_random_bytes(count integer) returns bytea

Returns count cryptographically strong random bytes. At most 1024 bytes can be extracted at a time. This is to avoid draining the randomness generator pool.

gen_random_uuid() returns uuid

Returns a version 4 (random) UUID. (Obsolete, this function internally calls the core function of the same name.)

F.38.6. OpenSSL Support Functions #

fips_mode() returns boolean

Returns true if OpenSSL is running with FIPS mode enabled, otherwise false.

F.38.7. Configuration Parameters #

There is one configuration parameter that controls the behavior of pgcrypto.

pgcrypto.builtin_crypto_enabled (enum) #

pgcrypto.builtin_crypto_enabled determines if the built in crypto functions gen_salt(), and crypt() are available for use. Setting this to off disables these functions. on (the default) enables these functions to work normally. fips disables these functions if OpenSSL is detected to operate in FIPS mode.

pgp_sym_encrypt() and pgp_pub_encrypt() do not use built in crypto so they are not affected.

In ordinary usage, this parameter is set in postgresql.conf, although superusers can alter it on-the-fly within their own sessions.

F.38.8. Notes #

F.38.8.1. Configuration #

pgcrypto configures itself according to the findings of the main Postgres Pro configure script. The options that affect it are --with-zlib and --with-ssl=openssl.

When compiled with zlib, PGP encryption functions are able to compress data before encrypting.

pgcrypto requires OpenSSL. Otherwise, it will not be built or installed.

When compiled against OpenSSL 3.0.0 and later versions, the legacy provider must be activated in the openssl.cnf configuration file in order to use older ciphers like DES or Blowfish.

F.38.8.2. NULL Handling #

As is standard in SQL, all functions return NULL, if any of the arguments are NULL. This may create security risks on careless usage.

F.38.8.3. Security Limitations #

All pgcrypto functions run inside the database server. That means that all the data and passwords move between pgcrypto and client applications in clear text. Thus you must:

  1. Connect locally or use SSL connections.

  2. Trust both system and database administrator.

If you cannot, then better do crypto inside client application.

The implementation does not resist side-channel attacks. For example, the time required for a pgcrypto decryption function to complete varies among ciphertexts of a given size.

F.38.9. Author #

Marko Kreen

pgcrypto uses code from the following sources:

AlgorithmAuthorSource origin
DES cryptDavid Burren and othersFreeBSD libcrypt
MD5 cryptPoul-Henning KampFreeBSD libcrypt
Blowfish cryptSolar Designerwww.openwall.com
FAQ