From 3b69dc3357e30c73ea802ae6174e38ee9991d4d5 Mon Sep 17 00:00:00 2001 From: bedoyadaniel Date: Fri, 10 Apr 2026 16:25:42 +0000 Subject: [PATCH] updating with automated translations --- docs/pt/references/00-glossary/index.md | 253 ++++ .../index.md | 1023 +++++++++++++++++ .../index.md | 747 ++++++++++++ .../04-reference-cheat-sheet-android/index.md | 36 + 4 files changed, 2059 insertions(+) create mode 100644 docs/pt/references/00-glossary/index.md create mode 100644 docs/pt/references/02-reference-mvt-bugreport-dictionary/index.md create mode 100644 docs/pt/references/03-reference-mvt-androidqf-dictionary/index.md create mode 100644 docs/pt/references/04-reference-cheat-sheet-android/index.md diff --git a/docs/pt/references/00-glossary/index.md b/docs/pt/references/00-glossary/index.md new file mode 100644 index 000000000..0db893c3c --- /dev/null +++ b/docs/pt/references/00-glossary/index.md @@ -0,0 +1,253 @@ +--- + +title: Glosario +summary: Glosario +keywords: glosario +lang: es +tags: [glossary, glosario, reference] +last_updated: 2025-08-04 +some_url: +created: 2025-08-04 +author: + name: Daniel + url: https://socialtic.org/quienes-somos/ + description: SocialTIC +alternate: + en: en/references/00-glossary.html +translation-review-pending: true +--- + +# Glossário + +Este documento é **parte de um repositório de documentação técnica** que visa estabelecer uma base de conhecimento comprovada, flexível e acessível para **promover a análise forense consensual em benefício da sociedade civil**. + +Este recurso específico é um glossário de termos que inclui **conceitos, abreviações e outros termos** que são considerados relevantes para a compreensão do conteúdo. Eles estão organizados em ordem alfabética. + +## Termos + +### ADB + +ADB significa *Android Debug Bridge*, ou Ponte de depuração do Android. O ADB é uma **ferramenta de linha de comando** **que permite que você se comunique diretamente via USB com um dispositivo Android** e inicie diferentes ações e comandos. + +Do ponto de vista da **forense digital** e, em particular, ao fazer [investigações baseadas em logs](../../explainers/03-explainer-log-forensics-android/) usando ferramentas como o AndroidQF, o **ADB permite estabelecer comunicação direta com um dispositivo**. Ele é útil em situações em que **você tem acesso físico ao dispositivo** e quando deseja obter informações diretamente do dispositivo por meio de **comandos nativos**, sem usar ferramentas adicionais. + + +### Aquisição + +Refere-se a um estágio da investigação forense, em que o analista forense deve determinar a melhor maneira de coletar evidências forenses e aplicar os procedimentos necessários para extrair artefatos forenses. + + +### Análise de risco + +Os riscos específicos que uma organização ou indivíduo enfrenta **dependem do contexto e do trabalho específico**. O processo de identificação de vulnerabilidades, riscos e ameaças em um determinado momento é conhecido como análise de risco. + +### AndroidQF + +O [AndroidQF] (https://github.com/mvt-project/androidqf) é uma ferramenta de software gratuita e de código aberto **focada na extração forense de dispositivos Android**. Atualmente é mantida pelo [Amnesty International Security Lab](https://securitylab.amnesty.org/es/). + +Seu foco é especificamente para jornalistas, ativistas, defensores dos direitos humanos e os **laboratórios técnicos que acompanham casos de vigilância digital e ameaças de spyware**. + +### APK + +De acordo com a Wikipedia, um [APK](https://es.wikipedia.org/wiki/APK_(format)) é um arquivo com extensão .apk (Android Application Package) é um pacote para o sistema operacional Android. Esse formato é uma variante do formato Java JAR e é usado para distribuir e instalar componentes empacotados para a plataforma Android para smartphones e tablets. + +### Artefato forense + +Um artefato forense refere-se à evidência ou aos dados recuperados durante a análise forense digital, incluindo arquivos, registros de processos, registros, metadados etc. + +### Binário + +Binários de software referem-se a arquivos que contêm apenas código binário pré-compilado, ou seja, instruções que são apenas legíveis por máquina e **prontas para serem executadas.** Exemplos incluem arquivos com a extensão ``.bin``, ``.exe`` ou ``.app``. + +### Bugreport + +Esta é uma ferramenta de linha de comando nativa do Android, disponível na GUI ou no shell ADB. Ela permite gerar um relatório de bug contendo registros de diagnóstico, gerados a partir da chamada de logcat, dumsptate e dumpsys. Ele é gerado em um arquivo .zip e é composto por uma estrutura de pastas com informações sobre erros, uso de memória, chamadas do sistema, informações de rede, informações do dispositivo, entre outras. + +### Cadeia de custódia + +O processo de documentar claramente quem e como as evidências são manipuladas é conhecido como **cadeia de custódia**. A evidência forense pode ser adulterada ou destruída durante o processo forense, portanto, o analista deve ser capaz de demonstrar a [integridade da evidência] (https://www.ibm.com/es-es/topics/data-integrity). Se essa demonstração não for possível ou suficientemente robusta, a evidência pode não ser **admissível em processos judiciais** ou pode ser refutada e descartada por outros especialistas. + +### Consentimento informado + +Consent](https://es.wikipedia.org/wiki/Consentimiento) é um princípio que se refere à externalização da vontade entre duas ou mais pessoas de aceitar direitos e obrigações. No contexto da análise forense digital para o benefício de indivíduos da sociedade civil, o consentimento informado refere-se à **concordância e aprovação de ações para facilitar a coleta, a análise, a apresentação e a preservação de evidências digitais**. + +Um aspecto fundamental de qualquer acordo de consentimento é a capacidade do consentidor de tomar uma **decisão informada** sobre o curso da investigação, incluindo a capacidade de recusar assistência. Na práticaNa prática forense, isso significa fornecer todas as informações necessárias para que a pessoa que solicita a análise compreenda as ações, os riscos, os direitos e as obrigações envolvidos no processo investigativo. É importante que o **analista se comunique de forma clara e transparente** e respeite os desejos da pessoa que está solicitando apoio. + +### Copiar pouco a pouco + +A cópia bit a bit, DD ou duplicação de disco refere-se ao processo de criação de uma réplica exata de um meio eletrônico. Elas permitem que a evidência original seja protegida de forma a salvaguardar sua integridade e preservá-la de acordo com as práticas recomendadas. + +### CVE + +Um programa para relatar, classificar e publicar vulnerabilidades de segurança. Registros CVE exclusivos são estabelecidos para cada vulnerabilidade, como ```CVE-2014-0160``. + +###taxis + +(https://diataxis.fr/start-here/) é uma estrutura para escrever e organizar a documentação técnica. Como princípio fundamental, ele tenta agrupar a documentação em quatro categorias diferentes: **Explicadores**, **Guias de instruções**, **Tutoriais** e **Referências**; que, por sua vez, respondem a necessidades específicas do leitor. Cada tipo de material tem uma finalidade e um estilo diferentes. + +### DFIR (Digital Forensics and Incident Response) + +DFIR refere-se à combinação e à unificação dos procedimentos de resposta a incidentes e de análise forense. O objetivo é que, durante a resposta a um incidente, sejam consideradas as práticas recomendadas para a coleta e a preservação de evidências, e que as descobertas da análise forense sejam usadas para conter e erradicar ameaças e, por fim, evitar futuros incidentes. + +### Exploração + +[Exploit (https://es.wikipedia.org/wiki/Exploit) é um termo da ciência da computação que significa explorar ou explorar, que é um software, um dado ou uma sequência de comandos ou ações, usado para explorar uma vulnerabilidade de segurança em um sistema de informações para obter um comportamento indesejado do sistema. + + +### Forense digital + +A perícia digital é o processo usado para a coleta, preservação, análise e apresentação de evidências digitais derivadas de mídias e dispositivos eletrônicos, usando **técnicas de investigação e métodos científicos** que sejam confiáveis, precisos e repetíveis, de modo que os resultados possam ser usados em **processos judiciais**.[1](https://csrc.nist.gov/glossary/term/digital_forensics) + +A perícia digital é usada para descobrir e examinar dados de dispositivos eletrônicos com o objetivo de **identificar, recuperar, documentar e interpretar informações digitais** e sua conexão com [ataques digitais](https://protege.la/ataques/). O uso de procedimentos padrão, de acordo com as práticas recomendadas, **permite a geração de evidências úteis** para impulsionar ações de **responsabilidade**, o que pode reduzir a impunidade com que os ataques digitais são executados. + + +### Google Takeout + +É uma função para contas on-line do Google que permite extrair informações de diferentes aplicativos, logs de acesso, logs de segurança, e-mail, entre outros. O processo leva alguns dias para ser concluído. + + [Siga este link para acessar o recurso e iniciar uma solicitação de retirada] (https://takeout.google.com/?pli=1). + + +### Lawfare + +Lawfare refere-se ao uso do sistema jurídico ou de instituições para prejudicar, desacreditar ou afetar indivíduos ou organizações. Por exemplo, em relação ao processo judicial dos EUA entre a NSO e o WhatsApp, o Citizen Lab enfrentou uma série de desafios legais e aplicativos que buscavam desmantelar seu trabalho e acessar informações confidenciais, incluindo a lista de vítimas. Em outro exemplo, em 2018, a empresa canadense Sandvine ameaçou o Citizen Lab com um processo de difamação após sua publicação sobre o uso de equipamentos da Sandvine para a implantação de spyware. + +### Hash + +[Hash](https://es.wikipedia.org/wiki/Funci%C3%B3n_hash) são funções criptográficas que permitem a produção de um único valor para um determinado conjunto de dados. Os exemplos incluem MD5, SHA1. + +### Ferramenta portátil + +Refere-se a uma ferramenta de software que não requer instalação para ser executada. A ferramenta não modifica nem adiciona arquivos ao sistema, mas inclui todos os arquivos de que precisa para ser executada em sua própria pasta ou binário de tempo de execução. + +Uma das vantagens desse tipo de programa é que ele deixa menos rastros de sua execução, em comparação com os programas que precisam ser instalados. + +### Identificação + +Refere-se a um estágio da investigação forense, em que o analista determina **quais dispositivos, contas ou sistemas podem conter informações relevantes para a investigação**. Exemplos de dispositivos incluem telefones celulares, computadores, contas on-line, mídia de armazenamento, hardware e software de computador.re outros. Idealmente, para determinar quais evidências coletar, o analista deve entrar em contato com a pessoa afetada para entender o que aconteceu, quais ações foram tomadas até o momento e quais evidências podem estar disponíveis. + +### Indicador de compromisso (IOC) + +[Um indicador de comprometimento (IoC) (https://es.wikipedia.org/wiki/Indicador_de_compromiso) é uma informação relevante que descreve qualquer incidente de segurança cibernética, atividade e/ou artefato malicioso por meio da análise de seus padrões de comportamento.[1] A intenção de um indicador de comprometimento é delinear as informações recebidas ou extraídas durante a análise de um incidente de forma que possam ser reutilizadas por outros investigadores ou partes afetadas para descobrir as mesmas evidências em seus sistemas e determinar se eles foram ou não comprometidos, seja do ponto de vista do monitoramento de ameaças ou da análise forense. 2] Por exemplo, arquivos criados, entradas de registro modificadas, novos processos ou serviços são identificados. A ideia subjacente é que, se você escanear um sistema e encontrar os detalhes contidos em um determinado indicador de comprometimento, estará lidando com uma infecção causada pelo programa malicioso (malware) ao qual o indicador de comprometimento se refere.[3] Os indicadores de comprometimento permitem uma troca simples e prática de informações para fins de detecção de intrusão a partir de análise forense, resposta a incidentes ou análise de malware. + +### Integridade da informação + +A integridade das informações, juntamente com a confidencialidade e a disponibilidade, está entre os princípios fundamentais da proteção das informações. A integridade busca garantir que os dados sejam precisos e confiáveis e **que não tenham sido acidentalmente ou intencionalmente modificados por terceiros não autorizados**, seja em repouso, em uso ou em movimento. + +### Inteligência contra ameaças + +De acordo com a [wikipedia](https://es.wikipedia.org/wiki/Inteligencia_de_Ciberamenazas), a inteligência sobre ameaças cibernéticas (CTI), também conhecida como inteligência sobre ameaças cibernéticas, é a atividade de coleta de informações com base em conhecimento, habilidade e experiência sobre a ocorrência e a avaliação de ameaças cibernéticas e físicas, bem como sobre os agentes de ameaças, com a intenção e o objetivo de ajudar a mitigar possíveis ataques e eventos prejudiciais que ocorrem no espaço cibernético. + +Esse conceito surgiu para combater a grande variedade de ameaças que estão ocorrendo, bem como para ajudar os profissionais de segurança a reconhecer indicadores de ataques cibernéticos, extrair informações sobre os métodos de ataques e, consequentemente, responder a eles de forma adequada e precisa. + +A inteligência sobre ameaças cibernéticas busca gerar conhecimento sobre o inimigo a fim de reduzir o risco para qualquer instituição. Trata-se de uma estratégia que sempre buscará antecipar e neutralizar os ataques, analisando a ameaça como um todo para detectar os principais dados que ajudam a identificar o autor do ataque, o criminoso cibernético. Seu objetivo final é fornecer a capacidade de perceber, reconhecer, raciocinar, aprender e agir de forma inteligente e oportuna sobre os indicadores de cenários de ataque e ataques cibernéticos avançados, ou seja, tomar as ações defensivas inteligentes correspondentes. + +### Registro + +Os logs, também conhecidos como registros ou logs, são arquivos que documentam as atividades que ocorrem em um sistema de computador, rede ou aplicativo. Esses logs podem conter informações sobre o acesso do usuário, alterações no sistema, erros e outras atividades relevantes para uma investigação forense. + +Neste recurso, detalhamos considerações importantes para [investigações forenses baseadas em logs em dispositivos Android](../../explainers/03-explainer-log-forensics-android/). + +### Malware + +Malware, traduzido como programa malicioso, programa malicioso, programa malicioso ou código malicioso, é qualquer tipo de software que executa ações prejudiciais em um sistema de computador intencionalmente (em oposição a malware) e sem o conhecimento do usuário (em oposição a software potencialmente indesejado). + +### Modo de desenvolvedor + +As [**opções do desenvolvedor**] (https://developer.android.com/studio/debug/dev-options) referem-se a um **menu oculto** do sistema operacional **Android** que permite configurar algumas **funções adicionais**, especialmente destinadas a apoiar o processo de [depuração] (https://es.wikipedia.org/wiki/Depuraci%C3%B3n_de_programas) durante a **criação de novos aplicativos ou alterações no sistema**. Entre as opções de desenvolvedor, também é comum colocar algumasalgumas **configurações avançadas**, como o ajuste das preferências do driver gráfico ou das configurações avançadas de rede e até mesmo **opções experimentais** que ainda estão sendo testadas ou desenvolvidas. + + +### MVT + +O MVT é uma ferramenta para facilitar a análise forense consensual de dispositivos pertencentes a pessoas que podem ser alvo de ataques avançados de spyware e, especificamente, pessoas da sociedade civil e comunidades em risco. + +Ela é indicada em seu [site](../../community/license/): + +_O Mobile Verification Toolkit (MVT) é uma ferramenta para facilitar a análise forense consensual de dispositivos Android e iOS, com o objetivo de identificar traços de comprometimento. + +Ele foi desenvolvido e lançado pelo Laboratório de Segurança da Anistia Internacional em julho de 2021 no contexto do Projeto Pegasus, juntamente com uma metodologia técnica forense. Ele continua a ser mantido pela Anistia Internacional e por outros colaboradores. + +Nesta documentação, você encontrará instruções sobre como instalar e executar os comandos mvt-ios e mvt-android e orientações sobre como interpretar os resultados extraídos. + +### Notificação de ameaça + +As notificações de ameaças referem-se a mensagens enviadas por plataformas e fabricantes para pessoas que podem ter sido + +De acordo com a Apple, as notificações de ameaças informam e ajudam as pessoas que usam dispositivos que podem ter sido alvo de ataques mercenários de spyware. A Apple envia essas notificações por e-mail e iMessage para os endereços e números de telefone registrados em todos os dispositivos associados à conta Apple de uma pessoa. A notificação também é exibida na parte superior da página depois que a pessoa faz login em account.apple.com. + +### n-day + +n-day refere-se a um tipo de [vulnerabilidade](#vulnerabilidade) que já é conhecida, mas ainda não foi resolvida em todos os sistemas afetados. Em alguns casos, podem existir patches de segurança ou atenuações oficiais, mas ainda não foram aplicados aos computadores afetados. + +### Pessoa especializada (expert) + +De acordo com a [wikipedia](https://es.wikipedia.org/wiki/Perito), um especialista (feminino, perita ou experta)[1] é uma pessoa reconhecida como fonte confiável em um determinado assunto, técnica ou habilidade, cuja capacidade de julgar ou decidir de forma correta, equilibrada e inteligente confere autoridade e status por seus pares ou pelo público em um assunto específico. + +No contexto das investigações forenses, um especialista é uma pessoa que tem conhecimento reconhecido (por exemplo, por meio de certificação) e que, por meio de seu conhecimento, pode analisar, avaliar e fazer julgamentos sobre as evidências coletadas. + +### Phishing + +Phishing é uma técnica baseada na personificação ou falsificação de informações para induzir uma pessoa a realizar uma ação, como clicar em um link, abrir um arquivo infectado, conectar-se a uma rede ou sistema falso ou inserir informações em sites falsos. Geralmente, com o objetivo de roubar informações, infectar um computador ou sistema de informações. + +* Por exemplo, e-mails ou SMS suspeitos pedindo para clicar em links. +* Por exemplo, e-mails ou SMS suspeitos solicitando o envio ou a resposta de informações privadas, confidenciais ou financeiras. +* Por exemplo, e-mails suspeitos solicitando a abertura de anexos. + +### Provedor de serviços de Internet (ISP) + +Refere-se à empresa que fornece serviço de Internet ao usuário. Eles geralmente fornecem conexão de última milha, + +### Resposta a incidentes de segurança + +Resposta a incidentes](https://www.ibm.com/es-es/topics/incident-response) concentra-se em **detectar e responder a eventos de segurança**. Por meio de procedimentos de resposta, ela visa minimizar o impacto e conter as consequências dos incidentes. Para uma resposta eficaz, é importante identificar a causa raiz das intrusões para que a ameaça possa ser erradicada e a recuperação em tempo hábil possa ser obtida. + +### Backup gerado pelo ADB + +Um dos comandos da ferramenta de console [ADB](#adb) permite gerar um backup completo do dispositivo, incluindo aplicativos e algumas configurações. Geralmente, ele é acessado no ADB por meio do comando ``adb backup`` ou usado por meio de ferramentas como o AndroidQF. Quando executado, o dispositivo solicita uma senha para criptografar os dados. + +### SocialTIC + +A [SocialTIC] (https://socialtic.org) é uma organização da sociedade civil sediada no México. Sua missão é SocialTIC **capacitar com segurança os atores da mudança na América Latina**, fortalecendo suas ações de análise, comunicação social e defesa de direitos por meio do uso estratégico de tecnologias e dados digitais. + +### Spyware + +Um tipo de malware que coleta informações de um computador ou dispositivo móvel e, em seguida, transmite essas informações para uma entidade externa sem o conhecimento ou o consentimento do proprietário do computador.dor. As funcionalidades desse tipo de ferramenta são variadas, mas, em geral, permitem acessar e extrair informações armazenadas e em trânsito, além de manipular os sensores do dispositivo (câmera, microfone etc.). + +### Stalkerware + +Stalkerware é um spyware usado em pequena escala, principalmente em círculos íntimos, como casais, familiares ou amigos. + +Eles geralmente são instalados por meio de acesso físico ao dispositivo e buscam coletar o máximo de informações possível. O invasor pode ter acesso a um painel de controle onde pode visualizar todas as informações. + +Esses tipos de ferramentas geralmente são vendidos como opções de proteção familiar para evitar o uso mal-intencionado do dispositivo ou para evitar roubos; no entanto, suas funções e recursos permitem que sejam usados como ferramentas de monitoramento doméstico e espionagem. + + +### TTP + +TTP significa _Techniques, Tactics and Procedures_ (técnicas, táticas e procedimentos) e refere-se a uma lista de técnicas, táticas e comportamentos usados por agentes de ameaças. A estrutura de TTP mais conhecida é a do [MITRE ATT&CK] (https://attack.mitre.org/), que também inclui um registro histórico de [TTPs associados a determinados agentes de ameaças] (https://attack.mitre.org/groups/). + +### Triagem + +A triagem de incidentes de segurança refere-se ao processo de avaliação inicial e classificação de incidentes de segurança com base em vários fatores, como gravidade, urgência e impacto potencial. Seu principal objetivo é alocar recursos e prioridades de forma eficaz, permitindo que as equipes de resposta a incidentes se concentrem nas ameaças mais críticas e reduzam o risco para a organização. Esse processo, fundamental para o gerenciamento de incidentes, é semelhante à triagem médica, em que os pacientes são classificados de acordo com a gravidade de sua condição para determinar a ordem de atendimento. + + +### Volatilidade + +A volatilidade das evidências digitais refere-se ao fato de que algumas informações disponíveis nos sistemas são destruídas ou alteradas com o tempo. + +Por exemplo, alguns arquivos de registro são sobrescritos quando atingem um determinado limite, de modo que algumas dessas evidências podem não existir permanentemente ao longo do tempo. + +### Vulnerabilidade + +Por outro lado, uma vulnerabilidade refere-se a uma deficiência ou fraqueza em processos, sistemas, práticas ou hábitos que podem levar a ameaças ou aumentar o impacto e as consequências de um incidente. + +### Clique zero + +Refere-se a um tipo de ataque no qual **nenhuma intervenção do usuário é necessária para a implantação do malware**. Normalmente, esse tipo de ataque é muito sofisticado e caro, e requer várias vulnerabilidades encadeadas para ser bem-sucedido. + + +### Dia zero + +Refere-se a um tipo de ataque que explora uma [vulnerabilidade](#vulnerabilidade) que não é conhecida, nem mesmo pelo fabricante do dispositivo. Portanto, não há patches ou correções que possam ser aplicados. + +Você pode consultar aqui a [página da wikipedia para "Zero-day attack"](https://es.wikipedia.org/wiki/Ataque_de_d%C3%ADa_cero). diff --git a/docs/pt/references/02-reference-mvt-bugreport-dictionary/index.md b/docs/pt/references/02-reference-mvt-bugreport-dictionary/index.md new file mode 100644 index 000000000..a4b36219e --- /dev/null +++ b/docs/pt/references/02-reference-mvt-bugreport-dictionary/index.md @@ -0,0 +1,1023 @@ +--- + +title: Diccionario de archivos generados por MVT Bugreport +summary: dictionary of files generated by mvt-bugreport +keywords: android, reference, bugreport +lang: es +tags: [explainer, intro] +last_updated: 2025-08-27 +some_url: +created: 2025-08-27 +comments: true +name: jose +translation-review-pending: true +--- + +# Dicionário de arquivos gerados pela ferramenta mvt ao analisar um relatório de bug + +Este documento contém informações sobre os arquivos gerados pelo MVT por meio do componente [mvt-check bugreport] (https://github.com/mvt-project/mvt/tree/main/src/mvt/android/modules/bugreport). O objetivo desse dicionário é facilitar ao analista a busca por informações específicas e conhecer o formato em que as informações da análise forense são apresentadas. + +Esse recurso é **parte de um repositório de documentação técnica** que visa estabelecer uma base de conhecimento testada, flexível e acessível para **promover a análise forense consensual em benefício da sociedade civil**. Para organizar o conteúdo, é utilizada a [estrutura de referência da documentação técnica Diataxis](../../references/00-glossary/index.md#ditaxis). + +Esse recurso específico se enquadra na categoria [references](https://diataxis.fr/reference) e contém informações sobre a análise de [bugreport](../references/00-glossary.md#bugreport) gerado por dispositivos Android usando o comando ***mvt-android check-bugreport*** durante o uso da ferramenta MVT (*Mobile Verification Toolkit)*, desenvolvida e mantida pelo [Amnesty International Security Lab](https://securitylab.amnesty.org/es/) e parte do [MVT Project](../../references/00-glossary/index.md#mvt). Isso serve para que um analista **saiba quais arquivos são gerados, como usá-los, onde procurar informações específicas e em que formato encontrá-las. + +A versão 2.6.0 do MVT foi usada como base para a coleta das informações. + +As informações geradas pelo *mvt-bugreport* podem ser agrupadas em 4 categorias principais: + +* Detalhes da aquisição +* Configuração do dispositivo +Informações de registro e de eventos do sistema * Processos e aplicativos +* Processos e aplicativos + +## Detalhes da aquisição + + +### info.json {#info.json} + +**Informações contidas** + +Esse arquivo está no formato *json* e contém informações relacionadas à análise realizada em um arquivo de relatório de bug. Ele contém as seguintes informações: + +* Caminho do arquivo analisado. +* Versão do MVT usada. +* Data da análise. +* Lista de arquivos de indicadores de compromisso. +* Hash do relatório de bug analisado (SHA-256). + +**Por que isso é importante? + +Esse arquivo nos permite **validar a análise que foi realizada**, documentando que temos um registro do processo de aquisição e dos indicadores que foram considerados para fazer a comparação. + +Essas informações nos permitem estabelecer uma referência do arquivo analisado e das ferramentas de indicadores usadas na análise, o que facilita o [processo de custódia da extração forense](../../explainers/01-explainer-introduction-digital-forensics/index.md#custody-chain). + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "target_path": "/path/from/file/bugreport.zip", + "mvt_version": "2.6.1", + "date": "YYYYY-MM-DD hh:mm:ss", + "ioc_files": [ + "/caminho/para/indicadores/pegasus.stix2", + "/path/to/indicators/predator.stix2", + "/path/to/indicators/rcs_lab.stix2", + "... mais indicadores usados ..." + ], + "hashes": [ + { + "file_path": "/path/from/file/bugreport.zip", + "sha256": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + } + ] +} +``` + +### command.log {#command.log} + +**informação contida** **informação contida** **informação contida** **informação contida** **informação contida** **informação contida + +Este arquivo está em texto simples com uma extensão *.log* e contém registros detalhados da execução do comando *mvt-android check-bugreport*. + +Seu conteúdo lista a análise realizada no relatório de erros, incluindo a detecção de indicadores de comprometimento para identificar alertas de segurança relacionados a malware. + +Os registros no arquivo são apresentados de forma estruturada com: + +* Carimbos de data e hora +* Nomes do módulo em execução +* Tipo de mensagem (*INFO*, *DEBUG*, WARNING, *ERROR*) +* Ação do módulo correspondente (análise de arquivo, carregamento de IoCs, comparação e resultado da comparação). + +Os tipos de mensagem correspondem ao seguinte: + +*INFO*. As mensagens também são exibidas na tela durante a execução. +*DEBUG*. Informações não exibidas na tela, mas associadas a uma ação executada durante a análise, por exemplo, o carregamento de um IoC ou a revisão de um hash. +* WARNING* Corresponde a alertas de atividade ou informações suspeitas que um analista deve verificar. +* ERRO: mensagens de erro sobre alguma ação realizada durante a análise, por exemplo, ao carregar um arquivo corrompido ou um problema com a execução do código correspondente. + +**Por que isso é importante? + +Permite gerar um registro das ações realizadas durante a análise. Por meio desse registro, é possível verificar o seguinte: + +* Que a análise foi realizada corretamente +* Se houve coincidências com IoCs +* Se foram identificadas informações ou atividadesad sospechosa. + +Estrutura do arquivo:** ** Estrutura do arquivo + +Esse arquivo segue um formato de linha por linha com a seguinte estrutura. + +``` +[TIMESTAMP] - [MODULE] - [LOG LEVEL] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE]. +... +2025-07-25 21:51:28,004 - mvt.android.cmd_check_bugreport - INFO - Analisando o arquivo de indicadores STIX2 no caminho /home/user/.local/share/mvt/indicators/raw.githubusercontent.com_AmnestyTech_investigations_master_2021-07-18_nso_pegasus.stix2 +2025-07-25 21:51:28,082 - mvt.android.cmd_check_bugreport - DEBUG - Extraiu 1549 indicadores para a coleção com o nome "Pegasus" +... +2025-07-25 21:51:29,524 - mvt.android.cmd_check_bugreport - INFO - Carregou um total de 10747 indicadores exclusivos +2025-07-25 21:51:29,524 - mvt - INFO - Verificando relatório de bug do Android no caminho: ./0caba18f-20a7-48d0-b9ba-724fdaa3ff85/bugreport.zip +... +2025-07-25 21:51:29,527 - mvt.android.modules.bugreport.accessibility - INFO - Executando o módulo Acessibilidade... +2025-07-25 21:51:30,794 - mvt.android.modules.bugreport.accessibility - INFO - Encontrado serviço de acessibilidade instalado "com.samsung.accessibility/.assistantmenu.serviceframework.AssistantMenuService" +... +2025-07-25 21:51:30,797 - mvt.android.modules.bugreport.accessibility - INFO - Identificou um total de 4 serviços de acessibilidade +2025-07-25 21:51:30,822 - mvt.android.modules.bugreport.accessibility - INFO - O módulo de acessibilidade não produziu nenhuma detecção! +... +2025-07-07-25 21:51:30,823 - mvt.android.modules.bugreport.activities - INFO - Executando o módulo Activities... +2025-07-25 21:51:32,156 - mvt.android.modules.bugreport.activities - INFO - Extraiu 4312 atividades do pacote +2025-07-25 21:51:32,844 - mvt.android.modules.bugreport.activities - INFO - O módulo Activities não produziu nenhuma detecção! +... +2025-07-25 21:51:51,292 - mvt.android.modules.bugreport.adb_state - INFO - Executando o módulo DumpsysADBState... +2025-07-25 21:51:52,196 - mvt.android.modules.bugreport.adb_state - INFO - Identificou um total de 0 chaves ADB confiáveis +2025-07-25 21:51:52,220 - mvt.android.modules.bugreport.adb_state - INFO - O módulo DumpsysADBState não produziu nenhuma detecção! +2025-07-25 21:51:52,222 - mvt.android.modules.bugreport.fs_timestamps - INFO - Executando o módulo BugReportTimestamps... +2025-07-25 21:51:52,224 - mvt.android.modules.bugreport.fs_timestamps - INFO - Extraiu um total de 239 registros de data e hora do sistema de arquivos do bugreport. +2025-07-25 21:51:52,225 - mvt.android.modules.bugreport.fs_timestamps - INFO - O módulo BugReportTimestamps não suporta a verificação de indicadores +2025-07-25 21:51:52,228 - mvt.android.modules.bugreport.tombstones - INFO - Executando o módulo Tombstones... +2025-07-25 21:51:53,552 - mvt.android.modules.bugreport.tombstones - INFO - Extraiu um total de 64 arquivos de tombstone +2025-07-25 21:51:53,555 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'Loc_hal_worker' em execução como UID '1000' em tombstone 'tombstone_13' em 2024-12-27 06:46:15.013046 +2025-07-25 21:51:53,556 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'LocApiMsgTask' em execução como UID '1000' em tombstone 'tombstone_13.pb' em 2024-12-27 06:46:15.013046 +2025-07-25 21:51:53,557 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'thermal@1.0-ser' em execução como UID '1000' em tombstone 'tombstone_14' em 2025-03-09 06:46:15.606938 +2025-07-25 21:51:53,558 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'POSIX timer 1' rodando como UID '1000' em tombstone 'tombstone_14.pb' em 2025-03-09 06:46:15.606938 +2025-07-25 21:51:53,559 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'HwBinder:1251_2' rodando como UID '1000' em tombstone 'tombstone_15' em 2025-03-30 06:46:15.306491 +2025-07-25 21:51:53,560 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'LocApiMsgTask' em execução como UID '1000' em tombstone 'tombstone_15.pb' em 2025-03-30 06:46:15.306491 +2025-07-25 21:51:53,561 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'Loc_hal_worker' em execução como UID '1000' em tombstone 'tombstone_17' em 2025-05-22 06:46:16.292957 +2025-07-25 21:51:53,562 - mvt.android.modules.bugreport.tombstones - AVISO - Falha potencialmente suspeita no processo 'LocApiMsgTask' em execução como UID '1000' em tombstone 'tombstone_17.pb' em 2025-05-22 06:46:16.292957 +2025-07-25 21:51:53,623 - mvt.android.cmd_check_bugreport - INFO - Hash de referência do arquivo info.json: "aee39fbcabf86848a4d806b7217b030f6240e5c62d02b12e330206c6a229c2b0" +2025-07-25 21:51:53,624 - mvt.android.cmd_check_bugreport - AVISO - [negrito]OBSERVAÇÃO: indicadores de comprometimento detectados[/negrito]. Somente uma análise especializada pode confirmar se os indicadores detectados são sinais de um ataque. + +Procure ajuda de um especialista de renome se você tiver sérias preocupações sobre um possível ataque de spyware. Esse suporte está disponível para defensores de direitos humanos e para a sociedade civil por meio doLaboratório de segurança em https://securitylab.amnesty.org/get-help/?c=mvt +2025-07-25 21:51:53,625 - mvt - AVISO - A análise do relatório de bug do Android produziu 13 detecções! + + +``` + +**Saiba mais** + +* [Introdução ao STIX](https://oasis-open.github.io/cti-documentation/stix/intro.html) + +### timeline.csv {#timeline.csv} + +**Informações contidas** **Informações contidas** **Informações contidas** **Informações contidas** **Informações contidas** **Informações contidas +Esse arquivo está no formato *csv* e armazena uma linha do tempo da atividade do dispositivo. Essa atividade é obtida a partir da execução dos módulos de análise do MVT e é classificada por tempo. + +Cada linha do *csv* corresponde a: + +* Timestamp (carimbo de data/hora local do dispositivo). +* Módulo executado (Plugin). +* Atividade identificada no dispositivo (Event). +* Descrição da atividade identificada no dispositivo (Description). + +**Por que isso é importante? + +Esse arquivo permite rastrear a atividade interna do dispositivo, podendo gerar uma ideia geral de como o dispositivo se comportou e identificar eventos relevantes. + +**Estrutura do arquivo + +Esse arquivo segue um formato de linha por linha com a seguinte estrutura. + +``` +"Device Local Timestamp", "Plugin", "Event", "Description", "1969-12-31 18:00:00", "Packages", "package_install", "Install or update". +"1969-12-31 18:00:00", "Packages", "package_install", "Instalar ou atualizar o pacote com.android.uwb.resources", "Description". +"1969-12-31 18:00:00", "Packages", "package_first_install", "Instalar ou atualizar o pacote com.cr +unchyroll.crunchyroid", "package_first_install", "Instalar ou atualizar o pacote com.cr" +"1969-12-31 18:00:00", "Pacotes", "package_last_update", "Instalar ou atualizar o pacote com.goog +le.android.ext.services" +... +"2008-12-31 09:00:00", "Packages", "package_last_update", "Instalar ou atualizar o pacote com.samsung.android.ardrawing", "Instalar ou atualizar o pacote com.samsung.android.ardrawing" ... +"2008-12-31 09:00:00", "Packages", "package_install", "Instalar ou atualizar o pacote com.samsung.android.ConnectivityUxOverlay" +... +"2019-01-19 02:53:42.000000","BugReportTimestamps","M---","FS/cache/recovery/last_log.1" +"2019-01-19 02:53:42.000000","BugReportTimestamps","M---","FS/cache/recovery/last_kmsg.1" +... +"2021-12-13 08:39:45.243000", "Appops", "Rejeitar", "com.google.android.como acesso a GET_USAGE_STATS: Rejeitar", "Appops", "Rejeitar", "com.google.android.como acesso a GET_USAGE_STATS: Rejeitar" +"2021-12-13 08:39:46.277000", "Appops", "Access", "com.android.providers.media access to READ_EXTERNAL_STORAGE: Access" +... +"2024-12-26 00:52:24.264000", "Appops", "Access", "com.google.android.gms access to READ_CONTACTS: Access", "Appops", "Access", "com.google.android.gms access to READ_CONTACTS: Access" ... +"2024-12-26 22:31:06.194000", "Appops", "Access", "com.samsung.android.messaging access to WRITE_CALL_LOG: Access", "Appops", "Access", "com.samsung.android.messaging access to WRITE_CALL_LOG: Access" +"2024-12-27 06:46:15.013046", "Tombstones", "Tombstone", "Crash no processo 'Loc_hal_worker' em execução como UID '1000' no arquivo 'tombstone_13' Crash type 'SIGABRT' with code 'SI_QUEUE'" +"2024-12-27 06:46:15.013046", "Tombstones", "Tombstone", "Falha no processo 'LocApiMsgTask' em execução como UID '1000' no arquivo 'tombstone_13.pb' Tipo de falha 'SIGABRT' com código 'SI_QUEUE'" +"2024-12-27 06:46:16.000000","BugReportTimestamps","M---","FS/data/tombstones/tombstone_13" +"2024-12-27 06:46:16.000000","BugReportTimestamps","M---","FS/data/tombstones/tombstone_13.pb" +"2024-12-27 06:46:58.561000", "Appops", "Access", "com.qti.snapdragon.qdcm_ff access to BLUETOOTH_CONNECT: Access", "Appops", "Access", "com.qti.snapdragon.qdcm_ff access to BLUETOOTH_CONNECT: Access" +"2024-12-27 06:47:03.100000", "Appops", "Reject", "com.android.inputdevices access to NO_ISOLATED_STORAGE: Reject" +... +"2025-06-30 21:30:30.477000", "Appops", "Access", "com.sec.android.app.launcher access to REQUEST_DELETE_PACKAGES: Access", "Appops", "Access", "com.sec.android.app.launcher access to REQUEST_DELETE_PACKAGES: Reject" ... +"2025-07-01", "BatteryDaily", "battery_daily", "Atualização gravada do pacote com.google.android.apps.restore com a versão 818758", "battery_daily", "Atualização gravada do pacote com.google.android.apps.restore com a versão 818758" +"2025-07-01", "BatteryDaily", "battery_daily", "Atualização gravada do pacote com.google.android.apps.chromecast.app com a versão 30503818" +"2025-07-01", "BatteryDaily", "battery_daily", "Atualização registrada do pacote com.google.android.apps.tasks com a versão 1885693" +... + +``` + +## Configuração do dispositivo {#device-configuration} + +### getprop.json {#getprop.json} + +As informações contidas nesse arquivo são obtidas por meio do módulo [getprop](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/getprop.py) e do artefato [getprop](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/getprop.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém uma lista de propriedades do dispositivo que são extraídas da seção *SYSTEM PROPERTIES* do *dumpsys*. + +Essas propriedades do sistema são pares de cadeias de valores chave que são armazenados no dicionário global [*build.prop*] (https://xdaforums.com/t/guide-build-prop-wiki.2056266/) ou em arquivos de descrição *.sysprop* e fornecem uma maneira conveniente de compartilhar configurações dentro do sistema. + +As informações podem ser encontradas usando o seguinte formato: + +``` +[{prefix}.]{group}[.{subgroup}]*.{name}[.{type}] +``` + +Algumas propriedades são prefixadas com *ro*, indicando que são propriedades somente leitura ou que foram atribuídas após a reinicialização do dispositivo. As propriedades prefixadas com *persist* referem-se a configurações resistentes à reinicialização. Algumas propriedades não devem ser prefixadas, portanto, começam diretamente com o grupo a que pertencem. + +Os grupos mais comuns são: + +*bluetooth*, relacionado ao Bluetooth. +*boot*, sysprops de linha de comando do kernel +*build*, sysprops que identificam uma compilação +*telefonia*, relacionado à telefonia +*audio*, relacionado a áudio +*graphics*, relacionado a gráficos +*vold*, relacionado ao vold, que gerencia a montagem de volumes físicos de armazenamento externo + +Para obter mais detalhes, consulte a [lista de propriedades já definidas no código-fonte do Android] (https://android.googlesource.com/platform/system/sepolicy/+/refs/heads/main/private/property_contexts). + +**Por que isso é importante? + +As propriedades fornecem informações importantes sobre o hardware e o software do dispositivo, que podem ser alteradas por software mal-intencionado para ocultar sua presença ou para modificar inadvertidamente o comportamento do dispositivo. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +[ + { + "nome": "DEVICE_PROVISIONED", + "value": "1" + }, + { + "name": "aaudio.hw_burst_min_usec", + "value": "2000" + }, + { + "name": "bluetooth.device.class_of_device", + "value": "90,2,12" + }, + { + "name": "ro.boot.serialno", + "value": "RF8T11XXXXX" + }, + { + "name": "ro.bootimage.build.date", + "value": "Mon Mar 24 20:09:54 KST 2025" + }, + { + "name": "ro.hardware.chipname", + "value": "SM8250" + }, + { + "name": "ro.product.system.model", + "value": "SM-G780G" + }, + { + "name": "ro.build.selinux", + "value": "1" + } +] +``` + +**Saiba mais** + +* Visão geral da configuração | Propriedades do sistema | Projeto de código aberto do Android](https://source.android.com/docs/core/architecture/configuration?hl=es-419#system-properties) +* [Como implementar propriedades do sistema como APIs | Android Open Source Project](https://source.android.com/docs/core/architecture/configuration/sysprops-apis?hl=es-419) +* [Adicionar propriedades do sistema | Projeto de código aberto do Android](https://source.android.com/docs/core/architecture/configuration/add-system-properties?hl=es-419) +* [Policy Compatibility (Compatibilidade de políticas) | Android Open Source Project (Projeto de código aberto Android)](https://source.android.com/docs/security/features/selinux/compatibility?hl=es-419#system-property-and-ownership) + +## Registro do sistema e informações sobre eventos + +### dumpsysys_adb_state.json {#dumpsys_adb_state.json} + +O conteúdo desse arquivo é gerado pelo módulo [adb\_state](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/adb_state.py). e pelo artefato [dumpsysys_adb_adb](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_adb.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém informações de uma conexão ADB extraídas do serviço *adb* do *dumpsys.*. + +As informações no arquivo são apresentadas da seguinte forma: + +**connected_to_adb**. Indica se o dispositivo tinha uma conexão ADB ativa (verdadeira ou falsa). +**last_key_received**. Cadeia de caracteres em formato hexadecimal que representa a última chave pública usada para emparelhar o dispositivo com o host do ADB. +**keystore**. Pode conter informações sobre o armazenamento de chaves usado para autenticação, embora na maioria dos casos apareça como nulo. +**user_keys**. Lista de chaves públicas de usuário armazenadas no dispositivo. + +**Por que isso é importante? + +O conteúdo desse arquivo permite que o analista saiba se o dispositivo foi conectado recentemente a um computador via ADB, o que pode revelar tentativas de extrair e analisar informações forenses em um dispositivo móvel. + +Isso é particularmente útil se houver suspeita de que ferramentas como o [UFED da Cellebrite](https://www.amnesty.org/en/latest/news/2024/12/serbia-authorities-using-spyware-and-cellebrite-forensic-extraction-tools-to-hack-journalists-and-activists/) ou similares estejam sendo usadas em detenções arbitrárias ou acesso físico ao dispositivo. + +Uma consideração sobre essas informações é que elas não necessariamente comprovam uma intervenção maliciosa, mas são um precedente para conexões ADB recorrentes. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +O arquivo segue uma estrutura de lista de objetos JSON de valor-chave. + +``` +[ + { + "connected_to_adb": "true", + "last_key_received": "A0:4B:43:78:C0:B2:3D:A1:38:37:A0:B0:CE:E8:94:96", + "keystore": nulo, + "user_keys": [] + } +] +``` + +### bugreport_timestamps.json {#bugreport_timestamps.json} + +O conteúdo desse arquivo é gerado pelo módulo [fs\_timestamps] (https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/fs_timestamps.py) e pelo artefato [file_timestamps] (https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/file_timestamps.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém informações sobre oO relatório de bug deve conter as informações associadas ao sistema de arquivos e aos pontos de montagem do sistema encontrados na pasta *FS* (Sistema de arquivos) dentro do relatório de bug. + +Mais claramente, se */dirA/dirB/fileC* existir no sistema de arquivos, isso se traduz em *FS/dirA/dirB/fileC*. + +É importante não confundir o sistema de arquivos e os pontos de montagem com arquivos gerados pelo usuário. + +As informações são apresentadas como uma lista que contém o caminho para o arquivo e sua data de última modificação. + +**Por que isso é importante? + +As informações contidas nesse arquivo nos permitem identificar alterações incomuns no sistema de arquivos e nos pontos de montagem, o que pode indicar atividade mal-intencionada. Por exemplo, elas podem revelar sinais de escalonamento de privilégios, montagens não autorizadas ou acesso incomum que pode ter se originado de um escape de sandbox por meio de descritores de arquivos associados a hardware como a GPU. Além disso, essas informações podem ajudar a rastrear falhas do sistema vinculadas a outros registros, como relatórios de bugs anteriores, registros de falhas ou lápides, facilitando a reconstrução de eventos suspeitos. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "caminho": "FS/cache/recovery/last_log.8", + "modified_time": "2019-03-27 23:48:02.000000" + }, + { + "path" (caminho): "FS/cache/recovery/block.map" (FS/cache/recuperação/bloco.mapa), + "modified_time": "2025-05-15 12:26:18.000000" + }, + { + "path": "FS/cache/recovery/last_history", + "modified_time": "2019-04-19 07:40:26.000000" + }, + { + "path": "FS/cache/recovery/last_log.1", + "modified_time": "2019-01-19 02:53:42.000000" + }, + { + "path": "FS/proc/3188/mountinfo", + "modified_time": "2025-07-07 11:23:36.000000" + }, + { + "path" (caminho): "FS/proc/3209/mountinfo" (FS/proc/3209/mountinfo), + "modified_time": "2025-07-07 11:23:36.000000" + }, + { + "path": "FS/data/anr/anr_2025-07-05-06-49-16-315", + }, { "modified_time": "2025-07-05 06:49:18.000000": "2025-07-05 06:49:18.000000" + }, + { + "path": "FS/data/log/bt/btsnooz_hci.log.last", + }, { "modified_time": "2025-07-07 11:22:20.000000". + } +} +``` + +**Saiba mais** + +* Configuração do dispositivo [Android Open Source Project](https://source.android.com/docs/core/storage/config#file_mappings) +* Visão geral das partições [Android Open Source Project](https://source.android.com/docs/core/architecture/partitions) + +### dbinfo.json {#dbinfo.json} + +O conteúdo desse arquivo é gerado pelo módulo [dbinfo](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/dbinfo.py) e pelo artefato [dumpsysys_dbinfo](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_dbinfo.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre os bancos de dados usados pelos aplicativos e serviços do dispositivo. Essas informações são extraídas do serviço *adb* do *dumpsys.*. + +Internamente, o Android usa bancos de dados SQLite que estão localizados dentro de cada aplicativo. Por exemplo, o aplicativo *com.example.myapp* pode conter um banco de dados chamado *mydatabase.db*, que está localizado em */data/data/com.example.myapp/databases/mydatabase.db .*. + +Cada objeto no arquivo especifica uma operação executada nesses bancos de dados, incluindo: + +* Carimbo de data/hora. +* Identificador de processo (pid). +* Tipo de operação realizada. +* A consulta executada. +* O banco de dados usado. + +**Por que isso é importante? + +Esse arquivo é importante para rastrear as consultas executadas em diferentes bancos de dados de aplicativos que podem ser considerados críticos, permitindo o rastreamento de padrões potencialmente maliciosos no dispositivo. + +Estrutura do arquivo:** **Estrutura do arquivo + +``` +[ + { + "isodate": "2025-01-17 16:55:18.665", + "pid": "0", + "action": "executeForLong", + "sql": "PRAGMA temp.page_size;", + "path": "/data/user/0/com.sec.android.app.launcher/databases/Icon.db" + }, + { + }, "isodate": "2025-01-17 16:52:18.136", + }, { "pid": "7280", + "action": "execute", + "sql": "COMMIT;", + "path": "/data/user/0/com.sec.android.app.launcher/databases/Icon.db" + }, + { + }, "isodate": "2025-01-17 16:52:18.133", + }, { "pid": "7280", + "action": "executeForChangedRowCount", + "sql": "DELETE FROM icon WHERE component_name LIKE ? || '/%' AND profile_id = ?", + "path": "/data/user/0/com.sec.android.app.launcher/databases/Icon.db" + } +] +``` + +**Saiba mais** + +* [Visão geral do armazenamento de dados e arquivos | Dados e arquivos de aplicativos | Desenvolvedores Android](https://developer.android.com/training/data-storage) + +### Receptores.json {#receptores.json} + +As informações nesse arquivo são geradas pelo módulo [receivers](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/receivers.py) e pelo artefato [dympsysys_receivers](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_receivers.py). + +**Informações contidas + +Esse arquivo está em *json* e contém informações sobre [*receivers*] (https://developer.android.com/develop/background-work/background-tasks/broadcasts) e [*intents*] (https://developer.android.com/guide/components/intents-filters) dos aplicativos e serviços no dispositivo. Essas informações são extraídas do serviço *package* do *dumpsys*. + +Em termos gerais, um *intent* é uma mensagem que pode ser usada para solicitar uma ação de outro aplicativo ou componente do sistema, e um *receptor* ou *receptor de difusão* é um componente que responde a eventos do sistema ou do aplicativo. Um transmite e o outro escuta ou responde. + +As informações no arquivo são apresentadas da seguinte forma: + +**intent**. Emissão ou solicitação de ação. +**Nome_do_pacote**. Nome do pacote (aplicativo ou serviço) que contém o receptor. +** **receiver**. Nome da classe que manipula o receptor. + +**Por que isso é importante? + +As informações associadas a *intents* e *receivers* nos permitem identificar se um aplicativo ou serviço mal-intencionado pode estar se comunicando ou obtendo informações privadas ou confidenciais por meio desses métodos. + +Estrutura do arquivo:** ** Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "android.intent.action.SCREEN_OFF": [ + { + "nome_do_pacote": "com.facebook.katana", + "receiver": "com.facebook.katana/com.facebook.notifications.tray.util.NotificationsClientSignalStaticBroadcastReceiver" + }, + { + "nome_do_pacote": "com.zhiliaoapp.musically", + "receiver": "com.zhiliaoapp.musically/com.ss.android.message.MessageReceiver" + } + ], + "com.samsung.android.easysetup.batteryInfo": [ + { + "nome_do_pacote": "com.samsung.android.easysetup", + "receiver": "com.samsung.android.easysetup/.BeaconBroadcastReceiver" + } + ] +} +``` + +## Processos e aplicativos {#processos-e-aplicativos} + +### packages.json {#packages.json} + +As informações contidas nesse arquivo são geradas pelo módulo [packages](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/packages.py) e pelo artefato [dumpsyspackages](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_packages.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre os aplicativos instalados no dispositivo. Essas informações são extraídas do serviço *package* do *dumpsys*. + +As informações no arquivo são apresentadas da seguinte forma: + +** **package_name**: Nome do pacote de aplicativos. +** **uid**: Identificador de usuário associado ao aplicativo +**version_name**: Nome da versão do aplicativo +** **version_code**: Código da versão, incluindo o SDK mínimo e o destino. +* timestamp**: Carimbo de data e hora da última atualização. +**first_install_time**: Data e hora da primeira instalação. +**last_update_time**: Data e hora da última atualização. +**permissions**: Lista de permissões associadas ao aplicativo +** **requested permissions**: lista de permissões solicitadas pelo aplicativo, embora nas versões recentes isso já esteja obsoleto e você só precise prestar atenção a ***permissions***. + +Dentro das permissões (*permissões* e *permissões solicitadas*), podemos encontrar: + +**name**: Nome da permissão solicitada. +**granted**: Indica se a permissão foi concedida (true) ou negada (false). +* type**: tipo de permissão + **declared** para permissões declaradas no manifesto do aplicativo. + **install** para permissões concedidas na instalação. + * para permissões solicitadas em tempo de execução. + +**Por que isso é importante? + +As informações contidas nesse arquivo permitem que o analista conheça e mapeie os aplicativos instalados. A partir delas, é possível identificar informações associadas para diagnosticar se eles podem ser potencialmente maliciosos, por exemplo, abusando de permissões perigosas ou suspeitas, tendo sido instalados em datas relevantes identificadas no diagnóstico, sendo associados a processos suspeitos em execução por meio de seu *uid* ou identificando vetores de ataque, como o uso de versões antigas, desatualizadas ou vulneráveis de aplicativos. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +[ + { + "nome_do_pacote": "com.whatsapp", + "uid": "10365", + "nome_da_versão": "2.25.18.80", + "version_code": "251880000 minSdk=21 targetSdk=35", + "timestamp": "2025-06-26 03:25:25", + "first_install_time": "1969-12-31 18:00:00", + "last_update_time": "2025-06-26 03:25:44", + "permissões": [ + { + "nome": "com.whatsapp.permission.BROADCAST", + "type": "declared" + }, + { + "nome": "com.whatsapp.permission.MAPS_RECEIVE", + "type": "declared" (tipo: "declarado") + }, + { + "name": "com.google.android.finsky.permission.BIND_GET_INSTALL_REFERRER_SERVICE", + "granted": true, + "type": "install" + }, + { + "name": "android.permission.USE_CREDENTIALS", + "granted": true, + "type": "install" + }, + { + "name": "android.permission.POST_NOTIFICATIONS", + "granted": true, + "type": "runtime" + }, + { + "nome": "android.permission.READ_CALL_LOG", + "granted": false, + "type": "runtime" (tipo: "tempo de execução") + }, + { + "nome": "android.permission.ACCESS_FINE_LOCATION", + "granted": true, + "type": "runtime" (tipo: "tempo de execução") + }, + { + "nome": "android.permission.NEARBY_WIFI_DEVICES", + "granted": false, + "type": "runtime" (tipo: "tempo de execução") + }, + { + "nome": "android.permission.RECEIVE_SMS", + "granted": false, + "type": "runtime" + }, + { + "nome": "android.permission.BLUETOOTH_CONNECT", + "granted": false, + "type": "runtime" (tipo: "tempo de execução") + } + ], + "requested_permissions": [] + } +] +``` + +**Saiba mais** + +* [Permissões no Android](https://developer.android.com/guide/topics/permissions/overview?hl=es-419) + +### activities.json {#activities.json} + +As informações nesse arquivo são geradas pelo módulo [activities](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/activities.py) e pelo artefato [dumpsys_package_activities](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_package_activities.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre as [*intents](https://developer.android.com/guide/components/intents-filters) e [*activities](https://developer.android.com/guide/components/activities/intro-activities) associadas a cada aplicativo instalado no dispositivo. Essas informações são extraídas do serviço *package* do *dumpsys*. + +Em termos gerais, uma *intent* é uma mensagem que pode ser usada para solicitar uma ação de outro aplicativo ou componente do sistema, e uma *activity* é um componente que responde como o ponto de entrada principal de um aplicativo, ou seja, o equivalente a um *main* em algumas linguagens de programação ou uma janela em ambientes gráficos. Um emite ações para outros aplicativos e o outro é com o que o usuário interage. + +As informações no arquivo são apresentadas da seguinte forma: + +**intent**. Emissão ou solicitação de ação. +** **package_name**. Nome do pacote (aplicativo ou serviço) associado à * atividade. +**Activity**: nome da classe que manipula a *atividade*. + +**Por que isso é importante? + +As informações associadas a intents e receivers nos permitem identificar se um aplicativo ou serviço mal-intencionado pode estar se comunicando ou obtendo informações privadas ou confidenciais por meio desses métodos. +As *intents* nos permitem identificar se um aplicativo está enviando informações ou solicitações de ação para outro aplicativo, enquanto a *atividade* nos permite identificar de onde a *intent* foi emitida. + +Isso é útil para identificar como os aplicativos interagem entre si ou que tipo de serviços são expostos em alguns componentes do aplicativo. Assim, é possível detectar *intents* e *activities* que poderiam ser usados maliciosamente em segundo plano. + +Estrutura de arquivos:** ** Estrutura de arquivos:** Estrutura de arquivos:** Estrutura de arquivos:** Estrutura de arquivos:** Estrutura de arquivos:** Estrutura de arquivos:** Estrutura de arquivos + +``` +[ + { + "intent": "com.google.android.gms.autofill.ACTION_SETTINGS", + "nome_do_pacote": "com.google.android.gms", + "activity": "com.google.android.gms/.autofill.ui.AutofillSettingsPrivacyHubActivity" + }, + { + "intent": "android.settings.FINGERPRINT_SETUP" }, { "intent": "android.settings.FINGERPRINT_SETUP", + "nome_do_pacote": "com.android.settings", + "activity": "com.android.settings/.biometrics.fingerprint.SetupFingerprintEnrollIntroduction" + }, + { + "intent": "com.samsung.android.samsungaccount.action.REQUEST_SA_CONSENT_AGREEMENT_SUW", + "nome_do_pacote": "com.osp.app.signin", + "activity": "com.osp.app.signin/com.samsung.android.samsungaccount.authentication.ui.tnc.view.TncReAgreementView" + } +] + +``` + +**Saiba mais** + +* [Intenções e filtros de intenção](https://developer.android.com/guide/components/intents-filters) +* [Introdução às atividades](https://developer.android.com/guide/components/activities/intro-activities?hl=es-419#tcoa) + +### appops.json {#appops.json} + +As informações nesse arquivo são geradas pelo módulo [appops](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/appops.py) e pelo artefato [dumpsys_appos](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_appops.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre as operações associadas às permissões dos aplicativos instalados no dispositivo. Essas informações são extraídas do serviço *appos* do *dumpsys*. + +As informações no arquivo aO arquivo é apresentado da seguinte forma: + +* **nome_do_pacote**. Nome do pacote (aplicativo ou serviço). +** **permissions**: Lista de permissões associadas ao aplicativo. + **name**: Nome da permissão solicitada pelo pacote. + **entries**: Histórico de operações na permissão. + * access**: Status da permissão + *allow**. O acesso à permissão foi permitido. + *ignore*. O acesso à permissão não foi permitido. + *deny*. Lança uma *SecurityException* ao solicitar acesso à permissão. + *default*. Comportamento padrão da permissão. + *foreground*. O acesso à permissão foi permitido, mas somente se o aplicativo estiver em segundo plano. + **type**: categoria da operação. É composta pelo estado atual da operação e por um sinalizador associado ao contexto de execução da operação. O estado da operação refere-se ao fato de ela ter sido executada em primeiro plano, em segundo plano etc. E o contexto de execução refere-se ao fato de a operação ter sido executada diretamente pelo aplicativo, por um aplicativo externo confiável, por um aplicativo não verificado etc. Eles são concatenados por um hífen. *Não incluído em todos os registros. + * Os valores para o status da operação podem ser os seguintes: + *pers*. A operação pertence a um processo persistente (por exemplo, serviços do sistema que não podem morrer). + *top*. A operação corresponde ao aplicativo que está em primeiro plano no momento (visível para o usuário). + *fgsvcl*. A operação pertence a um serviço em primeiro plano que acessa o local. + *fgsvc*. A operação pertence a um serviço em primeiro plano. + *fg*. A operação está em primeiro plano (atividade visível ou componente em uso). + *bg*. A operação está em segundo plano. + *cch*. A operação é armazenada em cache, ou seja, o processo não está sendo executado ativamente. + *gone*. A operação não tem processos ativos (não existe no momento). + *unknown* (desconhecido). Status desconhecido ou não categorizado. + * Os valores do sinalizador de contexto da operação podem ser os seguintes: + * *s*. A operação foi executada diretamente pelo próprio aplicativo (contexto próprio). + *tp*. A operação foi executada por um aplicativo confiável que atua como proxy de outro aplicativo. + *up*. A operação foi executada por um aplicativo não confiável atuando como proxy de outro aplicativo. + *tpd*. A operação foi executada em nome desse aplicativo por um proxy confiável. + *upd*. A operação foi executada em nome desse aplicativo por um proxy não confiável. + *unknown*. Contexto de operação desconhecido. + * Carimbo de data/hora**: Carimbo de data/hora em que a operação foi registrada. *Não está incluído em todos os registros. +**uid**: identificador de usuário associado ao aplicativo. + +**Por que isso é importante? + +As operações *apps* permitem identificar com precisão quais aplicativos solicitaram permissões específicas e sob quais condições e contexto de execução elas estão sendo solicitadas. + +Isso é útil para identificar se um aplicativo está sendo executado em um *contexto confiável* ou não confiável ao solicitar uma permissão, ou seja, para identificar se um aplicativo está usando outro aplicativo como proxy para solicitar uma permissão e para verificar como essa operação foi executada, por exemplo, se essa solicitação de permissão veio de outro aplicativo como proxy em segundo plano ou em execução no cache. + +A identificação de contextos arriscados de solicitação de permissão em operações de *aplicativos* nos permite reconhecer padrões suspeitos e repetitivos de solicitação de permissão que nos permitem avaliar em profundidade se o contexto no qual a operação é executada é legítimo ou está vinculado ao abuso de permissões e privilégios, revelando um comportamento mal-intencionado relacionado a malware. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "nome_do_pacote": "com.samsung.android.provider.filterprovider", + "permissões": [ + { + "name": "MANAGE_EXTERNAL_STORAGE", + "entradas": [ + { + "access" (acesso): "reject" (rejeitar), + "type": "pers-s", + "timestamp": "2024-12-01 19:47:10.776000" + } + ], + "access" (acesso): "default" (padrão) + }, + { + }, "name": "BLUETOOTH_CONNECT", + "entries": [ + { + "access" (acesso): "access" (acesso), + "type": "pers-s", + "timestamp": "2024-12-11 06:41:14.035000" + } + ], + "access" (acesso): "allow" (permitir) + } + ], + }, "uid": "1000" +} +``` + +**Saiba mais** + +* [AppOpsManager](https://developer.android.com/reference/android/app/AppOpsManager) +* [App-ops](https://android.googlesource.com/platform/frameworks/base/+/refs/heads/main/core/java/android/app/AppOps.md) + +### accessibility.json {#accessibility.json} + +As informações nesse arquivo são geradas pelo módulo [accessibility](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/accessibility.py) e pelo artefato [dumpsys accessibility](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_accessibility.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre os *serviços* de *acessibilidade* ativos relacionados a um aplicativo de dispositivo. Essas informações são extraídas do serviço de *acessibilidade* do *dumpsys*. + +Em termos gerais, um *serviço de acessibilidade* é um componente de um aplicativo executado em segundo plano que pode observar os eventos que ocorrem na interface e executar alguma ação para o usuário a fim de ajudar as pessoas com deficiências. Por exemplo, leitores de tela em voz alta, controle de cores de contraste do sistema, escuta do microfone para comandos de voz, etc., que podem ser abusados ou usados de forma maliciosa. + +As informações no arquivo são apresentadas da seguinte forma: + +**package_name**: Nome do pacote (aplicativo ou serviço). +** **service**: Nome da classe que lida com o serviço de acessibilidade. + +**Por que isso é importante? + +Esse arquivo nos permite identificar se um aplicativo faz uso de um serviço de acessibilidade. Isso é útil para identificar o nome completo da classe do serviço e determinar se seu uso tem intenção maliciosa. + +Estrutura do arquivo:** **Estrutura do arquivo:** + +``` +[ + { + "nome_do_pacote": "com.google.android.apps.accessibility.voiceaccess", + "service": "com.google.android.apps.accessibility.voiceaccess/.JustSpeakService (A11yTool)" + }, + { + "nome_do_pacote": "com.microsoft.appmanager", + "service": "com.microsoft.appmanager/com.microsoft.mmx.screenmirroringsrc.accessibility.ScreenMirroringAccessibilityService" + }, + { + "nome_do_pacote": "com.samsung.accessibility", + "service": "com.samsung.accessibility/.universalswitch.UniversalSwitchService (A11yTool)" + }, + { + "nome_do_pacote": "com.samsung.accessibility", + "service": "com.samsung.accessibility/.assistantmenu.serviceframework.AssistantMenuService (A11yTool)" + }, + { + "package_name": "com.samsung.android.accessibility.talkback" }, { "package_name": "com.samsung.android.accessibility.talkback", + "service": "com.samsung.android.accessibility.talkback/com.samsung.android.marvin.talkback.TalkBackService (A11yTool)" + } +] +``` + +**Saiba mais** + +* [AccessibilityService no Android](https://developer.android.com/reference/android/accessibilityservice/AccessibilityService) + +### tombstones.json {#tombstones.json} + +As informações nesse arquivo são geradas pelo módulo [tombstones](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/tombstones.py), pelo artefato [tombstone\_crashes](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/tombstone_crashes.py) e pelo analisador [proto/tombstone](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/parsers/proto/tombstone.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre os registros de falhas de um aplicativo ou serviço. Essas informações são extraídas dos arquivos *tombstone.pb* localizados na pasta *FS/data/tombstones* dentro do relatório de bug. + +Esse arquivo contém informações detalhadas sobre os processos envolvidos, os sinais de erro que foram acionados no momento da falha, os binários associados à falha e o ambiente geral em que a falha ocorreu. + +As informações no arquivo são apresentadas da seguinte forma: + +**file_name**: Nome do arquivo, por exemplo, *tombstone_xx*. +**file_timestamp**: Registro de data e hora da última modificação do arquivo no formato AAAA-MM-DD hh-mm-ss.ms. +** **build_fingerprint**: identificador de compilação do Android que estava em execução no momento da falha. +** **revision**: Versão do formato do arquivo. +**Arquitetura**: Arquitetura do sistema em que ocorreu a falha. +** **timestamp**: Registro de data e hora em que a falha ocorreu no formato AAAA-MM-DD hh-mm-ss.ms. +**process_uptime**: Tempo em segundos que o processo com falha estava em execução. +**command_line**: Comando ou processo que gerou a falha. +** **pid**: identificador exclusivo do processo que causou a falha. +** **tid**: Identificador da thread em que ocorreu a falha (pode corresponder ao pid se for a thread principal). +** **process_name**: Nome do processo que sofreu a falha. +** **binary_path**: Caminho do binário executado no momento da falha. +** **selinux_label**: rótulo de contexto do SELinux *u:r:domain:s0:category* associado ao processo que falhou. Composto por: + **u**: processos de agrupamento de usuários do SELinux. em um único conjunto de regras de segurança. + **r**: função do SELinux que conecta o usuário aos domínios. No caso da política do SELinux do Android, a função está presente para compatibilidade com o formato padrão do SELinux. + * domínio**: tipo ou domínio do SELinux. Essa parte do contexto identifica o processo ou serviço que falhou. Os domínios que podem aparecer nesse campo vêm da política SELinux ativa do dispositivo, onde, dentro dessa política, os domínios são definidos em arquivos *.te* específicos para serviços do sistema, aplicativos de usuário, no HAL ou em um processo crítico. + * Nível de segurança:** Corresponde ao componente de segurança de vários níveis ou de várias categorias e inclui apenas o nível básico de segurança e, às vezes, categorias adicionais que permitem diferenciar instâncias de processos com falha no mesmo domínio. O nível mais simples é o s0, que é o valor básico presente na maioria dos processos do sistema. Quando o isolamento adicional é necessário, principalmente em aplicativos de usuário, o nível pode incluir categorias adicionais. +* ID do usuário associado ao processo em execução. +** **signal_info**: sinal enviado de ou para o sistema ao disparar a falha. + * código**: código específico que indica como o sinal foi gerado. Eles podem ser os seguintes: + * 0 \= SE USUÁRIO + * 128 = KERNEL + * 1 = QUEUE + * 2 = TIMER + * 3 = MSGQ_MESSAGE + \-4 = ASSÍNCRONO + \-5 = SIÈ SIÈ SIÈ SIGIO + \-6 = TKILL + * 7 = DETHREAD + **code_name**: Sinal associado ao código. Eles podem ser os seguintes: + * SI\_USER: sinal enviado manualmente do espaço do usuário (ou seja, por um programa ou pelo próprio usuário). Normalmente não indica um erro do sistema, mas sim que o processo foi encerrado externamente por alguém ou por outro programa. + * SIKERNEL: sinal gerado diretamente pelo kernel, geralmente associado a falhas graves de memória ou de hardware detectadas no nível mais baixo do sistema. + * SI_QUEUE: sinal que inclui informações adicionais e é enviado entre processos. É usado para comunicação avançada, por exemplo, em programas multithread ou ao usar filas de sinais. Não está relacionado a erros, mas a eventos de coordenação entre processos. Geralmente é usado para notificar um processo a outro com mais contexto do que apenas o sinal. + * SI_TIMER: sinal enviado pelo kernel quando um cronômetro expira. Os temporizadores são usados para controlar determinadas operações para que não sejam executadas por muito tempo, para obter amostras do estado dos threads ou para acionar tarefas automáticas do sistema. Nesse caso, o sinal pode significar que um processo terminou porque um cronômetro o forçou a encerrar. Alguns desses timers podem ser *watchdogs* do sistema ou processos de *amostragem* de memória. + * SI\_MESGQ: sinal gerado quando uma mensagem chega a uma fila de mensagens POSIX (um mecanismo de comunicação entre processos em sistemas do tipo Unix). Esse sistema é usado em vez de pipes, sockets ou binders. Normalmente, o sinal é acionado quando há atividade na fila, mas pode causar problemas se o envio e o recebimento não estiverem bem sincronizados. + * SIYNCIO: sinal enviado pelo kernel no final de uma operação de E/S assíncrona. Se o programa não tiver um manipulador adequado para esse sinal, ou se ele falhar, o aplicativo poderá ser encerrado inesperadamente. + * SIIGIO: sinal relacionado a operações de entrada/saída em arquivos ou soquetes. Ocorre quando um descritor de arquivo é configurado para notificar eventos por sinais ou quando ocorre um erro no descritor de arquivo. + * SIKILL: sinal usado para encerrar um thread específico (e não o processo inteiro). Geralmente gerado pelo próprio programa, seu ambiente de execução (por exemplo, Dalvik/ART) ou uma de suas bibliotecas internas. + * SI\_DETHREAD: sinal interno usado pelo sistema ao "desacoplar" os threads de um processo multithread. Isso ocorre se o thread principal morrer ou se um grupo de threads associados for explicitamente solicitado a encerrar. + **name**: nome do sinal. Pode ser o seguinte: + * SIGILL: execução de uma instrução inválida. + * SIGTRAP: ativação de um ponto de interrupção. Útil para identificar depuração ou interferência no fluxo de um processo. + * SIGABRT: encerramento forçado pelo próprio processo quando uma falha crítica é detectada. Pode estar relacionado a erros provocados. + * SIGBUS: acesso inválido ao barramento de memória. + * SIGFPE: erro aritmético, como divisão por zero. + * SIGSEGV: acesso ilegal à memória. Associado a estouros de buffer. + * SIGSTKFLT: falha na pilha de execução. + * SIGSTOP: pausa total de um processo sem a possibilidade de capturar informações sobre o processo. + ** **número**: número do sinal POSIX que causou a falha.Eles podem ser os seguintes: + * 4 = SIGILL + * 5 = SIGTRAP + * 6 = SIGABRT + * 7 \= SIGBUS + * 8 \= SIGFPE + * 11 \= SIGSEGV + * 16 \= SIGSTKFLT + * 19 \= SIGSTOP +** **cause**: Cadeia de caracteres textual que explica a causa da falha, se registrada explicitamente. Pode estar vazia ou ser nula. +**extra**: campos reservados para dados adicionais. + +**Por que isso é importante? + +Os túmulos permitem a identificação de falhas críticas de aplicativos ou processos, incluindo detalhes essenciais, como o sinal que causou a falha, o processo envolvido, o horário do evento e a linha ou o comando ativo no momento da falha. + +Isso é útil para detectar quais processos, serviços ou aplicativos estão falhando ou causando falhas no sistema. Dessa forma, é possível determinar se os processos que estão causando falhas são anormalidades do sistema, se o contexto de segurança e execução demonstra um comportamento incomum ou não autorizado e se os sinais indicam possíveis explorações do sistema ou falhas causadas por outro processo que indique comportamento malicioso. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "nome_do_arquivo": "tombstone_05", + "file_timestamp": "2025-01-01 00:00:00.000000", + "build_fingerprint": "phone/r8qxx/r8q:13/TP1A.220624.014/G780GXXSCEXI1:user/release-keys", + "revision": 10, + "arch": "arm64", + "timestamp": "2025-01-01 00:00:00.173266", + "process_uptime": 1, + "linha_de_comando": [ + "lowi-server". + ], + "pid": 17292, + "tid": 17293, + "nome_do_processo": "lowi-server", + "binary_path": "lowi-server", + "selinux_label": nulo, + "uid": 1021, + "signal_info": { + "code" (código): -1, + "nome_do_código": "SI_QUEUE", + "name": "SIGABRT", + "number": 6 + }, + "cause": nulo, + "extra": nulo + }, +``` + +**saiba mais** + +* Depurar código nativo da plataforma Android](https://source.android.com/docs/core/tests/debug) +* Diagnosticar falhas nativas | Android Open Source Project](https://source.android.com/docs/core/tests/debug/native-crash) +* [Tombstone.cpp](https://android.googlesource.com/platform/system/core/%2B/78786da/debuggerd/tombstone.cpp) +* [Android SEPolicy](https://android.googlesource.com/platform/system/sepolicy/) +* [Definições de domínio público](https://android.googlesource.com/platform/system/sepolicy/+/refs/heads/main/public/) +* Definições de domínio público do Vendor-HAL](https://android.googlesource.com/platform/system/sepolicy/+/refs/heads/main/vendor) + +### battery\_daily.json {#battery_daily.json} + +As informações contidas nesse arquivo são geradas pelo módulo [battery_daily](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/battery_daily.py) e pelo artefato [dumpsysys_battery_daily](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_battery_daily.py). + +**Informações contidas**. +Esse arquivo está no formato *json* e contém informações sobre registros *update* relacionados a um aplicativo. Essas informações são extraídas do serviço *batterystats* do *dumpsys*. + +A *ação* nesse arquivo refere-se a um evento *update* registrado pelo serviço *batterystats* que indica o intervalo de datas em que um aplicativo foi atualizado e qual versão foi registrada após a atualização. + +**Por que isso é importante? + +As informações em battery_daily permitem identificar as atualizações dos aplicativos instalados em um dispositivo no intervalo de datas em que ele foi alterado de uma versão para outra e registrar a versão do aplicativo atribuída após essa atualização. + +Isso é útil para identificar aplicativos que mudaram de versão com frequência e de forma incomum. Dessa forma, é possível determinar se uma atualização pode ser vinculada a períodos de tempo e datas específicos que coincidam com comportamentos ou atividades suspeitas no dispositivo que possam ser indicativos da presença de malware. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +[ + { + "ação": "atualizar", + "from": "2025-01-16", + "to": "2025-01-17", + "nome_do_pacote": "com.instagram.android", + "vers": "376704533" + }, + { + "ação": "atualizar", + "from": "2025-01-14", + "to": "2025-01-15", + "nome_do_pacote": "com.facebook.katana", + "vers": "458034716" + } +] +``` + +### battery\_history.json {#battery_history.json} + +As informações contidas nesse arquivo são geradas pelo módulo [battery_history](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/battery_history.py) e pelo artefato [dumpsys_battery_history](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_battery_history.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém informações sobre registros de *eventos* relacionados a um aplicativo instalado e ao fato de ele service. Essas informações são extraídas do serviço *batterystats* do *dumpsys*. + +Um *evento* é um registro que indica uma ação executada por um aplicativo e o serviço específico que fez a alteração. O *evento* representa o início ou o fim de uma ação programada de um aplicativo no dispositivo, a ativação ou a desativação de um método de um aplicativo que mantém um dispositivo ativo e as alterações de estados que um aplicativo tem ao passar do primeiro para o segundo plano. + +As informações no arquivo são apresentadas da seguinte forma: + +**time_elapsed**: Tempo decorrido desde o início do registro de histórico até a ocorrência do evento em milissegundos. +**event**: Ação registrada como um evento de um aplicativo, que pode ser + **Start_job**: o evento que indica que um aplicativo iniciou um trabalho ou uma tarefa programada. + * end_job**: evento que indica que um aplicativo concluiu um trabalho ou uma tarefa agendada. + **wake**: evento que indica que um aplicativo ativou um bloqueio de ativação para impedir que o dispositivo ou o processador entre em modo de espera. + * start_top**: o evento que indica que um aplicativo passou para o primeiro plano e ficou visível para o usuário. + * end_top**: o evento que indica que um aplicativo deixou o primeiro plano e passou para o segundo plano. +**uid**: identificador de usuário associado ao aplicativo. +**nome_do_pacote**: nome do pacote. +** **service**: nome completo do serviço ou componente específico que executou a ação. + +**Por que isso é importante? + +As informações do *battery_history* permitem identificar eventos executados por aplicativos instalados em um dispositivo, como o início ou a conclusão de trabalhos agendados, a alternância de um aplicativo para o primeiro ou segundo plano ou a ativação de mecanismos para manter o dispositivo acordado. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "time_elapsed": "+493ms", + "evento": "end_job", + "uid": "u0a234", + "nome_do_pacote": "com.android.vending", + "service": "com.android.vending/com.google.android.finsky.scheduler.process.backgroundimpl.PhoneskyJobServiceBackground" +} +``` + +### platform\_compact.json {#platform_compact.json} + +As informações contidas nesse arquivo são geradas pelo módulo [platform_compat](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/bugreport/platform_compat.py) e pelo artefato [dumpsysys_platform_compat](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/dumpsys_platform_compat.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém informações sobre os registros *packages_name* identificados com alterações do tipo *DOWNSCALED*. Essas informações são extraídas do serviço *platform_compat* do *dumpsys* para identificar aplicativos desinstalados. + +O serviço *platform_compat* é um gerenciador de configurações de compatibilidade de aplicativos e alterações internas do sistema Android. Se a versão do Android for incompatível com um recurso do aplicativo, o serviço *platform_compat* poderá ativar ou desativar essa alteração do sistema por aplicativo, de modo que ela permaneça ativa para o usuário ou para o sistema. + +O *platform_compat* é capaz de identificar cada uma das alterações e configurações de compatibilidade no sistema Android por meio de um *ChangeId.* Ele também é capaz de fornecer informações adicionais sobre essas alterações por meio do campo *name*, que se refere ao nome descritivo da alteração, da tag *overridable*, que indica se o sistema pode ativar ou desativar recursos para aplicativos específicos, e da lista *rawOverrides*, que contém os pacotes que têm uma configuração personalizada para uma alteração no sistema operacional. + +O arquivo gerado fornece uma lista de pacotes identificados pelo *changeId* *168419799* associado à política *DOWNSCALED* e, dentro dessa lista, identifica a seção *rawOverrides* para localizar aplicativos desinstalados. + +**Por que isso é importante? +As informações de *platform\_compat* nos permitem identificar aplicativos desinstalados, o que nos permite saber se um aplicativo mal-intencionado foi desinstalado antes da varredura. + +Estrutura do arquivo:** **Estrutura do arquivo:** + +``` +{ + "nome_do_pacote": "com.example.app" + }, + { + "nome_do_pacote": "com.example.app" + }, + { + "package_name": "com.example.app" + }, + { + "package_name": "com.example.app" + }, + { + }, { "package_name": "com.example.app" }, { "package_name": "com.example.app" }, } +``` + +**Saiba mais** + +* [Como funciona a compatibilidade de plataforma no Android?](https://developer.android.com/guide/app-compatibility?hl=es-419) +* [DOWNSCALED \- Compatibility Framework changes (Android 13)](https://developer.android.com/about/versions/13/reference/compat-framework-changes#:~:text=to%20their%20deadlines.-,DOWNSCALED,-Change%20ID%3A) + + +## Comentários + +Você tem **comentários ou sugestões** sobre este recurso? Você pode usar a função **comentário fornecida noSinta-se à vontade para deixar suas opiniões ou comentários abaixo**. Certifique-se de seguir nosso [código de conduta](../../community/code-of-conduct/). A função de comentário está vinculada diretamente à seção [_Discussions_ do Github] (https://github.com/Socialtic/forensics/discussions), onde você também pode **participar diretamente das discussões**, se preferir. diff --git a/docs/pt/references/03-reference-mvt-androidqf-dictionary/index.md b/docs/pt/references/03-reference-mvt-androidqf-dictionary/index.md new file mode 100644 index 000000000..f1fccc005 --- /dev/null +++ b/docs/pt/references/03-reference-mvt-androidqf-dictionary/index.md @@ -0,0 +1,747 @@ +--- + +title: Diccionario de archivos generados por mvt-androidqf +summary: Diccionario de archivos generados por mvt-androidqf +keywords: android, reference, bugreport +lang: es +tags: [explainer, intro] +last_updated: 2025-11-20 +some_url: +created: 2025-11-20 +comments: true +name: jose + +translation-review-pending: true +--- + +# Dicionário de arquivos gerados pela ferramenta MVT-androidqf + +Este documento contém informações sobre os arquivos gerados pelo MVT por meio do componente [mvt-check-androidqf.](https://github.com/mvt-project/mvt/tree/main/src/mvt/android/modules/androidqf). O objetivo desse dicionário é facilitar ao analista a busca por informações específicas e conhecer o formato em que as informações da análise forense são apresentadas. + +Esse recurso é **parte de um repositório de documentação técnica** que visa estabelecer uma base de conhecimento testada, flexível e acessível para **promover a análise forense consensual em benefício da sociedade civil**. A [estrutura de documentação técnica Diataxis] (https://diataxis.fr/) é usada para organizar o conteúdo. + +Esse recurso específico se enquadra na categoria de [referências] (https://diataxis.fr/reference) e contém informações sobre a análise da saída de aquisição gerada por dispositivos Android usando o comando ***mvt-android check-andoridqf*** durante o uso do MVT (*Mobile Verification Toolkit)*, desenvolvido e mantido pelo [Amnesty International Security Lab] (https://securitylab.amnesty.org/es/) e pertencente ao [MVT Project] (https://github.com/mvt-project/). Isso serve para que um analista **saiba quais arquivos são gerados, como usá-los, onde procurar informações específicas e em que formato encontrá-las. + +MVT significa *Mobile Verification Toolkit* (Kit de ferramentas de verificação móvel). Trata-se de uma ferramenta desenvolvida, lançada e mantida pelo [Amnesty International Security Lab] (https://securitylab.amnesty.org/es/) como parte do [MVT Project] (https://github.com/mvt-project/). A intenção desse kit de ferramentas é, em essência, facilitar a análise forense consensual de dispositivos Android e iOS com o objetivo de identificar traços de comprometimento. + +Esse recurso foi atualizado pela última vez em 18 de novembro de 2025 e foi baseado no [*commit 339a1d0712c4cc051e880b8a777d2b8b6295e57b*](https://github.com/mvt-project/mvt/commit/339a1d0712c4cc051e880b8a777d2b8b6295e57b) para a coleta das informações. + +As informações geradas pelo *mvt-androidqf* podem ser agrupadas em cinco categorias principais: + +* Detalhes da aquisição +* Configuração do dispositivo +* Informações de registro e eventos do sistema +* Processos e aplicativos +* Arquivos de backup + +Cada uma das categorias, por sua vez, contém arquivos específicos gerados pela ferramenta, que estão listados no **índice de conteúdo** abaixo: + +- [Acquisition-details](#acquisition-details) + - info.json](#info.json) + - command.log](#command.log) + - timeline.csv](#timeline.csv) +- [device-configuration](#device-configuration) + - [aqf_getprop.json](#aqf_getprop.json) + - [aqf_settings.json](#aqf_settings.json) + - mounts.json](#mounts.json) +- Processos e aplicativos](#processos-e-aplicativos) + - [aqf_packages.json](#aqf_packages.json) + - root_binaries.py](#root_binaries.py) +- backed-up_files](#backed-up_files) + - [aqf_files.json](#aqf_files.json) + +Durante a execução do comando ***mvt-android check-andoridqf***, o MVT também executa os módulos correspondentes a ***mvt-android check-bugreport*** e ***mvt-android check-backup***, desde que haja um arquivo bugreport.zip e um arquivo backup.ab dentro da pasta de entrada de uma extração androidqf. + +No material de referência suplementar [sobre os arquivos gerados pela ferramenta mvt ao analisar um relatório de bug] (../02-reference-mvt-bugreport-dictionary/index.md), a saída do comando check-bugreport e os arquivos resultantes são descritos. A seguir, as **referências específicas de módulo para os módulos executados pelo comando check-androidqf para analisar o relatório de bug:**. + +- device-configuration](../02-reference-mvt-bugreport-dictionary/index.md#device-configuration-device-configuration-device-configuration) + - dumpsys_get_prop.json](../02-reference-mvt-bugreport-dictionary/index.md#getprop.json) +- dumpsys_adb_system_logs-and-events_information](../02-reference-mvt-bugreport-dictionary/index.md#system_logs-and-events-information) + - dumpsys_adb_state.json](../02-reference-mvt-bugreport-dictionary/index.md#dumpsys_adb_state.json) + - bugreport_timestamps.json](../02-reference-mvt-bugreport-dictionary/index.md#bugreport_timestamps.json) + - dbinfo.json](../02-reference-mvt-bugreport-dictionary/index.md#dbinfo.json) + - dumpsys_receivers.json](../02-reference-mvt-bugreport-dictionary/index.md#receivers.json) +- processes-and-applications](../02-reference-mvt-bugreport-dictionary/index.md#processes-and-applications) + - dumpsys_packages.json](../02-reference-mvt-bugreport-dictionary/index.md#packages.json) + - dumpsys_activities.json](../02-reference-mvt-bugreport-dictionary/index.md#activities.json) + - dumpsys_appops.json](../02-reference-mvt-bugreport-dictionary/index.md#appops.json) + - dumpsys_accessibility.json](../02-reference-mvt-bugreport-dictionary/index.md#accessibility.json) + - tombstones.json](../02-reference-mvt-bugreport-dictionary/index.md#tombstones.json) + - dumpsys_battery_daily.json](../02-reference-mvt-bugreport-dictionary/index.md#battery_daily.json) + - dumpsys_battery_history.json](../02-reference-mvt-bugreport-dictionary/index.md#battery_history.json) + - [dumpsys_platform_compact.json](../02-reference-mvt-bugreport-dictionary/index.md#platform_compact.json) + + +Da mesma forma, também listamos os módulos executados pelo ***check-backup***, que estão detalhados no final deste recurso. + +- Informações sobre logs e eventos do sistema](#system-logs-and-events-information) +- sms.json](#sms.json) + +##procurement-details {#procurement-details}(#sms.json) + +### info.json {#info.json} + +**Informações contidas** + +Esse arquivo está no formato *json* e contém informações relacionadas à análise realizada em uma extração concluída usando o AndroidQF. Ele contém as seguintes informações: + +* Caminho do arquivo analisado. +* Versão do MVT usada. +* Data da análise. +* Lista de arquivos de indicadores de compromisso. +* Hash da pasta de saída analisada (SHA-256). + +**Por que isso é importante? + +Esse arquivo nos permite **validar a análise que foi realizada**, documentando que temos um registro do processo de aquisição e dos indicadores que foram considerados para fazer a comparação. + +Essas informações nos permitem estabelecer uma referência do arquivo analisado e das ferramentas de indicadores usadas na análise, o que facilita o [processo de custódia de extração forense] (https://forensics.socialtic.org/explainers/01-explainer-introduccion-forense-digital/01-explainer-introduccion-forense-digital.html#cadena-de-custodia). + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "target_path": "/path/file/path/acquisition-with-androidqf", + "mvt_version": "2.6.1", + "date": "YYYYY-MM-DD hh:mm:ss", + "ioc_files": [ + "/caminho/para/indicadores/pegasus.stix2", + "/path/to/indicators/predator.stix2", + "/path/to/indicators/rcs_lab.stix2", + "... mais indicadores usados ..." + ], + "hashes": [ + { + "file_path": "/path/from/file/acquisition-with-androidqf", + "sha256": "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx" + } + ] +} +``` + +### command.log {#command.log} + +**informação contida** **informação contida** **informação contida** **informação contida** **informação contida** **informação contida + +Esse arquivo está em texto simples com uma extensão *.log* e contém registros detalhados da execução do comando *mvt-android check-androidqf*. + +Seu conteúdo lista a análise realizada em uma pasta de saída de uma extração de dados forenses realizada com o AndroidQF, incluindo a detecção de indicadores de comprometimento para identificar alertas de segurança relacionados a malware. + +Os registros do arquivo são apresentados de forma estruturada com: + +* Carimbos de data e hora +* Nomes de módulos em execução +* Tipo de mensagem (*INFO*, *DEBUG*, WARNING, *ERROR*) +* Ação do módulo correspondente (análise de arquivo, carregamento de IoCs, comparação e resultado da comparação). + +Os tipos de mensagem correspondem ao seguinte: + +*INFO*. As mensagens também são exibidas na tela durante a execução. +*DEBUG*. Informações não exibidas na tela, mas associadas a uma ação executada durante a análise, por exemplo, o carregamento de um IoC ou a revisão de um hash. +* WARNING* Corresponde a alertas de atividade ou informações suspeitas que um analista deve verificar. +* ERRO: mensagens de erro sobre alguma ação realizada durante a análise, por exemplo, ao carregar um arquivo corrompido ou um problema com a execução do código correspondente. + +**Por que isso é importante? + +Permite gerar um registro das ações realizadas durante a análise. Por meio desse registro, é possível verificar o seguinte: + +* Que a análise foi realizada corretamente +* Se houve coincidências com IoCs. +* Se foram identificadas informações ou atividades suspeitas. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +Este arquivo segue um formato de linha por linha com a seguinte estrutura. + +``` +TIMESTAMP] - [MODULE] - [LOG LEVEL] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE] - [MESSAGE]. +... +2025-01-17 17:06:14,035 - mvt.android.cmd_check_androidqf - INFO - Analisando o arquivo de indicadores STIX2 no caminho /home/user/.local/share/mvt/indicators/raw.githubusercontent.com_AmnestyTech_investigations_master_2021-07-18_nso_pegasus.stix2 +2025-01-17 17:06:14,098 - mvt.android.cmd_check_androidqf - DEBUG - Extraiu 1549 indicadores para a coleção com o nome "Pegasus" +2025-01-17 17:06:14,812 - mvt.android.cmd_check_androidqf - DEBUG - Extraiu 245 indicadores para a coleção com o nome "mSpy" +``` + +**Saiba mais** + +* [Introdução ao STIX](https://oasis-open.github.io/cti-documentation/stix/intro.html) + +### timeline.csv {#timeline.csv} + +**Informações contidas** **Informações contidas** **Informações contidas** **Informações contidas** **Informações contidas** **Informações contidas +Esse arquivo está no formato *csv* e armazena uma linha do tempo da atividade do dispositivo. Essa atividade é obtida a partir da execução dos módulos de análise do MVT e é classificada por tempo. + +Cada linha do *csv* corresponde a: + +* Timestamp (carimbo de data/hora local do dispositivo). +* Módulo executado (Plugin). +* Atividade identificada no dispositivo (Event). +* Descrição da atividade identificada no dispositivo (Description). + +**Por que isso é importante? + +Esse arquivo permite rastrear a atividade interna do dispositivo, podendo gerar uma ideia geral de como o dispositivo se comportou e identificar eventos relevantes. + +**Estrutura do arquivo + +Esse arquivo segue um formato de linha por linha com a seguinte estrutura. + +``` +UTC Timestamp", "Plugin", "Event", "Description", "2025-01-01 00:00:00", "Packages", "package_first_install", "Description" +"2025-01-01 00:00:00", "Packages", "package_first_install", "com.example.app (system: False, third party: True)" +"2025-01-01 00:00:00", "Packages", "package_last_update", "com.system.module (sistema: Verdadeiro, terceiros: Falso)" +"2025-01-01 00:00:00", "Packages", "package_install", "com.example.newapp (sistema: Falso, terceiros: Verdadeiro)" +``` + +## device-configuration {#device-configuration} + +### aqf\_getprop.json {#aqf_getprop.json} + +As informações nesse arquivo são geradas pelo módulo [aqf\_getprop](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/androidqf/aqf_getprop.py) e pelo artefato [getprop](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/getprop.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém uma lista de propriedades do dispositivo que são extraídas do arquivo *getprop.tx*t gerado durante uma extração com o AndoridQF. + +Essas propriedades do sistema são pares de chave-valor de cadeias de caracteres armazenadas no dicionário global [*build.prop*] (https://xdaforums.com/t/guide-build-prop-wiki.2056266/) ou em arquivos de descrição *.sysprop* e fornecem uma maneira conveniente de compartilhar configurações dentro do sistema. + +As informações podem ser encontradas usando o seguinte formato: + +``` +[{prefix}.]{group}[.{subgroup}]*.{name}[.{type}] +``` + +Algumas propriedades são prefixadas com *ro*, indicando que são propriedades somente leitura ou que foram atribuídas após a reinicialização do dispositivo. As propriedades prefixadas com *persist* referem-se a configurações resistentes à reinicialização. Algumas propriedades não devem ter prefixo, portanto, começam diretamente com o grupo ao qual pertencem. + +Os grupos mais comuns são: + +*bluetooth*, relacionado ao Bluetooth. +*boot*, sysprops de linha de comando do kernel +*build*, sysprops que identificam uma compilação +*telefonia*, relacionado à telefonia +*audio*, relacionado a áudio +*graphics*, relacionado a gráficos +*vold*, relacionado ao vold, que gerencia a montagem de volumes físicos de armazenamento externo + +Para obter mais detalhes, consulte a [lista de propriedades já definidas no código-fonte do Android] (https://android.googlesource.com/platform/system/sepolicy/+/refs/heads/main/private/property_contexts). + +**Por que isso é importante? + +As propriedades fornecem informações importantes sobre o hardware e o software do dispositivo, que podem ser alteradas por software mal-intencionado para ocultar sua presença ou para modificar inadvertidamente o comportamento do dispositivo. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +[ + { + "nome": "aaudio.hw_burst_min_usec", + "value": "2000" + }, + { + "name": "bluetooth.device.class_of_device", + "value": "90,2,12" + }, + { + "name": "apex.all.ready", + "value": "true" + } +] +``` + +### aqf_settings.json {#aqf_settings.json} + +As informações nesse arquivo são geradas pelo módulo [aqf\_settings](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/androidqf/aqf_settings.py) e pelo artefato [settings](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/settings.py). + +**Informações contidas + +Esse arquivo está no formato *json* e contém informações sobre o status das configurações do dispositivo nos *namespaces* *system* (interface do usuário e comportamento geral, como brilho, matiz, rotação etc.), *secure* (configurações confidenciais que exigem permissões elevadas, como verificação de aplicativos, configurações de acessibilidade ou status do ADB) e *global* (parâmetros compartilhados entre usuários, como redes, localização, roaming, volumes globais etc.). + +As informações são apresentadas em três blocos, primeiro Configurações do sistema, depois Configurações seguras e, por fim, Configurações globais. Cada configuração é apresentada como um par de valores-chave na estrutura: + +````json +{{setting}:{level}] +``` + +Os valores que têm cada configuração têm significados diferentes dependendo dessa configuração, mas geralmente são os seguintes: + +* **0**geralmente significa desativado ou desligado. +** **1** geralmente significa ativado ou ligado. +* Números maiores** podem ser níveis, como o brilho da tela, por exemplo. +* Alguns valores são **paths** ou caminhos do sistema que apontam para recursos. + +Essas informações são extraídas diretamente dos arquivos settings\_global.txt, settings\_secure.txt e settings\_system.txt gerados durante uma extração com o AndoridQF. + +**Por que isso é importante? + +Permite identificar configurações anômalas que podem comprometer a segurança, a privacidade ou a funcionalidade do dispositivo. Configurações padrão incomuns podem sinalizar tentativas intencionais ou acidentais de modificar o comportamento do sistema. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "system": { + "SEM_VIBRATION_FORCE_TOUCH_INTENSITY": "4", + "SEM_VIBRATION_NOTIFICATION_INTENSITY": "5", + "SMLDM_BEARER": "0", + "SOFTWARE_UPDATE_LAST_CHECKED_DATE": "1736527562578", + "SOFTWARE_UPDATE_WIFI_ONLY2": "1", + "SOUNDALIVE_AUDIO_PATH": "0", + "TIME_DIFFERENCE": "445", + "VIB_FEEDBACK_MAGNITUDE": "2", + "VIB_RECVCALL_MAGNITUDE": "5", + "acc_last_status_logging": "1736780772300", + }, + "secure": { + "accessibility_allow_diagonal_scrolling": "1", + "accessibility_button_mode": "1", + "accessibility_button_target_component": "accessibility_change_magnification_size": "3", + "accessibility_display_magnification_enabled": "0", + "accessibility_display_magnification_scale": "2.0", + "accessibility_enabled": "0", + "accessibility_magnification_activated": "0", + "accessibility_magnification_capability": "3", + "accessibility_magnification_mode": "2", + "accessibility_shortcut_dialog_shown": "1", + "accessibility_shortcut_target_service": + }, + "global": { + "contacts_move_simcontacts_not_now": "0", + "phenotype_boot_count": "131", + "phenotype_flags": "_boot_Phenotype_flags": "", + "activity_starts_starts_logging_enabled": "1", + "adb_allowed_connection_time": "604800000", + "adb_enabled": "1", + "adb_wifi_enabled": "0", + "add_users_when_locked": "0", + "airplane_mode_on": "0", + "airplane_mode_radios": "cell,bluetooth,uwb,wifi,wimax", + "airplane_mode_toggleable_radios": "bluetooth,wifi", + } +} +``` + +**Saiba mais** + +* Lista completa de preferências do sistema [https://developer.android.com/reference/android/provider/Settings.System?hl=es-419](https://developer.android.com/reference/android/provider/Settings.System?hl=es-419) +* [Lista completa de preferências do sistema - Configurações seguras](https://developer.android.com/reference/android/provider/Settings.Secure?hl=es-419) +* [Lista completa de preferências do sistema \- Configurações globais](https://developer.android.com/reference/android/provider/Settings.Global?hl=es-419) + +### mounts.json {#mounts.json} + +As informações contidas nesse arquivo são geradas pelo módulo [mounts](https://github.com/mvt-project/androidqf/blob/main/modules/mounts.go) e pelo artefato [mounts](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/artifacts/mounts.py). + +**Informações contidas + +Este arquivo está no formato *json* e contém informações sobre as partições e os diretórios dos sistemas de arquivos montados em um dispositivo no espaço do usuário *e* no kernel do Linux Android extraído do arquivo *mounts.json* gerado durante uma extração com o AndoridQF. + +O módulo se encarrega de identificar configurações suspeitas nos pontos de montagem /system, /vendor, /product e /system\_ext, como modo de acesso de leitura e gravação, carimbos de data e hora noatime ou nodiratime e, em seguida, se encarrega de formatar cada ponto de montagem da seguinte forma: + +**device**: partição ou volume montado, no android os mais comuns são: + * Partições de armazenamento físico + /dev/block/sdX: dispositivo de armazenamento físico ([eMMC/UFS](https://new.c.mi.com/es/post/11738)) exposto como sd pelo kernel. + /dev/block/mmcblk: dispositivo de armazenamento eMMC exposto como mmcblk. + /dev/block/dm-X: dispositivo gerenciado pelo device-mapper (partições criptografadas, verity ou lógicas). + /dev/block/by-name/: links simbólicos que apontam para partições reais por nome, por exemplo, sistema, fornecedor, userdata. + * Volume virtual do kernel na RAM + * proc: interface virtual para obter informações sobre o kernel e o processo. + * sysfs: expõe informações sobre dispositivos, drivers e parâmetros do kernel. + * selinuxfs: exibe políticas, estados e rótulos do SELinux. + * tracefs: sistema virtual para ferramentas de rastreamento e depuração do kernel. + * pstore: armazena registros persistentes de falhas do kernel. + * bpf: expõe interfaces para programas [eBPF] (https://source.android.com/docs/core/architecture/kernel/bpf) carregados no kernel. + * Espaço do usuário + /dev/fuse: interface [FUSE](https://source.android.com/docs/core/storage/fuse-passthrough) usada pelo Android para montar o armazenamento.emulated p.j /storage/emulated. + * Interfaces de controle interno do kernel + * Nenhum: Identificador que indica que a montagem não vem de um dispositivo real. + * binder: o [sistema IPC] interno do Android (https://source.android.com/docs/core/architecture/ipc/binder-overview) para comunicação entre processos. + * Arquivos APEX montados como loopback + /dev/block/loopX: dispositivos de loop usados para montar pacotes APEX como se fossem partições reais. + +* Ponto de montagem**: caminho para a pasta raiz do armazenamento em que as informações são acessadas; no Android, geralmente são os seguintes: + /system: contém o sistema operacional principal. + /vendor: inclui componentes e drivers fornecidos pelo fabricante do hardware, como HALs, firmware e binários específicos do fornecedor. + * product: armazena as personalizações do fabricante das funções do sistema e dos aplicativos específicos do dispositivo. + /data: área para dados do usuário e armazenamento de aplicativos. + /cache: espaço temporário usado para arquivos de atualização e dados transitórios do sistema. + /metadata: contém informações críticas necessárias para [AVB] (https://source.android.com/docs/security/features/verifiedboot/avb), criptografia e validações do sistema. + /mnt/media_rw/: ponto de montagem para armazenamento removível ou adotado, por exemplo, cartão SD. Cartão SD. + /storage/emulated: visualização emulada do armazenamento interno do usuário. + /proc: sistema virtual que expõe o kernel e as informações do processo (não o armazenamento real). + /sys: Sistema virtual que expõe informações sobre dispositivos e drivers do kernel. + /mnt/user/0/emulated: exibição específica do armazenamento emulado para o usuário 0. + +** **filesystem_type**: tipo de sistema de arquivos, no android são os seguintes: + * ext4: sistema de arquivos Linux usado em partições internas. + * f2fs: sistema de arquivos otimizado para armazenamento flash. + * erofs: sistema de arquivos otimizado somente para leitura. + * vfat: sistema de arquivos FAT32 usado para cartões SD e armazenamento externo. + * sdfat: implementação estendida do FAT/exFAT. + * tmpfs: sistema de arquivos RAM temporário usado para diretórios voláteis, por exemplo, /dev, /run, /apex. + * proc: sistema de arquivos virtual que expõe informações do kernel e do processo. + * sysfs: sistema virtual que exibe informações de hardware, driver e driver do kernel. + * selinuxfs: sistema virtual que expõe os parâmetros e o status do SELinux no dispositivo. + * functionfs: sistema usado para interfaces [USB gadget] (https://source.android.com/docs/core/permissions/usb-hal) quando o Android atua como um dispositivo USB. + * incremental-fs: sistema projetado para instalar ou executar aplicativos "sob demanda" enquanto eles ainda estão sendo baixados. + * binder: sistema de comunicação IPC interno do Android. + * cgroup: sistema virtual baseado em grupos de controle para gerenciar recursos por processo, por exemplo, CPU, memória. CPU, memória. + * fuse: sistema de arquivos do espaço do usuário usado para armazenamento emulado. + +* **mount_options** + * Modos de acesso + * ro: somente leitura + * rw: leitura e gravação + * Etiquetas de segurança + * seclabel: ativa e aplica rótulos do SELinux ao sistema de arquivos. + * nodev: impede que arquivos de dispositivos sejam usados nessa partição. + * nosuid: bloqueia binários com [set-UID/set-GID] (https://www.cbtnuggets.com/blog/technology/system-admin/linux-file-permissions-understanding-setuid-setgid-and-the-sticky-bit) para evitar escalonamento. + * noexec: impede a execução de arquivos dessa partição. + * hidepid=invisible: oculta processos de outros usuários em * /proc *. + * user_xattr: permite atributos estendidos definidos pelo usuário. + * acl: permite listas de controle de acesso mais detalhadas do que *rwx*. + * inlinecrypt: Usa a criptografia em linha compatível com o hardware/FS (Android). + * usrquota: habilita cotas por usuário. + * grpquota: habilita cotas por grupo. + * Carimbos de data/hora + * lazytime: adia a gravação de registros de data e hora no armazenamento para melhorar o desempenho. + * relatime: atualiza os tempos de acesso somente se necessário. + * noatitime: desativa a atualização do tempo de acesso. + * Usuários ou grupos relacionados + * uid=0: proprietário da montagem (raiz). + * gid=1000: grupo base do Android (system ou media_rw). + * user_id=0: usuário primário do sistema Android. + * group_id=0: grupo primário do usuário root. + +** **is_system_partition**: valor booleano que indica se a partição é /system ou /sys. +**is_read_write**: valor booleano que indica se a partição tem acesso de leitura e gravação. + + +**Por que isso é importante? + +Os pontos de montagem permitem identificar as **áreas de armazenamento montadas no dispositivo**, sua origem e como estão configuradas. Com essas informaçõesn pode saber as permissões com as quais as partições foram montadas, os usuários associados e, em alguns casos, os rótulos de segurança SELinux aplicados. Isso é útil para **identificar montagens que possam ser suspeitas** de atividade mal-intencionada no dispositivo; por exemplo, uma partição do sistema, como as partições /system, /vendor, /product, cuja montagem geralmente é somente de leitura, é montada com permissões de gravação ou sem rótulos de segurança, ou uma partição como /data é montada com permissões de leitura em subpastas que contêm informações de aplicativos, o que pode indicar montagens fraudulentas não autorizadas, evidenciando um comportamento altamente suspeito. + +Exemplo de conteúdo de arquivo** **Exemplo de conteúdo de arquivo** **Exemplo de conteúdo de arquivo** **Exemplo de conteúdo de arquivo + +``` +{ + "dispositivo":"/dev/block/mmcblk0p63", + "mount_point": "/", + "filesystem_type": "ext4", + "mount_options": "ro,seclabel,relatime,discard", + "options_list": [ + "ro", + "seclabel", + "relatime", + "discard" + ], + "is_system_partition": falso, + "is_read_write": false + } + { + "device" (dispositivo): "tmpfs", + "mount_point": "/dev", + "filesystem_type": "tmpfs", + "mount_options": "rw,seclabel,nosuid,relatime,size=1812632k,nr_inodes=453158,mode=755", + "options_list": [ + }, "rw", + "seclabel", + "nosuid", + "relatime", + "size=1812632k", + "nr_inodes=453158", + "mode=755" + ], + "is_system_partition": falso, + "is_read_write": true + }, + { + "device" (dispositivo): "devpts", + "mount_point": "/dev/pts", + "filesystem_type": "devpts", + "mount_options": "rw,seclabel,relatime,mode=600,ptmxmode=000", + "options_list": [ + "rw", + "seclabel", + "relatime", + "mode=600", + "ptmxmode=000" + ], + "is_system_partition": falso, + "is_read_write": true + }, +``` + +**Para saber mais:** + +* [Visão geral do particionamento do Android](https://source.android.com/docs/core/architecture/partitions?hl=es-419) +* [Histórico e terminologia do particionamento dinâmico](https://source-android-com.translate.goog/docs/core/ota/virtual_ab?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=sge#background) +* Sistema de arquivos do Android](https://medium.com/@aditi.kale20/file-system-of-android-a89dcbb693f1) +* Compatibilidade do sistema de arquivos do kernel do Android](https://source-android-com.translate.goog/docs/core/architecture/android-kernel-file-system-support?_x_tr_sl=en&_x_tr_tl=es&_x_tr_hl=es&_x_tr_pto=tc) +* Compatibilidade com o SELinux](https://source.android.com/docs/security/features/selinux/compatibility) +* [Formato de arquivo APEX](https://source.android.com/docs/core/ota/apex) +* [Sistema de arquivos do Android](https://keepcoding.io/blog/sistema-de-ficheros-android/) + +## Processos e aplicativos {#processos-e-aplicativos} + +### aqf_packages.json {#aqf_packages.json} + +As informações contidas nesse arquivo são geradas pelo módulo [aqf_packages] (https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/androidqf/aqf_packages.py). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém informações sobre os aplicativos instalados no dispositivo. Essas informações são extraídas do arquivo *packages.json* gerado durante a aquisição do AndroidQF. + +As informações contidas nesse arquivo são apresentadas da seguinte forma: + +**name**: Nome do pacote de aplicativos. +**files**: Caminho do arquivo APK correspondente com seus respectivos hashes e informações de certificado. +**installer**: a partir do qual o aplicativo foi instalado. +** **uid**: O PID de execução associado. +**disabled**: Indica se o aplicativo está desativado. +** **system**: Indica se o pacote pertence ao sistema. +**terceiro**: Indica se é um aplicativo de terceiros. + +**Por que isso é importante? +O conteúdo desse arquivo inclui informações para identificar os aplicativos instalados e seu status no dispositivo. Isso ajuda os analistas a avaliar se existem aplicativos arriscados ou mal-intencionados, quais permissões eles têm e quais podem comprometer a segurança. + +Estrutura do arquivo:** ** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo:** Estrutura do arquivo + +``` +{ + "nome": "com.samsung.android.arzone", + "arquivos": [ + { + "path": "/data/app/ARZone/ARZone.apk", + "local_name": "", + "md5": "947b59f40de694e2359c007abe0c0191", + "sha1": "508d9207ca6218bf599171c13f8141c37e97f580", + "sha256": "76f972c04be51d0cad7980df85f76219eebfc0f770001e8ef02b4fa9a180f9d4", + "sha512": "3b34c13fb1150df1b347f0cc0913f55d17abe2be96354a64e2ed8369fdce5b2fb10c5748deb7a66409153b766d84039fa01b0a1ced1bf2ccb62ab5368b38599a", + "erro": "", + "verified_certificate": true, + "certificate": { + "Md5": "d087e72912fba064cafa78dc34aea839", + "Sha1": "9ca5170f381919dfe0446fcdab18b19a143b3163", + "Sha256": "34df0e7a9f1cf1892e45c056b4973cd81ccf148a4050d11aea4ac5a65f900a42", + "ValidFrom": "2011-06-22T12:25:12Z", + "ValidTo": "2038-11-07T12:25:12Z", + "Emissor": "C=KR, ST=Coreia do Sul, L=Cidade de Suwon, O=Samsung Corporation, OU=DMC, CN=Samsung Cert", + "Subject": "C=KR, ST=Coreia do Sul, L=Cidade de Suwon, O=Samsung Corporation, OU=DMC, CN=Samsung Cert", + "SignatureAlgorithm": "SHA1-RSA", + "SerialNumber": 15134792569865480918 + }, + "certificate_error": "", + "trusted_certificate": true + } + ], + "installer" (instalador): "null" (nulo), + "uid": 10295, + "disabled": falso, + "system": falso, + "third_party": true + } +``` + +### root_binaries.py {#root_binaries.py} + +As informações contidas nesse arquivo são geradas pelo módulo [root_binaries](https://github.com/mvt-project/androidqf/blob/main/modules/root_binaries.go). + +**Informações contidas**. + +Esse arquivo está no formato *json* e contém uma lista de binários relacionados ao enraizamento no dispositivo, extraídos do arquivo r*oot_binaries.json* gerado durante uma extração com o AndoridQF. + +Esse módulo é responsável por extrair os binários do arquivo de base para poder identificar os binários suspeitos de fazer o root e seus rastros. O formato aplicado é o seguinte: + +* Caminho: Caminho para o binário de enraizamento encontrado. +* binary\_name: Nome do binário, que pode ser o seguinte: + * su + * busybox + * supersu + * Superuser.apk + * KingoUser.apk + * SuperSu.apk + * magisk + * magiskhide + * magiskinit + * magiskpolicy +* Descrição: Descrição do binário de root, que pode ser o seguinte: + * su: Binário do SuperUser + * busybox: utilitários do BusyBox + * supersu: gerenciamento de raiz do SuperSU + * Superuser.apk: aplicativo Superuser + * KingoUser.apk: aplicativo KingRoot + * SuperSu.apk: aplicativo SuperSU + * magisk: estrutura de raiz do Magisk + * magiskhide: utilitário de ocultação do Magisk + * magiskinit: binário de inicialização do Magisk + * magiskpolicy: binário de política do Magisk + +**Por que isso é importante? + +Esse arquivo detecta ferramentas de root, o que pode ser uma indicação de acesso não autorizado e escalonamento de privilégios que pode expor uma vulnerabilidade. Ele também permite que o analista identifique binários suspeitos que podem ter sido instalados sem o conhecimento do usuário e ajuda a determinar se o dispositivo foi adulterado. + +**Exemplo de conteúdo de arquivo + +``` + { + "caminho": "/sistema/xbin/su", + "binary_name": "su", + "description": "SuperUser binary" (binário do superusuário) + }, + { + "path" (caminho): "/system/bin/su", + "binary_name": "su", + "description": "SuperUser binary" (binário do superusuário) + }, + { + "path": "/system/bin/busybox", + "binary_name": "busybox", + "description": "Utilitários do BusyBox" + }, + { + "path": "/data/local/tmp/magisk", + "binary_name": "magisk", + "description": "Magisk root framework" (Estrutura raiz do Magisk) + } +``` + +## arquivos de backup {#backed-up-files} + +### aqf_files.json {#aqf_files.json} + +As informações contidas nesse arquivo são geradas pelo módulo [files](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/androidqf/files.py). + +**Informações contidas + +Esse arquivo está no formato json e contém informações sobre os arquivos e seus metadados nos caminhos /sdcard/, /system, /data, etc., no dispositivo. Essas informações são extraídas do arquivo *files.json* gerado durante a aquisição do AndroidQF. + +Cada entrada inclui um arquivo com seus metadados, como: o caminho completo do arquivo, o tamanho, o registro de data e hora (indica a última modificação do arquivo e o último acesso ao arquivo), as permissões do arquivo, o identificador do proprietário, as mensagens de erro e os hashes sha1, sha256, sha512, md5, se pré-computados. + +As informações desse arquivo são apresentadas da seguinte forma: + +**path**: Caminho do arquivo +**size**: Tamanho do arquivo em bytes +**mode**: Permissões do arquivo (leitura, gravação ou execução no formato unix) +**id_usuário**: Identificador do usuário proprietário +**Nome_do_usuário**: Nome do usuário proprietário +**group_id**: Identificador do grupo proprietário +**Nome_do_grupo**: Nome do proprietário do grupo +**changed_time**: Data e hora em que os metadados do arquivo foram modificados +**modified_time**: Data e hora em que o conteúdo do arquivo foi alterado +**Access_time**: Data e hora do último acesso ao arquivo. +* error**: Registro de erros durante a leitura do arquivo +**context**: tag de segurança do SELinux +** **Hashses:** Valores calculados dos hashes associados a cada arquivo + +**Por que isso é importante? + +Porque éEsse arquivo é relevante para identificar arquivos de interesse em uma investigação forense, incluindo possíveis arquivos usados por invasores para comprometer um dispositivo, e para análise oportuna para rastrear atividades mal-intencionadas. + +**Estrutura do arquivo: + +``` + "caminho":"/sdcard/Android/.Trash/com.sec.android.app.myfiles/.nomedia", + "tamanho": 62, + "mode":"-rw-rw----", + "user_id": 10276, + "nome_do_usuário": "", + "group_id": 1023, + "nome_do_grupo": "", + "changed_time": "2025-07-28 03:46:55.000000", + "modified_time": "2025-07-28 03:46:55.000000", + "access_time": "2024-05-05 13:35:15.000000", + "error": "", + "contexto": "u:object_r:fuse:s0", + "sha1": "", + "sha256": "", + "sha512": "", + "md5": "" + }, + { + "path": "/sdcard/Android/.Trash/com.sec.android.app.myfiles/0d2b854e-bc86-4478-b0a9-6802f21ba015/1753640873997/storage/emulated/0/Android/media/com.whatsapp/WhatsApp/Media/WhatsApp Images/.!%#@$/IMG-20250727-WA0000.jpg", + "tamanho": "130802, + "mode": "-rw-rw----", + "user_id": 10276, + "nome_do_usuário": "", + "group_id": 1023, + "nome_do_grupo": "", + "changed_time": "2025-07-28 03:46:55.000000", + "modified_time": "2025-07-27 12:06:02.000000", + "access_time": "2025-07-27 12:06:02.000000", + "error": "", + "contexto": "u:object_r:fuse:s0", + "sha1": "", + "sha256": "", + "sha512": "", + "md5": "" + } +``` + +### sms.json {#sms.json} + +As informações nesse arquivo são geradas pelo módulo de backup [sms](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/backup/sms.py), pelo auxiliar de backup [helpers](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/modules/backup/helpers.py) e pelo analisador [backup](https://github.com/mvt-project/mvt/blob/main/src/mvt/android/parsers/backup.py). + +**Informações contidas + +O arquivo está no formato *json* e contém informações sobre mensagens SMS e MMS recebidas e armazenadas no dispositivo móvel. Essas informações são extraídas do arquivo *backup.ab* gerado durante uma extração com o AndroidQF. + +Em termos gerais, as informações das mensagens SMS e MMS de backup são pesquisadas e descriptografadas (se necessário) para descompactar esse backup, analisar datas, detectar links e homologar formatos. + +As informações nesse arquivo são apresentadas da seguinte forma: + +* **endereço**: Número de telefone ou endereço que enviou ou recebeu a mensagem. +* body**: Conteúdo da mensagem em texto simples. +* date**: Carimbo de data/hora no formato Unix da hora do recebimento. +* date_sent**: carimbo de data/hora Unix de quando a mensagem foi enviada. Se o valor for 0, significa que a mensagem foi recebida. +* status**: código de status da mensagem: + * 1: Desconhecido ou sem informações. + * 0: Completa + * 64: Envio pendente + * 128: Rascunho +**type**: Tipo de mensagem + * 1: Recebida + * 2: Enviada + * 3: Rascunho + * 4: Saída +**recipients**: Lista de destinatários da mensagem. +** **read**: Indicador se a mensagem foi lida (1) ou não lida (0). +**isodate**: Data no formato ISO, para facilitar a compreensão. +**direction**: Direção da mensagem (se ela foi enviada ou recebida). + * enviado: Enviado + * received: Recebida +**links**: Lista de links identificados no corpo da mensagem. + +**Por que isso é importante? + +O conteúdo desse arquivo inclui informações que lhe permitem rastrear conversas e comunicações que indicam risco ou tentativas de ataques com conteúdo malicioso que indicam um vetor de ataque, como phishing. + +Estrutura do arquivo:** **Estrutura do arquivo + +``` +[ + { + "address": "12345", + "body": "Reative seu aplicativo para continuar usando o serviço. Se tiver algum problema, pedimos que você o reinstale em https://example.com/reactivacion", + "date": "1597872498518", + "date_sent": "1597872496000", + "status": "-1", + "type": "1", + "recipients": ["12345"], + "read": "1", + "isodate": "2025-01-01 00:00:00.000", + "direction": "sent", + "links": ["https://example.com/reactivacion"] + }, + { + "address" (endereço): "54321" (54321), + "body": "This is a sample message related to the verification of your account.", { "body": "This is a sample message related to the verification of your account.", + "date": "1601498392068", + "date_sent": "1601498390000", + "status": "-1", + "type": "1", + "destinatários": ["54321"], + "read": "0", + "isodate": "2025-01-01 00:00:00.000", + "direction": "sent" (direção) + } +] +``` + diff --git a/docs/pt/references/04-reference-cheat-sheet-android/index.md b/docs/pt/references/04-reference-cheat-sheet-android/index.md new file mode 100644 index 000000000..23a192d6c --- /dev/null +++ b/docs/pt/references/04-reference-cheat-sheet-android/index.md @@ -0,0 +1,36 @@ +--- + +title: Cheat Sheet de Forense en Android +summary: Resumen de las etapas, comandos y consideraciones de una investigación forense en Android +keywords: android, reference, bugreport +lang: es +tags: [reference, intro] +last_updated: 2026-01-16 +some_url: +created: 2026-01-16 +comments: true +name: daniel + +translation-review-pending: true +--- + +# Folha de consulta forense no Android + +Este recurso é **parte de um repositório de documentação técnica** que visa estabelecer uma base de conhecimento testada, flexível e acessível para **impulsionar a análise forense consensual em benefício da sociedade civil**. A [estrutura de documentação técnica Diataxis] (https://diataxis.fr/) é usada para organizar o conteúdo. + +Esse recurso específico se enquadra na categoria de **referências** e contém uma folha de resumo sobre as **fases de uma investigação forense consensual em um dispositivo Android, incluindo comandos úteis, links e considerações específicas em cada uma das fases. + +Abaixo está a folha de resumo, que você também pode baixar em [formato PDF neste link](../../assets/04-reference/cheat-sheet-forensics-english.pdf). + + + + + + + + +