INSTITUTO FEDERAL DE EDUCAÇÃO,

CIÊNCIA E TECNOLOGIA DE SÃO PAULO

CAMPUS SÃO JOÃO DA BOA VISTA

Roni Magozzo Paschoal

ANALISE DE SEGURANÇA EM APLICAÇÕES WEB MÓVEL

GERADAS COM O USO DA FERRAMENTA PHONEGAP

São João da Boa Vista

2016
 Roni Magozzo Paschoal

ANALISE DE SEGURANÇA EM APLICAÇÕES WEB MÓVEL

GERADAS COM O USO DA FERRAMENTA PHONEGAP

Trabalho de conclusão de curso apresentado ao Instituto

Federal de São Paulo, como parte dos requisitos para a
obtenção do grau de Tecnólogo em Sistemas para
Internet.

Área de Concentração: Segurança da Informação

Orientador: Prof. Roan Simões da Silva

Coorientador: Luiz Angelo Valota Francisco

São João da Boa Vista

2016
 Autorizo a reprodução e divulgação total ou parcial deste trabalho, por qualquer meio
convencional ou eletrônico, para fins de estudo e pesquisa, desde que citada a fonte.

Catalogação na Fonte preparada pela Biblioteca Comunitária “Wolgran Junqueira Ferreira”

do IFSP - Câmpus São João da Boa Vista

P279a Paschoal, Ronni Magozzo

Análise de segurança em aplicações web móvel geradas com o uso
da ferramenta PhoneGap/ Ronni Magozzo Paschoal; orientador: Roan
Simões da Silva; coorientador: Luiz Angelo Valota Francisco. -- São João
da Boa Vista: [s.n], 2016.
85 p..: il.

Trabalho de Conclusão (Tecnologia em Sistemas para Internet) –

Instituto Federal de Educação, Ciência e Tecnologia de São Paulo, São
João da Boa Vista, 2016.

1. Segurança da informação. 2. Dispositivos móveis. 3. Computação

móvel. 4. PhoneGap – Desenvolvimento de aplicações móveis. I. Silva,
Roan Simões da. II. Francisco, Luiz Angelo Valota. III. Título.

CDD 005.8
 AGRADECIMENTOS

A meus pais Rogério e Rita por todo carinho passado ao longo dos 31 anos e por
sempre acreditarem no meu potencial, muitas vezes mais que eu mesmo, sempre me
incentivando a continuar estudando e seguir em frente.
As minhas irmãs Rebeca e Rafaela, também sempre carinhosas, que mesmo distante
ajudaram a moldar meu caráter.
Aos meus avôs Léo e Raquel pelo apoio e carinho que recebo nesta etapa da minha
vida, nesta nova e ainda desconhecida cidade.
Aos mestres e doutores do IFSP, Roan Simões, Luiz Angelo, Rosana Ferrareto, Arthur
Emanuel, Nemésio Freitas, Breno Lisi, David Buzatto, Ederson Borges e Gustavo Prieto,
entre outros, por serem excelentes profissionais e por sempre me ajudarem em cada etapa do
meu aprendizado e crescimento pessoal. Em especial ao Roan Simões por ter me ajudado, e
muito, a concluir esta etapa importante da minha formação.
Aos meus amigos pela paciência e compreensão, em especial ao Diego Marinho,
Rafael Valentim, Kazuo Iha e Thiago Syrto por estarem apoiando e compartilhando
ensinamentos.
Por fim a minha namorada Cristina Santos, fundamental nesta etapa, por compartilhar
comigo todas as minhas conquistas, ajudar a enfrentar os contratempos, por me incentivar
sempre e acreditar no meu futuro, além de ter me ajudado a manter são nessa etapa
conturbada que é o TCC.
“Todo sistema tem falhas, os mais
complexos são os mais vulneráveis, sendo
impossível fugir delas”
__________________________________
Kevin Mitnick
 RESUMO

PASCHOAL, Roni Paschoal. Analise De Segurança Em Aplicações Web Móvel Geradas

Com O Uso Da Ferramenta PhoneGap. Trabalho de Conclusão de Curso - Instituto Federal
de São Paulo, São João da Boa Vista, 2016.

Cada vez mais os dispositivos móveis estão presentes em nossa vida e com mais
funcionalidades, dessa forma a demanda pela criação de aplicações para satisfazerem as
necessidades dos usuários cresce junto. Em paralelo, existem diversas plataformas que devem
ser contempladas, com distintos sistemas operacionais, de forma que se torna necessário uma
programação com linguagens específicas para cada caso. Essa necessidade resulta em códigos
replicados, o que aumenta o tempo de programação e dificulta a manutenção, algo que
impacta de forma negativa nos custos de cada projeto. Visando uma portabilidade do código,
e com isso uma redução nos custos, existem diversas ferramentas consagradas no mercado
que permitem rodar um só projeto web em diversas plataformas móveis de forma nativa.
Apesar de apresentar vantagens, essa prática também acrescenta desvantagens em termos de
segurança, a fim de elucidar as questões de segurança em uma programação hibrida e levantar
uma discussão sobre a segurança da informação, assunto desprezado por muitos
desenvolvedores e empresas, surge a motivação deste trabalho. Nele foram pesquisadas as
principais vulnerabilidades existentes no mercado, criada uma aplicação web móvel para
Android compilada com o uso do PhoneGap e foram exploradas brechas de segurança nessa
aplicação. O que resultou no levantamento de vulnerabilidades conhecidas no mercado,
identificação de pontos importantes a serem abordados pelo desenvolvedor, assim como na
proposta de soluções que procuram minimizar as vulnerabilidades existentes nesse tipo de
aplicação. Dessa forma foi possível ter uma abordagem do desenvolvimento através do
enfoque da segurança da informação.

Palavras-chave: Segurança; Aplicação Web Móvel; Vulnerabilidades; Aplicativo Móvel.

 ABSTRACT

PASCHOAL, Roni Paschoal. Security Analysis In Mobile Web Application Generated

With PhoneGap Tool. Course Conclusion Project - Instituto Federal de São Paulo, São João
da Boa Vista, 2016.

Increasingly mobile devices are present in our lives and with more functionality, this
way of creating applications to meet as users' needs grows together. In parallel, there are
several platforms that must be contemplated, with different operating systems, in this way
becomes necessary a programming with languages specific to each case. This need results in
duplicate codes, which increases programming time and makes maintenance difficult,
something that negatively impacts the costs of each project. Aiming at portability of the code,
and with this a reduction in costs, there are several tools in the market that allow you to run a
single web project on several mobile platforms natively. Although it presents advantages, this
practice also adds disadvantages in terms of security, in order to elucidate security issues in a
hybrid programming and raise a discussion about information security, subject despised by
many developers and companies, the motivation of this work appears. It was investigated the
main vulnerabilities in the market, was created a mobile web application for Android
compiled with the use of PhoneGap and was exploited security holes in this application. This
resulted in the presentation of known vulnerabilities in the market, the identification of
important points to be addressed by the developer, as well as the proposal of solutions that
seek to minimize the vulnerabilities in this type of application. In this way it was possible to
take a development approach through the information security approach.

Keywords: Security; Mobile Web Application; Vulnerabilities; Mobile Application.

 LISTA DE ILUSTRAÇÕES

Figura 1 - Recipiente Web ........................................................................................................ 28

Figura 2 - PhoneGap API ......................................................................................................... 29

Figura 3 - Riscos de Segurança em Aplicações........................................................................ 31

Figura 4 - XSS .......................................................................................................................... 35

Figura 5 - Código Vulnerável ao XSS Armazenado ................................................................ 36

Figura 6 - Código Vulnerável ao XSS Refletido ...................................................................... 36

Figura 7 - Código Malicioso XSS Refletido ............................................................................ 37

Figura 8 - Código Malicioso XSS Baseado em DOM ............................................................. 37

Figura 9 - Referência Insegura e Direta a Objetos ................................................................... 38

Figura 10 - Etapas do Teste ...................................................................................................... 49

Figura 11 - Estrutura dos Dados ............................................................................................... 50

Figura 12 - Telas do Aplicativo de Teste ................................................................................. 50

Figura 13 - Tela Web de Exibição dos Dados .......................................................................... 53

Figura 14 - Teste de Injeção de Código.................................................................................... 54

Figura 15 - Teste de Cross-Site Scripting................................................................................. 54

Figura 16 - Teste de Engenharia Reversa ................................................................................. 55

Figura 17 - Teste de Funcionalidade Estranha ......................................................................... 56

Figura 18 - Tela inicial do Scanner QARK .............................................................................. 57

Figura 19 - Interface do relatório do Scanner QARK .............................................................. 57

Figura 20 - Execução do AndroBugs ....................................................................................... 58

Figura 21 - Interface do relatório do Scanner Androbugs ........................................................ 58

Figura 22 - XML de Configuração do PhoneGap .................................................................... 59

Figura 23 - Remoção das Tags HTML usando JavaScript ....................................................... 61

Figura 24 - Remoção das Tags HTML usando PHP ................................................................ 61

Figura 25 - Chamada do Plugin Whitelist do PhoneGap ......................................................... 62

Figura 26 - Configuração do Whitelist com Permissão Total .................................................. 62

Figura 27 - Configuração do Whitelist com Permissão Apenas para o WebService ............... 63

Figura 28 - Código Original e Ofuscado.................................................................................. 63

Figura 29 - Manifest da Aplicação ........................................................................................... 64

Figura 30 - Manifest da Aplicação Após as Remoções dos Plugins........................................ 65

Figura 31 - Vulnerabilidade Potencial encontrada pelo QARK .............................................. 66

Figura 32 - Vulnerabilidade Crítica encontrada pelo AndroBugs ........................................... 66

Figura 33 - Assinado a Aplicação no PhoneGap ..................................................................... 66

Figura 34 - Informativo WebView QARK ............................................................................... 67

Figura 35 - Menu QARK Dashboard ....................................................................................... 77

Figura 36 - Menu QARK App Components ............................................................................ 77

Figura 37 - Menu QARK Manifest .......................................................................................... 78

Figura 38 - Menu QARK Web Views ..................................................................................... 79

Figura 39 - Menu QARK Parsing Errors ................................................................................. 80

 LISTA DE TABELAS

Tabela 1- Donwloads Móveis da App Store, 2010-2016 (Milhões de Downloads) ................. 24

Tabela 2 - Vantagens e Desvantagens da Aplicação Web Móvel ............................................ 27

Tabela 3 - Vantagens e Desvantagens do PhoneGap ............................................................... 30

Tabela 4 - Principais Vulnerabilidades Web ............................................................................ 32

Tabela 5 - Principais Vulnerabilidades Móveis ........................................................................ 32

Tabela 6 - Vulnerabilidades x Ferramentas Detecção e Exploração ....................................... 47

Tabela 7 - Quantidade de Vulnerabilidades Encontradas no QARK ....................................... 64

Tabela 8 - Quantidade de Vulnerabilidades Encontradas no AndroBugs ................................ 65

LISTA DE SIGLAS

2D Two-Dimensional (Bidimensional)

API Application Programming Interface (Interface de Programação de Aplicativos)

CWE Common Weakness Enumeration

CSS Cascading Style Sheets (Folha de Estilos em Cascata)

DOM Document Object Model (Modelo Objeto de Documento)

HTML Hypertext Markup Language (Linguagem de Marcação de Hipertexto)

HTML5 Fifth Version Hypertext Markup Language (Linguagem de Marcação de

Hipertexto Quinta Versão)

MP3 Moving Picture Experts Group Audio Layer-3

MP4 Moving Picture Experts Group-4 Part 14

OWASP Open Web Application Security Project (Projeto de Segurança de Aplicações

Open Web)

OSSTMM Open Source Security Testing Methodology Manual (Manual de Segurança de

Metodologia de Testes de Livre Distribuição)

QARK Quick Android Review Kit (Kit de Revisão Rápida para Android)

SMS Short Message Service (Serviço de Mensagens Curtas)

SSL Secure Sockets Layer (Camada Segura de Sockets)

XML eXtensible Markup Language (Linguagem de Marcação Extensível)

XSS Cross-Site Scripting (Scripting de Site Cruzado)

 SUMÁRIO

1 INTRODUÇÃO ........................................................................................................... 23

1.1 Motivação ............................................................................................................................. 24

1.2 Objetivos ............................................................................................................................... 25

1.3 Organização do trabalho ....................................................................................................... 25

2 PESQUISA BIBLIOGRÁFICA ................................................................................... 27

2.1 Considerações Iniciais .......................................................................................................... 27

2.2 Aplicação Web Móvel (Mobile Web Application)................................................................ 27

2.2.1 Recipiente Web (Web Container) ...................................................................................... 27

2.3 Middleware ........................................................................................................................... 29

2.3.1 PhoneGap ........................................................................................................................... 29

2.4 Ataque................................................................................................................................... 30

2.5 Riscos de Segurança ............................................................................................................. 31

2.6 Vulnerabilidade .................................................................................................................... 31

2.6.1 - A1 - Injeção de Código (Injection) .................................................................................. 33

2.6.2 - A2 - Quebra de Autenticação e Gerenciamento de Sessão (Broken Authentication

and Session Management) ........................................................................................................... 34

2.6.3 - A3 - Scripting de Site Cruzado (Cross-Site Scripting) .................................................... 34

2.6.3.1 XSS Armazenado ou Persistente (Stored XSS) ............................................................ 35

2.6.3.2 XSS Refletido ou Não Persistente (Reflected XSS) ..................................................... 36

2.6.3.3 XSS Baseado em DOM (DOM-Based XSS) ................................................................ 37

