RFI-Scanner

/ *
   Escáner RFI de DiGitalX ( DiGi7alX @Gmail . Com )
   Fecha :  6 / 4 / de 2007  - microsistema equipo
* /
 
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <stdio.h>
 
// #define _DEBUG // modo de depuración (para mí <img src = "https://underc0de.org/foro/Smileys/default/cheesy.gif" alt = "& # 58; D" title = "Cheesy" class = "smiley" />)
#definir DEBUG_ROOT "salida"
 
// pon las funciones vuln aquí
// funciona que si una var está en sus argumentos, entonces se produce una posible RFI
// IMPORTANTE : mantener este orden
char * vuln [ ]  =  {
   "include_once" ,  "include" ,  "require_once" ,  "require" , NULL
} ;
 
// global
BOOL bShortDis = FALSE ;
 
uso nulo ( aplicación char * )
{
   printf ( "uso: [-s]% s <directorio raíz> \ n " , aplicación ) ;
   printf ( " \ t -s \ t modo de visualización breve \ n " ) ;
}
 
banner vacío ( vacío )
{
   printf ( "Escáner RFI de DiGitalX ( DiGi7alX@Gmail.com ) \ n " ) ;
   printf ( "Fecha: 4/6/2007 - Equipo de MicroSystem \ n \ n " ) ;
}
 
// return : FALSE si EOF alcanzó , TRUE de lo contrario
BOOL freadline ( FILE * f , char * line ,  int size )
{
   int b , i =  0 ;
 
   // línea cero
   memset ( línea ,  0 , tamaño ) ;
 
   hacer  {
      // lee un byte
      b = fgetc ( f ) ;
      // verifica si EOF
      if  ( b == EOF )  devuelve FALSE ;
      // comprueba si se ha alcanzado la línea nueva o si la línea está llena
      if  ( ( b ==  '\ n' )  ||  ( i ==  1023 ) )  devuelve TRUE ;
      * línea ++  = b ;  // línea de relleno
      i ++;  // contador de incrementos
   }  mientras  ( 1 ) ;
 
   retorno  1 ;  /* código inalcanzable */
}
 
