Aviso de fim do suporte: em 7 de outubro de 2026, AWS o suporte para o. AWS IoT Greengrass Version 1 Depois de 7 de outubro de 2026, você não poderá mais acessar os AWS IoT Greengrass V1 recursos. Para obter mais informações, visite [Migrar de AWS IoT Greengrass Version 1](https://docs.aws.amazon.com/greengrass/v2/developerguide/migrate-from-v1.html).
As traduções são geradas por tradução automática. Em caso de conflito entre o conteúdo da tradução e da versão original em inglês, a versão em inglês prevalecerá.
# Módulo 7: Simular a integração de segurança de hardware
Esse recurso está disponível para AWS IoT Greengrass Core v1.7 e versões posteriores.
Esse módulo avançado mostra como configurar a simulação de um módulo de segurança de hardware (HSM) para uso com um núcleo do Greengrass. A configuração usa SoftHSM puro, que é uma implementação de software de [PKCS\$111](#console-mod7-see-also) que usa a interface de programação de aplicativo (API). O objetivo deste módulo é permitir que você configure um ambiente no qual você pode aprender e fazer testes iniciais em uma implementação apenas para software da API do PKCS\$111. Ele é fornecido apenas para fins de aprendizagem e testes iniciais, não é destinado a nenhum uso para produção.
Você pode usar esta configuração para teste usando um serviço compatível com PKCS\$111 a fim de armazenar suas chaves privadas. Para obter mais informações sobre a implementação somente para software, consulte [SoftHSM](https://www.opendnssec.org/softhsm/). Para obter mais informações sobre a integração da segurança de hardware em um AWS IoT Greengrass núcleo, incluindo requisitos gerais, consulte[Integração de segurança de hardware](hardware-security.md).
**Importante**
Este módulo é destinado somente a fins de experimentos. Não recomendamos em hipótese alguma o uso de SoftHSM em um ambiente de produção, pois ele pode fornecer uma falsa sensação de segurança adicional. A configuração resultante não fornece todos os benefícios de segurança reais. As chaves armazenadas em SoftHSM não são armazenadas com mais segurança do que qualquer outro meio de armazenamento de segredos no ambiente do Greengrass.
O objetivo deste módulo é permitir que você saiba mais sobre a especificação PKCS\$111 e que faça testes iniciais do seu software se, futuramente, você planejar usar um HSM com base em hardware real
Você deve testar sua implementação futura de hardware de forma separada e completa antes de qualquer uso de produção, pois pode haver diferenças entre a implementação PKCS\$111 fornecida no SoftHSM e uma implementação baseada em hardware.
Se precisar de ajuda com a integração de um [módulo de segurança de hardware compatível](hardware-security.md#hardware-security-reqs), entre em contato com seu representante do AWS Enterprise Support.
Antes de começar, execute o script de [configuração do dispositivo do Greengrass](quick-start.md) ou verifique se você concluiu o [módulo 1](module1.md) e o [módulo 2](module2.md) do tutorial Conceitos básicos. Neste módulo, presumimos que seu núcleo já esteja provisionado e se comunicando com. AWS Este modulo levará aproximadamente 30 minutos para ser concluído.
## Instalar o software SoftHSM
Nesta etapa, você instala o SoftHSM e as ferramentas pkcs11, que são usados para gerenciar sua instância SoftHSM.
+ Em um terminal no seu dispositivo AWS IoT Greengrass principal, execute o seguinte comando:
```
sudo apt-get install softhsm2 libsofthsm2-dev pkcs11-dump
```
Para obter mais informações sobre esses pacotes, consulte [Instalar softhsm2](https://www.howtoinstall.co/en/ubuntu/xenial/softhsm2), [Instalar libsofthsm2-dev](https://www.howtoinstall.co/en/ubuntu/xenial/libsofthsm2-dev), e [Instalar pkcs11-despejo](https://www.howtoinstall.co/en/ubuntu/xenial/pkcs11-dump).
**nota**
Se você encontrar problemas ao usar esse comando em seu sistema, consulte [SoftHSM versão 2](https://github.com/opendnssec/SoftHSMv2) em. GitHub Esse site fornece mais informações de instalação, incluindo a criação a partir do código-fonte.
## Configure o SoftHSM
Nesta etapa, você [configura o SoftHSM](https://github.com/opendnssec/SoftHSMv2#configure-1).
1. Mude para o usuário raiz.
```
sudo su
```
1. Use a página do manual para encontrar o `softhsm2.conf` no âmbito do sistema local. Um local comum é `/etc/softhsm/softhsm2.conf`, mas a localização pode ser diferente em alguns sistemas.
```
man softhsm2.conf
```
1. Crie o diretório para o arquivo de configuração softhsm2 no âmbito do sistema local. Neste exemplo, supomos que o local é `/etc/softhsm/softhsm2.conf`.
```
mkdir -p /etc/softhsm
```
1. Crie o diretório do token no diretório `/greengrass`.
**nota**
Se esta etapa for ignorada, o softhsm2-util relatará `ERROR: Could not initialize the library`.
```
mkdir -p /greengrass/softhsm2/tokens
```
1. Configure o diretório do token.
```
echo "directories.tokendir = /greengrass/softhsm2/tokens" > /etc/softhsm/softhsm2.conf
```
1. Configure um back-end baseado em arquivo.
```
echo "objectstore.backend = file" >> /etc/softhsm/softhsm2.conf
```
**nota**
Essas definições de configuração são projetadas para fins de experimentação apenas. Para consultar todas as opções de configuração, leia a página do manual para o arquivo de configuração.
```
man softhsm2.conf
```
## Importar a chave privada para o SoftHSM
Nesta etapa, você inicialize o token do SoftHSM, converte a chave privada e, em seguida, importa a chave privada.
1. Inicialize o token do SoftHSM.
```
softhsm2-util --init-token --slot 0 --label greengrass --so-pin 12345 --pin 1234
```
**nota**
Se solicitado, insira um pin de SO `12345` e um pin de usuário de `1234`. O AWS IoT Greengrass não usa o pin de SO (supervisor), portanto, você pode utilizar qualquer valor.
Se você receber o erro `CKR_SLOT_ID_INVALID: Slot 0 does not exist`, tente o seguinte comando em vez disso:
```
softhsm2-util --init-token --free --label greengrass --so-pin 12345 --pin 1234
```
1. Converta a chave privada em um formato que possa ser usado pela ferramenta de importação do SoftHSM. Para este tutorial, converta a chave privada obtida na opção **Default Group creation (Criação de grupo padrão)** no [Módulo 2](module2.md) do tutorial de Conceitos básicos.
```
openssl pkcs8 -topk8 -inform PEM -outform PEM -nocrypt -in hash.private.key -out hash.private.pem
```
1. Importar a chave privada para o SoftHSM. Execute apenas um dos seguintes comandos, dependendo da sua versão do softhsm2-util.
**Raspbian softhsm2-util** sintaxe v2.2.0
```
softhsm2-util --import hash.private.pem --token greengrass --label iotkey --id 0000 --pin 12340
```
**Ubuntu softhsm2-util** sintaxe v2.0.0
```
softhsm2-util --import hash.private.pem --slot 0 --label iotkey --id 0000 --pin 1234
```
Esse comando identifica o slot como `0` e define o rótulo de chave como `iotkey`. Você usa esses valores na próxima seção.
Após a chave privada ser importada, você tem a opção de removê-la do diretório `/greengrass/certs`. Certifique-se de manter a CA raiz e os certificados do dispositivo no diretório.
## Configurar o núcleo do Greengrass para usar o SoftHSM
Nesta etapa, você modifica o arquivo de configuração do núcleo do Greengrass para usar o SoftHSM.
1. Encontre o caminho para a biblioteca do provedor SoftHSM (`libsofthsm2.so`) no seu sistema:
1. Obtenha a lista de pacotes instalados para a biblioteca.
```
sudo dpkg -L libsofthsm2
```
O arquivo `libsofthsm2.so` está localizado no diretório `softhsm`.
1. Copiar o caminho completo para o arquivo (por exemplo, `/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so`). Você usará esse valor posteriormente.
1. Pare o daemon do Greengrass.
```
cd /greengrass/ggc/core/
sudo ./greengrassd stop
```
1. Abra o arquivo de configuração do Greengrass. Este é o arquivo [`config.json`](gg-core.md#config-json) no diretório `/greengrass/config`.
**nota**
Os exemplos neste procedimento são gravados com a suposição de que o arquivo `config.json` usa o formato gerado a com a opção **Default Group creation (Criação de grupo padrão)** no [Módulo 2](module2.md) do tutorial de Conceitos básicos.
1. No objeto `crypto.principals`, insira o seguinte objeto de certificado do servidor MQTT. Adicione uma vírgula onde for preciso criar um arquivo JSON válido.
```
"MQTTServerCertificate": {
"privateKeyPath": "path-to-private-key"
}
```
1. No objeto `crypto`, insira o seguinte objeto de `PKCS11`. Adicione uma vírgula onde for preciso criar um arquivo JSON válido.
```
"PKCS11": {
"P11Provider": "/path-to-pkcs11-provider-so",
"slotLabel": "crypto-token-name",
"slotUserPin": "crypto-token-user-pin"
}
```
O arquivo deverá ser semelhante ao seguinte:
```
{
"coreThing" : {
"caPath" : "root.ca.pem",
"certPath" : "hash.cert.pem",
"keyPath" : "hash.private.key",
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix.iot.region.amazonaws.com",
"ggHost" : "greengrass.iot.region.amazonaws.com",
"keepAlive" : 600
},
"runtime" : {
"cgroup" : {
"useSystemd" : "yes"
}
},
"managedRespawn" : false,
"crypto": {
"PKCS11": {
"P11Provider": "/path-to-pkcs11-provider-so",
"slotLabel": "crypto-token-name",
"slotUserPin": "crypto-token-user-pin"
},
"principals" : {
"MQTTServerCertificate": {
"privateKeyPath": "path-to-private-key"
},
"IoTCertificate" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key",
"certificatePath" : "file:///greengrass/certs/hash.cert.pem"
},
"SecretsManager" : {
"privateKeyPath" : "file:///greengrass/certs/hash.private.key"
}
},
"caPath" : "file:///greengrass/certs/root.ca.pem"
}
}
```
**nota**
Para usar atualizações over-the-air (OTA) com segurança de hardware, o `PKCS11` objeto também deve conter a `OpenSSLEngine` propriedade. Para obter mais informações, consulte [Configurar suporte para over-the-air atualizações](hardware-security.md#hardware-security-ota-updates).
1. Edite o objeto `crypto`:
1. Configure o objeto `PKCS11`.
+ Para `P11Provider`, insira o caminho completo para `libsofthsm2.so`.
+ Em `slotLabel`, digite `greengrass`.
+ Em `slotUserPin`, digite `1234`.
1. Configure os caminhos da chave privada no objeto `principals`. Não edite a propriedade `certificatePath`.
+ Para as propriedades `privateKeyPath`, insira o seguinte caminho RFC 7512 PKCS\$111 (que especifica o rótulo da chave). Faça isso para as entidades principais `IoTCertificate`, `SecretsManager`, e `MQTTServerCertificate`.
```
pkcs11:object=iotkey;type=private
```
1. Verifique o objeto `crypto`. A aparência deve ser semelhante à seguinte:
```
"crypto": {
"PKCS11": {
"P11Provider": "/usr/lib/x86_64-linux-gnu/softhsm/libsofthsm2.so",
"slotLabel": "greengrass",
"slotUserPin": "1234"
},
"principals": {
"MQTTServerCertificate": {
"privateKeyPath": "pkcs11:object=iotkey;type=private"
},
"SecretsManager": {
"privateKeyPath": "pkcs11:object=iotkey;type=private"
},
"IoTCertificate": {
"certificatePath": "file://certs/core.crt",
"privateKeyPath": "pkcs11:object=iotkey;type=private"
}
},
"caPath": "file://certs/root.ca.pem"
}
```
1. Remova os valores `caPath`, `certPath` e `keyPath` do objeto `coreThing`. A aparência deve ser semelhante à seguinte:
```
"coreThing" : {
"thingArn" : "arn:partition:iot:region:account-id:thing/core-thing-name",
"iotHost" : "host-prefix-ats.iot.region.amazonaws.com",
"ggHost" : "greengrass-ats.iot.region.amazonaws.com",
"keepAlive" : 600
}
```
**nota**
Para este tutorial, você especifica a mesma chave privada para todas as entidades principais. Para obter mais informações sobre como escolher a chave privada para o servidor MQTT local, consulte [Desempenho](hardware-security.md#hsm-performance). Para obter mais informações sobre o secrets manager local, consulte [Implante segredos até o AWS IoT Greengrass âmago](secrets.md).
## Testar a configuração
+ Inicie o daemon do Greengrass.
```
cd /greengrass/ggc/core/
sudo ./greengrassd start
```
Se o daemon for iniciado com êxito, seu núcleo será configurado corretamente.
Agora você está pronto para saber mais sobre a especificação PKCS\$111 e fazer testes iniciais com a API do PKCS\$111 fornecida pela implementação do SoftHSM.
**Importante**
Mais uma vez, é extremamente importante saber que este módulo é destinado somente a aprendizagem e testes. Na verdade, ele não fortalece a postura de segurança do seu ambiente do Greengrass.
Em vez disso, a finalidade do módulo é permitir que você inicie a aprendizagem e os testes como preparação para usar um verdadeiro HSM baseado em hardware no futuro. Quando isso ocorrer, você deverá testar seu software em relação ao HSM baseado em hardware antes de qualquer uso de produção, pois pode haver diferenças entre a implementação PKCS\$111 fornecida no SoftHSM e uma implementação baseada em hardware.
## Consulte também
+ *Guia de uso da interface de token criptográfico PKCS \$111 Versão 2.40*. Editada por John Leiseboer e Robert Griffin. 16 de novembro de 2014. Nota 02 do Comitê OASIS. [http://docs.oasis-open. org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html](http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/cn02/pkcs11-ug-v2.40-cn02.html). Versão mais recente: [http://docs.oasis-open. org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html](http://docs.oasis-open.org/pkcs11/pkcs11-ug/v2.40/pkcs11-ug-v2.40.html).
+ [RFC 7512](https://tools.ietf.org/html/rfc7512)