Mostrando entradas con la etiqueta Programacion. Mostrar todas las entradas
Mostrando entradas con la etiqueta Programacion. Mostrar todas las entradas

Haka: parte II (reglas de seguridad)


Hola amigos y lectores de Underc0de!

Hace unos días compartimos post sobre Haka, el nuevo lenguaje de seguridad informática. Hoy traemos una segunda parte sobre la sintaxis de sus reglas de seguridad.
...

Haka ofrece una forma sencilla de escribir reglas de seguridad para filtrar, modificar, crear e inyectar paquetes. Según expertos de auditoría de seguridad informática, cuando se detecta un flujo con algo malicioso, pueden informar los usuarios o pueden dejar el flujo. Los usuarios pueden definir escenarios más complejos para mitigar el impacto de un ataque. Por ejemplo, se puede alterar peticiones http y obligar a los navegadores obsoletos para actualizar o falsificar paquetes específicos para engañar herramientas de análisis de tráfico.
La siguiente regla es una regla de filtrado de paquetes básico que bloquea todas las conexiones de una dirección de red.
local ipv4 = require(“protocol/ipv4”)
local tcp = require(“protocol/tcp_connection”)
local net = ipv4.network(“192.168.101.0/24”)
haka.rule{
   hook = tcp.events.new_connection,
   eval = function (flow, pkt)
       haka.log(“tcp connection %s:%i -> %s:%i”,
           flow.srcip, flow.srcport,
           flow.dstip, flow.dstport)
       if net:contains(flow.dstip) then
           haka.alert{
               severity = “low”,
               description = “connection refused”,
               start_time = pkt.ip.raw.timestamp
           }
           flow:drop()
     end
   end
}
Las primeras líneas del código cargan los disectores de protocolo, Ipv4 y TCP explica profesor de hacking, Mike Stevens. La primera línea se encarga de paquetes IPv4. Después usamos un disector de TCP de estado que mantiene una tabla de conexión y gestiona flujos de TCP. Las siguientes líneas, definen la dirección de red que debe ser bloqueada.
La regla de seguridad se define a través de palabras clave haka.rule. Según expertos de servicios de auditoría informática las reglas de haka son muy útiles. Una regla de seguridad está hecha de un gancho y una función de evaluación eval. El gancho es un evento que activará la evaluación de la regla de seguridad. 
En este ejemplo, la regla de seguridad se evaluará en cada intento de establecimiento de conexión TCP. Los parámetros pasados a la función de evaluación dependen del evento explica el experto de servicios de seguridad informática. En el caso del evento new_connection, eval toma dos parámetros: flow y pkt. Lo primero de ellos tiene detalles sobre la conexión y el segundo es una tabla que contiene todos los campos del paquete TCP.
Según recomendación del profesor, en el núcleo de la regla de seguridad debemos registrar en haka.log primero alguna información acerca de la conexión actual. Luego, comprobamos si la dirección de origen pertenece a la gama de direcciones IP’s no autorizadas. Si la prueba tiene éxito, elevamos una alerta (haka.alert) y liberamos la conexión. Menciona asimismo, Roberto Talles,  que se tenga en cuenta que se informa sólo algunos detalles de la alerta. Se puede añadir más información, como el origen y el servicio de destino.
Utilizamos hakapcap herramienta para probar nuestra filter.lua regla en un archivo de pcap trace filter.pcap:
$ hakapcap filter.lua filter.pcap

De aquí en adelante, en los resultados sale algo de información sobre disectores cargados y reglas registrados. El resultado muestra que Haka logró bloquear conexiones dirigidas a dirección 192.168.101.62:
En el ejemplo anterior, hemos definido una sola regla para bloquear las conexiones. Uno puede escribir un conjunto de reglas de firewall usando la palabra clave haka.group . En este caso, la configuración, se puede elegir un comportamiento por defecto (por ejemplo, bloquear todas las conexiones) si ninguno de la regla de seguridad autoriza explícitamente el tráfico.
Fuente: noticiasseguridad.com
Visítanos en Underc0de

Haka: nuevo lenguaje de seguridad informática