2.6.4 - A4 - Referência Insegura e Direta a Objetos (Insecure Direct Object References) ......... 37

2.6.5 - A5 - Configuração Incorreta de Segurança (Security Misconfiguration) ........................ 38

2.6.6 - A6 - Exposição de Dados Sensíveis (Sensitive Data Exposure)...................................... 39

2.6.7 - A7 - Falta de Função para Controle do Nível de Acesso (Missing Function Level

Access Control) ........................................................................................................................... 39

2.6.8 - A8 - Falsificação de Requisições de Site Cruzado (Cross-Site Request Forgery) ........... 39

2.6.9 - A9 - Utilização de Componentes Vulneráveis Conhecidos (Using Components with

Known Vulnerabilities) ............................................................................................................... 40

2.6.10 - A10 - Redirecionamentos e Encaminhamentos Inválidos (Unvalidated Redirects and

Forwards) .................................................................................................................................... 40

2.6.11 - M1 - Uso da Plataforma Inadequada (Improper Platform Usage) .................................. 40

2.6.12 - M2 - Armazenamento de Dados Inseguro (Insecure Data Storage) ............................... 41

2.6.13 - M3 - Comunicação Insegura (Insecure Communication) ............................................... 42

2.6.14 - M4 - Autenticação Insegura (Insecure Authentication) .................................................. 42

2.6.15 - M5 - Criptografia Insuficiente (Insufficient Cryptography) ........................................... 42

2.6.16 - M6 - Autorização Insegura (Insecure Authorization) ..................................................... 43

2.6.17 - M7 - Qualidade de Código Cliente (Client Code Quality) ............................................. 44

2.6.18 - M8 - Adulteração de Código (Code Tampering) ............................................................ 44

2.6.19 - M9 - Engenharia Reversa (Reverse Engineering) .......................................................... 44

2.6.20 - M10 - Funcionalidade Estranha (Extraneous Functionality) .......................................... 45

2.7 Scanner de Vulnerabilidade (Vulnerability Scanner) ........................................................... 45

2.8 Trabalhos Correlatos ............................................................................................................. 46

3 METODOLOGIA ....................................................................................................... 49

3.1 Aplicativo de Teste ............................................................................................................... 49

3.1.1 Aplicação Web Móvel........................................................................................................ 50

3.1.1.1 Tela Principal ................................................................................................................ 51

3.1.1.2 Tela de Login ................................................................................................................ 51

3.1.1.3 Tela de Cadastro............................................................................................................ 51

3.1.1.4 Tela Home ..................................................................................................................... 51

3.1.1.5 Tela de Edição............................................................................................................... 52

3.1.2 Estrutura Online de Gerenciamento do Aplicativo ............................................................ 52

3.1.2.1 WebService ................................................................................................................... 52

3.1.2.1.1 Login ................................................................................................................................... 52

3.1.2.1.2 Cadastro............................................................................................................................... 52

3.1.2.1.3 Edição dos Dados ................................................................................................................ 53

3.1.2.2 Pagina Web ................................................................................................................... 53

3.2 Testes Manuais ..................................................................................................................... 53

3.2.1 Injeção de Código (Injection)............................................................................................. 53

3.2.2 Scripting de Site Cruzado (Cross-Site Scripting)............................................................... 54

3.2.3 Engenharia Reversa (Reverse Engineering)....................................................................... 55

3.2.4 Funcionalidade Estranha (Extraneous Functionality) ........................................................ 56

3.3 Execução dos Scanners de Vulnerabilidade ......................................................................... 56

3.3.1 QARK ................................................................................................................................ 57

3.3.2 AndroBugs ......................................................................................................................... 58

3.4 Pesquisa de Soluções ............................................................................................................ 59

3.4.1 Alteração das Configurações do PhoneGap ....................................................................... 59

3.4.2 Alterações no Código ......................................................................................................... 59

4 RESULTADOS ............................................................................................................. 61

4.1 Testes Manuais ..................................................................................................................... 61

4.1.1 Injeção de Código .............................................................................................................. 61

4.1.2 Scripting de Site Cruzado (Cross-Site Scripting)............................................................... 62

4.1.3 Engenharia Reversa (Reverse Engineering)....................................................................... 63

4.1.4 Funcionalidade Estranha .................................................................................................... 64

4.2 Scanners de Vulnerabilidade ................................................................................................ 64

5 CONCLUSÃO .............................................................................................................. 69

REFERÊNCIAS ................................................................................................................ 71

APÊNDICES ...................................................................................................................... 75

APÊNDICE A - RELATÓRIO QARK ............................................................................. 77

APÊNDICE B - RELATÓRIO ANDROBUGS .................................................................... 81

Introdução

Segundo Cisco (2016), o tráfego de dados móveis cresceu 4.000 vezes ao longo dos
últimos 10 anos e quase 400 milhões de vezes ao longo dos últimos 15 anos, sendo que em
2015 o tráfego global de dados móveis cresceu 74 por cento em relação ao ano anterior.
Em conseqüência ao aumento de utilização de dispositivos móveis, cresce junto a
demanda pela programação para distintos sistemas operacionais móveis. Devido à
incompatibilidade das diferentes plataformas disponíveis, um mesmo projeto tem que ser
replicado em variadas linguagens, criando assim vários projetos por aplicação.
Com o intuito de unificar esses códigos, proporcionando a portabilidade dos
aplicativos, surgiram ferramentas como o PhoneGap1 e o IonicFramework2.
Essas ferramentas são middlewares que rodam códigos criados com o uso de
tecnologias web, HTML5 (Fifth Version Hypertext Markup Language), CSS3 (Cascading
Style Sheets) e JavaScript, nas principais plataformas existentes no mercado. Dessa forma
facilita a vida dos desenvolvedores e reduz os custos no desenvolvimento e manutenção, já
que mesmo com a necessidade de ser executado em plataformas distintas é feito apenas um
código por aplicação.
Apesar de facilitar em termos de portabilidade, ao criar aplicações utilizando
tecnologias voltadas à web, herdamos vulnerabilidades que muitas vezes não existem nas
linguagens nativas. Algumas dessas vulnerabilidades já são muito conhecidas por usuários
mal-intencionados que tem o intuito de explorá-las para ganho próprio ou de forma que cause
algum dano. Com isso, torna-se necessário um cuidado redobrado em sua segurança, o que
muitas vezes não acontece (JIN ET. AL, 2014).
Segundo o relatório das principais vulnerabilidades publicado pelo Common
Vulnerabilities and Exposures Details (CVE Details, 2016), somente entre janeiro e maio de
2016, 2639 novas vulnerabilidades foram catalogadas para os sistemas dos 50 principais
fabricantes de software.
Obviamente essa lista inclui apenas vulnerabilidades oficialmente descobertas e é
composta somente por grandes empresas. O top 10 inclui empresas como Oracle, Adobe,
Google, Microsoft, Apple, Debian, IBM, Cisco, Linux e Novell. Deste modo, trata-se de

1
http://phonegap.com/
2
http://ionicframework.com/
 24

vulnerabilidades encontradas nos softwares desenvolvidos por grandes equipes, que

geralmente fazem uso de metodologias de desenvolvimento consolidadas e possuem equipes
de teste.
É possível imaginar que em empresas menores ou que não fazem uso de metodologias
adequadas de desenvolvimento, com testes adequados focados na segurança do software, a
situação seja bastante crítica.

Motivação

Segundo a Gartner (2013) as lojas de aplicações móveis estimavam que em 2013 os

donwloads deveriam atingir 102 bilhões frente aos 64 bilhões do ano anterior, resultando em
US$26 bilhões contra US$ 18 bilhões em 2012. Sendo responsáveis por 91 por cento do total.
Na Tabela 1 é demonstrada uma projeção para 2010-2016.

Tabela 1- Donwloads Móveis da App Store, 2010-2016 (Milhões de Downloads)

2012 2013 2014 2015 2016 2017
Downloads Gratuitos 57.331 92.876 127.704 167.054 211.313 253.914
Downloads Pagos 6.654 9.186 11.105 12.574 13.488 14.778
Total de Downloads 63.985 102.062 138.809 179.628 224.801 268.692
Downloads Gratuitos% 89,6 91,0 92,0 93,0 94,0 94,5
Fonte: Adaptado de Gartner (2012)

Este aumento está pressionando os gerentes de negócios a aumentar drasticamente a

velocidade do desenvolvimento e liberação das aplicações móveis, muitas vezes chegando a
terceirizar esse desenvolvimento. Com isso a supervisão da segurança é reduzida, fazendo-se
necessário uma nova estratégia para alterar a visão das empresas de “rápido para o mercado”
para “rápido e seguro para o mercado” (HP, 2013).
Considerando o alto índice de vulnerabilidades encontradas em softwares nos últimos
anos, como demonstrando no relatório do CVE Details (2016), é necessário que as empresas
adotem testes com foco em segurança nos aplicativos desenvolvidos.
Diante do aumento do uso de middlewares, como o PhoneGap para o desenvolvimento
de aplicativos móveis, fica a dúvida se essas ferramentas levam em considerações os
requisitos de segurança na hora de gerar o código dos aplicativos.
Com o objetivo de aumentar a segurança das aplicações, surgiu a idéia de pesquisar
possíveis brechas, com o uso de ferramentas que buscam as vulnerabilidades em sistemas,
 25

para verificar se esses middlewares adotam alguma medida para dificultar ações dos usuários
mal-intencionados e propor soluções nos casos não tratados.

Objetivos

O objetivo deste trabalho de pesquisa é verificar se o código gerado pela ferramenta

PhoneGap, selecionada por ser uma das mais utilizadas (APACHE CORDOVA, 2016),
aborda boas práticas de segurança e quais vulnerabilidades remanescentes ficam sob a
responsabilidade do desenvolvedor tratar.
Os objetivos específicos deste projeto são:
 Realizar um levantamento das vulnerabilidades mais exploradas em aplicações
web e móveis.
 Desenvolver um aplicativo web móvel usando HTML5, CSS3 e JavaScript,
compilado com a ferramenta PhoneGap.
 Pesquisar scanners de vulnerabilidade gratuitos para Android.
 Testar vulnerabilidades do aplicativo através de testes manuais e ferramentas
automatizadas.
 Pesquisar melhores práticas de segurança para minimizar vulnerabilidades.

Organização do trabalho

No segundo capítulo, “Pesquisa Bibliográfica”, são explanados conceitos referentes às

aplicações web e a segurança da informação que fundamentam a pesquisa, assim como
pesquisas correlatas. No terceiro capítulo, “Metodologia”, é descrita a proposta deste trabalho
com a apresentação da aplicação testada, ferramentas de teste e os testes realizados. No quarto
capítulo, “Resultados”, são apresentados os resultados obtidos através da metodologia
aplicada no terceiro capítulo. No quinto capítulo, “Conclusão”, são apresentadas análises dos
resultados obtidos no quarto capítulo, permitindo identificar a importância da segurança em
uma aplicação, dificuldades em seu tratamento e algumas causas.
26
Pesquisa Bibliográfica

Considerações Iniciais

Com o intuito embasar o projeto, este capítulo apresenta uma contextualização com
definições sobre aplicações web e segurança da informação, assim como pesquisas correlatas.

Aplicação Web Móvel (Mobile Web Application)

Também chamado de aplicativo móvel baseado em HTML5, ou HTML5-based mobile

app, “um aplicativo web para dispositivos móveis é um software construído com as
tecnologias web centradas no cliente em HTML, CSS e JavaScript, e é especificamente
projetado para os dispositivos móveis” (OEHLMAN; BLANC, 2012, p. 7).
Segundo Stark e Jepson (2012), o aplicativo web é um site otimizado para um
smartphone. Tendo como característica, a interface do usuário criada utilizando tecnologias
web padrão sem o uso da linguagem da plataforma, como no caso do Android, o Java. Como
em seu livro Stark e Jepson (2012) não usam ferramentas para compilar esse código web para
a plataforma móvel, disponibilizando a aplicação através de uma URL, afirmam também que
o aplicativo não pode ser instalado no telefone nem ser disponibilizado na Google Play. Os
autores listaram vantagens e desvantagens do uso da linguagem web nesse tipo de aplicação
sendo onde pode ser observado na Tabela 2.

Tabela 2 - Vantagens e Desvantagens da Aplicação Web Móvel

Vantagens
Os desenvolvedores web podem usar seus
frameworks
A utilização das habilidades de web design para
o desenvolvimento da interface
O aplicativo pode ser executado em qualquer
dispositivo que tenha um navegador web
É possível corrigir os erros em tempo real
O ciclo de desenvolvimento é rápido
Fonte: Adaptado de Stark e Jepson (2012)
Desvantagens
Não é possível acessar os recursos do hardware
do Smartphone
É necessário gerenciar os pagamentos para
cobranças no aplicativo
Pode ser difícil conseguir os efeitos da interface
do usuário mais sofisticados

Recipiente Web (Web Container)

Jin et. al (2014) ressaltam que o aplicativo web não pode ser executado diretamente
nos sistemas móveis pois estes sistemas não suportam HTML5 e JavaScript nativamente.
 28

