Wednesday, October 11, 2017

House of Ducks. We serve Badada

Por: Fábio Sartorato e Vinícius Henrique Marangoni


For the Portuguese version, click here.

The process of security assessment intends to find vulnerabilities in a software that would let an attacker perform operations that were not predicted by the programmer. Depending on the vulnerability the privacy of an end user may be completely compromised.

Finding these vulnerabilities can be hard. Reverse engineering may help understanding how a software works, but this task can also demand much more from the security analyst, as there are many ways a programmer can obfuscate a code. In a different approach, one can try to come up with hypotheses of vulnerabilities that could easily be tested if changing the original source code and recompiling it, which, many times, cannot be done due to signature checks.

These are the difficulties that encourage many researchers to develop tools to assist in these security assessment tasks. FRIDA, for instance, was born to make reverse engineering more productive and interactive.

In this post we will present Badada, a tool created to help in the process of security assessment of not only Android applications, but also its own framework code. As an initial post of this tool we will show its usage bypassing a security checking from a very simple application created for this purpose.


Frida

Frida (https://www.frida.re) is a toolkit to instrument code at runtime. This tool let you inject code into an application that is running in order to change its original behavior. Many security enthusiasts started to study this tool and use it while security assessing components. Frida's power is not limited to only instrumenting code, it may also enumerate all instantiated classes from a process, as well as methods from each class. Frida has many modes of operation that are detailed here. In this post we will talk about one of the 3 modes of operation: the one that uses frida-gadge.

To install Frida you can follow the guide in this link:
https://www.frida.re/docs/installation/


Badada

Although Frida has all these features, we could not find, until now, an interface that offers all these resources to the end user in a simple manner. Due to this need we started developing an interactive client for Frida that we called Badada (https://github.com/badadaf/badada). This client communicates directly with frida-server using a Python module created by Frida's development team.

The requirements to use Badada are: Python 2.7, Frida and Android Debug Bridge (ADB). The official documentation of ADB can be found here.

Badada repository needs to be cloned by, e.g. the following command:

git clone https://github.com/badadaf/badada

 Now add Badada directory to your path. In order to do this in Linux lets edit the file found in ~/.bashrc with your favorite text editor, adding the following line:
export PATH=$PATH:/home/username/Tools/badada

Notice that what comes after "$PATH:" is exactly the path where Badada was cloned.

Finally load the modifications we did to .bashrc file by running the following command:

source ~/.bashrc

OK. Badada is ready to run. Run the following command to test it:

badada --help

This command should return the help text about Badada.

Hands On

Now that we are all set with Badada, we will show some of its features and how this tool can make the process of analyzing Android a little bit easier. We created a simple application that shows an image if the user has permission to see it. Our aim is to bypass this check and see this picture without having official permission.
The apk of this app can be downloaded here and the source code is published on GitHub.

First things first. We need to install the application on our phone. After connecting it to an USB port, run the following command:

adb install BadadaPatos.apk

After the installation process is completed, the app should be available on Android launch screen with the name "BadadaPatos". When opened you will be able to see the following screen:
Image 1 - Main Activity


The text asks if you like rubber ducks with a button that says "Click me". Try clicking it and you will see that you do not have permission to see the rubber duck, as shown below:
Image 2 - Permission not granted

To understand what is happening when the button is clicked lets read the source code here.

The click triggers a permission check and, if the method hasPermission returns True, then the visibility of the duckView is set to Visible, as the code below:


In the original code the method hasPermission always returns false:


OK. So there is no way to see the rubber duck. =[
This is where Frida can help us. The bridge between client and application will be done using frida-gadget. This component is a dynamic library that is inserted on the entry point class constructor that we want to instrument and has the purpose of exposing an interface to the Frida client. This is an interesting option when you can't use frida-server. In cases you do not have access to a rooted device (this is the scenario proposed in this post), frida-gadget is the best option. The gadget can be inserted into the apk using the tool apkpatcher, that is published here.

The first thing to do after downloading apkpatcher is update the list of gadgets. The gadgets are associated with the current Frida version installed on the user computer. To update this list run the command:

apkpatcher --update

The output should be as the image shows:


Image 3 - Updating apkpatcher


To insert the gadget into our app, connect your smartphone into your computer with debugger mode turned on. With this, apkpatcher will retrieve the architecture of the device and then choose the correct gadget. To finally insert the gadget into the apk, run the command:
apkpatcher -a BadadaPatos.apk

The tool will extract the apk, insert frida-gadget and then remount the files of the new patched apk.

Image 4 - apkpatcher in action


Now you can install the new patched app.

adb install BadadaPatos_patched.apk

 Remember that apkpatcher re-signs the apk, so the signature of the patched apk will be different from the original one.

Now we can finally use Frida to instrument our application. When we run it, initially it will be paused, waiting connection to our client. When this connection is finished the execution flow will resume.

First, start BadadaPatos. If everything runs smoothly, a white screen will appear, as if the application has frozen. In fact this is frida-gadget waiting for our connection. Now lets connect to the application using Badada. Run the command below to start our client.

badada Gadget

This will connect Badada (that is running Frida's module)  to the application that has the gadget.


Image 5 - Badada's initial screen


If you want to list the available commands you can invoke help, as well as information of a specific  command, for instance, help getclasses. Besides that, the interactive shell also offers system commands that can be run with an exclamation point in the beginning, for example !ls /tmp will list the contents of /tmp directory. 

 First, let's list all existing classes of our application to gain some kind of information about the running process To do this, first we need the name of the package of BadadaPatos. Using aapt to get this information is a way to find the name:

!aapt dump badging BadadaPatos.apk | grep package

This will run, through your Linux shell, the program aapt. In this case, we have that the name is com.badadaf.badadapatos.

Image 6 - Finding package name

As said before, we can use the command getclasses to look though all classes in this package.

getclasses com.badadaf.badadapatos

Image 7 - Enumerating available classes

We found there is a class named MainActivity. This should be an entry point, so it is a good idea to list its methods.
getmethods com.badadaf.badadapatos.MainActivity

Image 8 - Enumerating methods from class MainActivity

Now we can see all methods from MainActivity class, with their return type and arguments. We can see a method called hasPermission() we talked about before. Remember it always returns False, so let's instrument it so it returns True.

To do so, we need to write a JavaScript code (we named ours hook.js):



And to load it, we just need to use the load command from Badada.

Image 9 - Loading script that instruments hasPermission() method

Now that the script is loaded we can try to see the rubber duck picture again clicking on the same button as before.

Figura 10 - Verification bypassed


at No comments:

House of Ducks. We serve Badada

Por: Fábio Sartorato e Vinícius Henrique Marangoni

Para a versão em inglês, clique aqui.

O processo de Security Assessment tem como objetivo encontrar vulnerabilidades em um software que permitem a um atacante realizar operações que não foram previstas pelo programador. Dependendo da vulnerabilidade, a privacidade do usuário pode ficar completamente comprometida.

A busca por vulnerabilidades pode ser bem complexa. A engenharia reversa de software pode auxiliar o analista de segurança a entender o funcionamento de um software a fim de encontrar bugs, mas essa tarefa pode ser dificultada quando o programador executou um ofuscador de código. Outras vezes é necessário partir de hipóteses para tentar encontrar uma falha, e essas hipóteses só podem ser testadas alterando parte do código original e recompilando o software, o que muitas vezes não é possível, como é o caso de aplicações que passam por checagem de assinatura.

São essas dificuldades que estimulam muitas pessoas a desenvolverem ferramentas que auxiliam nesse tipo de tarefa. O Frida, por exemplo, nasceu com o objetivo de tornar a tarefa de engenharia reversa mais produtiva e interativa.

O objetivo desse post é apresentar o Badada, uma ferramenta criada para auxiliar no processo de Security Assessment tanto em aplicações quanto no próprio framework do Android. Como este é um post inicial sobre o Badada, vamos exemplificar seu uso burlando uma checagem de segurança existente em uma aplicação simples.


Frida

Frida (https://www.frida.re) é um toolkit para instrumentação dinâmica de código. Essa ferramenta permite injetar código em aplicações que já estão sendo executadas com o objetivo de modificar seu comportamento original. Pensando nisso, vários entusiastas de segurança começaram a estudar essa ferramenta e utilizá-la em security assessments em busca de bugs. O poder do Frida não se limita apenas a instrumentar métodos, mas também é possível enumerar todas as classes instanciadas de um processo, bem como cada método presente em cada classe. O Frida possui diversos modos de operação que estão descritos em detalhes aqui. Nesse artigo falaremos sobre 1 dos 3 modos de operação usando o frida-gadget.

O processo de instalação do Frida é descrito no seguite link:
https://www.frida.re/docs/installation/


Badada

Apesar do Frida oferecer todas essas funcionalidades, não encontramos uma interface que disponibiliza esses recursos ao usuário final de forma simples. Pensando nisso, iniciamos o desenvolvimento de um cliente interativo para o Frida que chamamos de Badada (https://github.com/badadaf/badada). Este se comunica diretamente com o frida-server utilizando o módulo em Python feito pelo time de desenvolvimento do Frida.

Os únicos pré-requisitos para que o Badada funcione são: Python 2.7, Frida e Android Debug Bridge (ADB). A documentação oficial do ADB pode ser encontrada no seguinte link:

https://developer.android.com/studio/command-line/adb.html?hl=pt-br

Para instalar o Badada, primeiro temos que clonar o repositório. Para isso, execute o comando abaixo:

git clone https://github.com/badadaf/badada

 Agora, basta colocar o diretório do Badada em seu path. Para fazer isso no Linux, vamos editar o arquivo localizado em ~/.bashrc com seu editor de texto favorito de modo que ele contenha a seguinte linha:

export PATH=$PATH:/home/username/Tools/badada

Repare que o que vem após "$PATH:" é o diretório onde o Badada foi clonado.

Por último, para carregar as alterações feitas no .bashrc basta executar o seguinte comando:

source ~/.bashrc

Agora você deve ser capaz de executar o Badada em seu terminal. Para testar, digite:

badada --help

 Esse comando deverá retornar um texto de ajuda sobre o Badada.


Hands On

Abaixo mostraremos algumas das funcionalidades do Badada e como esta ferramenta pode tornar a tarefa de análise de aplicações Android um pouco mais fácil. Para isso, desenvolvemos uma simples aplicação. Nosso objetivo é burlar uma checagem de segurança realizada pela aplicação a fim de obter acesso a uma funcionalidade originalmente não autorizada.
O apk do aplicativo usado neste post pode ser baixado aqui e seu source está disponível em https://github.com/badadaf/BadadaPatos

Após baixar o apk, a primeira etapa é instalá-lo em nosso dispositivo Android. Para isso, execute o seguinte comando:

adb install BadadaPatos.apk

Após a instalação, o aplicativo deverá estar disponível no menu do Android com o nome de “BadadaPatos”. Ao abrir o aplicativo você irá se deparar com a seguinte tela:
Figura 1 - Main Activity

A tela apresenta uma mensagem que diz “Você gosta de patinhos de borracha?” e um botão que diz “Clique Aqui”. Ao clicar no botão, você se depara com a mensagem “Você não tem permissão para ver o pato de borracha!”, como mostra a imagem a seguir:
Figura 2 - Sem permissão de visualização

Para entender o que está acontecendo, vamos olhar para o código fonte da aplicação (https://github.com/badadaf/BadadaPatos/blob/master/app/src/main/java/com/badadaf/badadapatos/MainActivity.java#L24)

Ao clicar no botão, uma checagem de permissão é realizada, e, caso o método “hasPermission” retorne o valor “True”, a visibilidade da duckView é definida para “Visible”, como mostra o código a seguir (linha 4):



No código original, o método “hasPermission” sempre retorna false, como mostra o código abaixo:


Desta maneira, caso não alteremos algo no código original, nunca conseguiremos visualizar a duckView. É aqui que o Frida irá nos ajudar. A ponte entre o cliente e a aplicação será feita utilizando o frida-gadget. O frida-gadget é uma biblioteca dinâmica que é inserida no construtor da classe do entrypoint da aplicação que queremos instrumentar, e tem a finalidade de expor uma interface para um cliente do Frida. É uma alternativa interessante quando não se pode utilizar o frida-server. Em casos em que não se tem acesso root ao device (que é o cenário proposto neste post), o frida-gadget é nossa melhor opção. Nesse link você pode encontrar mais informações a respeito dos modos de funcionamento do Frida. Este gadget pode ser inserido usando a ferramenta apkpatcher, que está disponível em https://github.com/badadaf/apkpatcher

A primeira etapa após baixar o apkpatcher é atualizar a lista de gadgets. Os gadgets serão baixados de acordo com a versão do Frida instalada em seu computador. Para atualizar a lista de gadgets, execute o seguinte comando:

apkpatcher --update

O resultado deve ser parecido com o da imagem abaixo:



Figura 3 - Atualizando o apkpatcher


Agora, para inserir o gadget em nossa aplicação, conecte o seu smartphone em seu computador com o modo de depuração por USB ativo. Deste modo, o apkpatcher poderá reconhecer qual a arquitetura do smartphone para que possa selecionar o gadget correto. Após conectar o smartphone, execute o seguinte comando:
apkpatcher -a BadadaPatos.apk

O apkpatcher irá extrair o apk, inserir o frida-gadget e "reempacotar" os arquivos em um novo apk. O resultado deve ser parecido com o da imagem a seguir:

Figura 4 - apkpatcher em ação


Para instalar a aplicação, execute o comando abaixo:

adb install BadadaPatos_patched.apk

 Lembre-se que, caso execute o apkpatcher em uma aplicação que foi distribuída por outro publisher, a assinatura do apk será diferente da original.

Nossa aplicação agora está preparada para ser instrumentada com o Frida e instalada em nosso smartphone. Quando ela for executada, inicialmente ficará "pausada" aguardando uma conexão do cliente. Quando este se conectar a aplicação continuará sua execução normalmente.

Agora vamos iniciar a instrumentação com o Frida, e para isso iremos utilizar o Badada para auxiliar em algumas tarefas. Primeiramente vamos iniciar a aplicação BadadaPatos instalada em nosso smartphone. Se tudo ocorrer bem, você irá se deparar com uma tela branca, como se a aplicação estivesse "travada". Na verdade, isso é o frida-gadget aguardando nossa conexão. Agora vamos conectar com a aplicação utilizando o Badada. Para isso, vamos executar o seguinte comando:

badada Gadget

Isso fará com que o Badada (utilizando o módulo do Frida) conecte com a aplicação que possui o gadget. A imagem a seguir ilustra a execução do último comando:


Figura 5 - Tela inicial do Badada


Caso queira listar quais os comandos disponíveis você pode usar o comando help, bem como informações de um comando específico, por exemplo help getclasses. Além disso, o shell interativo também disponibiliza comandos de sistema. Para executá-los coloque um ponto de exclamação no início do comando, por exemplo, !ls /tmp listará o conteúdo no diretório /tmp.

Inicialmente, vamos listar as classes existentes em nosso aplicativo para começar a ter informações sobre o processo. Para isso, primeiro vamos descobrir o nome do pacote do BadadaPatos utilizando o comando abaixo.

!aapt dump badging BadadaPatos.apk | grep package


Isso executará através do shell de seu Linux o programa aapt e retornará o nome do pacote do BadadaPatos.apk. No nosso caso, com.badadaf.badadapatos. O resultado deverá se parecer com a imagem abaixo:

Figura 6 - Exibindo o nome do pacote


Podemos usar o comando getclasses do Badada para procurar as classes que existem neste pacote.

getclasses com.badadaf.badadapatos

O comando deverá retornar algo que se parece com a imagem abaixo:

Figura 7 - Enumerando as classes disponíveis no app

Vamos agora listar os métodos existentes na classe com.badadaf.badadapatos.MainActivity.

getmethods com.badadaf.badadapatos.MainActivity

O resultado deverá se parecer com o seguinte:

Figura 8 - Enumerando os métodos da classe MainActivity

Como podem perceber, o método hasPermission() foi listado. Originalmente, esse método sempre retorna False. Nosso objetivo é reescrever a implementação desse método, de modo que retorne True. Para isso, vamos abrir uma nova aba no terminal e escrever um script, que chamaremos de hook.js, o qual será responsável por reescrever o método hasPermission e fazê-lo retornar True. O conteúdo do nosso script hook.js deve ser o seguinte:


Para carregar o script, iremos utilizar o comando load hook.js, como ilustra a imagem abaixo:

Figura 9 - Carregando o script que instrumenta o método hasPermission()

Agora que o script foi carregado, vamos voltar para a aplicação e clicar no botão novamente. Se tudo ocorrer bem, a imagem de um patinho deverá ser exibida.

Figura 10 - Verificação burlada

AHA! Mas que belo patinho de borracha!

at No comments:
Subscribe to: Posts (Atom)