Haka es un lenguaje de seguridad orientado a código abierto que permite especificar y aplicar las políticas de seguridad Informática en el tráfico capturado en vivo. HAKA se basa en Lua y es un lenguaje sencillo, ligero y rápido. El alcance de Haka es doble explican consultores de empresa de seguridad informática y hacking ético. En primer lugar, permite la especificación de las normas de seguridad para filtrar flujos no deseados y reportar actividades maliciosas. 
Haka proporciona un API simple para la manipulación del tráfico corriente. Uno puede descartar paquetes o crear otros nuevos e inyectarlos. Haka también apoya la modificación de paquetes en la marcha. Esta es una de las principales características de Haka desde todas las tareas complejas tales como el cambio de tamaño de paquetes, ajuste correctamente de los números de secuencia. Esto se hace en vivo sin la necesidad de un proxy y se realiza todo de forma transparente para el usuario.
En segundo lugar, Haka permite la especificación de protocolos y estado subyacente de todo. Haka es compatible con ambos tipos de protocolos: protocolos basados en binario (por ejemplo, DNS) y protocolos basados en texto (por ejemplo, http). La especificación cubre los protocolos basados en paquetes, tales como IP, así como los protocolos basados en secuencias como http.
 Según consultores de empresas de seguridad informática y hacking ético, HAKA se encaja en un marco modular. Incluye varios módulos de captura de paquetes (pcap, nfqueue) que permiten a los usuarios finales a aplicar su política de seguridad informática en el tráfico capturado vivo. El marco proporciona el registro (syslog) y alerta de módulos (Syslog, Elasticsearch). 
Por último, el marco tiene módulos auxiliares, tales como un motor de búsqueda de patrones y un módulo de desensamblador de instrucciones. Estos módulos permiten escribir las reglas de seguridad informática de grano fino para detectar malware ofuscado. Haka fue diseñado de manera modular, permitiendo a los usuarios a ampliarlo con módulos adicionales.
Haka proporciona una colección de cuatro herramientas importantes para consultores de empresa de seguridad informática y hacking ético:
haka: Es el programa principal de la colección. Está diseñado para ser utilizado como un daemon para controlar los paquetes en el fondo. Los paquetes son disecados y filtrados de acuerdo con el archivo de políticas de seguridad especificadas. Haka toma como entrada un archivo de configuración. Este archivo script se carga disectores de protocolo típicamente incorporados o definidos por el usuario y define un conjunto de reglas de seguridad.
hakactl: Esta herramienta permite controlar daemon. Uno puede obtener estadísticas en tiempo real en los paquetes capturados, inspeccionar los registros o simplemente apagar/reiniciar el daemon.
hakapcap: Esta herramienta permite reproducir un archivo de política en una captura de paquetes utilizando el módulo pcap. Por ejemplo, esto es útil para realizar análisis forense y hacking ético de la red.
hakabana: Esta herramienta permite la visualización y monitoreo de tráfico de red en tiempo real utilizando Kibana y Elasticsearch según expertos de empresa de seguridad informática. Hakabana consiste en un conjunto de reglas de seguridad que lleva información sobre el tráfico que pasa a través de Haka en un servidor de elastisserach y muestra a través de una consola Kibana. Un panel adicional también está disponible para visualizar alertas de Haka.

Fuente: noticiasseguridad.com
Visítanos en Underc0de

miniBloq, el lenguaje de programación para robots

Desarrollado por el argentino Julián da Silva Gillig y utilizado por los kits educativos de la empresa local RobotGroup, esta plataforma de código abierto busca ofrecer un proceso didáctico orientado a niños, adolescentes y principiantes.


El aprendizaje de la programación suele ser un camino que conlleva diversos desafíos: comprender las estructuras, el lenguaje, la sintaxis y muchos otros factores. Y si a esto se le suma el interés por el desarrollo de robots, el panorama se vuelve aún más desafiante.

"En robótica, la programación conlleva cierta complejidad al estar basados en C++. Llaves, mayúsculas, comas y un sinfín de estructuras de programación pueden ser sorteados entre los estudiantes universitarios, pero se transforma en todo un desafío al trasladar estas actividades a otros niveles educativos, tales como escuelas primarias y secundarios", le explica a LA NACION Mónica Paves, profesora de matemática y una de las socias de RobotGroup, una empresa argentina especializada en crear kits educativos de robótica que se exportan a otros países.


Con la necesidad de sumar un proceso didáctico al momento de programar los kits de robótica, RobotGroup comenzó a utilizar miniBloq , un entorno gráfico de programación muy sencillo, orientado al ámbito educativo y utilizado de forma extendida entre niños y adolescentes de escuelas primarias y secundarias, y que fue creado por el argentino Julián da Silva Gillig.

