Open de todo

Estas son unas reflexiones a raiz de alguna conversación parcial en el grupo de cybercirujas, cosas que converso acaloradamente conmigo mismo. Por un lado comparto, por el otro registro para mí mismo dentro de unos años. No pretenden ser muy completas ni balanceadas, estoy apuntando más bien a open cores y open hardware y asumo que quien lea mayormente conoce el tema.

Empiezo con varias modalidades y áreas que irán creciendo:

• Gratis
  
• Free
• Open/Libre
• Pago

• Software
• Hardware

Hay mucho "open", que a veces se confunde con "free", el cuál por su significado en inglés se confunde "libre" con "gratis".

 

Gratis/Licenciado

 

Empecemos con "gratis", sabiendo que no hay (casi) nada gratis. Software gratis es el que uno no paga. ¿Son las herramientas  como Vivado, Keil, MCUxpresso gratis? Si, aunque nadie las llama "freeware". Yo las llamaría "licenciadas", o sea, no te cobran pero es igual a haberlas comprado, o sea, te las venden por $0.

No voy a ahondar en los aspectos en los cuales para los proveedores de estas herramientas les sacan provecho pese a ser $0, pero así rapidito podríamos mencionar que sirven para que la gente las use y sí pague por versiones más completas, librerías, servicios, cores y hardware real.

También existe el hardware gratuito, lo que pasa es que es muy muy escaso por su naturaleza no copiable sin costo.

Están las muestras gratis y los kits que se sortean o se reparten a ciertos proyectos, conozco algunos casos que comento para mostrar a quienes no conocen nada que si uno está atento, puede conseguir algo cada tanto. Hay poco link a artículos pues los tengo todos a medio hacer:

• A los asistentes de un workshop reciente de diseño de sistema embebido les regalaron una Raspberry Pi RP2040.
• A los asistentes de un tutorial de uso de ZYNQ con Python nos intentaron regalar unas PYNQ-Z2 pero los organizadores no sabían cómo funciona la aduana por acá y no hubo manera razonable de obtenerlos.
• A los que llenamos una encuesta de ya ni recuerdo qué, nos regalaron una MiMXRT-1020 EVK (te lo debo).
• A los que asistimos a un webinar de SRAM PUF de nos regalaron una STM32L4A6 (te lo debo).
• A los que asistimos a una charla de microvisores, estoy por recibir una placa apropiada para probarlos (te lo debo).
• Si tenés un proyecto Arduino que bastante gente use, pudiste haber recibido una placa Arduino UNO R4
• Me han contado que muchos fabricantes te mandan unas muestritas pequeñas de componentes y que hace algunos años Argentina había sido banneada por que empresas locales pedían mediante muchas personas modo proxy para sus productos finales.
  

El nicho de las muestras gratuitas se extiende bastante, pero contar con ello para algo por fuera de pruebas e investigaciones, me parece que es como llevarse el shampú del hotel... no escala.

 

Libre/Open

Los pongo juntos pues son extremandamente parecidos, es algo con lo que podés hacer lo que quieras, podés ver el código fuente, ya sea un programa, un diseño de hardware o un core, modificarlo y luego según el detalle de la licencia específica (gpl, apache, lo que sea), redistribuirlo, venderlo.

Puede ser open:

• Software
• Sistema operativo
• Programa
• Herramienta
• Librería
  
• BIOS/Firmware
• boot loader
  
• Core
• CPU
• Controlador de memoria
• Acelerador criptográfico
  
• Hardware
• Motherboard
  
• Placa
• de red
  
• Módulo
• Adaptador USB-Ethernet
  

La diferencia fundamental respeco a Gratis/Licenciado es que podés ver el código fuente, modificarlo, lo que sea dependiendo de la licencia específica.

Lo más correcto es llamarlos "Open Source XXX", que distingue claramente entre verle las tripas y tenerlo funcionando. Esto es tanto en hardware como en software, puede ser muy gratuito y open tener, pero ejecutar requiere hardware y electricidad (y otro montón de cosas que uno no presta atención como espacio, ventilación, seguridad, conectividad, limpieza) que no son gratis para nada.