Portanto, para viabilizar a execução é necessária a utilização de um recipiente web, que atua
como interface entre o dispositivo e o aplicativo web, como é o caso do WebView no
Android, o UIWebView no iOS, e o WebBrowser no Windows Phone.
Este recipiente web originalmente foi projetado para permitir que aplicativos nativos
possam processar o conteúdo de exibição da web, sendo basicamente pacotes que contém as
funcionalidades de navegação na Internet em uma classe.
Jin et. al (2014) afirmam também que como esses recipientes são destinados a
hospedar conteúdo web, que potencialmente possui riscos por estar exposto à Internet, os
recipientes assim como os navegadores, implementam um recurso de segurança chamado
caixa de areia, ou como chamado no idioma inglês, sandbox.
Este recurso sandbox tem como objetivo garantir que o funcionamento de alguma
aplicação, como por exemplo o código JavaScript possa ser executado em um ambiente
isolado contendo apenas recursos necessários para esse fim, de modo que não comprometa,
ou seja comprometido por, outras aplicações (PREVELAKIS; SPINELLIS, 2001).
Essa tecnologia é apropriada para conteúdo web, mas é bem restritiva para aplicativos
móveis, não permitindo que sejam acessados diretamente recursos do sistema, como arquivos,
câmeras, etc. O recipiente web permite também que os aplicativos criem uma ponte entre o
código JavaScript e o código nativo, por exemplo em linguagem Java. Esta ponte permite que
o código JavaScript possa invocar o código nativo de fora do container e com isso acessar
recursos do sistema caso o aplicativo tenha as permissões necessárias. Dessa forma os
desenvolvedores podem escrever seu próprio código nativo para trabalhar com o código
dentro do recipiente web, o que reduz a portabilidade do aplicativo. A prática mais comum é a
utilização de um middleware de terceiros para a parte NativeCode, deixando a questão
portabilidade para os desenvolvedores do middleware. (JIN ET. AL, 2014). Na Figura 1 é
exemplificado um recipiente web.
Figura 1 - Recipiente Web

Fonte: Adaptado de Trice (2012)

 29

Middleware

A definição de middleware existente no site Dictionnary.com traz que o termo é a

junção das palavras middle + (soft)ware, ou seja, é um software de computador que tem uma
função de intermediário entre as várias aplicações de um computador e seu sistema
operacional.
Segundo Tanenbaum e Steen (2007) o middleware atua como uma camada entre as
aplicações e as plataformas distribuídas, que tem como função ocultar das aplicações parte da
distribuição de dados, processamento e controle.
Segundo Bavuudorj e Trancioveanu (2013), o PhoneGap é um dos mais populares
middlewares com o intuito de fazer o intermédio entre o recipiente web e o código nativo, por
isso e pela familiaridade com a ferramenta, ele será utilizado neste projeto.

PhoneGap

PhoneGap é um middleware de código aberto que permite criar aplicações web móvel
nativamente instaladas, de forma que utiliza o recipiente web do dispositivo móvel para rodar
a aplicação. A ferramenta fornece uma API (Application Programming Interface) que permite
que o desenvolvedor acesse as funcionalidades nativas dos dispositivos através de chamadas
JavaScript. Essa ferramenta permite também a criação de classes nativas personalizadas para
usar como interface do JavaScript dentro do projeto (PHONEGAP, 2012). Na figura 2 pode se
observar essa interação mediada pelo middleware.

Figura 2 - PhoneGap API

Fonte: Adaptado de Trice (2012)

Em outras palavras, PhoneGap é uma biblioteca que permite que linguagens web
como HTML, CSS e JavaScript possam se comunicar e acessar características nativas do
 30

dispositivo móvel. Agindo como uma interface entre as APIs JavaScript e as APIs nativas,
permitindo que os desenvolvedores possam utilizar recursos, como câmera, Acelerômetro,
Bluetooth, GPS (BAVUUDORJ; TRANCIOVEANU, 2013). Na tabela 3 pode se observar
vantagens e desvantagens do PhoneGap.

Tabela 3 - Vantagens e Desvantagens do PhoneGap

Vantagens Desvantagens
Código base unificado para todas as plataformas PhoneGap pode ser um framework complexo, se
não for bem compreendido torna-se menos
responsivo
Desenvolvimento rápido Não possui uma Interface do Usuário padrão
Acesso a funções Nativas Acesso limitado a recursos mais avançados sem
plugins adicionais
Uso offline Lógica de negócio complexa
Fonte: Adaptado de Turkovic (2015)

Ataque

Ataques são ações realizadas por usuários mal-intencionados com o intuito de

ocasionar um incidente de segurança. O Cert.BR (2012) define que incidente de segurança é
um evento não usual, relacionado à segurança de um sistema computacional, que já tenha sido
confirmado ou esteja sob investigação.
Geralmente esses ataques utilizam técnicas que exploram alguma vulnerabilidade
(tópico abordado na seção 2.5) existente na aplicação. Quando ocorre um ataque de
exploração de vulnerabilidade, geralmente o intuito é executar ações maliciosas, como acesso
a informações sigilosas, tomar controle de um sistema, utilizar o sistema invadido como
intermediário para executar outros ataques ocultando a origem real, tornar um serviço
inacessível, entre outros (CERT.BR, 2012).
Ataques podem ser divididos em dois grupos principais, os passivos e os ativos. Os
ataques passivos tem o objetivo de descobrir informações ou utilizar informações do sistema,
sem que cause algum dano no sistema, de modo que muitas vezes sequer são detectados, pois
muitas vezes nenhum funcionamento é alterado. Exemplo de ataque passivo é o
monitoramento do tráfego, por meio de um analisador de protocolos. Por outro lado, os
ataques ativos tentam alterar ou afetar um sistema, de modo que causam algum dano ao
 31

sistema. Exemplos de ataque ativo muito populares, são os ataques de negação de serviço e a
exploração de vulnerabilidades por meio de exploits (STALLINGS, 2014).

Riscos de Segurança

A OWASP (Open Web Application Security Project) (2013) afirma que os atacantes
podem utilizar caminhos alternativos para causar danos. Alguns desses caminhos são triviais,
fácil de serem encontrados e explorados, porém em alguns casos são extremamente difíceis
assim como o dano causado pode ter nenhuma conseqüência ou pode ser muito prejudicial.
Dessa forma é importante levar em consideração ao considerar o risco, a probabilidade
associada em cada ameaça, vetor de ataque, vulnerabilidade de segurança frente a uma
estimativa dos impactos técnicos e no negócio da sua empresa. Na Figura 3 são demonstrados
os pontos importantes a serem considerados ao calcular os riscos.

Figura 3 - Riscos de Segurança em Aplicações

Fonte: OWASP (2013)

Vulnerabilidade

Segundo o Cert.BR (2012) “uma vulnerabilidade é definida como uma condição que,
quando explorada por um atacante, pode resultar em uma violação de segurança”. Muitas
podem ser as causas para a existência de uma vulnerabilidade, como por exemplo, falha na
elaboração do projeto do sistema, problemas na tecnologia utilizada, erros na configuração,
entre outros.
Segundo a Cielo (2012) falhas nas etapas do desenvolvimento do software como
problemas gerados desde o planejamento da aplicação quanto na segmentação da rede, como
a implementação dos ativos de TI e informações que podem comprometer o ambiente,
atualmente são portas de entrada para grande parte dos ataques em aplicações web.
 32

Com o objetivo de educar desenvolvedores, projetistas, arquitetos, gestores e

organizações sobre as conseqüências das mais importantes vulnerabilidades de segurança de
sistemas web, a OWASP fornece técnicas básicas para se proteger das 10 principais
vulnerabilidades de segurança selecionadas de acordo com sua relevância. A OWASP ressalta
também que existem centenas de outras vulnerabilidades que podem afetar a segurança de um
sistema web (OWASP, 2013).
Nas seções a seguir são descritas as vulnerabilidades contidas na versão 2013 do “Top
Ten” da OWASP (OWASP, 2013), a mais recente desse documento, seguidas da versão 2016
do “Mobile Top Ten” da OWASP (OWASP, 2016), release candidate também a mais recente.
Na Tabela 4 é possível visualizar a lista da versão 2013 do “Top Ten” da OWASP.

Tabela 4 - Principais Vulnerabilidades Web

Top Ten da OWASP
A1 - Injeção de Código (Injection) A6 - Exposição de Dados Sensíveis (Sensitive Data
Exposure)
A2 - Quebra de Autenticação e Gerenciamento de A7 - Falta de Função para Controle do Nível de
Sessão (Broken Authentication and Session Acesso (Missing Function Level Access Control)
Management)
A3 - Scripting de Site Cruzado (Cross-Site Scripting) A8 - Falsificação de Requisições de Site Cruzado
(Cross-Site Request Forgery)
A4 - Referência Insegura e Direta a Objetos (Insecure A9 - Utilização de Componentes Vulneráveis
Direct Object References) Conhecidos (Using Components with Known
Vulnerabilities)
A5 - Configuração Incorreta de Segurança (Security A10 - Redirecionamentos e Encaminhamentos
Misconfiguration) Inválidos (Unvalidated Redirects and Forwards)
Fonte: Adaptado de OWASP (2013)

Na Tabela 5 está presente a lista da versão 2016 do “Mobile Top Ten” da OWASP.

Tabela 5 - Principais Vulnerabilidades Móveis

Mobile Top Ten da OWASP
M1 - Uso da Plataforma Inadequada (Improper M6 - Autorização Insegura (Insecure Authorization)
Platform Usage)
M2 - Armazenamento de Dados Inseguro (Insecure M7 - Qualidade de Código Cliente (Client Code
Data Storage) Quality)
M3 - Comunicação Insegura (Insecure M8 - Adulteração de Código (Code Tampering)
Communication)
M4 - Autenticação Insegura (Insecure Authentication) M9 - Engenharia Reversa (Reverse Engineering)
M5 - Criptografia Insuficiente (Insufficient M10 - Funcionalidade Estranha (Extraneous
Cryptography) Functionality)
Fonte: Adaptado de OWASP (2016)
 33

As seções referentes a elas são nomeadas seguindo o padrão do documento da

OWASP, onde as vulnerabilidades web têm o prefixo “A” seguido da posição na lista e o
nome da vulnerabilidade e as vulnerabilidades móveis têm o prefixo “M” seguido da posição
na lista e o nome da vulnerabilidade.

- A1 - Injeção de Código (Injection)

O termo injeção de código representa uma categoria de diversos ataques onde um

código é injetado dentro de uma aplicação a partir de uma fonte externa.
Patel, Mohamed e Soni (2011) exemplificam este tipo de ataque citando a inserção de
um código malicioso por meio de um de um campo de entrada de texto que possua validação
insuficiente para os requisitos de segurança, de modo que o código inserido seja executado
como se fosse uma parte da própria aplicação.
Apesar de ser bastante popular o ataque utilizando campos de usuário e senha
referentes à autenticação de usuários, diversos outros métodos podem ser utilizados para
efetivar a inserção do código, como por exemplo, explorando vulnerabilidades em plugins de
sistemas de gerenciamento de conteúdo. As vulnerabilidades CVE-2015-78583 e CVE-2015-
72974 são exemplos desta técnica aplicada sob falhas do sistema de gerenciamento de
conteúdo Joomla!, uma ferramenta bastante popular, utilizada inclusive em diversos órgãos
do governo, como o site do MEC.
Quando ocorre a injeção de código, o atacante pode enviar dados não confiáveis ao
interpretador como parte de um comando ou consulta, de forma que o interpretador execute
comandos indesejados ou permita acesso a dados não autorizados (OWASP, 2013).
Entre os tipos mais populares de injeção de código, Patel, Mohamed e Soni (2011)
destacam: Injeção HTML, Scripting de Site Cruzado (especificamente abordado na seção
2.5.3), injeção de código SQL, ataque de interpretador de comandos (shell), spoofing de
conteúdo, HTTP Response Splitting, HTTP Request Splitting e ataque de envenenamento
de XML (eXtensible Markup Language), entre outros.

3
https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-7858
4
https://cve.mitre.org/cgi-bin/cvename.cgi?name=CVE-2015-7297
 34

- A2 - Quebra de Autenticação e Gerenciamento de Sessão (Broken Authentication

and Session Management)

A Quebra de autenticação e Gerenciamento de Sessão ocorre quando as funções

relacionadas à autenticação e gerenciamento de sessão não são implementados de forma
correta, permitindo que os atacantes comprometam senhas, chaves e tokens de sessão ou
explorem outras falhas para assumir a identidade de outro usuário (OWASP, 2013).
Kolsek (2007) ressalta que muitos aplicativos baseados em web utilizam de algum
gerenciamento de sessão para criar um ambiente amigável ao usuário, onde os servidores
usam identificadores de sessão para vincular ela ao seu respectivo usuário. Esses
identificadores são muito cobiçados pelos atacantes, que tem o intuito de interceptar essa
conexão, onde uma vez em posse dessas informações ele consegue acessar a conta do usuário
sem o conhecimento do mesmo.
Uma vez que o atacante se passa pelo usuário, ele pode ter acesso a informações
confidenciais, e ou chegar a causar danos e prejuízos ao usuário real. Uma vez que muitas
vezes esse acesso ocorre sem o conhecimento do próprio, é possível que esse acesso seja
repetido, por não ser tomada nenhuma ação para o reparo desse problema.

- A3 - Scripting de Site Cruzado (Cross-Site Scripting)

Encontrar pontos de acesso Wi-Fi gratuitos, digitalizar códigos de barras 2d, enviar
mensagens SMS e ouvir música são práticas comuns e típicas do uso de um dispositivo
móvel. Porém uma tendência tem ganhado popularidade, tornando essas práticas arriscadas.
Essas atividades e arquivos tem se tornado porta para atacantes injetarem códigos maliciosos,
levando a danos, danos estes que não param no aparelho da vítima podendo se espalhar por
outros aparelhos, muitas vezes se enviando para a lista de contatos da vítima (JIN ET. AL,
2014).
O XSS (Scripting de Site Cruzado) ocorre quando uma aplicação ao receber os dados
não confiáveis reenvia ao navegador sem validação ou filtro o que permite os atacantes
executarem scripts no navegador da vítima podendo roubar dados da sessão do usuário ou
 35

