Encontrando archivos duplicados con la Shell

Bueno, hablo de parte de las personas que conozco, pero al parecer los programadores de python detestan a Ruby. En vista esto, decidí hacer una entrada acerca de la entrada anterior, pero ahora, usando herramientas del sistema.

Utilizando La Orden Find Y Perl
Modo de invocación

find . -type f -exec sha1sum '{}' \; | perl script.pl

Fichero auxiliar, guárdese como script.pl, asegúrate de pasar la la dirección absoluta de este archivo a Perl.

use strict;

my %hsh = ();
while(<STDIN>) {
        /^([a-f0-9]+)\s+(.+)$/;
        print "$2\n";
        if( not $hsh{$1}) {
                @{$hsh{$1}} = ($2);
        } else {
                push @{$hsh{$1}}, $2
        }
}

print "\n\nDuplicates!\n\n";
for(keys %hsh) {
        next if(@{$hsh{$_}}==1); 
        print(join("\n  -> ", @{$hsh{$_}}));
        print "\n";
}

Utilizando La Orden Find Y AWK
Modo de invocacion

find . -type f -exec sha1sum '{}' \; | awk -f script.awk

Fichero auxiliar, guárdese como script.awk, asegúrate de pasar la la dirección absoluta de este archivo a AWK.

{
        path = substr($0, 41)
        print path
        if(!array[$1]) {
                array[$1]= path
                next
        }

        array[$1] = (array[$1] "\n  ->" path)
        duplicates[$1] = 1
}

END {
        if(!length(duplicates))
                exit

        print "\n\nDuplicates!\n\n"
        for(key in duplicates)
                print array[key] "\n\n"
}

Script Para Bash
Bueno, realmente considero que es un poco más práctico tener un script al que podamos invocar con argumentos, para esto seria conveniente incluir dentro de el  script de Bash el script para Perl, y con la opción -e pasar a Perl el programa como una cadena en vez de un fichero.  Por  motivos de brevedad, estaré utilizando la forma que he venido utilizando en toda la entrada.

#!/bin/bash

# By default, the current working directory is used.
DIR=$PWD

if [[ -n $1 ]]; then
        DIR=$1
fi
find $DIR -type f -exec sha1sum '{}' \; | perl script.pl

Es guay utilizar algoritmos de digest II

En la entrada anterior se habló de como utilizar las funciones hash para proteger un poco más nuestros datos. En esta entrada estaremos utilizando las funciones hash para conseguir los archivos duplicados dentro de nuestro sistema.

El tema de esta entrada es simple, la temática es la siguiente: Se calcula el hash de los datos — en este caso de cada archivo — y se está pendiente de que dos archivos no tengan la misma función hash, de ser así, se tiene un archivo duplicado y se procede con el procesamiento deseado.

Para ejecutar el siguiente programa se necesita:

• Ruby
• La gema Mp3Info
  

  gem install mp3info 

#!/usr/bin/env ruby
# encoding: utf-8
# Program that looks for duplicate files.
# Author: MaG, http://newbieshell.blogspot.com

require 'digest/sha2'
require 'find'
require 'mp3info'

class FileRecord
     attr_reader :file, :sum, :duplicates
     def initialize(path, sum)
          @file = path
          @sum = sum
          @duplicates = []
     end

     def has_duplicates?
          not @duplicates.empty?
     end

     def add(path)
          @duplicates.push path
     end
end

if ARGV[0].nil? or not File.directory? ARGV[0]
     $stderr.puts "Use: #$0 <directory>"
     exit 1
end

hsh = {}
EMPTY_STRING_SUM = Digest::SHA256.hexdigest ''

Find.find(ARGV[0]) do|path|
     next unless File.file? path

     puts path

     sum = nil
     if path =~ /\.mp3$/i
          begin
               mp3 = Mp3Info.new(path)
               pos, length = mp3.audio_content
               mp3.close
          rescue
               next # discard this problematic file
          end

          File.open(path) do|file|
               file.pos = pos
               sum = Digest::SHA256.hexdigest(file.read(length))
          end
     else
          sum = Digest::SHA256.file(path).hexdigest
     end

     next if sum == EMPTY_STRING_SUM

     # nah!, let's use +unless+
     unless hsh[sum]
          hsh[sum] = FileRecord.new(path, sum)
     else
          file_record = hsh[sum]
          file_record.add(path)
     end