BOOL php_scanfile ( archivo char * )
{
   línea de char [ 1024 ] , línea2 [ 1024 ] ;
   lino int =  0 ;
   BOOL notend ;
   char * tmp ,  * tmp2 ,  * x ;
 
   // abrir archivo
   ARCHIVO * f = fopen ( archivo ,  "rb" ) ;
   // comprobar
   si  ( f == NULL )
      volver FALSO ;
 
   hacer  {
      // abierto ,  luego  lee línea por línea
      notend = freadline ( f , línea , sizeof ( línea ) ) ;
      lino ++;
 
      // baja la línea
      strcpy ( línea2 , línea ) ;
      CharLower ( line2 ) ;
 
      for  ( int i =  0 ; vuln [ i ]  ! = NULL ; i ++ )  {
         // ahora línea contiene una línea de código , buscar para funciones de RFI
         // include , include_once ,  require , require_once
         tmp = strstr ( line2 , VULN [ i ] ) ;
         if  ( tmp ! = NULL )  {
            // la línea contiene la función vuln, tal vez RFI .
            // verifica si la función
            tmp + = strlen ( vuln [ i ] ) ;  // omitir el nombre de la función
            while  ( * tmp  ! =  '(' )  {
               // verifica si se alcanzó el final de la línea u otro carácter ( no espacio en blanco significa que no funciona )
               if  ( * tmp  ==  '\ 0' )  pasa a  siguiente ;  // luego  valla a  la próxima función VULN
               // verifica si hay basura entre la función vuln y el primer ' ( ' alcanzado
               // si es así, que' s  no una función VULN quizá comentario o var o cadena o algo otra cosa
               if  ( ( * tmp  ! =  '' )  &&  ( * tmp  ! =  '\ t' ) )  pasa a  siguiente ;  // solo Dun molesta y  goto  siguiente función VULN
               tmp ++;  // sigue incrementando tmp hasta atrapar '('  [ paréntesis de apertura de la función vuln ]
            }
            // cheque para var dentro de esta función
            tmp2 = tmp ;  // establece tmp2 al comienzo de la función de inclusión
            while  ( * tmp2  ! =  ')' )  {
               tmp2 ++;  // sigue incrementando tmp2 hasta capturar ')'  [ paréntesis de cierre de la función de inclusión ]
               // comprobar si se alcanzó el final de la línea
               if  ( * tmp2  ==  '\ 0' )  pasa a  siguiente ;  // luego  valla a  la próxima función VULN
            }
            x = tmp ;  // establece x al comienzo de la función de inclusión
            while  ( ( * x  ! =  '$' )  &&  ( x < tmp2 ) ) x ++;  // sigue incrementando x hasta atrapar una var dentro de incluir functino o incluir paréntesis de cierre de funciones
            // verifica qué condición acaba de retener
            if  ( * x  ==  '$' )  {
               // BINGO , posible solicitud de RFI < img src = "https://underc0de.org/foro/Smileys/default/cheesy.gif" alt = "& # 58; D" title = "Cheesy" class = "smiley"  / >
               printf ( "posible RFI en la línea:% u" , lino ) ;
               // si bShortDis entonces proporcionar nombre de archivo
               if  ( bShortDis )  printf ( "en \" % s \ " \ n " , archivo ) ;
               sino  printf ( " \ n " ) ;  // de lo contrario solo nueva línea
               romper ;  // rompe el bucle for
            }
         }
         siguiente :
      }
     
      if  ( ! notend ) break ;  // NO no end == end < img src = "https://underc0de.org/foro/Smileys/default/cheesy.gif" alt = "& # 58; D" title = "Cheesy" class = "smiley"  />
   }  mientras  ( 1 ) ;
 
   fclose ( f ) ;
   devolver TRUE ;
}
 
void php_search ( void )  {
   WIN32_FIND_DATA wfd ;
   MANGO fh ;
   char lpBuffer [ 320 ] ;
   char * lpFilePart ;
 
   fh = FindFirstFile ( "*. *" , & wfd ) ;
   if  ( fh ! = INVALID_HANDLE_VALUE )  {
      hacer  {
         // omitir '.'  y  '..' dirs
         if  ( wfd . cFileName [ 0 ]  ==  '.' )  continuar ;
         //  si dir ingrésalo
         if  ( wfd . dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY )  {
            if  ( SetCurrentDirectory ( wfd . cFileName )  == TRUE )  {
               php_search ( ) ;  // llamada recursiva
               SetCurrentDirectory ( ".." ) ;
            }
            continuar ;
         }
         // de lo contrario continuar nuestro proceso
         if  ( GetFullPathName ( wfd . cFileName , 320 , lpBuffer , & lpFilePart )  ==  0 )  continuar ;
         CharLower ( lpBuffer ) ;
         // comprobando si la extensión del archivo es php
         if  ( memcmp ( & lpBuffer [ lstrlen ( lpBuffer ) - 3 ] , "php" , 3 )  ==  0 )  {
            // omitir si bShortDis está configurado
            if  ( ! bShortDis )  printf ( "Escaneando% s ... \ n " , lpBuffer ) ;
            php_scanfile ( lpBuffer ) ;
         }
      }  , Mientras que  ( FindNextFile ( FH , y DMA )  == TRUE ) ;
      FindClose ( fh ) ;  // cierre del identificador de búsqueda
   }
}
 
BOOL begin_rfi_scan ( char * root )
{
   // primero establece el directorio raíz como el directorio actual
   if  ( ! SetCurrentDirectory ( root ) )
      volver FALSO ;
 
   // comienza la búsqueda de archivos php
   printf ( "Vulnerabilidades de RFI de inicio de búsqueda ... \ n " ) ;
   // si  se da - s , informe al usuario que el modo está activado
   if  ( bShortDis )  printf ( "Modo de visualización corta activado \ n " ) ;
   php_search ( ) ;
   printf ( "Terminado de Cazar. \ n " ) ;
 
   devolver TRUE ;
}
 
int main ( int argc , char ** argv )
{
   int  pos  =  1 ;  // posición raíz en la línea cmd
 
   // muestra banner
   banner ( ) ;
 
   #ifndef _DEBUG
   // verifica si el directorio raíz se da en la línea cmd
   if  ( argc <  2 )  {
      // muestra la pantalla de uso y  sale
      uso ( argv [ 0 ] ) ;
      retorno  1 ;
   }
   #terminara si
 
   // - s se especifica conmutador
   if  ( strcmp ( argv [ 1 ] ,  "-s" )  ==  0 )  {
      bShortDis = VERDADERO ;  // establecer bandera
      pos  =  2 ;  // cambia la posición raíz en la línea cmd
   }
 
   // el directorio raíz se da bien ,  luego escanea todos los archivos dentro de este directorio raíz
   #ifndef _DEBUG
   if  ( ! begin_rfi_scan ( argv [ pos ] ) )  {
   #más
   if  ( ! begin_rfi_scan ( DEBUG_ROOT ) )  {
   #terminara si
      printf ( "Error: inicializando el escáner RFI ... Inténtalo de nuevo" ) ;
      retorno  1 ;
   }
 
   devuelve  0 ;
}  [ / cita ]
 
[ cita ] Es un escáner simple - RFI que escanea archivos - php o posibles vulnerabilidades como include ( ) , require ( ) ... etc y luego chekea si hay alguna variable en los argumentos de la función .
Si la hay muestra el resultado para tu chekes si hay una RFI / LFI muy feliz xD !
 
* Nota :
Podes poner un monton de scripts php dentro de una carpeta y cocorrer el escáner contra el mismo .
 
El scaner scanneara todo el directorio raíz ( dentro de la lina cmd )  y te provera cada función funcional bugg junto con la línea y nombre del script