redirecionar a algum site malicioso (OWASP, 2013). Na Figura 4 estão presentes os pontos
do XSS conforme os riscos de segurança em aplicações (tópico abordado na seção 2.4).

Figura 4 - XSS

Fonte: OWASP (2013)

Segundo a CWE (Common Weakness Enumeration) (2015) a vulnerabilidade XSS
ocorre da seguinte forma:
1. São passados dados não confiáveis para o sistema web, normalmente a partir de
uma solicitação web;
2. O sistema web gera dinamicamente uma página web que contém esses dados não
confiáveis;
3. Durante a geração da página, o sistema não valida os dados que podem ser
executados pelo navegador, como JavaScript, tags HTML, atributos HTML;
4. A vítima visita uma página web que contém script malicioso que foi injetado
usando dados não confiáveis;
5. O script vem de uma página externa que é executada pelo navegador da vítima
como se fosse um script do domínio;
6. A requisição viola a política de mesmo domínio, que afirma que scripts em um
domínio não podem acessar recursos de outro domínio.

XSS Armazenado ou Persistente (Stored XSS)

XSS armazenado ocorre quando o sistema salva os dados não confiáveis em seu banco
de dados, podendo ser em fóruns de mensagens, log de visitantes, ou outra forma de
armazenamento confiável. Em um momento posterior os dados não confiáveis são lidos e
integrados no conteúdo dinâmico do sistema.
 36

Estes ataques costumam ser direcionados tanto para áreas que possuem uma
quantidade grande de usuários quanto em áreas que possuem poucos usuários com privilégios
maiores, que possuem dados sensíveis valiosos para o atacante. Se um usuário com
privilégios executa um código desses, o atacante pode ser capaz de executar operações
privilegiadas em nome do usuário.
Como exemplo, o atacante pode injetar o XSS em uma mensagem de log que pode não
ter sido tratada adequadamente, sendo executado quando um administrador os acessa (CWE
2015). Na Figura 5 é apresentado um código vulnerável que exibe o nome do funcionário
através de uma busca no banco de dados em JSP, que foi salvo através de um formulário
preenchido pelo usuário.

Figura 5 - Código Vulnerável ao XSS Armazenado

Fonte: CWE (2015)

XSS Refletido ou Não Persistente (Reflected XSS)

O XSS refletido ocorre quando o servidor lê os parâmetros diretamente da requisição

HTTP e reflete na resposta também por HTTP. O atacante ao explorar essa vulnerabilidade
pode fazer com que a vítima, o sistema web vulnerável, reflita o conteúdo não confiável para
outra vítima que é executado pelo navegador web. A forma mais comum de passagem dos
dados não confiáveis é através da URL (Uniform Resource Locator) e enviado por e-mail para
a vítima. Esta forma de ataque constitui muitos esquemas de phishing (CWE 2015). Na Figura
6 é apresentado um código vulnerável que exibe uma mensagem de boas-vindas através de
uma requisição GET em PHP.

Figura 6 - Código Vulnerável ao XSS Refletido

Fonte: CWE (2015)

 37

O código acima recebe o parâmetro pela URL e o exibe sem nenhuma validação. Na
Figura 7 é apresentado um exemplo de ataque XSS refletido, que solicita login e senha de um
usuário e os envia para um servidor que os armazena.

Figura 7 - Código Malicioso XSS Refletido

Fonte: CWE (2015)

XSS Baseado em DOM (DOM-Based XSS)

O XSS baseado em DOM (Document Object Model) diferente dos outros tipos de
XSS, que são injetados pelo servidor, o baseado em DOM é injetado diretamente na pagina.
Este tipo de ataque geralmente envolve um script confiável salvo em um servidor que é
enviado para o cliente, tal como um JavaScript, este script é executado pelo navegador
injetando código na página web, como um HTML dinâmico (CWE 2015). Na Figura 8 é
exibida uma injeção da chamada de um script malicioso externo, facilitado pelo uso da
biblioteca jQuery.

Figura 8 - Código Malicioso XSS Baseado em DOM

Fonte: Jin et. al (2014)

- A4 - Referência Insegura e Direta a Objetos (Insecure Direct Object References)

A Referência insegura e Direta a Objetos ocorre quando uma referência a uma

implementação interna fica exposta de forma que os atacantes podem manipular ela para
acessar dados não autorizados (OWASP, 2013). Na Figura 9 segue um exemplo de um código
com essa vulnerabilidade.
 38

Figura 9 - Referência Insegura e Direta a Objetos

Fonte: Adaptado de Tutorialspoint (2016)

No caso apresentado o atacante pode alterar o parâmetro “acct”, acrescentando o nome

de conta “admin”, conseguindo assim acesso a conta com todos os privilégios de forma
indevida.
Segundo Gawker 2010, a Apple, através dessa vulnerabilidade, sofreu sua pior
violação de segurança até então, onde possivelmente mais de 114.000 usuários tiveram seus
dados expostos. Seus e-mails e os IDs do cartão SIM, os ICC-IDs, foram coletados por
atacantes que utilizaram um serviço de troca de dados entre a Apple e a AT&T, uma
companhia americana de telecomunicações. Essa vulnerabilidade foi capaz, pois quando
fornecido um ICC-ID como parte de uma solicitação HTTP, o script retornaria o endereço de
email associado ao usuário deste ID em uma resposta AJAX de dentro de um aplicativo Web.
Para que os servidores da AT&T respondessem com os dados dos usuários, era necessário
apenas que fosse passado o "User agent" da Apple. Essa ação foi automatizada em um código
PHP e compartilhada por terceiros antes mesmo de corrigida pela AT&T.

- A5 - Configuração Incorreta de Segurança (Security Misconfiguration)

A Configuração Incorreta de Segurança ocorre quando não há uma boa definição das
configurações de segurança na aplicação, no banco de dados, no servidor web, etc. Em alguns
casos chega a ser mantida a configuração padrão, que é insegura, é necessário também manter
uma manutenção apropriada da configuração assim como a utilização de um software sempre
atualizado (OWASP, 2013).
 39

Ao explorar essa vulnerabilidade os atacantes podem efetuar acessos legítimos a

páginas restritas, podendo causar problemas ou acessar informações que não poderiam ser
acessadas sem algum nível de privilégio.
Ribeiro (2013) afirma que essa vulnerabilidade pode ocorrer em qualquer parte da
aplicação, onde os desenvolvedores e os administradores das redes devem atuar em conjunto
para minimizar brechas e configurar corretamente as aplicações, desde o sistema operacional
até as aplicações instaladas no servidor, sendo aconselhadas ferramentas que auxiliam nesse
processo detecção de correções e a atualização da segurança.

- A6 - Exposição de Dados Sensíveis (Sensitive Data Exposure)

A Exposição de Dados Sensíveis ocorre quando os dados sensíveis, como cartões de

crédito e credenciais de autenticação, não são protegidos de forma correta podendo ser
interceptado e ou adulterado pelos atacantes durante o armazenamento ou transito. É
interessante que seja adotado o uso de criptografia para a proteção desses dados (OWASP,
2013).

- A7 - Falta de Função para Controle do Nível de Acesso (Missing Function Level

Access Control)

A Falta de Função para Controle do Nível de Acesso ocorre quando as funções que
verificam os direitos de acesso do usuário são implementadas apenas na interface e não no
servidor, permitindo assim que o atacante consiga forjar essa função e consiga acessar a
funcionalidade sem a permissão adequada (OWASP, 2013).

- A8 - Falsificação de Requisições de Site Cruzado (Cross-Site Request Forgery)

A Falsificação de Requisições de Site Cruzado ocorre quando o atacante força o

navegador da vítima a criar requisições a uma aplicação vulnerável como se fossem legitimas.
Isso ocorre quando o atacante força uma vítima, que possui uma sessão ativa, a enviar uma
requisição HTTP forjada, deixando vulneráveis dados como o cookie da sessão e ou quaisquer
 40

informações de autenticação dentro de uma sessão de uma aplicação vulnerável (OWASP,

2013).

- A9 - Utilização de Componentes Vulneráveis Conhecidos (Using Components with

Known Vulnerabilities)

A Utilização de Componentes Vulneráveis Conhecidos ocorre quando os sistemas

utilizam ferramentas que possuem vulnerabilidades conhecidas, as quais os atacantes podem
se valer delas para enfraquecer as defesas e causar diversos ataques com diversos resultados.
O problema se agrava, pois componentes como frameworks e outros módulos do software
geralmente são executados com altos privilégios, o que pode causar danos altos aos dados e
ao servidor (OWASP, 2013).
Segundo Jin et. al (2014), o PhoneGap apresenta 16 plugins integrados na própria base
e inúmeros distribuídos gratuitamente, sendo que alguns deles possuem vulnerabilidades ao
XSS e essas vulnerabilidades são integradas na aplicação com o seu uso. Ressaltam também
que o problema chega a ser potencializado pelas permissões que os plugins têm na
manipulação do hardware, o que possibilita até mesmo a replicação e a propagação do código
malicioso à agenda de contatos da vítima.

- A10 - Redirecionamentos e Encaminhamentos Inválidos (Unvalidated Redirects

and Forwards)

Os Redirecionamentos e Encaminhamentos Inválidos ocorrem quando as páginas web,

por falta de uma validação adequada, redirecionam, com o intermédio de atacantes, as vítimas
para sites maliciosos, como sites de phishing ou malware ou encaminhar para páginas não
autorizadas. (OWASP, 2013).

- M1 - Uso da Plataforma Inadequada (Improper Platform Usage)

O Uso da Plataforma Inadequada ocorre devido o mau uso de um recurso da

plataforma ou a incapacidade de usar os controles de segurança, como o uso de permissões da
 41

plataforma, ou algum outro controle de segurança pertencente ao sistema operacional móvel,

o que pode ser explorado de diversas maneiras (OWASP, 2016).
Segundo Singh e Tere (2016), é difícil descrever o impacto causado por esse risco,
pois apesar das plataformas oferecerem inúmeros controles e diretrizes de segurança, na
forma de autenticação, no armazenamento de dados e na proteção das comunicações de rede,
se não forem seguidos ou implementados corretamente, conforme o recomendado pelo
fabricante, essas aplicações podem ser expostas.
As falhas nas implementações desses controles, poderiam revelar dados, permitir
acesso para hosts não confiáveis e até mesmo ativar pagamentos falsos, o que pode ser
ocasionado por erros simples de chamada da API ou por má interpretação da forma que as
proteções trabalham.

- M2 - Armazenamento de Dados Inseguro (Insecure Data Storage)

A Cielo (2012) ressalta que alguns dados críticos, como senha, usuário e código de
confirmação do cartão de crédito, mesmo que criptografados, não devem ser salvos na
aplicação, e dados como números de cartões que são sensíveis, mas necessários a aplicação
nunca devem ser salvos completos ou devem ser criptografados.
Essa preocupação se deve, pois mesmo que pareça que o usuário não possa acessar
esses dados, os atacantes podem usar brechas na forma de armazenamento dos dados do
dispositivo para conseguir esse acesso ínvido, sendo assim interessante que eles tenham
acesso a menor quantidade de informações críticas possíveis e de forma que dificulte a leitura
desses dados.
Segundo a OWASP (2016) o Armazenamento de Dados Inseguro abrange situações
em que o desenvolvedor assume que malwares ou usuários não tem como acessar o sistema
de arquivos de um dispositivo móvel e as informações confidenciais nos armazenamentos de
dados do dispositivo, deixando facilmente acessível ao atacante dados sensíveis salvos no
aplicativo.
Outro caso que o Armazenamento de Dados Inseguro abrange é o vazamento de dados
não intencional onde ao processar informações sensíveis fornecidas pelo usuário ou no
backend, de forma desconhecida pelo desenvolvedor, a aplicação disponibiliza essa
informação em um local inseguro que pode ser acessado abertamente por outra aplicação.
Este segundo caso, muitas vezes é agravado pelo fato do desenvolvedor não ter um
 42

conhecimento aprofundado sobre como a informação é processada ou armazenada pelo

sistema operacional (OWASP, 2016).

- M3 - Comunicação Insegura (Insecure Communication)

A comunicação insegura existe em qualquer caso que são trocadas informações entre o
aplicativo e o servidor sem qualquer forma de proteção, como a comunicação por texto plano,
configurações incorretas do SSL (Secure Sockets Layer) e protocolos precários (OWASP,
2016).
Stallings (2014) destaca que a principal técnica de segurança utilizada para garantir a
confidencialidade das mensagens trocadas entre qualquer tipo de sistemas é a criptografia.
Sistemas que não fazem uso da criptografia, ou a aplicam de maneira incorreta, estão
sujeitas à interceptação de dados, como por exemplo, através do uso de um analisador de
protocolos (também conhecido como sniffer), permitindo também que os dados sejam
adulterados através de ataques de modificação e fabricação.

- M4 - Autenticação Insegura (Insecure Authentication)

A Autenticação Insegura ocorre sempre que há uma falha de autenticação do usuário

ou no gerenciamento de uma sessão, como não identificar corretamente o usuário quando é
necessário, a aplicação falha ao manter a identificação do usuário durante uma sessão ou a
aplicação possui outros erros na gestão da sessão (OWASP, 2016).
Segundo Uto (2013), um erro de autenticação é uma fraqueza que permite que o
atacante, sem o conhecimento prévio de uma senha, consiga ser reconhecido como um
usuário legítimo, como exemplo uma tela de autenticação vulnerável a injeção de SQL, e uma
falha no gerenciamento da sessão ocorre pelo tratamento inseguro dos identificadores de uma
sessão em algum momento do seu ciclo de vida, o que possibilita um acesso não autorizado a
funcionalidades e a informações, como exemplo o uso de números seqüenciais para os
identificadores de uma sessão.