end

print "\n\nduplicates!\n\n"

hsh.each_value do|record|
     next unless record.has_duplicates?

     print "#{record.file}:\n->"
     print record.duplicates.join("\n-> "), "\n\n"
end

Se utiliza la gema Mp3Info para localizar el segmento de audio y calcular la función hash a dicha parte del archivo. Se hace esto, porque es posible que los metadatos de dos archivos varíen y de esta manera corrompan la singularidad del archivo, aun cuando dichos archivos contengan el mismo audio.

Si bien, el programa utiliza un buen algoritmo, este requiere una cantidad considerable de cálculos, los cuales son directamente proporcionales al tamaño de los archivos dentro del directorio raíz en cuestión. Pero algo si es seguro, encuentra los archivos duplicados.

Conclusión
Es posible implementar este programa en un Shell Script utilizando la herramienta sha256sum y el comando find. Aunque con el Shell será un poco más difícil contrarrestar el problema de los metadatos en los archivos de tipo: mp3, jpeg, png, pdf, etc.

Al parecer, los formatos de audio parecen ser los más propensos a este tipo de casos, donde los metadatos corrompen la función hash. Es muy importante tener esto pendiente para cuando se necesite un poco más de precisión.

Si necesitas una solución utilizando Bash, o necesitas ayuda, deja un comentario o contáctame por correo, el cual está en la parte de arriba de este blog.

Es guay utilizar algoritmos de digest

Las funciones hash — o algoritmos de digest — tienen muchas aplicaciones y sobre todo, son guay. En esta entrada estaré hablando del uso de las funciones hash y los datos de validación.

Las Funciones Hash Y Las Contraseñas
Imagina que eres un intruso con pocos privilegios dentro de un servidor.  Encuentras un programa que posee privilegios para apagar el sistema, pero necesita clave, por eso examinas su código:

#!/usr/bin/env ruby

print 'Password '
exec 'shutdown -h now' if gets.chomp == 'adios'

puts 'Wrong password, try again.'

 Y ahí está la clave, ahora la cuestión es ¿Cómo reparar el script de modo que otras personas con privilegios de lectura no puedan ver la contraseña? Pues es simple en realidad, con una función hash codificas la contraseña y a la hora de comprobar, codificas la entrada y luego compruebas el hash resultante con el hash previamente calculado, así:

#!/usr/bin/env ruby
require 'digest/sha2'

# pass = newbieshell
PASSWORD = 'eeedeff1fde3065be0afcfc56fc775fb6de1f449bcb3f1845a8503e113bd8236'

print 'Password: '
sha2 = Digest::SHA256.hexdigest(gets.chomp)

exec 'shutdown -h now' if PASSWORD == sha2

puts 'Wrong password, try again.'

De esta forma el usuario no podrá ver la contraseña, para eso deberá recurrir a la fuerza bruta y si la clave es segura^en, le será muy difícil hallarla, incluso si cuenta con todo procesamiento del mundo .

Guardando Información En La Base De Datos
Cualquier ordenador conectado al Internet es vulnerable, por más seguridad y cosas que se hagan para protegerlo, seguirá siendo vulnerable; es la pura realidad. Por esta razón, también se deberá poner hincapié en proteger la información sensible; poner todo lo más difícil posible para cuando penetren el sistema (!).

Pues bien, lo primero que se debe hacer es, poner clave de acceso a todos los servicios y base de datos, incluso si solo se pueden acceder de manera local. Codificar con una función hash todos los campos de las base de datos que solo se utilizan para validar, p. ej. nombre de usuario, contraseña, correo.

De esta forma, si sufrimos un ataque de inyección SQL u otro de la misma naturaleza y tenemos todo los campos de validación codificados con una función hash, cuando el atacante obtenga la información, tendrá todo un reto en frente de él.