---
title: "Emitir a partir de um CSR"
description: "Como emitir um certificado do Amplia a partir de um CSR gerado no seu servidor ou no navegador do usuário: mídia da chave, a chamada de emissão, exemplos de e-CNPJ e SSL/TLS, e emissão de um e-CPF depois de uma verificação facial."
canonical: "https://docs.lacunasoftware.com/articles/amplia/integration/issue-from-csr"
locale: "pt-BR"
product: "Amplia"
last_updated: "2026-10-12"
---

# Emitir a partir de um CSR

Quando você mesmo gera o par de chaves, no seu servidor ou no navegador do usuário, você envia ao [Amplia](https://docs.lacunasoftware.com/articles/amplia) só uma requisição
de assinatura de certificado (CSR), e ele devolve o certificado. 

## Fluxo

1. Gere o par de chaves e o CSR. Faça isso antes de criar o pedido, para que uma falha na chave não consuma um pedido.
1. [Crie o pedido](https://docs.lacunasoftware.com/articles/amplia/integration/orders). O subject do certificado vem dos parâmetros do pedido, nunca do CSR.
1. Emita o certificado: `POST /api/v2/certificates` com o id do pedido, o CSR e a [mídia da chave](https://docs.lacunasoftware.com/articles/amplia/integration/issue-from-csr#mídia-da-chave).
1. Mantenha a chave privada onde ela foi gerada, e o certificado junto dela.

Os samples geram a chave e o CSR com o [PKI Express](https://docs.lacunasoftware.com/articles/pki-express), depois emitem o certificado e guardam os dois no
servidor: 

**Node.js**

```js
const {KeyGenerator} = require('pki-express');
const {KeyMedia } = require('amplia-client/lib/enums');

const keyGenerator = new KeyGenerator({
	keySize: req.body.keySize,
	genCsr: true
});
let genKey = await keyGenerator.generate();
let generatedKey = genKey.getKey();
let cert = await client.issueCertificate(order.getId(), genKey.getCsr(), KeyMedia.PC);
let certId = cert.getId();
// WARNING: It is highly RECOMMENDED to ENCRYPT the key before storing
// in your database.
StorageMock.storeSync(generatedKey, certId, '.json');
StorageMock.storeSync(cert.getContentRaw(), certId, '.cer');
```

**Java**

```java
KeyGenerator keyGenerator = new KeyGenerator();
keyGenerator.setKeySize(2048);
keyGenerator.setKeyFormat(KeyFormats.JSON);
keyGenerator.setGenCsr(true);
KeyGenerationResult genKey = keyGenerator.generate();
Certificate cert = client.issueCertificate(order.getId(), genKey.getCsr());
// WARNING: It is highly RECOMMENDED to ENCRYPT the key before storing in your database.
StorageMock.storeKey(genKey.getKey().getBytes(), ".json", cert.getId());
StorageMock.storeKey(cert.getContent(), ".cer", cert.getId());
```

**PHP**

```php
use Lacuna\PkiExpress\KeyGenerator;
use Lacuna\PkiExpress\SupportedKeySizes;
use Lacuna\PkiExpress\KeyFormats;

$keyGenerator = new KeyGenerator();
$keyGenerator->keySize = SupportedKeySizes::S2048;
$keyGenerator->keyFormat = KeyFormats::JSON;
$keyGenerator->genCsr = true;
$genKey = $keyGenerator->generate();
$cert = $client->issueCertificate($order->getId(), $genKey->csr);
StorageMock::storeKey($genKey->key, ".json", $cert->id);
StorageMock::storeKey($cert->getContentRaw(), ".cer", $cert->id);
```

**Python**

```python
from pkiexpress import KeyGenerator, Pkcs12Generator, SupportedKeySizes

key_generator = KeyGenerator()
key_generator.key_size = SupportedKeySizes.S2048
key_generator.gen_csr = True
gen_key = key_generator.generate()
cert = client.issue_certificate(order.id, gen_key.csr)

pkcs12_generator = Pkcs12Generator()
pkcs12_generator.key = gen_key.key
pkcs12_generator.set_cert_file_from_base64(cert.content_base64)
pkcs12_gen_result = pkcs12_generator.generate('1234')
```

* Os samples alertam que a chave privada deve ser criptografada antes de ser guardada em um banco de dados. 
* O sample em Python depois junta a chave e o certificado em um arquivo PKCS #12 com o PKI Express, para assinar com ele mais tarde. 
  Para que o Amplia gere a chave e devolva o arquivo PKCS #12, veja [Emitir um arquivo PKCS #12](https://docs.lacunasoftware.com/articles/amplia/integration/pkcs12).

## A chamada de emissão

`POST /api/v2/certificates` recebe um `IssueCertificateRequest`: 

| Campo | Significado |
|---|---|
| `orderId` | Id do pedido a atender. |
| `csr` | O CSR. A demo de SSL/TLS o envia codificado em PEM. |
| `keyMedia` | Onde a chave fica; veja [Mídia da chave](https://docs.lacunasoftware.com/articles/amplia/integration/issue-from-csr#mídia-da-chave). |
| `keyId` | Id de uma chave. |

TODO(docs): a que se refere `keyId`.

A resposta é um `CertificateModel2` com o `id` do certificado, o `content` dele (em Base64), datas, número de série e, em `info`, o
subject, o emissor, os pontos de distribuição de LCR e as URIs de OCSP. `POST /api/certificates` recebe o mesmo corpo e devolve o
`CertificateModel` mais antigo. 
A demo de e-CNPJ envia este corpo, com o enum como número: 

```json
{
  "OrderId": "00000000-0000-0000-0000-000000000000",
  "Csr": "<Csr, 944 bytes>",
  "KeyMedia": 1
}
```

Para ler o certificado depois, use `GET /api/v2/certificates/{id}` (com `fillContent=true` para incluir `content`) ou baixe-o de
`GET /api/certificates/{id}/content`. 
TODO(docs): o formato do arquivo devolvido por `GET /api/certificates/{id}/content`.

### Mídia da chave

`keyMedia` é `PC`, `CryptoDevice`, `Mobile` ou `Cloud`. 

* Uma chave gerada no seu servidor, ou pelo Web PKI no navegador do usuário, no computador dele: `PC`.
* Uma chave gerada pelo Web PKI em um token ou smart card: `CryptoDevice`.

O `keyMediaConstraints` de um pedido lista as mídias da chave que ele aceita. 

Só o cliente Node.js envia `keyMedia`: o enum `KeyMedia` dele vem de `amplia-client/lib/enums`, já que o ponto de entrada do pacote não o
exporta. O cliente Java envia o id do pedido, o CSR e, opcionalmente, `keyId`; os clientes PHP e Python enviam só o id do pedido e o CSR. 
TODO(docs): que mídia da chave o Amplia registra quando a requisição não traz nenhuma.

TODO(docs): quando usar `Mobile` e `Cloud` (o Amplia guarda ele mesmo as chaves dos certificados em nuvem, veja [gerenciamento de certificados em nuvem](https://docs.lacunasoftware.com/articles/amplia/on-premises/configure-cert-management)).

## Gerar a chave no navegador do usuário

Com o [Web PKI](https://docs.lacunasoftware.com/articles/web-pki), a chave pode ser gerada no computador ou no token do usuário pela sua própria página, e só o CSR
chega ao seu servidor. O Web PKI devolve o id da chave junto com o CSR: depois da emissão, passe o id de volta para
[`importCertificate`](https://docs.lacunasoftware.com/content/typedocs/web-pki/classes/_lacuna_web_pki_d_.lacunawebpki.html#importcertificate) (ou
[`importTokenCertificate`](https://docs.lacunasoftware.com/content/typedocs/web-pki/classes/_lacuna_web_pki_d_.lacunawebpki.html#importtokencertificate))
para instalar o certificado junto da chave. 
O par de chaves em si vem de
[`generateSoftwareRsaKeyPair`](https://docs.lacunasoftware.com/content/typedocs/web-pki/classes/_lacuna_web_pki_d_.lacunawebpki.html#generatesoftwarersakeypair)
ou de [`generateTokenRsaKeyPair`](https://docs.lacunasoftware.com/content/typedocs/web-pki/classes/_lacuna_web_pki_d_.lacunawebpki.html#generatetokenrsakeypair). 

TODO(docs): nenhum artigo ou sample mostra a geração de chave do Web PKI junto com o Amplia; para que a própria página do Amplia faça
isso, veja [Emitir na máquina do titular](https://docs.lacunasoftware.com/articles/amplia/integration/issue-on-user-machine).

## Certificados SSL/TLS

A demo de SSL/TLS gera uma chave RSA de 2048 bits e um CSR no servidor dela, cria um [pedido SSL](https://docs.lacunasoftware.com/articles/amplia/integration/orders#certificados-ssltls) e emite o
certificado com a mídia da chave `PC`; os visitantes também podem trazer o próprio CSR. 

* Ela verifica o CSR do usuário antes de chamar o Amplia: no máximo 16 KB, em PEM, Base64 ou DER, uma chave RSA de 2048 a 4096 bits ou
  uma chave EC em P-256 ou P-384, e uma assinatura que confere. Ela envia ao Amplia a requisição recodificada em PEM.
* O que ela devolve depende de quem gerou a chave: com uma chave do servidor, um .pfx, a chave privada em PEM e um .crt com o certificado
  e a AC emissora, nunca a raiz; com o CSR do usuário, só o .crt. Ela mantém as chaves só em memória.

## Emitir um e-CPF depois de uma verificação facial

A demo de e-CPF com o rosto verifica a identidade do titular antes da emissão: o Datavalid do Serpro compara o rosto dele com a foto da
CNH, pelo Lacuna Bio no [Rest PKI Core](https://docs.lacunasoftware.com/articles/rest-pki/core). Depois que o rosto é aprovado, ela emite o e-CPF a partir de um CSR,
como no fluxo desta página, sem a página de emissão do Amplia e sem retorno. 
Para a captura do rosto, veja o [cadastro biométrico](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/bio-sessions/enrollment) e a
[autenticação facial](https://docs.lacunasoftware.com/articles/rest-pki/core/integration/bio-sessions/authentication) do Rest PKI Core. 

* A demo faz a verificação `pf-basica` do Datavalid antes de qualquer captura do rosto: o nome precisa conferir exatamente, a data de
  nascimento conferir, o CPF estar regular e existir uma CNH.
* Ela cadastra o rosto com os dígitos do CPF como identificador do titular (subject identifier) e `VerifyFaceIdentityExternally = true`;
  com `BioSubjectAlreadyEnrolled`, ela inicia uma autenticação facial em vez disso.
* O resultado do Datavalid não vem no status de conclusão: a demo o lê com `GetSessionDetailsAsync(sessionId)`, que exige uma chave de
  API com permissão para ver sessões biométricas.

TODO(docs): nenhuma sequência de chamadas foi gravada para essa demo, e nenhum artigo cobre a verificação do Datavalid.

## Veja também

* [Criar pedidos de certificado](https://docs.lacunasoftware.com/articles/amplia/integration/orders)
* [Emitir um arquivo PKCS #12](https://docs.lacunasoftware.com/articles/amplia/integration/pkcs12)
* [Erros](https://docs.lacunasoftware.com/articles/amplia/integration/errors)

**Demonstrações e exemplos**

- Demonstração: [Issue an e-CNPJ certificate](https://try.lacunasoftware.com/pt/amplia/issue-e-cnpj-certificate)
- Demonstração: [Issue an SSL/TLS certificate](https://try.lacunasoftware.com/pt/amplia/issue-ssl-tls-certificate)
- Demonstração: [Issue an e-CPF with your face](https://try.lacunasoftware.com/pt/amplia/issue-an-ecpf-with-your-face)
- Issue a certificate with the key on the server using Amplia: [Java](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/java/springmvc/src/main/java/com/lacunasoftware/pkisuite/controller/IssueCertServerAmpliaController.java) · [Node.js](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/nodejs/expressmvc/routes/issue-cert-server-amplia.js) · [PHP](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/php/plain/public/issue-cert-server-amplia/index.php) · [Python](https://github.com/LacunaSoftware/PkiSuiteSamples/blob/master/python/flask/sample/views/issue_cert_server_amplia.py)