- M5 - Criptografia Insuficiente (Insufficient Cryptography)

A The H Security (2012), abordou problemas ocorridos na criptografia de aplicativos

Android. Segundo os pesquisadores 41 dos 100 aplicativos testados tiveram implementação
 43

falha e insegura do protocolo de criptografia SSL/TLS, onde conseguiram recolher dados

bancários e de cartões de crédito dos usuários, além de tokens de acesso para suas contas
Facebook, Twitter, email e serviços de mensagens.
Em seus testes realizaram ataques man-in-the-middle com o intuito de sobrepor a
criptografia das conexões, ao constatar nos exames dos aplicativos que apresentavam sinais
que poderiam conferir de forma insuficiente os certificados que verificam a identidade do
parceiro de comunicação, onde 20 desses aplicativos aceitaram qualquer certificado e os
outros 21 aceitaram certificados validos mas não conferiram e o certificado foi emitido de
forma correta. Os aplicativos afetados testados foram escolhidos por sua popularidade,
chegando a apresentar de 39,5 e 180 milhões de downloads.
A Criptografia Insuficiente aborda situações, como essa, que é necessário o uso da
criptografia e que não foram abordados nos casos anteriores, M2 - Armazenamento de Dados
Inseguro e M3 - Comunicação Insegura, de forma que houve um cuidado do desenvolvedor
ao proteger uma informação sensível, mas a criptografia adotada foi ineficaz (OWASP,
2016).

- M6 - Autorização Insegura (Insecure Authorization)

A OWASP (2016) afirma que a Autorização Insegura abrange qualquer falha na

autorização, ou seja, quando a aplicação não autentica os usuários nos momentos que é
necessário, como a concessão de acesso anônimo a algum recurso ou serviço, diferente da M4
- Autenticação Insegura que autentica de forma ineficaz, ou quando é fácil o atacante burlar
como no caso de decisões de autorização no lado do cliente.
Segundo Uto (2013), algumas vulnerabilidades permitem que um usuário consiga
acessar dados ou funções que não possua privilégios, e exemplifica como no caso de um
sistema que esconde os menus de acordo com os níveis de permissão, mas não valida
requisições quando realizadas.
A Cielo (2013) chama a atenção a essa necessidade do exemplo anterior de
desenvolver permissões de acesso em cada funcionalidade e não somente nos menus, em seu
guia de boas praticas de segurança para e-commerce.
 44

- M7 - Qualidade de Código Cliente (Client Code Quality)

A Qualidade de Código Cliente engloba os problemas de codificação no lado do

servidor, o que podem causar problemas também na execução do código no lado do cliente
móvel. São vulnerabilidades como estouros de buffer, vulnerabilidades nas strings e outros
erros de código onde é possível se reescrever o código em tempo de execução (OWASP,
2016).
Segundo Singh e Tere (2016), essa vulnerabilidade está ligada a decisões de segurança
por fontes não confiáveis, o que facilita a possibilidade de exploração do atacante, podendo
ser usado para ganho de privilegio, dando permissões superiores ao atacante, e até mesmo
sobrepor os mecanismos de segurança aplicados a aplicação, levando a perda de sigilo e sua
integridade.

- M8 - Adulteração de Código (Code Tampering)

A Adulteração de Código ocorre através da modificação do recurso local, modificação

da memória dinâmica e outros casos, pois quando o aplicativo é instalado em um dispositivo,
seus recursos de códigos e dados ficam no dispositivo, onde o atacante pode modificar
diretamente o código, substituir APIs que o sistema utiliza alterar o conteúdo da memória ou
modificar os recursos do aplicativo. Dessa forma o atacante pode alterar o funcionamento do
aplicativo de forma que consiga tirar a vantagem desejada (OWASP, 2016).

- M9 - Engenharia Reversa (Reverse Engineering)

Arxan (2014) afirma partir da pesquisa que efetuaram e de relatórios dos principais
especialistas da indústria que aplicações são vulneráveis a engenharia reversa, reengenharia e
republicação tornando com isso armas maliciosas e por isso as empresas devem adotar
medidas preventivas.
A Engenharia Reversa acontece algumas vezes antes dos ataques, onde é feita uma
análise do binário para pesquisar no código fonte, bibliotecas, algoritmos e outros ativos atrás
de informações, como dados do servidor e ou constantes de criptografia, que podem ser
usadas para explorar outras vulnerabilidades. Podem ser usadas ferramentas de inspeção de
binários a facilitar essa inspeção e reverter o código (OWASP, 2016).
 45

HP (2013) revelou em pesquisa que 97 por cento das aplicações móveis testadas
possuíam alguma fonte de informação privada em fácil acesso e que 86 por cento não tinham
medidas de segurança para proteger essas informações dos mais comuns exploits.
Arxan (2014) ratifica, em sua pesquisa, os dados apresentados pela HP no ano
anterior, informando que na maioria dos aplicativos móveis avaliados os dados estáticos
estavam com informações sensíveis expostas, como senhas, nomes de usuários,
identificadores de contas e chaves criptográficas, o que pode facilitar a ação de atacantes e
que 25% das aplicações testadas algumas das mais básicas medidas de segurança não eram
tomadas.

- M10 - Funcionalidade Estranha (Extraneous Functionality)

A Funcionalidade Estranha ocorre, pois muitas vezes durante o período de

desenvolvimento os desenvolvedores adicionam funcionalidades ocultas ou outros controles
internos, como um comentário com senha ou até mesmo alguma função que desativa a
autenticação, que não se destinam ao ambiente de produção e que acabam não sendo
removidos posteriormente (OWASP, 2016).
Não é incomum que sejam apenas comentados, e não excluídos, os códigos que não
serão usados no programa, códigos usados para facilitar na programação e teste ou até mesmo
sejam mantidos códigos que podem ser acessados por pessoas que tenham o conhecimento
deles, também conhecidos com easter eggs. Temos como exemplos, modos de burlar a
autenticação ou até mesmo comentários com as senhas e usuários para o teste, isso por
acreditar que somente os programadores da empresa irão ter acesso ao código.
Porém em conjunto com a Engenharia Reversa, outras técnicas ou até mesmo por
força bruta, tentativa e erro, alguns atacantes conseguem ler esses comentários ou acessar as
funções ocultas, tendo acesso a informações privilegiadas, ou idéias de como burlar o sistema.

Scanner de Vulnerabilidade (Vulnerability Scanner)

Segundo OWASP (2014) scanners de vulnerabilidades são ferramentas que fazem

varredura em aplicações para buscar vulnerabilidades de segurança conhecidas, como cross-
site scripting, injeção de SQL, execução de comandos, passagem de diretório e configuração
 46

do servidor inseguro. Existe uma grande quantidade de ferramentas disponíveis, comerciais e

open source, cada uma com suas forças e fraquezas.
São exemplos dessas ferramentas, o Nikto5 para aplicações web e o QARK6, Quick
Android Review Kit, e o AndroBugs7 para Android. Para este projeto foram utilizados os
Scanners QARK e AndroBugs, por tratarem aplicações Android.

Trabalhos Correlatos

Jin et. al (2014) desenvolveram e documentaram testes em aplicações web móvel

usando o PhoneGap como middleware para sua execução na plataforma Android, tendo foco
no ataque XSS, uma vulnerabilidade na tecnologia usada para sistemas e sites web, onde
pesquisam também diversas formas de injetar esses códigos maliciosos (Code Injection),
como através de leitor de códigos de barras 2D (Two-Dimensional), mensagens SMS (Short
Message Service), meta tags de arquivos MP3 (Moving Picture Experts Group Audio Layer-
3) e MP4 (Moving Picture Experts Group-4 Part 14), campos de identificação de dispositivos
Bluetooth e Wi-Fi access points.
Além de demonstrarem os ataques através de exemplos de aplicações, foram
pesquisadas vulnerabilidades em aplicativos reais e em 186 plugins PhoneGap que são
distribuídos gratuitamente e 16 integrados na própria biblioteca base, estando presente em
todos os dispositivos que usam esse middleware, tendo como resultado nessa etapa a
descoberta de 11 plugins vulneráveis. Assim como duas aplicações web móveis reais
vulneráveis aos ataques.
Ressaltaram também que esse ataque chega a ser mais prejudicial nos aplicativos
móveis, pois os aplicativos têm diversas permissões de manipular o dispositivo o que em
aplicações web estão limitadas ao servidor que é um canal de dados não confiável para
alcançar outras vítimas. Já no dispositivo móvel ele está ligado ao mundo exterior, permitindo
ataques de outros dispositivos, não necessariamente um dispositivo móvel.

5
https://cirt.net/Nikto2
6
https://github.com/linkedin/qark
7
http://www.androbugs.com/
 47

Em seu projeto, Almeida (2013) abordou vulnerabilidades da plataforma Android,

pesquisando as ameaças à segurança existentes na rede e as principais ameaças da plataforma,
apresentando e testando ferramentas de segurança.
Nos testes utilizando aplicativo, foi usada a técnica de engenharia reversa, através da
ferramenta Java Decompiler, que além de ser utilizada para atualizar sistemas antigos, pode
ser também utilizada por pessoas mal-intencionadas, com a finalidade de inserir códigos
maliciosos em aplicativos prontos disponíveis na Play Store do Google e disponibilizar
novamente em outros sites gratuitamente.
Nesse teste o intuito foi verificar se as ferramentas de segurança possuem algum
tratamento dos aplicativos sem a assinatura da Play Store. Como resultado encontrou 4
antivírus que detectaram, em 1 desses casos chegando a desinstalar automaticamente o
aplicativo, e 2 antivírus que não detectaram a alteração no código.
Ribeiro (2013) abordou as principais vulnerabilidades em sistemas web, onde
escolheu as 5 primeiras apontadas pelo Top Ten de 2010 da OWASP definindo em seguida
scanners de vulnerabilidade e ferramentas de automação de testes de penetração que foram
utilizadas, tanto para procurar e explorar as vulnerabilidades quanto para atestar a sua
ausência, conforme relação ilustrada no Tabela 6:

Tabela 6 - Vulnerabilidades x Ferramentas Detecção e Exploração

Fonte: Ribeiro (2013)

Na execução dos testes realizados, Ribeiro utilizou uma adaptação dos sete passos
descritos na 3ª versão do guia OSSTMM (Open Source Security Testing Methodology
Manual), sendo removida uma etapa por não se aplicar aos sistemas web. Dessa forma foram
definidas quais vulnerabilidades proteger, foram utilizados os protocolos de internet HTTP ou
 48

HTTPS nas interações e acessos às aplicações, os testes foram divididos em pequenas etapas,
foram escolhidos os scanners de vulnerabilidade a serem utilizados, foram determinadas quais
informações seriam extraídas com os testes e por fim foi assegurado que os testes não
desrespeitassem as leis vigentes uma vez que foram realizados em um ambiente controlado.
Como resultado, o autor conseguiu reproduzir todas as vulnerabilidades propostas e
foram apresentadas formas de tratamento da seguinte forma:

1. Injection a utilização das consultas SQL foram parametrizadas;

2. Cross-Site Scripting, após desabilitar a proteção automática que o framework .NET
4.5 possui, todas as entradas de dados passaram a ser validadas no código para
evitar a passagem de possíveis códigos maliciosos;
3. Broken Authentication and Session Management os dados sensíveis no lado do
cliente foram minimizados e os que permaneceram foram criptografados;
4. Insecure Direct Object References foi tratado também ocultando dados sensíveis,
criptografando os remanescentes e as buscas SQL passaram a ter um segundo
parâmetro, como o e-mail, além do identificador único do registro buscado;
5. Cross-Site Request Forgery foi utilizada uma técnica chamada Anti-Forgery Token
onde é salvo um cookie de valor único no lado cliente que é armazenado também
em um campo oculto do formulário a ser enviado que são comparados, gerando um
erro e a interrupção da requisição caso a comparação tenha um retorno negativo.

Da mesma forma que os trabalhos aqui apresentados, este trabalho teve como intuito
explorar vulnerabilidades em aplicações de forma manual e através de ferramentas que
automatizam o processo. Porém, ao invés dos testes ocorrerem em sistemas e aplicações
preparados para reproduzir vulnerabilidades, foi criada uma aplicação web móvel, compilada
com o uso do PhoneGap para a plataforma Android, como se fosse ser utilizada
comercialmente, sem a preocupação de reproduzir ou tratar as vulnerabilidades estudadas.
Após sua criação ela foi submetida a testes, de forma que foram coletadas vulnerabilidades e
foram pesquisadas formas de amenizar esses riscos, através de configurações do PhoneGap e
de intervenção do programador no código.
 49

Metodologia

Uma vez definidos os conceitos de aplicações web móveis, apresentado o PhoneGap,

os conceitos sobre segurança e pesquisadas as 20 principais vulnerabilidades web e móvel,
este capítulo apresenta a descrição da aplicação submetida aos scanners e a execução dos
testes. As etapas seguem descritas na Figura 10, apresentada abaixo:

Figura 10 - Etapas do Teste

Fonte: Elaboração do Autor

Aplicativo de Teste

Durante a execução dos testes foi utilizada uma aplicação web móvel8, compilada com
o PhoneGap para a plataforma Android, criada sem abordar os conceitos de segurança e que
contempla a parte de login, cadastro e edição dos dados do usuário. Etapas as quais estão
presentes na maior parte das aplicações disponíveis no mercado e que podem ser portas de
entrada para a realização de ataques.
Esse cadastro é exibido na própria aplicação e em um sistema web, onde os dados são
sincronizados através de um WebService. Deste modo, os dados permanecem salvos na
aplicação móvel em um banco local, o qual pode ser apagado através do logout, e no servidor
para sua persistência. Assim, os dados podem ser resgatados para a aplicação móvel através