Los modelos de Machine Learning pueden ser muy Open Source, pero entrenar uno te puede salir un ojo de la cara en hardware/tiempo/electricidad.

 

Todos contra todos

 

¿Algo pago puede ser open?

El primer ejemplo que me viene a la cabeza es todo lo del proyecto CIAA que es Open Source Hardware y Firmware, pero tenés que pagar las placas. La sutileza es que no tenés que pagar para usar, modificar o fabricar los diseños, sólo pagás el producto terminado o los componentes y el uso de herramientas y trabajo si vas a fabricarlo vos.

El hardware tiene al menos dos niveles, siendo "cores" lo que hay dentro de un chip y "hardware" lo que une los chips: 

El diseño del chip, lo que va ahí dentro, no voy a decir que cualquiera puede hacerlo, pero si voy a decir que fabricar ese diseño es infernalmente caro.

Open Source Core o Silicon es el diseño del chip, no su fabricación.

El de armar una placa que dependiendo de la tecnología es algo que uno mismo puede hacer o mandar a hacer por un precio relativamente accesible.

 Open Source Hardware es el diseño del hardware, no el hardware físico.

FPGA te permite instanciar en Hardware que puede ser Open Source o no (ciaa-fpga o iceStick respectivamente), Cores que pueden ser Open, como una CPU RISC-V en un SOC icicle en las anteriores () o no como un Microblaze (que es Gratis/Licenciado) en una placa de Xilinx (que no es ni Open ni nada).

Con una FPGA más poderosa, con una CPU RISC-V apropiada y otros cores adicionales como MMU, timers, controlador de interrupciones, podés ejecutar un Linux, que es Open Source Software.

Una placa del proyecto CIAA que utilice un SoC RISC-V o POWER para correr un Linux, sería el ejemplo más Open que puedo imaginar.

¿Es posible una computadora completamente Open Source? No sé, no creo, ¿qué pasa con la memoria? ¿con los componentes analógicos?

 

Una especie de resumen:

	software	bios	cores	hardware
gratis	linux	libreboot	open cores	muestras
open/libre	linux	libreboot	risk-v	el proyecto ciaa
licenciado	vivado	???	los que vienen con vivado	???
cerrado	windows	ami bios	arm	nxp
pago	windows y vivado	ami bios	arm	nxp

Algunos links interesantes

 

https://libreboot.org/

https://lowrisc.org/open-silicon/

https://www.proyecto-ciaa.com.ar/

Parte de Flisol 2022

En esta oportunidad expuse un mezcladito de varios open:

Open HW/Core/SW: SoC ICICLE con CPU RISC-V en EDU-CIAA-FPGA

A mi propuesta original que incluía el ataque mostrado en H4CK3D 2021, el Profesor Matías me recomendó podarla para que sea menos técnica. Esa poda fué insuficiente, ya el título es bastante largo y complicado, a la mayor parte de la asistencia no era un tema que le interesara, no importa, para FLISoL 2023 tengo pensado algo más apropiado.

 

Mi idea fue ir evolucionando distintas implementaciones de la luz ondulante de K.I.T.T. hasta llegar a un softcore en FPGA, aprovechando el trabajo de un montón de gente:

 

Historia

 Lo rojito a la derecha era mi objetivo, lo expuesto en H4CK3D 2021

 

La primera versión es con componentes digitales, la hice hace casi 35 años, un registro de desplazamiento con unas puertas OR animadas a continuación, con un 555 para el clock, unos OR, un flip flop y algún capacitor para  inyectar el primer bit.

Ese bit entra en la primera posición del registro de desplazamiento y en cada tick del clock se va moviendo, con la salida conectada a la entrada con un OR al flip flop que salvo en el arranque siempre está en cero, lo tenemos para siempre. Yendo hacia los leds, con los OR de la derecha transformamos el movimiento en un aparente ida y vuelta.

K.I.T.T. con compuertas digitales

 

Comparando precios, el costo es similar a implementarlo con un microcontrolador. Ponemos un bit en uno y lo vamos desplazando para un lado hasta detectar que llegó al punto deseado, ahí invertimos el sentido del movimiento, para siempre.

K.I.T.T. con microcontrolador y lógica específica

El programa es corto pero complicado e inadaptable a otros patrones. Una versión mejor aunque te indigne desde el punto de vista de la programación es:

