Como gerar chave gpg sem interação do usuário?

Encontrei no método https://www.gnupg.org/documentation/manuals/gnupg/Unattended-GPG-key-generation.html#Unattended-GPG-key-generation para gerar chaves gpg sem interação do usuário, mas isso não acontece parece funcionar.

Meu script é:

#!/usr/bin/env bash
rm -rf .gnupg
mkdir -m 0700 .gnupg
touch .gnupg/gpg.conf
chmod 600 .gnupg/gpg.conf
tail -n +4 /usr/share/gnupg2/gpg-conf.skel > .gnupg/gpg.conf

touch .gnupg/{pub,sec}ring.gpg


cat >.gnupg/foo <<EOF
    %echo Generating a basic OpenPGP key
    Key-Type: RSA
    Key-Length: 2048
    Subkey-Type: RSA
    Subkey-Length: 2048
    Name-Real: User 1
    Name-Comment: User 1
    Name-Email: [email protected]
    Expire-Date: 0
    Passphrase: kljfhslfjkhsaljkhsdflgjkhsd
    %pubring foo.pub
    %secring foo.sec
    # Do a commit here, so that we can later print "done" :-)
    %commit
    %echo done
EOF

gpg2 --verbose --batch --gen-key .gnupg/foo

Quando eu o executo, ele mostra:

=$ ./gen.keys.sh 
gpg: Generating a basic OpenPGP key
gpg: no running gpg-agent - starting one
gpg: writing public key to `foo.pub'
gpg: writing secret key to `foo.sec'

Mas então isso simplesmente trava.

Quando eu verifico, nesse meio tempo, a árvore ps para esse usuário, vejo:

USER       PID %CPU %MEM    VSZ   RSS TTY      STAT START   TIME COMMAND
tstpg    22603  0.0  0.0  24108  5688 pts/9    Ss   14:59   0:00 -bash
tstpg    22624  0.0  0.0  13688  3168 pts/9    S+   14:59   0:00  \_ bash ./gen.keys.sh
tstpg    22632  0.2  0.0  27428  3676 pts/9    SL+  14:59   0:00      \_ gpg2 --verbose --batch --gen-key .gnupg/foo
tstpg    22634  0.3  0.0  18072  2884 pts/9    SL+  14:59   0:00          \_ gpg-agent --server

No ~ / .gnupg / gpg.conf não há menção sobre o agente, e eu não tenho ideia do que ele está tentando fazer.

Os arquivos foo.pub/foo.sec são gerados no diretório home, mas estão vazios.

o que estou perdendo? Como gerar a chave sem nenhum tipo de interação do usuário?

Versões:

• gpg (GnuPG) 2.0.26
• libgcrypt 1.6.2

É provável que você esteja ficando sem entropia. A geração de chaves requer muitos números aleatórios de alta qualidade; sem a atividade do usuário de fornecer aleatoriedade de alta qualidade ao computador, o pool de entropia está sendo esgotado por geração, e o processo de geração é interrompido, aguardando a recarga do pool.

Suas escolhas, em ordem crescente de satisfação, são

1. reconfigurando o gpg para usar o gerador de números pseudo-aleatórios sem bloqueio, o que seria mais imprudente (embora veja abaixo),

2. usando uma solução de software para derivar mais entropia do estado existente do sistema (o kernel é notoriamente conservador sobre a quantidade de entropia preparada para derivar do estado do sistema, particularmente onde esse estado não tem entrada humana direta, por exemplo, temporizações de CPU ou NIC); como você apontou, haveged é uma dessas soluções, ou

3. fornecendo ao computador outra fonte física de entropia de alto grau. Dispositivos como a Chave de Entropia ou o OneRNG podem atender a esse requisito (não tenho conexão com nenhum dos produtos, exceto que eu possuo uma Chave de Entropia e estou muito feliz com isso).

Edit : mzhaase chama minha atenção em um comentário para este artigo em / dev / urandom vs. / dev / random (pelo qual muito obrigado, é um excelente artigo!) E discorda de minha aversão ao usar urandompara criar chaves. De fato, o artigo não diz que as duas fontes são equivalentes e observa que