8
https://github.com/ronipaschoal/tcc_1410
 50

do login ou serem conferidos através de uma página web em PHP. Na Figura 11 é possível
ver a estrutura dos bancos de dados, presente na aplicação e no servidor.

Figura 11 - Estrutura dos Dados

Fonte: Elaboração do Autor

Aplicação Web Móvel

A aplicação web móvel é uma aplicação single page, onde todas as telas são
renderizadas na mesma página HTML através de funções em JavaScript. Ela foi desenvolvida
com o uso de HTML, CSS, JavaScript (jQuery), um banco local em SQLite e compilada com
o uso do framework PhoneGap. Na Figura 12, exibida abaixo, é possível ver as telas do
aplicativo.

Figura 12 - Telas do Aplicativo de Teste

Fonte: Elaboração do Autor

 51

Tela Principal

A Tela Principal é a primeira tela que aparece ao abrir o aplicativo, onde estão
disponíveis dois links, o “logar” que direciona para a Tela de Login e o “cadastrar” que
direciona para a Tela de Cadastro.

Tela de Login

A Tela de Login apresenta um formulário onde é possível preencher o usuário e senha

e solicitar o acesso através do botão “Logar”. A partir do referido comando, o aplicativo
acessa um WebService que verifica se os dados do usuário conferem com os presentes no
banco de dados do servidor. Caso estejam corretos, são retornados todos os dados referentes
ao usuário logado para serem salvos no banco de dados local, além de exibir um alerta de
boas vindas contendo o nome do usuário e redirecionar o usuário para a Tela Home. Caso os
dados estejam incorretos, o sistema apresenta um alerta contendo uma mensagem de erro (é
possível inserir as imagens das mensagens de erro e boas vindas). Nessa tela possui também o
link “Cadastrar” pelo qual é possível acessar a Tela de Cadastro.

Tela de Cadastro

A Tela de Cadastro possui um formulário onde o usuário pode preencher seus dados.
Após o preenchimento, a solicitação de cadastro é realizada através do botão “Cadastrar”,
gerando um acesso ao WebService para salvar os dados no banco de dados do servidor e ao
mesmo tempo no banco de dados local. O usuário recém cadastrado é logado no sistema e
redirecionado para a Tela Home. Nessa tela possui também o link “Voltar” pelo qual o
aplicativo retorna a Tela Principal.

Tela Home

A Tela Home apresenta os dados do usuário salvos no banco de dados local e dois
links, o “Atualizar” que redireciona para a Tela de Edição; e o “Logout” que apaga os dados
do banco local e retorna à Tela Principal.
 52

Tela de Edição

A Tela de Edição apresenta um formulário com os dados do usuário, tornando possível

ao usuário alterá-los. Ao utilizar o botão “Atualizar”, são alterados quaisquer dados presentes
no banco de dados do servidor e, conseqüentemente, replicando as alterações para o banco de
dados local, para em seguida, redirecionar para a Tela Home. Possui também o link “Voltar”
que redireciona para a Tela Home.

Estrutura Online de Gerenciamento do Aplicativo

O intuito da estrutura de gerenciamento do aplicativo, que contempla um WebService

e uma tela web, é verificar se as brechas presentes na aplicação podem repercutir na estrutura
presente em um servidor ou se são limitadas ao próprio aplicativo. Ambas se encontram
presentes em um subdomínio de um servidor web.

WebService

O WebService não possui uma interface visual e foi construído com o uso de PHP e
um banco de dados no servidor em MySql. As funções presentes nele contemplam o login, o
cadastro e a edição dos dados que seguem descritas abaixo.

Login

O login recebe um post com as informações preenchidas na Tela de Login, contendo o

email e senha do usuário, realiza com essa informação uma verificação no banco de dados e
retorna em uma estrutura em Json que contem todos os dados do usuário encontrado.

Cadastro

O cadastro recebe um post contendo as informações preenchidas na Tela de Cadastro,

que são o nome, o e-mail, a senha e o telefone, os salva no banco de dados local e retorna o id
do usuário cadastrado para que a aplicação possa salvar no banco local.
 53

Edição dos Dados

A edição dos dados recebe um post contendo as informações preenchidas na Tela de

Edição, que são o nome, o e-mail, a senha e o telefone, junto com o id do usuário que se
encontra logado no aplicativo web móvel, e os salva no banco de dados local no registro
referente ao id, retornando o status da requisição.

Pagina Web

A página web é uma pagina para o uso de um gestor onde são exibidos os dados dos
associados cadastrados. Ela foi construída com o uso de HTML, CSS, PHP e faz acesso ao
banco de dados do servidor. Na Figura 13 é possível ver a única tela disponível na web, onde
são exibidos os dados dos usuários cadastrados.

Figura 13 - Tela Web de Exibição dos Dados

Fonte: Elaboração do Autor

Testes Manuais
Nesta etapa foram executados alguns testes manuais baseados na lista da OWASP e
nos trabalhos correlatos estudados no capitulo anterior, com o intuito de verificar alguns casos
específicos. Estes testes seguem descritos nos tópicos seguintes.

Injeção de Código (Injection)

A Injeção de Código foi testada durante o cadastro ao adicionar um código JavaScript,

que exibe um alerta, no campo referente ao nome. Dessa forma foi possível verificar se o
 54

aplicativo interpreta esse código ao renderizar a página inicial onde são exibidos os dados do
usuário. Na figura 14 é possível visualizar o ataque sendo realizado.

Figura 14 - Teste de Injeção de Código

Fonte: Elaboração do Autor

A primeira imagem ocorre logo após o usuário se logar, onde é apresentada a

mensagem de boas vindas. Nela é possível ver o código JavaScript que foi usado para o teste.
Já a segunda imagem é o resultado da execução do código malicioso que foi executado pelo
aplicativo.

Scripting de Site Cruzado (Cross-Site Scripting)

O Scripting de Site Cruzado foi testado de forma parecida com a Injeção de Código,
porém, o código JavaScript inserido durante o cadastro era uma chamada a um código
JavaScript disponibilizado em um subdomínio do servidor onde estavam hospedados os
WebServices. Na figura 15 é possível visualizar o ataque sendo realizado.

Figura 15 - Teste de Cross-Site Scripting

Fonte: Elaboração do Autor

A primeira imagem ocorre logo após o usuário se logar, onde é apresentada a

mensagem de boas vindas. Nela é possível ver o código JavaScript que aponta ao servidor
 55

onde o código malicioso está armazenado. Já a segunda imagem é o resultado da execução do

código malicioso que foi requisitado ao servidor do atacante e executado pelo aplicativo.

Engenharia Reversa (Reverse Engineering)

A Engenharia Reversa foi facilmente reproduzida efetuando o download do o arquivo

.APK no site do PhoneGap e abrindo em uma simples ferramenta de descompactação de
arquivos, neste caso o 7-Zip9. Na Figura 16 é possível visualizar a tela do 7-Zip exibindo a
estrutura da aplicação.

Figura 16 - Teste de Engenharia Reversa

Fonte: Elaboração do Autor

Almeida (2013) apresenta em sua pesquisa, citada como um dos trabalhos correlatos,
uma ferramenta que pode ser usada para fazer o Backup dos aplicativos Android. Com o uso
dessa ferramenta o atacante pode ter acesso ao mesmo arquivo .APK usado nessa etapa,
mesmo tendo instalado o aplicativo através do Google Play10.

9
http://www.7-zip.org/
10
https://play.google.com/store?hl=pt_BR
 56

Funcionalidade Estranha (Extraneous Functionality)

A Funcionalidade Estranha foi reproduzida em conjunto com a Engenharia Reversa,

explorando o código resultante na etapa anterior, onde foi possível acessar aos arquivos do
aplicativo em texto plano e visualizar comentários no código que foram deixados durante a
execução do projeto. Na figura 17 é possível visualizar parte do código que apresenta
informações úteis a um atacante.

Figura 17 - Teste de Funcionalidade Estranha

Fonte: Elaboração do Autor

Execução dos Scanners de Vulnerabilidade

Nesta etapa foram executados os scanners de vulnerabilidade, com o intuito de

levantar brechas existentes nessa aplicação, que não são tratadas ao gerar o aplicativo nem
pelo uso do PhoneGap. Nessa etapa foram utilizadas duas ferramentas, o QARK e o
AndroBugs, e a utilização dessas ferramentas seguem descritas nos próximos tópicos.
 57

QARK

Para utilizar o QARK, foi efetuado o Download no site e executado através do

terminal do Kali Linux, usando o Python e passando como um dos parâmetros o caminho do
aplicativo de teste criado. Na Figura 18, abaixo, é possível ver a tela inicial do QARK.

Figura 18 - Tela inicial do Scanner QARK

Fonte: Elaboração do Autor

No fim da sua execução o QARK gera um relatório em HTML onde ficam registradas
as vulnerabilidades encontradas e em alguns casos uma breve descrição. Na Figura 19,
apresentada a seguir, é possível visualizar o relatório gerado pela ferramenta.

Figura 19 - Interface do relatório do Scanner QARK

Fonte: Elaboração do Autor

 58

AndroBugs

O AndroBugs possui uma versão para Windows que deve ser executada pelo prompt
de comando, passando parâmetros, tal como o “-f” e o caminho do aplicativo. Uma lista dos
parâmetros permitidos pode ser encontrada através do -h. Na Figura 20, é possível visualizar
execução da ferramenta através do prompt de comando.

Figura 20 - Execução do AndroBugs

Fonte: Elaboração do Autor

No fim de sua execução o AndroBugs gera um relatório contendo o resultado da

varredura, porém diferente do QARK seu relatório é um arquivo de texto, também com uma
breve descrição em cada resultado. Na Figura 21 é possível visualizar parte do relatório.

Figura 21 - Interface do relatório do Scanner Androbugs

Fonte: Elaboração do Autor

 59

Pesquisa de Soluções

Após a execução dos testes manuais e dos automatizados, foram pesquisadas formas
de tratar ou minimizar algumas vulnerabilidades encontradas. Essas pesquisas foram divididas
em duas etapas, a alteração das configurações do PhoneGap e alterações no código do
aplicativo.

Alteração das Configurações do PhoneGap

A primeira ação tomada foi verificar se o próprio middleware usado na criação da
aplicação, o PhoneGap, possui configurações que podem ser adicionadas ou alteradas, para
tratar algumas das vulnerabilidades ou minimizar os impactos de um ataque. Na Figura 22 é
possível visualizar o XML de configuração do PhoneGap.

Figura 22 - XML de Configuração do PhoneGap

Fonte: Elaboração do Autor

Alterações no Código
Após a verificação das configurações do PhoneGap, foram pesquisadas alterações no
código e o uso de outras ferramentas com o intuito de tratar vulnerabilidades ou dificultar a
ação do atacante.
60
 61

Resultados

Após os testes serem realizados, neste capítulo constam os resultados obtidos e

propostas de correções de algumas vulnerabilidades encontradas.

Testes Manuais
Nos tópicos a seguir seguem descritos os resultados obtidos a partir dos testes
manuais, assim como a forma utilizada em seu tratamento.

Injeção de Código
A Injeção de Código foi reproduzida com sucesso nos testes manuais, de forma que
além de afetar o aplicativo, chegou a afetar o sistema online que exibe os dados dos usuários.
Dessa forma foi possível verificar que, além da aplicação estar vulnerável a esse ataque, ela
também é uma porta de entrada que o atacante pode utilizar para chegar ao sistema web.
Essa vulnerabilidade foi tratada com a remoção das tags HTML nas funções
responsáveis pelo cadastro e alteração dos dados do associado, assim como no recebimento de
qualquer dado enviado ao WebService. Na Figura 23 é possível visualizar a remoção das tags
HTML através da aplicação.

Figura 23 - Remoção das Tags HTML usando JavaScript

Fonte: Elaboração do Autor

A expressão regular passada na função replace substitui todas as tags HTML por uma
string vazia. Na Figura 24 é possível visualizar a remoção das tags HTML através do
servidor.

Figura 24 - Remoção das Tags HTML usando PHP

Fonte: Elaboração do Autor

 62

Dessa forma, quando o atacante tenta inserir um script malicioso, o aplicativo e o

WebService salvam apenas o conteúdo, não salvando a tag script que é responsável pela
execução conteúdo.

Scripting de Site Cruzado (Cross-Site Scripting)

Assim como na Injeção de Código, o Scripting de Site Cruzado conseguiu ser

reproduzido, tanto no aplicativo quanto no sistema web. O tratamento da vulnerabilidade
anterior também impossibilitou a passagem dos caminhos do script externo pelo atacante.
Além da remoção das tags, também foi alterada uma configuração referente ao plugin
responsável pelo controle das requisições externas. Na Figura 25 é possível verificar este
plugin no XML do PhoneGap.

Figura 25 - Chamada do Plugin Whitelist do PhoneGap

Fonte: Elaboração do Autor

Na Figura 26 é possível verificar a configuração original dele ao gerar um novo

aplicativo utilizando o PhoneGap.

Figura 26 - Configuração do Whitelist com Permissão Total

Fonte: Elaboração do Autor

O campo access origin é responsável pela configuração dos scripts externos aceitos
pela aplicação e vem definido o valor “*” por padrão, o que permite a execução de qualquer
script externo. Ao alterar este valor para o endereço do WebService contido no servidor, que
está no subdomínio associates, a aplicação passa a aceitar somente o endereço configurado.
 63

