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á.
# PKCS11 biblioteca principal
**nota**
O conteúdo desta página pode não ser up-to-date. Consulte a [página da biblioteca do FreeRTOS.org](https://www.freertos.org/Documentation/03-Libraries/01-Library-overview/01-All-libraries) para obter a atualização mais recente.
## Visão geral do
O Padrão de criptografia de chave pública \#11 define uma API independente de plataforma para gerenciar e usar tokens criptográficos. O [PKCS \#11](https://en.wikipedia.org/wiki/PKCS_11) se refere à API definida pelo padrão e para o padrão. A API criptográfica PKCS \#11 abstrai o armazenamento de chaves, get/set as propriedades dos objetos criptográficos e a semântica da sessão. É amplamente usada para manipular objetos criptográficos comuns, sendo importante porque as funções que ela especifica permitem que o software da aplicação use, crie, modifique e exclua objetos criptográficos, sem expor esses objetos à memória da aplicação. Por exemplo, as integrações de referência do AWS FreeRTOS usam um pequeno subconjunto da API PKCS \#11 para acessar a chave secreta (privada) necessária para criar uma conexão de rede autenticada e protegida pelo protocolo [Transport Layer Security (TLS) sem que o](https://en.wikipedia.org/wiki/Transport_Layer_Security) aplicativo nunca “veja” a chave.
A PKCS11 biblioteca principal contém uma implementação simulada baseada em software da interface PKCS \#11 (API) que usa a funcionalidade criptográfica fornecida pelo Mbed TLS. O uso de uma simulação de software permite rápido desenvolvimento e flexibilidade, mas o esperado é que você substitua a simulação por uma implementação específica para o armazenamento seguro de chaves usado em nos dispositivos de produção. Geralmente, fornecedores de criptoprocessadores seguros, como Trusted Platform Module (TPM), Hardware Security Module (HSM), Secure Element ou outros tipos de enclaves de hardware seguros, distribuem uma implementação de PKCS \#11 com o hardware. O objetivo da biblioteca simulada exclusiva de PKCS11 software principal é, portanto, fornecer uma implementação PKCS \#11 não específica de hardware que permita prototipagem e desenvolvimento rápidos antes de mudar para uma implementação PKCS \#11 específica de criptoprocessador em dispositivos de produção.
Somente um subconjunto do padrão PKCS \#11 é implementado, com foco em operações envolvendo chaves assimétricas, geração de números aleatórios e hashes. Os casos de uso alvo incluem gerenciamento de certificados e chaves para autenticação TLS e verificação de assinatura de código em dispositivos pequenos incorporados. Consulte o arquivo `pkcs11.h` (obtido do OASIS, o corpo padrão) no repositório de código-fonte do FreeRTOS. Na [implementação de referência do FreeRTOS](https://docs.aws.amazon.com/embedded-csdk/latest/lib-ref/libraries/standard/corePKCS11/docs/doxygen/output/html/index.html), as chamadas de API do PKCS\#11 são feitas pela interface auxiliar do TLS para executar a autenticação do cliente TLS durante `SOCKETS_Connect`. Chamadas de API do PKCS\#11 também são feitas pelo nosso fluxo de trabalho de provisionamento de desenvolvedor único para importar um certificado de cliente TLS e uma chave privada para autenticação do agente MQTT da AWS IoT . Esses dois casos de uso, o provisionamento e a autenticação de cliente TLS, exigem a implementação de apenas um pequeno subconjunto do padrão de interface PKCS\#11.
## Recursos
O subconjunto do PKCS\#11 a seguir é usado. Essa lista é aproximadamente a ordem em que as rotinas são chamadas no suporte ao provisionamento, à autenticação de cliente TLS e à limpeza. Para descrições detalhadas das funções, consulte a documentação do PKCS\#11 fornecida pelo comitê padrão.
### API de configuração geral e desativação
+ `C_Initialize`
+ `C_Finalize`
+ `C_GetFunctionList`
+ `C_GetSlotList`
+ `C_GetTokenInfo`
+ `C_OpenSession`
+ `C_CloseSession`
+ `C_Login`
### API de provisionamento
+ `C_CreateObject CKO_PRIVATE_KEY` (para a chave privada do dispositivo)
+ `C_CreateObject CKO_CERTIFICATE` (para o certificado do dispositivo e o certificado de verificação de código)
+ `C_GenerateKeyPair`
+ `C_DestroyObject`
### Autenticação de cliente
+ `C_GetAttributeValue`
+ `C_FindObjectsInit`
+ `C_FindObjects`
+ `C_FindObjectsFinal`
+ `C_GenerateRandom`
+ `C_SignInit`
+ `C_Sign`
+ `C_VerifyInit`
+ `C_Verify`
+ `C_DigestInit`
+ `C_DigestUpdate`
+ `C_DigestFinal`
## Suporte ao sistema criptográfico assimétrico
A implementação de referência do FreeRTOS usa PKCS \#11 RSA de 2048 bits (somente assinatura) e ECDSA com as curvas do NIST P-256. As instruções a seguir descrevem como criar AWS IoT algo com base em um certificado de cliente P-256.
Verifique se você está usando as seguintes versões (ou mais recentes) do AWS CLI e do OpenSSL:
```
aws --version
aws-cli/1.11.176 Python/2.7.9 Windows/8 botocore/1.7.34
openssl version
OpenSSL 1.0.2g 1 Mar 2016
```
O procedimento a seguir considera que você usou o comando `aws configure` para configurar o AWS CLI. Para obter mais informações, consulte [Configuração rápida com o `aws configure`](https://docs.aws.amazon.com/cli/latest/userguide/cli-configure-quickstart.html#cli-configure-quickstart-config) no *Manual do usuário do AWS Command Line Interface *.
**Para criar AWS IoT algo com base em um certificado de cliente P-256**
1. Crie qualquer AWS IoT coisa.
```
aws iot create-thing --thing-name {{thing-name}}
```
1. Use o OpenSSL para criar uma chave P-256.
```
openssl genpkey -algorithm EC -pkeyopt ec_paramgen_curve:P-256 -pkeyopt ec_param_enc:named_curve -outform PEM -out {{thing-name}}.key
```
1. Crie uma solicitação de inscrição de certificado assinada pela chave criada na etapa 2.
```
openssl req -new -nodes -days 365 -key {{thing-name}}.key -out {{thing-name}}.req
```
1. Envie a solicitação de inscrição do certificado para AWS IoT.
```
aws iot create-certificate-from-csr \
--certificate-signing-request file://{{thing-name}}.req --set-as-active \
--certificate-pem-outfile {{thing-name}}.crt
```
1. Anexe o certificado (referenciado pela saída do ARN pelo comando anterior) à coisa.
```
aws iot attach-thing-principal --thing-name {{thing-name}} \
--principal "arn:aws:iot:{{us-east-1}}:{{123456789012}}:cert/{{86e41339a6d1bbc67abf31faf455092cdebf8f21ffbc67c4d238d1326c7de729}}"
```
1. Crie uma política. (Essa política é muito permissiva. Ela deve ser usada somente para fins de desenvolvimento.)
```
aws iot create-policy --policy-name FullControl --policy-document file://policy.json
```
A seguir, uma listagem do arquivo policy.json especificado no comando `create-policy`. Você pode omitir a ação `greengrass:*` se não quiser executar a demonstração do FreeRTOS para a conectividade e a descoberta do Greengrass.
------
#### [ JSON ]
****
```
{
"Version":"2012-10-17",
"Statement": [
{
"Effect": "Allow",
"Action": "iot:*",
"Resource": "*"
},
{
"Effect": "Allow",
"Action": "greengrass:*",
"Resource": "*"
}
]
}
```
------
1. Anexe o principal (certificado) e a política à coisa.
```
aws iot attach-principal-policy --policy-name FullControl \
--principal "arn:aws:iot:us-east-1:{{123456789012}}:cert/{{86e41339a6d1bbc67abf31faf455092cdebf8f21ffbc67c4d238d1326c7de729}}"
```
Agora, siga as etapas na seção [Conceitos básicos do AWS IoT](https://docs.aws.amazon.com/iot/latest/developerguide/iot-gs.html) desse guia. Não se esqueça de copiar o certificado e a chave privada que você criou no arquivo `aws_clientcredential_keys.h`. Copie o nome da coisa em `aws_clientcredential.h`.
**nota**
O certificado e a chave privada são codificados para fins de demonstração somente. Por este motivo, as aplicações devem armazenar esses arquivos em um local seguro.
## Portabilidade
Para obter informações sobre como portar a PKCS11 biblioteca principal para sua plataforma, consulte [Portando a PKCS11 biblioteca principal no Guia de portabilidade](https://docs.aws.amazon.com/freertos/latest/portingguide/afr-porting-pkcs.html) do FreeRTOS.
## Uso de memória
****
| Tamanho do código do núcleo PKCS11 (exemplo gerado com GCC para ARM Cortex-M) |
|---|
| Arquivo | Com otimização -O1 | Com otimização: Os |
|---|
| core\_pkcs11.c | 0,8 K | 0,8 K |
| core\_pki\_utils.c | 0,5 K | 0,3 K |
| core\_pkcs11\_mbedtls.c | 8,9 K | 7,5 K |
| Estimativas totais | 10,2 K | 8,6 K |