"miniBloq es un software libre de código abierto, que utiliza símbolos y con una lógica de programación como cualquier otro programa. Está basado en C++ y permite visualizar en tiempo real los posibles errores de código. No tiene límites de uso, es decir, está orientado a todos los niveles educativos, pero al ser tan didáctico en su uso, es ideal para ser utilizado en niños y jóvenes", agrega Paves. Y puede usarse para plataformas Arduino, Multiplo y varias otras.

El miniBloq en acción



La adopción de miniBloq en los robots educativos de RobotGroup comenzó en 2008, cuando se sumó como socio Da Silva Gillig, junto a Paves y el ingeniero Lucio Mercado. Con el apoyo del Fondo Fiduciario de Promoción del Software (FONSOFT) de la Agencia de Promoción Científica y Tecnológica, esta plataforma educativa de programación logró tomar impulso y se posicionó como el software ideal para los kits educativos de la empresa.

"La idea es reducir al máximo los errores de sintaxis. Esto permite que el usuario se concentre sólo en el programa a desarrollar, algo muy importante, cuando se trabaja con chicos y principiantes", dijo Julián da Silva Gillig en una entrevista realizada por el sitio RedUsers , donde hay más detalles técnicos sobre su funcionamiento y nacimiento.


Con la experiencia del trabajo en conjunto con diversas universidades nacionales, RobotGroup ahora está abocado a diversas iniciativas educativas con la Universidad Nacional de La Matanza. En este distrito bonaerense también desarrollan los programas de capacitación de alumnos y docente en escuelas secundarias técnicas.

Tanto miniBlog como los kits de desarrollo N6 de RobotGroup también forman parte de los talleres que se llevan a cabo dentro de la iniciativa Program.ar , que comenzará el próximo 6 de junio en Quilmes.

"miniBlog avanzó muchísimo desde su primera versión, y ahora buscará ser compatible con muchas más placas, más allá de Arduino y las diversas placas utilizadas en robótica, con el objetivo de ser lo más universal posible. Al ser código abierto y software libre, muchos de los aportes al crecimiento de miniBloq fueron realizados por la comunidad de desarrolladores de todo el mundo, con una plataforma que ya está disponible en diez idiomas", dijo Paves.

"El kit provee todos los elementos necesarios para un proyecto de robótica, y con miniBloq logramos concretar una propuesta factible para el aula, que cubre las necesidades del alumno durante el proceso de aprendizaje sin importar la edad. Su interfaz promueve la lógica y ayuda a resolver problemas", dijo sobre la plataforma que le da vida a los robots con sello argentino, y que según reporta RedUsers se usa en China, Estados Unidos y Chile, entre otros países.

[PHP] Creando una firma dinamica


Introduccion

Buenas he estado sin tiempo para postear pero en esta ocasion les mostraré como crear una firma dinamica de manera que obtengan algunos datos, muchos ya saben como realizarlo por que no tiene tanta dificultad mas que nada se trata de utilizar la libreria de PHP GD.

Un buen tutorial que recomiendo mucho sobre PHP GD es el siguiente: http://wiki.elhacker.net/programacion/php/libreria-gd el cual esta muy bien explicado.
Tratare de ser breve colocando solo los pasos.

Estructura a realizar

La estructura con la que trabajaremos sera la siguiente:



Explicando un poco que hace cada archivo.

.htaccess - Con este archivo interpretaremos imagenes png (con su extension .png) como archivos php y bloquearemos cualquier intento de acceso al archivo logs.txt

firma.php - Con este archivo generamos la imagen dinamica (pronto le cambiaremos la extension a .png)

KeepCalm-Medium.ttf - Es el tipo de letra que utilizaremos para la firma dinamica.

logs.txt - Aqui guardaremos los logs, en este caso IP, Sistema, Si usa proxy.

rVJgsdx.png - Es la imagen que utilizaremos para la firma dinamica.

view_logs.php - Este es un archivo para ver los logs online. Con un simple formulario que tiene que ingresar una clave.

Nota importante: Nada de aqui es guardado en una base de datos. Y esto es facilmente explotable haciendo peticiones desde la misma IP un sin fin de veces cargaria todo el archivo logs.txt haciendolo demasiado pesado (Esa idea la hizo un amigo JhonJhon_123) entonces lo unico que podemos realizar en este caso es:

1.- Denegar las ips que realizen demasiadas peticiones
2.- No insertar IPS repetidas en el archivo logs.txt
3.- Cambiar el nombre de la carpeta para que no hagan mas peticiones.

Cualquiera de estos tres puntos no se ven en este tutorial.

Creando la firma

En este caso crearemos el archivo PHP para realizar la firma dinamica, no entrare en detalles de explicaciones ya que comente el codigo lo mas posible para que se entendiera, de todas maneras si no entienden algo, arriba deje una buena documentacion con la que pueden guiarse.

Código: PHP
  1.  <?php
  2.  // no reportamos errores
  3.  // el nombre de la imagen a poner como firma
  4.  $im_name = "rVJgsdx.png";
  5.  // los datos de la imagen
  6.  $data_im = getimagesize($im_name);
  7.  // el tipo de imagen
  8.  header("Content-type: {$data_im['mime']}");
  9.  // creamos la imagen en este caso png
  10.  $im = imagecreatefrompng($im_name);
  11.  // creamos un color para usarlo en el texto
  12.  $color = imagecolorallocate($im, 45, 196, 236);
  13.  // obtenemos la IP
  14.  $ip = $_SERVER['REMOTE_ADDR'];
  15.  // obtenemos los datos del navegador
  16.  $user_agent = $_SERVER['HTTP_USER_AGENT'];
  17.  // vemos si existe algun proxy (no es 100% fiable), y lo agregamos a la variable ip
  18.  $proxy_headers = array(
  19.         'HTTP_VIA',
  20.         'HTTP_X_FORWARDED_FOR',
  21.         'HTTP_FORWARDED_FOR',
  22.         'HTTP_X_FORWARDED',
  23.         'HTTP_FORWARDED',
  24.         'HTTP_CLIENT_IP',
  25.         'HTTP_FORWARDED_FOR_IP',
  26.         'VIA',
  27.         'X_FORWARDED_FOR',
  28.         'FORWARDED_FOR',
  29.         'X_FORWARDED',
  30.         'FORWARDED',
  31.         'CLIENT_IP',
  32.         'FORWARDED_FOR_IP',
  33.         'HTTP_PROXY_CONNECTION'
  34.     );
  35.     foreach($proxy_headers as $x){
  36.         if (isset($_SERVER[$x])) {
  37.          $ip .= "/Estas usando proxy!";
  38.          break;
  39.         }
  40.     }
  41.  
  42.     // reemplazamos los datos del navegador en caso de que sea firefox por firefox o chrome por chrome, la lista es corta se pueden agregar mas
  43.  $navegador = preg_replace('/.*(firefox|chrome).*/i', '$1', $user_agent);
  44.  // lo mismo que arriba en este caso con el sistema, igual podemos hacer la lista personalizable
  45.  $sistema = preg_replace('/.*(windows|mac|linux).*/i', '$1', $user_agent);
  46.  // guardamos los datos en una variable para usarla en el texto
  47.  $string = " Tu IP: $ip \n Tu navegador: $navegador \n Tu sistema: $sistema \n Te estoy vigilando!\n";
  48.  // asignamos una variable con la fuente para usarla en el texto
  49.  $fuente = "KeepCalm-Medium.ttf";
  50.  // en caso de que no se haya detectado nada mostramos el navegador, aunque nos trolleen xD :P
  51.  if($navegador == ''){
  52.   $navegador = $_SERVER['HTTP_USER_AGENT'];
  53.  }
  54.  // what? :3, Guardamos logs
  55.  $manejador = fopen("logs.txt", 'a+');
  56.  fwrite($manejador, "$string\n\n\n");
  57.  fclose($manejador);
  58.  // magia is here! Mostramos el texto en las coordenadas dadas
  59.  imagettftext($im, 10, 0, 300, 10, $color, $fuente, $string);
  60.  // png transparency, para la transparencia en la imagen sino se veria desfigurada
  61.  imagealphablending($im, true);
  62.  imagesavealpha($im, true);
  63.  imagepng($im);
  64.  // destroy image, liberamos la memoria
  65.  imagedestroy($im);
  66. ?>
  67.  
  68.  

Asignar formato a la imagen y denegar acceso a los logs