while (true) {
  gpio_A.out(1);
  delay(DELAY);
  gpio_A.out(2);
  delay(DELAY);
  gpio_A.out(4);
  delay(DELAY);
  gpio_A.out(8);
  delay(DELAY);
  gpio_A.out(16);
  delay(DELAY);
  gpio_A.out(8);
  delay(DELAY);
  gpio_A.out(4);
  delay(DELAY);
  gpio_A.out(2);
  delay(DELAY);
  gpio_A.out(1);
  delay(DELAY);
}

¿Por qué me atrevo a incluir esta manera? Pues por que es el precursor para esta version más linda, en lugar de código hardcodeado, la información está en un array:

unsigned int out[]={1,2,4,8,16,8,4,2,1};
int pos = 0;
int limit = sizeof(out)/sizeof(out[0]);

while ( true) {
  gpio_A.out(1);
  delay(DELAY);
  ++pos;
  if (pos == limit) {
    pos = 0;
  }
}

y esto se parece mucho a la implementación nuevamente con componentes digitales.

K.I.T.T. con contador y memoria

 

Ahora, tanto en hardware como en software, podemos con gran facilidad mostrar otros patrones manipulando la memoria o el array según corresponda:

 

K.I.T.T. con contador y memoria y patrones arbitrarios

 

En la charla acompañando a esta evolución también fui contando como funciona una computadora a un nivel más bajo, que me cuesta mucho convertir a este formato, quizás haga un video en algún momento, lamentablemente no pude grabar la sesión.

Eso llevó a la explicación de FPGA y RISC-V, desembocando en el tema que me interesaba, la implementación primero en Verilog de la versión con lógica, como dispositivo incluido en el SoC icicle:

https://github.com/cpantel/evilCodeSequence/blob/master/kitt.sv

module kitt #( parameter BASETIME) (
    input clk,
    input reset,
    output [4:0]display_out,
    /* memory bus */
    input [31:0] address_in,
    input sel_in,
    //input read_in,
    //output logic [31:0] read_value_out,
    input [3:0] write_mask_in,
    input [31:0] write_value_in,
    output logic ready_out
);

    logic [25:0]q;
    logic direction;
    logic [4:0]display;

    assign ready_out = sel_in;
    assign display_out = display;

    always_ff @(posedge clk) begin
        if (reset) begin
            display <= 1;
            direction <= 1;
        end else if ( q > ( BASETIME / 1000 * 300 ) ) begin
            q <= 0;
            if (direction ) begin
                 if ( display[4] ) begin
                     direction = ~ direction;
                     display <= display >> 1;
                 end else
                     display <= display << 1;
            end else begin
                 if ( display[0] ) begin
                     direction = ~ direction;
                     display <= display << 1;
                 end else
                     display <= display >> 1;
            end 
       end else begin
            q <= q + 1;
            display <= display;
       end
    end

endmodule

 

Y por software, de modo concurrente y absolutamente independiente, ejecutándose en la CPU:

 

/*
  This program implements a SW kitt
*/

#include <stdint.h>
#include "../memmap.h"
#include "../uart.h"
#include "../delay.h"


int main() {
    uart_init();

    uart_puts("KITT starting\r\n");
    for (;;) {
        LEDS = 1;
        delay();
        LEDS = 2;
        delay();
        LEDS = 4;
        delay();
        LEDS = 8;
        delay();
        LEDS = 4;
        delay();
        LEDS = 2;
        delay();
        uart_puts("KITT .\r\n");
    }
}

 

 

Si algo entendés de Verilog, te darás cuenta que ese dispositivo como que está en vano conectado a los buses, ya que no hay nada con lo que el programa en la CPU pueda interactuar. Es que me quedé sin tiempo, querría al menos haberle permitido cambiar la velocidad.

En una próxima entrega espero no muy lejana, mostraré la implementación de un nuevo dispositivo que he de llamar "sequencer", que consistirá en una lógica que lea un trozo de memoria y lo exponga en los leds (vía PMOD como es ahora kitt) y que desde el programa se pueda arrancar, detener, pausar, cambiar la velocidad y modificar esa memoria.

 

 

w3af on raspberry pi

