> For the complete documentation index, see [llms.txt](https://docs.caf.io/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/configuracao/ios/security-checks.md).

# Verificações de segurança

## Contexto

O Face Liveness Lite protege o resultado de liveness com duas camadas independentes de verificações:

| Camada                                                         | Onde ele é executado                                        | O app pode desativá-lo?   | Como ele chega ao seu app                                                          |
| -------------------------------------------------------------- | ----------------------------------------------------------- | ------------------------- | ---------------------------------------------------------------------------------- |
| [Verificações de dispositivo da Certta](#certta-device-checks) | No dispositivo, antes e durante a captura                   | Sim, com `enableSecurity` | `didFinishWithError(type: .securityException, description:)`, sem `signedResponse` |
| [Verificações de liveness](#liveness-checks)                   | Nos servidores de liveness, enquanto a captura é processada | Não                       | `didFinishWithFailure(type:description:signedResponse:)`, com um `signedResponse`  |

Ambas as camadas fazem parte de toda captura. As verificações de dispositivo da Certta podem ser desativadas com `enableSecurity`. As verificações de liveness não podem ser desativadas pelo app.

## Verificações de Dispositivo da Certta

O SDK verifica o dispositivo e o ambiente do app para garantir que o resultado não tenha sido adulterado. Se o ambiente parecer comprometido, o SDK para e retorna um erro em vez de um resultado.

### O que é verificado

| Área                        | Exemplos                                                           |
| --------------------------- | ------------------------------------------------------------------ |
| Integridade do dispositivo  | Um dispositivo com jailbreak                                       |
| Instrumentação e hooking    | Ferramentas que injetam código no app ou interceptam suas chamadas |
| Depuração                   | Ferramentas de depuração conectadas ao app                         |
| Integridade do app e do SDK | Um binário do app modificado ou re-assinado, ou um SDK corrigido   |

Qualquer detecção bloqueia a captura. Não há nenhum nível de severidade que possa prosseguir.

{% hint style="info" %}
A captura só é executada em um dispositivo físico. O iOS Simulator não é compatível.
{% endhint %}

### Como funciona

{% stepper %}
{% step %}

## Antes da captura

Quando você chama `startSDK(viewController:)`, o SDK verifica a permissão da câmera e depois executa as verificações do dispositivo, antes de criar a sessão de liveness e abrir a câmera. Se uma ameaça for encontrada, a câmera nunca abre.
{% endstep %}

{% step %}

## Durante a captura

Enquanto a captura está em execução, o SDK verifica o dispositivo novamente periodicamente. Se surgir uma ameaça, por exemplo uma ferramenta de hooking anexada no meio da captura, a captura é interrompida imediatamente.
{% endstep %}

{% step %}

## No final

Quando a execução termina, com qualquer resultado, o monitoramento é interrompido.
{% endstep %}
{% endstepper %}

`prewarm()` não executa as verificações do dispositivo. Elas sempre são executadas quando `startSDK` é chamado, independentemente de a sessão ter sido pré-aquecida ou não.

O resultado não é salvo no dispositivo. Toda `startSDK` chamada executa as verificações novamente, então o mesmo ambiente retorna o mesmo resultado até que a condição que o acionou desapareça.

### Configuração

`enableSecurity` é definido no construtor e o padrão é `verdadeiro`:

```swift
let sdk = CafFaceLivenessLiteSDK(enableSecurity: true)
```

| Cenário                                      | `enableSecurity`           | Efeito                                                                                                            |
| -------------------------------------------- | -------------------------- | ----------------------------------------------------------------------------------------------------------------- |
| Produção                                     | `verdadeiro` (recomendado) | As verificações do dispositivo são executadas e `securityException` pode ser retornado                            |
| QA manual e testes de aceitação              | `verdadeiro` (recomendado) | Mesmo comportamento da produção, então os testes refletem o que os usuários recebem                               |
| Testes automatizados de interface do usuário | `falso`                    | As verificações do dispositivo não são executadas, então as ferramentas de teste não podem interromper a execução |
| Qualquer build com `enableSecurity: false`   | `falso`                    | `securityException` nunca é retornado                                                                             |

O `ambiente` passado para `setup` (`.dev`, `.beta` ou `.prod`) não altera as verificações do dispositivo. Apenas `enableSecurity` o faz.

{% hint style="warning" %}
Mantenha `enableSecurity` definido como `verdadeiro` na produção. Desativá-lo remove a proteção contra dispositivos comprometidos.
{% endhint %}

### Quando uma ameaça é encontrada

O SDK chama `didFinishWithError(type: .securityException, description:)`. Nenhuma captura é avaliada e nenhum `signedResponse` é retornado.

O `description` é um texto técnico destinado aos seus logs. Não o analise nem o mostre ao usuário. Se precisar de ajuda com um caso, compartilhe-o com o suporte da Certta exatamente como está.

Tentar novamente no mesmo ambiente retorna o mesmo erro até que a condição que o acionou desapareça. Para ver a mensagem recomendada e o que fazer, consulte [`securityException`](https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/tratamento-de-erros/ios/error-handling.md#securityexception).

## Verificações de Liveness

A captura é processada pelo serviço de liveness, que executa suas próprias verificações contra ataques de apresentação, como fotos, telas ou máscaras, e contra ataques de injeção digital, como fluxos de vídeo manipulados ou um app adulterado. Essas verificações são executadas no servidor, então não podem ser burladas no dispositivo.

Quando essas verificações não são aprovadas, a captura ainda é processada e o SDK chama `didFinishWithFailure(type:description:signedResponse:)` com um `signedResponse`. Valide-o no seu backend como qualquer outro resultado.

{% hint style="warning" %}
Nunca decida o resultado do liveness no cliente. Seu backend valida o `signedResponse` e então recupera o resultado final com o `livenessAttemptId` que ela carrega. Veja [Configuração do Backend](https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/configuracao/backend/setup.md).
{% endhint %}

### Códigos de feedback

Quando uma captura não é aprovada, o SDK entrega o motivo mais provável como o `tipo` de `didFinishWithFailure`, um `CafFailureType` valor. Um código que o SDK não reconhece é retornado como `desconhecido`. A lista completa está em [Referência de resultados](https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/configuracao/ios/result-reference.md).

Os códigos de feedback são orientações para a próxima tentativa, não uma descrição do que foi detectado. O feedback relacionado ao dispositivo é deliberadamente genérico: descrever quais sinais são avaliados ajudaria os atacantes a se adaptar.

Para a mensagem recomendada para cada tipo, incluindo `motionIssue` e `deviceIssue`, consulte [Motivos da falha e orientação ao usuário](https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/tratamento-de-falhas/mobile/failure-handling.md).

### Erros durante a captura

Quando a captura não pode ser concluída, o SDK chama `didFinishWithError(type:description:)`. Veja [Tratamento de erros](https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/tratamento-de-erros/ios/error-handling.md) para saber o que cada tipo significa e o que fazer.

### Ambientes de liveness

As verificações de liveness são executadas no ambiente configurado para sua conta. Esse ambiente é configurado pela Certta. Se você precisar de uma configuração diferente para testes, entre em contato com sua equipe de conta da Certta.

## Testando sua integração

* Teste em um dispositivo físico. O iOS Simulator não consegue executar a captura.
* Mantenha `enableSecurity = true` em QA manual. Defina-o como `falso` somente para testes automatizados de interface do usuário.
* As verificações de liveness são executadas em toda captura, independentemente do tipo de build ou do valor de `enableSecurity`.
* Para reproduzir o que seus usuários recebem, teste com uma build distribuída da mesma forma que a produção, como TestFlight ou a App Store.
* Se as capturas de teste continuarem retornando `deviceIssue`, envie o `signedResponse` de cada tentativa, com a data e a hora, para a sua equipe de conta da Certta.


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.caf.io/sdk-lite/sdk-lite-english-pt-br/configuracao/ios/security-checks.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.