En este apartado crearemos el archivo .htaccess el cual denegara acceso a los logs y interpretara nuestro archivo png como php.

Citar
AddType application/x-httpd-php .png
<FilesMatch "\.(txt)$">
  Order Deny,Allow
  Deny from all
</FilesMatch>

Creando archivo para ver los logs

Por ultimo creamos nuestro archivo view_logs.php con el cual veremos los logs.

Código: PHP
  1.  <?php
  2.  if (isset($_POST['pass']) && !empty($_POST['pass']) && $_POST['pass'] == 'tucontraseñae.e') {
  3.   $gestor = fopen('logs.txt', 'r');
  4.   $contenido = fread($gestor, filesize('logs.txt'));
  5.   fclose($gestor);
  6.   echo "<pre>" . $contenido . "</pre>";
  7.  }
  8. ?>
  9. <form method="post" action="">
  10.  <p><input type="text" name="pass" /></p>
  11.  <p><input type="submit" name="enviar" /></p>
  12. </form>
  13.  

En este caso solo hay que cambiar tucontraseñae.e por la contraseña que le quieras asignar a la entrada.

Finalizando

Le cambiamos la extension al archivo firma.php y le ponemos el nombre que queramos en mi caso firma.png
Lo abrimos en el navegador para ver los resultados.


En este caso mi ip es ::1 ya que es una ip local.

Les dejo por ultimo los archivos por si quieren probarlo, igual pueden realizar el suyo propio cambiando algunas funciones como dependiendo del tipo de imagen que sea JPEG, PNG, etc. el tipo de letra, sus datos, etc. De igual manera con esto podrian crearse hasta generadores de firmas, saludos!

Archivos: http://www.mediafire.com/download/wr4yeydjyoyc397/firma_dinamica.rar

[CSS & JS]Personalizar input file


Los que alguna vez jugueteamos con el diseño web, muy seguramente nos encontramos con el problema de personalizar los input file. Inteentaré mostrar la forma en que logré personalizar los input file usando sólo CSS, JS, y el DOM de una manera sencilla. Que además nos permite eliminar archivos que ya estan en la lista para ser subidos al servidor.

La idea es convertir esto:


en esto:


Código: HTML5
  1. <html>
  2.     <head>
  3.         <link href="input.css" rel="stylesheet" />
  4.         <script src="input.js"></script>
  5.     </head>
  6.     <body>
  7.         <center>
  8.             <form action="http://127.0.0.1:5000/upload" enctype="multipart/form-data" method="POST" id="frm_upload">
  9.                 <div id="upload">
  10.                     <input id="archivos" type="file" name="file[]" multiple="multiple" onchange="seleccionados();"/>
  11.                 </div>
  12.                 <span id="filename"></span>
  13.                 <p/>
  14.                 <input type="button" name="submit" value="Subir" onclick="subir();"/>
  15.             </form>
  16.         </center>
  17.     </body>
  18. </html>
  19.  

Para eso, vamos a usar un formulario normal, estructurado así:

un div con id "upload" dentro del cual meteremos el input file; es el div que moldearemos para que tome la forma que nuestro upload tenga.
un input file configurado para seleccionar multiples archivos. Cuando se selecciona un archivo (evento onchange) llama a la función seleccionados
un span con id "filename" que es donde mostraremos los archivos seleccionados
un input button que se encargara cuando hagamos click sobre el de enviar el formulario.

El css (input.css):

Código: CSS
  1. input[type=file] {
  2.     opacity: 0;
  3.     width: 100%;
  4.     height: 100%;
  5. }
  6.  
  7. #upload {
  8.     background: url("https://cdn2.iconfinder.com/data/icons/internet/512/Upload-128.png") #111 center center no-repeat;
  9.     width: 150px;
  10.     border-radius: 5px;
  11.     height: 150px;
  12.     box-shadow: 0 0 5px #111;
  13. }

Este sencillo CSS simplemente hace invisible el input file (opacity: 0) y le da un ancho y alto de 100% para que ocupe la totalidad del div (upload)
en el bloque #upload, damos la apariencia que queremos que tengo nuestro upload agrgando un simple background, una sombra y unas dimensiones (150x150).

Hasta ahora, nuestro upload se ve así:

Si lo clickeamos, nos abre la ventana para seleccionar los archivos, pero una vez seleccionados, NO LOS MUESTRA. Así que ahora vamos a codear el JS:

El JS (input.js): Los navegadores no nos dejan modificar los datos de los input file, pero si que nos permite juguetear un poco con los datos. Así que lo que haremos sera obtener la lista de los elementos seleccionados y la guardaremos en un array que podremos modificar (ara eliminar los elemento que no queremos subir) y a la hora de enviar el formulario al servidor, lo que haremos es simular un formulario que llenaremos con la informacion del array y lo enviamos al servidor.

La función seleccionados:

Código: Javascript
  1. //Creamos el array que usaremos para almacenar y enviar la informacion
  2. var ELEMENTOS = new Array();
  3.  
  4. function seleccionados() {
  5.     //Obtenemos el inputfile
  6.     var input = document.getElementById("archivos");
  7.     //Obtenemos los archivos
  8.     var archivos = input.files;
  9.     //Aca es donde mostraremos los elementos seleccionados
  10.     var elementos = document.getElementById("filename");
  11.        
  12.     //Limpiamos los elementos seleccionados anteriormente
  13.     elementos.innerHTML = " ";
  14.     ELEMENTOS = [];
  15.    
  16.     //Recorremos archivo por archivo
  17.     for (item=0; item< archivos.length; item++) {
  18.         //duplicamos el archivo seleccionado en el array elementos
  19.         ELEMENTOS[item] = archivos[item];
  20.         //Creamos un div donde mostramos el archivo seleccionado
  21.         crear_div("file", elementos, archivos[item].name);
  22.     }
  23. }
  24.  

La funcion crear_div: Esta funcion se encarga de crear un div, agregarle propiedades y luego incrustarlo en un elemento padre

Código: Javascript
  1. //funcion que crea un div
  2. function crear_div(clase, padre, informacion) {
  3.     //Escapamos la variable informacion para evitar posibles XSS
  4.     informacion = escape(informacion);
  5.     //Creamos el div
  6.     var div = document.createElement("div");
  7.     //Le agregamos al div sus propiedades
  8.     div.setAttribute("class", clase);
  9.     div.setAttribute("title", "click para eliminar");
  10.    
  11.     //en caso de hacer click en un elemento, lo elimina de la lista de los archivos a subir
  12.     div.onclick = function() {
  13.         var index = -1;
  14.         //eliminamos el archivo seleccionado de la lista
  15.         for (indice=0; indice < ELEMENTOS.length; indice++) {
  16.             //Buscamos el index del elemnto seleccionado para ser eliminado
  17.             if (ELEMENTOS[indice].name == unescape(informacion)) {
  18.                 index = indice;
  19.             }
  20.         }
  21.         if (index != -1) {
  22.             //removemos el elemento de la lista
  23.             ELEMENTOS.splice(index, 1);
  24.             padre.removeChild(div);
  25.         } else {
  26.             alert("No se pudo eliminar el elemento");
  27.         }
  28.        
  29.     }
  30.    
  31.     //Agregamos el div al padre
  32.     padre.appendChild(div);
  33.     div.innerHTML = informacion;
  34. }
  35.  


Hasta ahora, nuestro upload se ve así.

Sólo nos resta darle un estilo a los div que contienen el nombre de los archivos seleccionados (que tienen la clase file):

Código: CSS
  1. .file {
  2.     background: #111;
  3.     display: inline-block;
  4.     margin: 5px;
  5.     color: #FFF;
  6.     line-height: 25px;
  7.     padding: 5px;
  8.     border-radius: 5px;
  9.     box-shadow: 0 0 5px #000;
  10. }

Y programar la función para subir los archivos al servidor:

Código: Javascript
  1. function subir() {
  2.     //creamos un nuevo formulario y lo llenamos con la información del array con los elementos a enviar
  3.     var formulario = new FormData();
  4.    
  5.     for (file=0; file < ELEMENTOS.length; file++) {
  6.         formulario.append("file[]", ELEMENTOS[file]);
  7.     }
  8.    
  9.     //obtenemos el action y method del formulario original
  10.     var frm = document.getElementById("frm_upload");
  11.     var metodo = frm.method.toUpperCase();
  12.     var action = frm.action;
  13.    
  14.     //enviamos el formulario
  15.     var request = new XMLHttpRequest;
  16.     request.open(metodo, action);
  17.     request.send(formulario);
  18. }

Y nuestro uploader está listo.