w3af on raspbian (debian 7.0)

Si necesitas versión en español, pídela y la haré.

Update: check http://seguridad-agile.blogspot.com/2015/11/choco-pi.html for a cool and tasty case 

Dreaming about plugging in a tiny box in a free port, wait a few minutes and walk away with a network scan and a vulnerability assessment in your pocket? Perhaps running an automated exploit too? So are you ready for load average: 2.85, 2.40, 1.72? You are not alone.

Step 0

Install raspbian[1] on your raspberry pi B[2]

$> sudo apt-get update
$> sudo apt-get upgrade

First attempt

Install w3af[3] from the repos

$> sudo apt-get install w3af

$> w3af_console

/usr/bin/w3af_console: 3: /usr/bin/w3af_console: /usr/bin/python2.5: not found

$> whereis w3af_console

w3af_console: /usr/bin/w3af_console

$> cat /usr/bin/w3af_console



Rename python2.5 to python, bad start.

$> w3af_console

28 seconds later...



w3af>>> profiles
w3af/profiles>>> use fast_scan
The plugins configured by the scan profile have been enabled, and their options configured.
Please set the target URL(s) and start the scan.
w3af/profiles>>> back
w3af>>> target
w3af/config:target>>> set target http://192.168.1.102/
w3af/config:target>>> back
w3af>>> start
Auto-enabling plugin: grep.error500
The thread: <WorkerThread(Thread-9, started daemon -1319824272)> raised an exception while running the request: <bound method fingerprint_404._send_404 of <core.controllers.coreHelpers.fingerprint_404.fingerprint_404 instance at 0x1a8d3c8>>
Exception: w3afMustStopException found by _send_404, someone else will handle it.
The thread: <WorkerThread(Thread-14, started daemon -1361767312)> raised an exception while running the request: <bound method fingerprint_404._send_404 of <core.controllers.coreHelpers.fingerprint_404.fingerprint_404 instance at 0x1a8d3c8>>

try again...
 
w3af>>> version
w3af - Web Application Attack and Audit Framework
Version: 1.1 (from Debian Package 1.0-rc3svn3489-1)
Author: Andres Riancho and the w3af team.

oops! it's too old! but its new! I've just installed it from the repo! I can not ask for help: "Please upgrade to the latest version". We have to clean up the mess.


# dependencies.pl

# parses an apt log searching for a package
# and prints all the packages that were 
# installed to fulfil it's dependencies.

my $found = 0;
my $stop=0;
my $result='';
while (( $line = <> ) && !$stop) {
  chomp;
   
  if ($found==1) {
    foreach my $val (split(' ', $line)) {
      if (! ( $val =~ m/[()]/ ) and ! ($val =~ /Install/ )) {
        my ($name,$arch) = split(':',$val);
          $result .= "$name ";
        }
      }
      $stop=1;
   } elsif ($line =~ m/Commandline: apt-get install w3af/) {
      $found=1;
   }
}
print $result . "\n";

Run this script to remove w3af and it's dependencies.

$> sudo apt-get remove $( cat /var/log/apt/history.log | perl dependencies.pl)

Second attempt

Install w3af from github.

$> git clone https://github.com/andresriancho/w3af.git

$> ./w3af_console

It will start crying for dependencies, be kind with it and resolve them:

$> sudo apt-get install python-setuptools git libxslt-dev python2.7-dev libsqlite3-dev libxml2-dev python-pip



$> sudo pip install PyGithub GitPython pybloomfiltermmap esmre nltk pdfminer futures pyOpenSSL lxml scapy-real guess-language cluster msgpack-python python-ntlm


$> sudo pip install -e git+git://github.com/ramen/phply.git#egg=phply

Run it again and again

$> ./w3af_console
$> sudo pip install chardet
$> sudo pip install -e git+git://github.com/ramen/phply.git#egg=phply

$> ./w3af_console

Do you accept the terms and conditions? [N|y] y

I'd only tried the console because I don't have an hdmi monitor and did not want to burn my eyes with the tv output, so I used ssh from a "real" computer.

Later, I connected with ssh -X and tried the gui:

$> ssh pi@192.168.1.105 -X

$> ./w3af_gui


Resolve until it runs