Na Figura 27 é possível verificar a configuração alterada para informar que o script externo
confiável é apenas o do WebService.

Figura 27 - Configuração do Whitelist com Permissão Apenas para o WebService

Fonte: Elaboração do Autor

Como cada subdomínio é tratado como um domínio distinto foi possível testar esta
correção utilizando um script malicioso contido no subdomínio attacker, que passou a ser
bloqueado pela aplicação.
Os demais campos, allow-intent, são responsáveis pela permissão de acesso a links
externos através de ancoras a, como a função mailto ou redirecionar a outra pagina web, e
nesse caso não foram alterados para permitir que o aplicativo acesse links externos.

Engenharia Reversa (Reverse Engineering)

No caso da engenharia reversa, o Aplicativo compilado com o uso da ferramenta
PhoneGap foi descompactado da mesma forma que um arquivo compactado no formato .zip,
sem a necessidade de uma ferramenta própria de engenharia reversa. Assim, seu código pôde
ser lido, uma vez que foi exibido com as estruturas das pastas, os arquivos de configuração,
CSS, JavaScripts e HTML, tudo em texto plano.
Para dificultar a ação do atacante foi usado o Javascript Obfuscator11, um ofuscador
de código, com o intuito de deixar o código ilegível. Na figura 40 é possível ver o código
original e ofuscado.

Figura 28 - Código Original e Ofuscado

Fonte: Elaboração do Autor

11
http://www.javascriptobfuscator.com/Javascript-Obfuscator.aspx
 64

Funcionalidade Estranha

Ao utilizar o ofuscador de código, dificultou-se a leitura do código como um todo,

assim como os comentários presentes. Mesmo assim é importante remover todos os códigos
que não são necessários a aplicação, mesmo que não possam ser acessados normalmente.

Scanners de Vulnerabilidade

Cada Scanner gerou relatórios bem distintos, que seguem em anexo no apêndice deste
documento. Na Tabela 7 é possível visualizar a quantidade de alertas agrupados por tipo
encontrados pelo QARK.

Tabela 7 - Quantidade de Vulnerabilidades Encontradas no QARK

Tipo do Alerta Quantidade
Vulnerabilidade Potencial 1
Avisos 1
Informativo 2
Erros de Análise 25

Fonte: Elaboração do Autor

Além dos alertas, o QARK exibe o AndroidManifest da aplicação que pode ser
visualizado na Figura 29.

Figura 29 - Manifest da Aplicação

Fonte: Elaboração do Autor

 65

No manifest é possível observar que foram adicionadas por padrão diversas

permissões a aplicação que não são necessárias para o propósito dela, e que podem ser usadas
pelos atacantes para causar maiores danos ao usar o aplicativo em um ataque. Isso se deve aos
plugins que vem como padrão no XML de configuração do PhoneGap.
Para o propósito da aplicação, foi mantido apenas um plugin do PhoneGap, o cordova-
plugin-whitelist, que é responsável pelo gerenciamento dos acessos externos e que foi citado
no Capitulo 4. Dessa forma as permissões solicitadas pela aplicação foram minimizadas a
apenas duas, a de acesso a internet e a de acesso ao status da rede, como pode ser visto na
Figura 30.

Figura 30 - Manifest da Aplicação Após as Remoções dos Plugins

Fonte: Elaboração do Autor

Na Tabela 8 é possível visualizar a quantidade de alertas agrupados por tipo

encontradas pelo AndroBugs.

Tabela 8 - Quantidade de Vulnerabilidades Encontradas no AndroBugs

Tipo do Alerta Quantidade
Crítico 1
Avisos 1
Notícia 1
Informativo 49

Fonte: Elaboração do Autor

Nas duas ferramentas o único caso considerado crítico, ou vulnerabilidade potencial,

foi o Modo de Depuração do Android, Android Debug Mode, estar ativo na configuração do
 66

AndroidManifest. Na Figura 31 é possível visualizar o aviso da vulnerabilidade potencial

encontrada pelo QARK.

Figura 31 - Vulnerabilidade Potencial encontrada pelo QARK

Fonte: Elaboração do Autor

Segundo o QARK, manter a aplicação no modo de depuração durante a produção pode

resultar em vazamento de dados e outros problemas de segurança. Na Figura 32 é possível
visualizar o aviso crítico encontrado pelo AndroBugs.

Figura 32 - Vulnerabilidade Crítica encontrada pelo AndroBugs

Fonte: Elaboração do Autor

O AndroBugs informa que os atacantes serão capazes de capturar as mensagens de

depuração pelo Logcat12, uma ferramenta de linha de comando do Android que gera logs da
aplicação.
Como pelo PhoneGap não é possível acessar o AndroidManifest.xml, a forma
encontrada para desativar o modo debug foi assinar a aplicação utilizando uma conta de
desenvolvedor Android, de forma que foi gerada uma Keystore e utilizada ao compilar a
aplicação no PhoneGap. Na Figura 33 é possível visualizar o local onde a Keystore deve ser
adicionada.
Figura 33 - Assinado a Aplicação no PhoneGap

Fonte: Elaboração do Autor

12
https://developer.android.com/studio/command-line/logcat.html
 67

Utilizar a Keystore ao compilar chegou também a remover 18 erros de análise e 1

alerta sinalizado como Informativo do relatório do QARK. Este alerta Informativo do QARK
é referente ao uso da WebView feito pelo PhoneGap. Na Figura 34 é possível visualizar este
alerta.
Figura 34 - Informativo WebView QARK

Fonte: Elaboração do Autor

68
 69

Conclusão

Diante das pesquisas apresentadas, fica evidente que os conhecimentos em relação às

vulnerabilidades devem estar sempre atualizados, pois grande parte das brechas é decorrente
do seu desconhecimento e estão sempre presentes, como pode ser visto nos testes executados.
Além disto, algumas vulnerabilidades uma vez descobertas podem ser facilmente
minimizadas através de modificações no código, uma configuração diferenciada e até mesmo
com o uso de boas práticas no desenvolvimento.
Como os testes das vulnerabilidades foram bem sucedidos, com a configuração padrão
da ferramenta e sem uma introdução proposital das brechas, fica claro que a presença delas é
algo comum nos códigos gerados sem um conhecimento prévio e uma preocupação voltada à
segurança em sua confecção.
Além disso, por ser uma das vulnerabilidades mais conhecidas, chega a ser alarmante
o fato da Injeção de Código continuar sendo abordada pelos atacantes e continuar no primeiro
lugar da lista. Apesar de seu fácil tratamento, como demonstrado nos resultados, a quantidade
de aplicações que não tratam essa questão demonstra um despreparo dos programadores em
relação ao assunto de segurança.
Apesar de o conhecimento ser algo importante, foram encontradas na etapa dos testes
automatizados outras brechas na aplicação. Por este motivo e pelo fato de que novas
vulnerabilidades são descobertas a cada momento, os desenvolvedores devem estar sempre
cientes que os testes de segurança devem ir além das vulnerabilidades conhecidas e das
apresentadas neste documento.
Outra questão importante quando se trata de segurança, é sempre pesar os riscos
envolvidos em cada vulnerabilidade frente aos prejuízos que podem ser causados em
decorrência de sua exploração, pois apesar alguns casos serem fáceis de serem tratados,
outros são mais difíceis e o dano causado pode ter pouca ou nenhuma consequência, assim
como alguns tratamentos podem impactar pontos como desempenho e facilidade de
codificação e manutenção.
Ficou evidente também que, apesar de algumas vulnerabilidades serem tratadas
através de configurações e plugins da ferramenta PhoneGap, uma aplicação gerada dessa
forma soma as vulnerabilidades presentes em sistemas web e em aplicações móveis, sendo
necessário dessa forma ter um cuidado redobrado no momento da execução de um projeto.
 A principal dificuldade durante este projeto foi encontrar scanners gratuitos de
vulnerabilidade em aplicações Android, além do fato que os existentes não apresentam em seu
resultado algumas vulnerabilidades testadas de forma manual.
Como trabalhos futuros, seria interessante realizar testes na aplicação compilada para
a plataforma IOs, assim como em aplicações criadas com o uso das linguagens nativas, para
verificar se as vulnerabilidades existentes na a aplicação em PhoneGap compilada para
Android também se aplicam nesses outros casos.
Outro trabalho possível é utilizar diferentes ferramentas voltadas com o mesmo intuito
do PhoneGap, como o IonicFramework.
 Referências

ADOBE PHONEGAP, Build Amazing Mobile Apps Powered By Open Web Tech. Disponível
em: <http://phonegap.com/>. Acesso em 22 de maio 2016.

KOLSEK, M. ACROS Security, Session Fixation Vulnerability in Web-based Applications.

Disponível em: <http://www.acrossecurity.com/papers/session_fixation.pdf>. Acesso em
03 de outubro 2016.

ALMEIDA, J.: Análise da Segurança e de Ferramentas na Plataforma Android. IFSUL, Passo

Fundo, 2013. Disponível em: <http://painel.passofundo.ifsul.edu.br/uploads/arq/
201505221025371866507687.pdf>. Acesso em 08 de maio 2016

APACHE CORDOVA, Disponível em: <https://cordova.apache.org/>. Acesso em 26 de

Julho 2016.

ARXAN, State of Mobile App Security. Disponível em: <https://www.arxan.com/wp-

content/uploads/assets1/pdf/State_of_Mobile_App_Security_2014_final.pdf>. Acesso em 06
de junho 2016.

BAVUUDORJ, B.; TRANCIOVEANU, I. PhoneGap: Potentials of a Mobile Cross-Platform

Application. Disponível em: <https://gupea.ub.gu.se/bitstream/2077/38520/1/gupea_2077_
38520_1.pdf>. Acesso em 26 de abril 2016.

CERT, The CERT Division Research. Disponível em: <http://www.cert.org/research/index.

cfm>. Acesso em 15 de maio 2016.

CERT.br, Estatísticas dos Incidentes Reportados ao CERT.br. Disponível em: <http://www.

cert.br/stats/incidentes/>. Acesso em 15 de maio 2016.

CERT.br, Cartilha de Segurança para Internet. Disponível em: <http://cartilha.cert.br/>.

Acesso em 07 de Junho 2016.