Felizmente, o / dev / urandom do Linux fornece números não tão aleatórios antes que o kernel tivesse a chance de coletar entropia. Quando é isso? Na inicialização do sistema, inicializando o computador.

Isto é, após a inicialização, até que o urandomPRNG seja inicializado com entropia suficiente, é realmente inseguro usá-lo para geração de chaves. Isso pode levar um tempo, especialmente em um servidor autônomo e sem cabeça, e não sabemos quando o limite foi atingido, porque o sistema não nos diz explicitamente.

Agora, se /dev/randomestiver preparado para emitir números, posso inferir razoavelmente que o pool de entropia é profundo o suficiente para que urandomtenha sido inicializado corretamente. Mas se eu tiver que verificar o /dev/randombloqueio antes de cada uso de urandom(que, como é possível gerar chaves com menos frequência do que reinicializo, é provável que seja o caso), é melhor usar os números de /dev/randompara gerar minhas chaves.

Descobri que existem algumas mudanças simples que fazem seu script funcionar. Também incluí alguns testes para que, uma vez criada a chave, ela seja automaticamente testada.

Também removi a senha para que os principais testes possam ser automatizados.

#!/usr/bin/env bash
rm -rf .gnupg
mkdir -m 0700 .gnupg
touch .gnupg/gpg.conf
chmod 600 .gnupg/gpg.conf
tail -n +4 /usr/share/gnupg2/gpg-conf.skel > .gnupg/gpg.conf

cd .gnupg
# I removed this line since these are created if a list key is done.
# touch .gnupg/{pub,sec}ring.gpg
gpg2 --list-keys


cat >keydetails <<EOF
    %echo Generating a basic OpenPGP key
    Key-Type: RSA
    Key-Length: 2048
    Subkey-Type: RSA
    Subkey-Length: 2048
    Name-Real: User 1
    Name-Comment: User 1
    Name-Email: [email protected]
    Expire-Date: 0
    %no-ask-passphrase
    %no-protection
    %pubring pubring.kbx
    %secring trustdb.gpg
    # Do a commit here, so that we can later print "done" :-)
    %commit
    %echo done
EOF

gpg2 --verbose --batch --gen-key keydetails

# Set trust to 5 for the key so we can encrypt without prompt.
echo -e "5\ny\n" |  gpg2 --command-fd 0 --expert --edit-key [email protected] trust;

# Test that the key was created and the permission the trust was set.
gpg2 --list-keys

# Test the key can encrypt and decrypt.
gpg2 -e -a -r [email protected] keydetails

# Delete the options and decrypt the original to stdout.
rm keydetails
gpg2 -d keydetails.asc
rm keydetails.asc

Resolvido isso como parte da geração de chaves para uma instalação automatizada de aplicativos. Instalar e iniciar o pacote ' rngd ' para gerar entroy corrigirá o seu problema. Simples de instalar e usar.

Aqui está o código .

• Inicia rngd ( /dev/hwrandompor padrão, mas modificável) para fornecer uma fonte de entropia
• Copia um modelo simples (substitua o e-mail e o nome do modelo jinja pelo que você deseja)
• gera uma chave usando gpg
• importa para o chaveiro local

Aqui está um que você poderia usar, mas eu recomendaria executar este script em um novo terminal para não afetar o atual. Esse script continuará gerando entropia mantendo a máquina ocupada e presa em um loop infinito até que um usuário saia do script. Nenhuma interação do usuário é necessária até após a geração da chave. Tudo o que o script faz é listar arquivos para sempre.

Pode levar alguns minutos (às vezes 10 ou mais) para gerar, dependendo da sua máquina e tamanho da chave, mas é bom não ter que interagir com ela.

#!/bin/sh

while true;
do find * / && find * / && find * / && find * / && find * / && find * / && find * / && find * / && find * /;

echo "Press ctrl+c to exit this infinite loop"
sleep 2;
done