$> sudo apt-get install graphviz python-gtk2 python-gtksourceview2

$> sudo pip install xdot

If you are using a 2GB card like me,

rootfs           1838936 1488260    257636  86% /

keep an eye on df. If you are running out of space, remember to purge /var/cache/apt/archives. pip does not keep temporary files, but apt-get installs the packages in the root partition. Remember that 4GB is the recommended size.

I am using an extra pendrive with ext4 to host w3af with no problems.

Some people would say "why didn't you use http://pwnpi.sourceforge.net?[4]"

Well, it's more fun this way and learn about it later and I don't have another sd card.

(update: there is a pretty list at http://resources.infosecinstitute.com/pentesting-distributions-and-installer-kits-for-your-raspberry-pi/ )

One way or another, the nerd thing:

Step two

Be careful, don't fry your computer

 

Thanks to Andrés Riancho from w3af for the advice on monitoring w3af.

There is a single file [5] to modify.

First you have to import gpio and add some setup code



import RPi.GPIO as GPIO
GPIO.setmode(GPIO.BCM)
GPIO.setup(channel, GPIO.OUT) // for each channel

Then you turn on the leds

GPIO.output(channel, True/False) // for each channel


Event based blinking effect without PWM

GPIO.output(channel, not GPIO.input(channel))

I left this out in order to keep the leds on when the script is over

GPIO.cleanup()

update: Andrés asked me for the code, here it is:

diff --git a/core/controllers/core_helpers/status.py b/core/controllers/core_
helpers/status.p
index 8aa19bf..353f154 100644
--- a/core/controllers/core_helpers/status.py
+++ b/core/controllers/core_helpers/status.py
@@ -19,6 +19,7 @@ along with w3af; if not, write to the Free Software
 Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

 '''
+import RPi.GPIO as GPIO
 import time

 import core.controllers.output_manager as om
@@ -33,6 +34,12 @@ class w3af_core_status(object):
     the different methods to (get) the information required.
     '''
     def __init__(self, w3af_core):
+        GPIO.setmode(GPIO.BCM)
+        GPIO.setup(25, GPIO.OUT, initial=GPIO.LOW)
+        GPIO.setup(24, GPIO.OUT, initial=GPIO.LOW)
+        GPIO.setup(23, GPIO.OUT, initial=GPIO.LOW)
+        GPIO.setup(4, GPIO.OUT, initial=GPIO.LOW)
+
         # Store the core to be able to access the queues to get status
         self._w3af_core = w3af_core
        
@@ -49,6 +56,8 @@ class w3af_core_status(object):
         # The current fuzzable request that the core is analyzing at each phase
         # where a phase means crawl/audit
         self._current_fuzzable_request = {}
+        print "#### INIT ####\n"
+        GPIO.output(25, True)

     def pause(self, pause_yes_no):
         self._paused = pause_yes_no
@@ -81,6 +90,8 @@ class w3af_core_status(object):
             audit_fr = self.get_current_fuzzable_request('audit')
            
             if crawl_plugin == audit_plugin == crawl_fr == audit_fr == None:
+                print "#### STARTING SCAN ####\n"
+                GPIO.output(24, True)
                 return 'Starting scan.'

             status_str = ''
@@ -110,6 +121,8 @@ class w3af_core_status(object):
         self._running_plugin[plugin_type] = plugin_name
         self._latest_ptype, self._latest_pname = plugin_type, plugin_name
+        print "#### SET RUNNING PLUGIN: %s ####\n" % plugin_name
+        GPIO.output(23, not GPIO.input(23))

     def get_running_plugin(self, plugin_type):
         '''
@@ -129,6 +142,9 @@ class w3af_core_status(object):
         :return: If the user has called start, and then wants to know if the
         core is still working, it should call is_running() to know that.
         '''
+        print "### RUNNING ###\n"
+        GPIO.output(23, not GPIO.input(23))
+
         return self._is_running
    
     def is_paused(self):
@@ -170,6 +186,10 @@ class w3af_core_status(object):
         self._is_running = False
         self._running_plugin = {}
         self._current_fuzzable_request = {}
+        print "### SCAN FINISHED ###\n"
+
+        GPIO.output(23, True)
+        GPIO.output(4, True)

     def get_current_fuzzable_request(self, plugin_type):
         '''
@@ -282,11 +302,10 @@ class w3af_core_status(object):
                       ' ETA (%(aeta)s)\n'
                      
         status_str += 'Requests per minute: %(rpm)s'
-       
         return status_str % data

 def round_or_None(float_or_none):
     if float_or_none is None:
         return None
     else:
-        return round(float_or_none, 2)
\ No newline at end of file
+        return round(float_or_none, 2)

References

[1] http://www.raspbian.org
[2] http://www.raspberrypi.org

[3] http://w3af.org
[4] http://pwnpi.sourceforge.net
[5] https://github.com/andresriancho/w3af/blob/master/core/controllers/core_helpers/status.py
[6] http://code.google.com/p/raspberry-gpio-python

Addon Chrome

Read first http://seguridad-agile.blogspot.com/2012/02/addon-firefox.html

It is the Chrome version, it is almost the same but I could not find an easy way to copy the cleaned url to the clipboard, so there is an ugly alert where you can copy from.

The other difference is that the FF version understands a more fine grained context, where Chrome sees a "link", FF can see an "a" of class "l". So, FF only offers nogoogle to the links that may have an intercepted link, whereas Chrome offers nogoogle for every link.

Don't expect any improvement unless some feedback or hint is given, as I seldom use Chrome.

As I don't have yet access to the store, here [1] is a base64 encoded version.

Paste it to nogoogle.base64
cat nogoogle.base64 | base64 --decode > nogoogle.tgz
tar -xzf nogoogle.tgz

Open google chrome, go to Wrench ->Tools-> Extensions-> Enable Developer Mode -> Load Unpacked Extension


Versión en español:

Lee primero http://seguridad-agile.blogspot.com/2012/02/addon-firefox.html

Esta es la versión para Chrome, que es casi igual salvo que no he hallado la manera de utilizar el clipboard, asi que hay que copiar desde un horrible alert()

La otra diferencia es que en FF se puede tener un mejor control de selección de contexto; donde Chrome ve un "link", FF ve un "a" de la clase "l". Asi es que FF ofrece nogoogle para los links que pueden estar interceptados mientras Chrome lo ofrece para todos los links.

No esperes cambios a menos que haya alguna ayuda, ya que casi no uso Chrome.


Dado que no tengo aun acceso al store, aqui [1] hay un versión en base64.


Pegala en nogoogle.base64

cat nogoogle.base64 | base64 --decode > nogoogle.tgz
tar -xzf nogoogle.tgz


Abrí Chrome y Wrench ->Tools-> Extensions-> Enable Developer Mode -> Load Unpacked Extension


[1]

H4sIAJapO08AA+1X32/bNhD2s/+Kgx4WB3EV+TeQxgW2rBsCdO2ArNhDFgS0RElcGFIgqXhG4f+9
R9JqbNdpuixtEIzfQxIdj/d9JO/Ii5CFlAWnlzdJ77D1bZAgJqOR/d2bjJL13w1avd6kNx4NxsPJ
sJX0+pP+oAWjb6RnA7U2RAG0UqK41Hf73Tf+TCHWz7/5iP9+1IXaAx4Ph3ed/2CQjG/PfzTG8x8l
mAaQPKaIu/A/P//DQziR1UKxojTQSfehj9UHJ26x8DsRhnKWUR3Dj5yD89KgqKbqhmZxG2e/1xRk
DqZkGrSsVUohlRkF/CzkDVWCZjBbAIGfzn5+oc2CU+AspQKnmZIYSImAGbWRclmLDJhAO4U3pyev
3569hpxhOrbbK5mQckpsRM7EFRiJ36yaSaIyFKjhFKlrnoGQBidiMIKhjaEK5mTRBV3KOTADc2ZK
QFrCqTKQMcJl0c5rkRomBYaoFm8wfIeJXHYNme3DhzbADWaJY516EW74PLKm94pHF/sv0clF7ERn
Uinks+vb0245M6rNJ3mZ7DoW1JBBRbShkCt5DSVV9C8RwYEnwohLt/J3FRWbK8dNSmulqDCAAm+1
2whbutMSQ9MYv3VcVxkxtIN/xyzrwoeoRuVHu5ez/DI9AUHnm+Ro+IPMvkCfKmrp/zvtHM9WzjeY
/3Sm3eTe/d/yn9hxQFdYyw03B20+vkuKiiisian1jHXFGZ7/D5HLBjfss3oKOeGaOmsuFXTsEJsm
L4HBsQ8RcyoKU6Ll4GAVfhWfKZzvfM7ZRcMxXXEAy6Fjfc6TC5hOwS2umQ+f6I2qPTtihvtw5T+W
+HMJbR/F+TZTFTW1wvULqlNSUU/R82luZzXjirsNW+2Ezchps++pxOvjH/MbFfXa5htmOI2OIHor
4Vf33ERdiFa+OjrypxFdLB2VC5yWjGe9rw7sbgoXBAN7UacZDvg/d5KhUQq8TNIr9GtugCVsSeh/
tQSXvC5pbUnu1AG7hazpsFM/0zB4gAYmmmp94I740v5My/DhWnxNPlyOr3ebIxZP/Yo+X2z0f9dE
sBxfKuz/pHg8jnv6v2QwmWz3f8PBIPR/3wP2so8EuXZV2iRD1LVWbN40Pnp2IIl73oatYKpYZVb2
XyTn2FP5Wb6+sTmsOT6ItsmStcExJgrsgZSsixLW41dUXTNtKbDO4Txav0LsxWB7Bix86zoj6VWh
7PN0WZHCab01xaW55j6kCyHMpabYHjGzuKwkXhkL65/RnKCwF1qlsKcpz/cifLeeevufHBv1v7Wn
j8VxX/0nOLZV/5P+ONT/98Cxr2fAsphGa///R6+OD/3Qq1AkAQEBAQEBAQEBAQEBAQEBAQEBAQHP
EB8BzrrVBAAoAAA=

Addon Firefox

Tired of going through google every time I followed a result, I've made an add-on for firefox. It is very simple, adds some options to the contextual menu that allows you from getting the clean url in the clipboard to following the link in the same window, a new tab or a new window.

The usage of this add-on decreases a little bit the network usage as you access the url directly.

It avoids google knowing where you went.

This is the first link for a "hello world" search:

http://en.wikipedia.org/wiki/Hello_world_program

But if you ask the browser to "Copy Link Location" or click it, this is what you get:

http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&sqi=2&ved=0CDcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FHello_world_program&ei=cVQ5T5m5Oqfo0QHQub2hAg&usg=AFQjCNFFxBoE89z6dbsDCZwbcw9fSh-1TA

That is a trip to google where some statistics are gathered and then you are redirected to the correct link.


You can download from mozilla add-ons:

https://addons.mozilla.org/en-US/firefox/addon/nogoogle/


Chrome version: http://seguridad-agile.blogspot.com/2012/02/addon-chrome.html

Versión en español

Cansado de pasar por google cada vez que sigo un resultado, hice un addon para Firefox. Es muy simple, agrega unas opciones al menú contextual que permiten desde copiar el link limpio hasta seguirlo, tanto en el tab actual como en uno nuevo o en una nueva ventana.

Su uso disminuye un poquito el uso de la red al acceder directamente al sitio.


Tambien evita que google sepa a donde fuiste.

Este es el primer link de una búsqueda de "hello world"

http://en.wikipedia.org/wiki/Hello_world_program

Pero si copiás directamente la dirección o la seguís, esto es lo que obtenés:


http://www.google.com/url?sa=t&rct=j&q=&esrc=s&source=web&cd=1&sqi=2&ved=0CDcQFjAA&url=http%3A%2F%2Fen.wikipedia.org%2Fwiki%2FHello_world_program&ei=cVQ5T5m5Oqfo0QHQub2hAg&usg=AFQjCNFFxBoE89z6dbsDCZwbcw9fSh-1TA

Esto significa un viajecito a google, dejar algunas estadísticas y ser redirigido al link correcto.

Se puede bajar de  mozilla add-ons:

https://addons.mozilla.org/en-US/firefox/addon/nogoogle/


Versión Chrome: http://seguridad-agile.blogspot.com/2012/02/addon-chrome.html