CWE, CWE-79: Improper Neutralization of Input During Web Page Generation ('Cross-site
Scripting'). Disponível em: <http://cwe.mitre.org/data/definitions/79.html>. Acesso em 05
junho 2016.

CVE Details (2016). Top 50 Vendors By Total Number Of "Distinct" Vulnerabilities.

Disponível em <https://www.cvedetails.com/top-50-vendors.php>. Acesso em 17 de junho
2016.

CIELO (2012). Guia de boas práticas de segurança para e-commerce – Cielo. Disponível em
<https://www.cielo.com.br/wps/wcm/connect/11a69252-599e-4dc9-99e7-4bd53f341c6f/
guia_de_boas_praticas.pdf?MOD=AJPERES&CONVERT_TO=url&CACHEID=11a69252-
599e-4dc9-99e7-4bd53f341c6f/>. Acesso em 22 de outubro 2016.

CISCO, Cisco Visual Networking Index: Global Mobile Data Traffic Forecast Update, 2015-
2020 White Paper. Disponível em: <http://www.cisco.com/c/en/us/solutions/collateral/
 72

service-provider/visual-networking-index-vni/mobile-white-paper-c11-520862.html>. Acesso
em 15 de maio 2016.

DICTIONARY.COM, Disponível em: <http://www.dictionary.com/>. Acesso em 26 de maio

2016.

Gartner, Gartner Says Mobile App Stores Will See Annual Downloads Reach 102 Billion in
2013. Disponível em: <http://www.gartner.com/newsroom/id/2592315>. Acesso em 29 de
maio 2016.

Gawker; Apple's Worst Security Breach: 114,000 iPad Owners Exposed. Disponível em
<http://gawker.com/5559346/apples-worst-security-breach-114000-ipad-owners-exposed/>.
Acesso em 18 de outubro 2016.

HP, HP Research Reveals Nine out of 10 Mobile Applications Vulnerable to Attack.

Disponível em: <http://www8.hp.com/us/en/hp-news/press-release.html?id=1528865#.
V1Y8SJErLIW/>. Acesso em 06 de maio 2016.

JIN, X.; LUO T., et al: Code Injection Attacks on HTML5-based Mobile Apps. arXiv, New
York, out. 2014. Disponível em: <https://arxiv.org/abs/1410.7756>. Acesso em 08 maio 2016.

OEHLMAN, D; BLANC, S. Aplicativos Web Pro Android Desenvolvimento Pro Android

Usando HTML5, CSS3 & JavaScript. Rio de Janeiro: Editora Ciência Moderna Ltda, 2012.
468p.

OSSTMM; Open Source Security Testing Methodology Manual. Disponível em:

<http://www.isecom.org/research/osstmm.html>. Acesso em 29 de maio 2016.

OWASP; The Free And Open Software Security Community. Disponível em: <https://www.
owasp.org/>. Acesso em 22 de maio 2016.

PATEL, N; MOHAMED, F; SONI, S. SQL Injection Attacks: Techniques and Protection

Mechanisms. International Journal on Computer Science and Engineering, Jan 2011.
Disponível em: <http://www.enggjournals.com/ijcse/doc/IJCSE11-03-01-139.pdf>. Acesso
em 06 de junho 2016.

PREVELAKIS, V; SPINELLIS, D. Sandboxing Applications. Disponível em: <http://www

.dmst.aueb.gr/dds/pubs/conf/2001-Freenix-Sandbox/html/sandbox32final.pdf>. Acesso em 01
junho 2016.

RIBEIRO, W. Aplicação de Boas Práticas de Segurança no Desenvolvimento de Sistemas

Web. São João da Boa Vista: Instituto Federal de São Paulo, 2013. 103p.

SINGH, N; TERE, G. Study of Security Threats and Vulnerabilities Associated With Mobile
Device. India, International Journal of Computing Experiments, 2016. Disponível em: <
http://tcsc.org.in/ijce/v01i01/p3.pdf>. Acesso em 23 de Outubro 2016.

STALLINGS, W. Criptografia e Segurança de Redes. 6ª edição. Ribeirão Preto: Pearson

Education – Br, 2014. 576p.
 73

STARK, J; JEPSON,B. Building Android Apps with HTML, CSS, and JavaScript. 2ª edição.
Sebastopol: O’Reilly Media, Inc., 2012. 159p.

TANENBAUM, A; STEEN, M. Sistemas Distribuídos: Princípios e Paradigmas. 2ª edição.

São Paulo: Pearson Prentice Hall, 2007. 403p.

The H Security: Encryption found insufficient in many Android apps. Disponível em: <http://
www.h-online.com/security/news/item/Encryption-found-insufficient-in-many-Android-apps-
1732847.html>. Acesso em 23 de outubro 2016.

TRICE, A. PhoneGap Explained Visually. In: Adobe PhoneGap. Disponível em: <http://
phonegap.com/blog/2012/05/02/phonegap-explained-visually/>. Acesso em 22 de maio 2016.

TURKOVIC, I; PhoneGap Essentials. 1ª edição. Birmingham: Packt Publishing, 2015. 156p.

Tutorialspoint; Security Testing - Insecure Direct Object References. Disponível em:

<https://www.tutorialspoint.com/security_testing/pdf/insecure_direct_object_reference.pdf/>.
Acesso em 18 outubro 2016.

UTO, N. Teste de Invasão de Aplicações Web. Disponível em: <https://pt.scribd.com/doc/

73586437/Teste-de-Invasao-de-Aplicacoes-Web> Acesso em 22 de outubro 2016.
74
 75

Apêndices
76
 77

APÊNDICE A - Relatório QARK

Seguem as telas que apresentam informações no relatório gerado pelo QARK. Na

figura 35 é possível visualizar a aba Dashboard do relatório.

Figura 35 - Menu QARK Dashboard

Fonte: Elaboração do Autor

Na figura 36 é possível visualizar a aba App Components do relatório.

Figura 36 - Menu QARK App Components

Fonte: Elaboração do Autor

 78

Na figura 37 é possível visualizar a aba Manifest do relatório.

Figura 37 - Menu QARK Manifest

Fonte: Elaboração do Autor

 79

Na figura 38 é possível visualizar a aba Web Views do relatório.

Figura 38 - Menu QARK Web Views

Fonte: Elaboração do Autor

 80

Na figura 39 é possível visualizar a aba Parsing Errors do relatório.

Figura 39 - Menu QARK Parsing Errors

Fonte: Elaboração do Autor

 81

APÊNDICE B - Relatório AndroBugs

*************************************************************************
** AndroBugs Framework - Android App Security Vulnerability Scanner **
** version: 1.0.0 **
** author: Yu-Cheng Lin (@AndroBugs, http://www.AndroBugs.com) **
** contact: androbugs.framework@gmail.com **
*************************************************************************
Platform: Android
Package Name: br.com.ronipaschoal
Package Version Name: 1.0.0
Package Version Code: 1
Min Sdk: 14
MD5 : 46e046cbd603761d41f4045fba87b67f
SHA1 : 5c09d05c0762781ddbb38da29e431c1e4963df80
SHA256: e9fc544ad208c0dcfd22f3e43521bca361ab6fd9659cd873e35c98d8a335d3e0
SHA512:
e8577304fc1d85953355064ec709260460c06023216c95e1b77767e8e02a12bb2ba84bb5bdde0
515addbb39e55afeb8f287aa9e0628f8bea6a713db79996a1b8
Analyze Signature:
6e3d6ccf7809763750bf0a95176901815eccc9799acb06145f1eeb65ce4c9163780995499a47a9
7b1f7193f92f7474a0901eacb2103503d7d37fd243cd3a4100
------------------------------------------------------------------------------------------------
[Critical] <Debug> Android Debug Mode Checking:
DEBUG mode is ON(android:debuggable="true") in AndroidManifest.xml. This is
very dangerous. The attackers will be able to sniffer
the debug messages by Logcat. Please disable the DEBUG mode if it is a released
application.
[Warning] <SSL_Security> SSL Certificate Verification Checking:
Please make sure this app has the conditions to check the validation of SSL Certificate.
If it's not properly checked, it MAY
allows self-signed, expired or mismatch CN certificates for SSL connection.
This is a critical vulnerability and allows attackers to do MITM attacks without your
knowledge.
If you are transmitting users' username or password, these sensitive information may
be leaking.
Reference:
(1)OWASP Mobile Top 10 doc:
https://www.owasp.org/index.php/Mobile_Top_10_2014-M3
(2)Android Security book: http://goo.gl/BFb65r

(3)https://www.securecoding.cert.org/confluence/pages/viewpage.action?pageId=134807561
 82

This vulnerability is much more severe than Apple's "goto fail" vulnerability:
http://goo.gl/eFlovw
Please do not try to create a "X509Certificate" and override "checkClientTrusted",
"checkServerTrusted", and "getAcceptedIssuers"
functions with blank implementation.
We strongly suggest you use the existing API instead of creating your own
X509Certificate class.
Please modify or remove these vulnerable code:
--------------------------------------------------
[Maybe Vulnerable (Please manually confirm)]
=> Lorg/apache/cordova/filetransfer/FileTransfer$3;
-> used by: Lorg/apache/cordova/filetransfer/FileTransfer;-><clinit>()V
[Notice] AndroidManifest Adb Backup Checking:
ADB Backup is ENABLED for this app (default: ENABLED). ADB Backup is a good
tool for backing up all of your files. If it's open
for this app, people who have your phone can copy all of the sensitive data for this app
in your phone (Prerequisite: 1.Unlock
phone's screen 2.Open the developer mode). The sensitive data may include lifetime
access token, username or password, etc.
Security case related to ADB Backup:
1.http://www.securityfocus.com/archive/1/530288/30/0/threaded
2.http://blog.c22.cc/advisories/cve-2013-5112-evernote-android-insecure-storage-of-
pin-data-bypass-of-pin-protection/
3.http://nelenkov.blogspot.co.uk/2012/06/unpacking-android-backups.html
Reference: http://developer.android.com/guide/topics/manifest/application-
element.html#allowbackup
[Info] <Command> Runtime Command Checking:
This app is not using critical function 'Runtime.getRuntime().exec("...")'.
[Info] <Command> Executing "root" or System Privilege Checking:
Did not find codes checking "root" permission(su) or getting system permission (It's
still possible we did not find out).
[Info] <Database> SQLiteDatabase Transaction Deprecated Checking:
Ignore checking "SQLiteDatabase:beginTransactionNonExclusive" because your set
minSdk >= 11.
[Info] <Database> Android SQLite Databases Encryption (SQLite Encryption Extension
(SEE)):
This app is "NOT" using SQLite Encryption Extension (SEE) on Android
(http://www.sqlite.org/android) to encrypt or decrpyt
databases.
[Info] <Database> Android SQLite Databases Encryption (SQLCipher):
This app is "NOT" using SQLCipher(http://sqlcipher.net/) to encrypt or decrpyt
databases.
[Info] <Database><#CVE-2011-3901#> Android SQLite Databases Vulnerability Checking:
 83

This app is "NOT" using Android SQLite databases.

[Info] Dynamic Code Loading:
No dynamic code loading(DexClassLoader) found.
[Info] External Storage Accessing:
External storage access not found.
[Info] File Unsafe Delete Checking:
Did not detect that you are unsafely deleting files.
[Info] <#BID 64208, CVE-2013-6271#> Fragment Vulnerability Checking:
Did not detect the vulnerability of "Fragment" dynamically loading into
"PreferenceActivity" or "SherlockPreferenceActivity"
[Info] <Framework> Framework - MonoDroid:
This app is NOT using MonoDroid Framework (http://xamarin.com/android).
[Info] <Hacker> Base64 String Encryption:
No encoded Base64 String or Urls found.
[Info] <Database><Hacker> Key for Android SQLite Databases Encryption:
Did not find using the symmetric key(PRAGMA key) to encrypt the SQLite databases
(It's still possible that it might use but we
did not find out).
[Info] <Debug><Hacker> Codes for Checking Android Debug Mode:
Did not detect codes for checking "ApplicationInfo.FLAG_DEBUGGABLE" in
AndroidManifest.xml.
[Info] <Hacker> APK Installing Source Checking:
Did not detect this app checks for APK installer sources.
[Info] <KeyStore><Hacker> KeyStore File Location:
Did not find any possible BKS keystores or certificate keystore file (Notice: It does not
mean this app does not use keysotre):
[Info] <KeyStore><Hacker> KeyStore Protection Checking:
Ignore checking KeyStore protected by password or not because you're not using
KeyStore.
[Info] <Hacker> Code Setting Preventing Screenshot Capturing:
Did not detect this app has code setting preventing screenshot capturing.
[Info] <Signature><Hacker> Getting Signature Code Checking:
Did not detect this app is checking the signature in the code.
[Info] HttpURLConnection Android Bug Checking:
Ignore checking "http.keepAlive" because you're not using "HttpURLConnection" and
min_Sdk > 8.
[Info] <KeyStore> KeyStore Type Checking:
KeyStore 'BKS' type check OK
[Info] Google Cloud Messaging Suggestion:
Nothing to suggest.
[Info] <#CVE-2013-4787#> Master Key Type I Vulnerability:
No Master Key Type I Vulnerability in this APK.
[Info] App Sandbox Permission Checking:
 84

No security issues "MODE_WORLD_READABLE" or

"MODE_WORLD_WRITEABLE" found on 'openOrCreateDatabase' or
'openOrCreateDatabase2' or
'getDir' or 'getSharedPreferences' or 'openFileOutput'
[Info] Native Library Loading Checking:
No native library loaded.
[Info] AndroidManifest Dangerous ProtectionLevel of Permission Checking:
No "dangerous" protection level customized permission found (AndroidManifest.xml).
[Info] AndroidManifest Exported Components Checking:
No exported components(except for Launcher) for receiving Android or outside
applications' actions (AndroidManifest.xml).
[Info] AndroidManifest PermissionGroup Checking:
PermissionGroup in permission tag of AndroidManifest sets correctly.
[Info] <Implicit_Intent> Implicit Service Checking:
No dangerous implicit service.
[Info] AndroidManifest "intent-filter" Settings Checking:
"intent-filter" of AndroidManifest.xml check OK.
[Info] AndroidManifest Normal ProtectionLevel of Permission Checking:
No default or "normal" protection level customized permission found
(AndroidManifest.xml).
[Info] <#CVE-2013-6272#> AndroidManifest Exported Lost Prefix Checking:
No exported components that forgot to add "android:" prefix.
[Info] AndroidManifest ContentProvider Exported Checking:
No exported "ContentProvider" found (AndroidManifest.xml).
[Info] <Sensitive_Information> Getting IMEI and Device ID:
Did not detect this app is getting the "device id(IMEI)" by
"TelephonyManager.getDeviceId()" approach.
[Info] <Sensitive_Information> Getting ANDROID_ID:
Did not detect this app is getting the 64-bit number "Settings.Secure.ANDROID_ID".
[Info] Codes for Sending SMS:
Did not detect this app has code for sending SMS messages (sendDataMessage,
sendMultipartTextMessage or sendTextMessage).
[Info] <System> AndroidManifest sharedUserId Checking:
This app does not use "android.uid.system" sharedUserId.
[Info] <SSL_Security> SSL Implementation Checking (Verifying Host Name in Custom
Classes):
Self-defined HOSTNAME VERIFIER checking OK.
[Info] <SSL_Security> SSL Implementation Checking (Verifying Host Name in Fields):
Critical vulnerability "ALLOW_ALL_HOSTNAME_VERIFIER" field setting or
"AllowAllHostnameVerifier" class instance not found.
[Info] <SSL_Security> SSL Implementation Checking (Insecure component):
Did not detect SSLSocketFactory by insecure method "getInsecure".
[Info] <SSL_Security> SSL Implementation Checking (HttpHost):
 85

DEFAULT_SCHEME_NAME for HttpHost check: OK

[Info] <SSL_Security> SSL Connection Checking:
Did not discover urls that are not under SSL (Notice: if you encrypt the url string, we
can not discover that).
[Info] <SSL_Security> SSL Implementation Checking (WebViewClient for WebView):
Did not detect critical usage of "WebViewClient"(MITM Vulnerability).
[Info] Unnecessary Permission Checking:
Permission 'android.permission.ACCESS_MOCK_LOCATION' sets correctly.
[Info] Accessing the Internet Checking:
No HTTP-related connection codes found.
[Info] AndroidManifest System Use Permission Checking:
No system-level critical use-permission found.
[Info] <WebView> WebView Local File Access Attacks Checking:
Did not find potentially critical local file access settings.
[Info] <WebView> WebView Potential XSS Attacks Checking:
Did not detect "setJavaScriptEnabled(true)" in WebView.
[Info] <WebView><Remote Code Execution><#CVE-2013-4710#> WebView RCE
Vulnerability Checking:
WebView addJavascriptInterface vulnerabilities not found.
------------------------------------------------------------
AndroBugs analyzing time: 0.641 secs
Total elapsed time: 1.704 secs