Генерация пары RSA 2048: через openssl 0.5s через gpg 30s, в чем разница?

Генерация пар ключей RSA 2048: через openssl 0.5s через gpg 30s, почему разница Есть несколько программ, которые могут генерировать открытые / закрытые пары ключей RSA

Например, в GnuPG / OpenPGP волшебник вызывается через

gpg --gen-key

OpenSSL может генерировать пару ключей, используя эти командные строки

openssl genrsa -out testkey.private 2048
openssl rsa -in testkey.private -pubout -out testkey.public

для той же самой вещи, которая генерирует пару ключей RSA 2048, которую я могу воспринимать - на одной и той же машине - очень разные времена.

opensslгенерирует пару ключей примерно за 0,5 с,
gpgзанимает около 30, и даже реклама "двигать мышь, чтобы генерировать случайность / энтропию"

Можно ли объяснить разницу? Я знаю, что gpg делает немного больше, чем просто создание ключа RSA, но я специально выбрал вариант (4)

Пожалуйста, выберите, какой ключ вы хотите:
   (1) RSA и RSA (по умолчанию)
   (2) DSA и Эльгамал
   (3) DSA (только подпись)
   (4) RSA (только подпись)
Ваш выбор?

Поэтому на самом деле генерируется только 2048-битная пара ключей RSA. И все же разница во времени уменьшается на 30 секунд?

Мне кажется, что либо gpg напрасно тратит время, либо OpenSSL не ждет достаточно времени и, следовательно, создает небезопасные ключи.

Мой вопрос, что может объяснить разницу?

Обновить

Создание RSA должно быть случайным. Следовательно, чтобы убедиться, что быстрый openssl - это не просто результат использования некоторой накопленной случайности, я запускаю его несколько раз

time bash -c "для i в {1..50}; сделать openssl genrsa -out / dev / null 2048; сделано;"

что дает

реальный 0m16.577s
пользователь 0m16.309s
sys 0m0.092s

что означает, что для 50 2048-битных ключей RSA (я полагаю, нужно много энтропии / случайности) openssl все еще требуется всего 16 секунд. Мое предположение здесь, следовательно, будет «ответом», что openssl должен быть нарушен. В конце концов, я не доверяю тому, что мой Linux (ядро 3.2.0-59) настолько хорош в генерировании случайности.

Возможно, разница в том, что openssl использует /dev/urandomи gpg использует, /dev/randomчто если true может объяснить разницу во времени, то моя проблема в том, что я не знаю, как я узнаю об этом, чтобы это проверить.

Update2

Чтобы проверить источник случайного openssl я использовал

strace -xe trace = файл, чтение, запись, закрытие openssl genrsa -out testkey5.private 2048 2> & 1 | grep random -A1

что дает

open ("/ dev / urandom", O_RDONLY | O_NOCTTY | O_NONBLOCK) = 4
читать (4, "\ x21 \ xd8 \ xaa \ xf1 \ x2b \ x5f \ x4a \ x89 \ x5d \ x6c \ x58 \ x82 \ xc1 \ x88 \ x21 \ x04 \ xfa \ x5b \ x18 \ x98 \ x8a \ x34 \ x2b \ xe3 \ xf3 \ xc0 \ xb1 \ xef \ xfb \ x44 \ x15 \ x09 ", 32) = 32

так что кажется, что 32 байта из /dev/urandom(не «лучшего» /dev/random) достаточно для 2048-битной пары ключей RSA в openssl. Поэтому так быстро!

измерения

2048bit RSA означает создание пары ключей

• Только 32 байта /dev/urandom(используя openssl)
• 300 байт /dev/random(используя openPGP GNU Privacy Guard)

это объясняет конечно разницу во времени!

GnuPG потребляет несколько байтов /dev/randomдля каждого случайного байта, который он фактически использует. Вы можете легко проверить это с помощью этой команды:

start cmd:> strace -e trace=open,read gpg --armor --gen-random 2 16 2>&1 | tail
open("/etc/gcrypt/rngseed", O_RDONLY)   = -1 ENOENT (No such file or directory)
open("/dev/urandom", O_RDONLY)          = 3
read(3, "\\\224F\33p\314j\235\7\200F9\306V\3108", 16) = 16
open("/dev/random", O_RDONLY)           = 4
read(4, "/\311\342\377...265\213I"..., 300) = 128
read(4, "\325\3\2161+1...302@\202"..., 172) = 128
read(4, "\5[\372l\16?\...6iY\363z"..., 44) = 44
open("/home/hl/.gnupg/random_seed", O_WRONLY|O_CREAT, 0600) = 5
cCVg2XuvdjzYiV0RE1uzGQ==
+++ exited with 0 +++

Чтобы вывести 16 байтов высококачественной энтропии, GnuPG считывает 300 байтов из /dev/random.

Это объясняется здесь: Архитектура подсистемы с произвольным числом

Linux хранит максимум 4096 байт (см. cat /proc/sys/kernel/random/poolsize) Энтропии. Если процессу требуется больше, чем доступно (см. cat /proc/sys/kernel/random/entropy_avail), Тогда загрузка ЦП становится более или менее неактуальной, так как скорость подачи пула энтропии ядра становится релевантным фактором.

Ваше предположение, что это различие, потому что opensslиспользует / dev / urandom и gpgиспользует /dev/randomправильно.

Вы можете наблюдать снижение доступной энтропии при генерации ключей с gpgпомощью:

watch -n 1 cat /proc/sys/kernel/random/entropy_avail

Я использовал программу для генерации описания шагов по настройке смарт-карты OpenGPG с помощьюgpg , поэтому мне пришлось запускаться gpgнесколько раз, пока все не заработало как задумано. После начальных прогонов я заметил, /dev/randomчто энтропии будет недостаточно, и gpg просто остановится в ожидании накопления новой энтропии.

Я написал небольшую программу для предоставления дополнительных неслучайных данных, и при этом gpgне "останавливался", а генерировал ключи почти сразу: это удобно для проверки правильности работы скрипта, но, конечно, это не то, что вы должны делать при генерации своего реального ключи.

Программа для ускорения gpg( не используйте в реальных ситуациях ):

# For testing purposes only 
# DO NOT USE THIS, tHIS DOES NOT PROVIDE ENTROPY TO /dev/random

import fcntl
import time
import struct

RNDADDENTROPY=0x40085203

while True:
    random = "3420348024823049823-984230942049832423l4j2l42j"
    t = struct.pack("ii32s", 8, 32, random)
    with open("/dev/random", mode='wb') as fp:
        # as fp has a method fileno(), you can pass it to ioctl
        res = fcntl.ioctl(fp, RNDADDENTROPY, t)
        time.sleep(0.001)

Когда я запускаю это во время просмотра, entropy_availя вижу, что доступная энтропия возрастает до 3800.