Reemplace la dirección MAC con UUID

El siguiente perl script usa el Digest::MD5 o Digest::SHA módulo para transformar una dirección MAC en un hash, utilizando una sal secreta. Consulte las páginas man de los módulos para obtener más detalles sobre ellos. Vale la pena señalar que Digest::SHA tiene varios algoritmos más para elegir.

El código está escrito para facilitar la elección de un algoritmo hash diferente:descomente uno y comente los demás para elegir el que más le convenga. Por cierto, la salida del _base64 versiones de las funciones es un poco más corto que el _hex funciona pero se parece más a un ruido de línea.

Simplifiqué su expresión regular proporcionada (no pude ver ninguna necesidad de mirar hacia atrás). Es posible que deba modificarlo un poco para que funcione con sus datos de entrada... no proporcionó ninguna muestra, así que solo supuse.

#!/usr/bin/perl

# choose one of the following digest modules:
use Digest::MD5 qw(md5_hex md5_base64);
#use Digest::SHA qw(sha256_hex sha256_base64);

use strict;

my $salt='secret salt phrase';

# store seen MAC addresses in a hash so we only have to calculate the digest
# for them once.  This speed optimisation is only useful if the input file
# is large AND any given MAC address may be seen many times.
my %macs=();

while(<>) {
  if (m/clientMac:\s*([A-Z0-9]{12})/i) {
    my $mac = $1;

    if (!defined($macs{$mac})) {
      # choose one of the following digest conversions:

      #my $uuid = sha256_hex($mac . $salt);
      #my $uuid = sha256_base64($mac . $salt);
      my $uuid = md5_hex($mac . $salt);
      #my $uuid = md5_base64($mac . $salt);

      $macs{$mac} = $uuid;
    };

    s/(clientMac:\s*)$mac/$1$macs{$mac}/gio;
  };
  print;
};

Como se solicita en el comentario, aquí hay un ejemplo de cómo realizar dicha sustitución con sed . Usaste la etiqueta /linux, por lo que debería ser seguro usar GNU sed con su e bandera para el s comando:

sed -E 'h;s/.*clientMac":\s"([A-Z0-9]{12}).*/echo secretKey\1|md5sum/e;T
  G;s/(.*)\s*-\n(.*clientMac":\s")[A-Z0-9]{12}(.*)/\2\1\3/' logfile

Explicación:

• El h El comando guarda la línea en el espacio de retención, por lo que podemos restaurarla después de estropear la línea (-;
• s/.*clientMac":\s"([A-Z0-9]{12}).*/echo secretKey\1|md5sum/e coincide con toda la línea, colocando el MAC real en () para ser reutilizado en el reemplazo. El reemplazo forma el comando a ejecutar:echo ing el MCA junto con la "sal" y canalizándolo en md5sum . El e bandera hace sed ejecute esto en el shell y vuelva a colocar el resultado en el búfer
• T se bifurca hasta el final del script si no se realizó ningún reemplazo. Esto es para imprimir líneas sin MAC sin modificar. Las siguientes líneas se ejecutan solo si se realizó un reemplazo
• G agrega la línea original del búfer de espera, por lo que ahora tenemos el md5sum salida, una nueva línea y la línea original en el búfer
• s/(.*)\s*-\n(.*clientMac":\s")[A-Z0-9]{12}(.*)/\2\1\3/ captura el MD5 en el primer par de () , la línea antes de MAC en el segundo y el resto de la línea después de MAC en el tercero, así \2\1\3 reemplaza el MAC con el MD5

Como enfoque alternativo, a veces utilicé números de línea simples como valor de ofuscación. Esto hace que la salida sea más compacta y legible.

Además, awk es una buena herramienta cuando se necesita realizar operaciones "inteligentes" en un archivo de texto, teniendo un lenguaje más legible que sed . La operación "inteligente" a realizar en este caso es evitar volver a ejecutar el algoritmo de ofuscación cuando se encuentra una dirección MAC más de una vez. Esto puede acelerar bastante las operaciones si tiene miles de líneas que se refieren a una pequeña cantidad de direcciones MAC.

En la práctica, considere la siguiente secuencia de comandos, que también maneja posibles direcciones MAC múltiples que ocurren en cualquier línea, identificando y reemplazando cada ocurrencia, y luego imprime una tabla de mapeo al final:

awk -v pat='clientMac"\\s*"[[:xdigit:]]{12}' -v table='sort -k 1,1n | column -t' -- '
$0 ~ pat {
    for (i=1; i <= NF; i++)
        if (match($i, pat)) {
            if (!($i in cache))
                cache[$i]=NR "." i
            $i = "MAC:" cache[$i]
        }
}
1
END {
    print "---Table: "FILENAME"\nnum MAC" | table
    for (mac in cache)
        print cache[mac], mac | table
}
' file.log

La tabla al final se puede separar fácilmente de la salida principal mediante un paso de edición adicional, o simplemente haciendo la cadena de comando en el -v table= argumento redirigir su salida a un archivo, como en -v table='sort -k 1,1n | column -t > table' . También se puede eliminar por completo simplemente eliminando todo el END{ … } bloquear.

Como variante, utilizando un motor de cifrado real para calcular los valores de ofuscación y, por lo tanto, sin una tabla de asignación al final:

awk -v pat='clientMac"\\s*"[[:xdigit:]]{12}' -v crypter='openssl enc -aes-256-cbc -a -pass file:mypassfile' -- '
$0 ~ pat {
    for (i=1; i <= NF; i++)
        if (match($i, pat)) {
            addr = cache[$i]
            if (addr == "") {
                "echo '\''" $i "'\'' | " crypter | getline addr
                cache[$i] = addr
            }
            $i = "MAC:" addr
        }
}
1
' file.log

Aquí usé openssl como motor de cifrado seleccionando su aes-256-cbc cifrado (también con una salida codificada en base64 para que sea compatible con el texto) y hacer que lea el secreto de cifrado de un archivo llamado mypassfile .

Cadenas encriptadas con un cifrado simétrico (como aes-256-cbc ) se puede descifrar conociendo el secreto utilizado (el contenido de mypassfile , que desea mantener para usted), por lo tanto, se pueden revertir. Además, desde openssl usa una sal aleatoria por defecto, cada ejecución produce diferentes valores para la misma entrada. No usar una sal (opción -nosalt ) haría openssl produciría el mismo valor para cada ejecución, por lo que sería menos seguro, pero por otro lado produciría textos más cortos mientras aún estuviera encriptado.

El mismo awk script funcionaría para otros comandos externos en lugar de openssl simplemente reemplazando el comando en el -v crypter= argumento para awk , siempre que el comando externo que elija pueda aceptar entradas desde la entrada estándar e imprimir la salida en la salida estándar.

Las cadenas codificadas con algoritmos como MD5 o SHA en cambio son unidireccionales (es decir, no se pueden revertir) y siempre producen el mismo valor para la misma entrada, por lo tanto, querrá "salarlas" para que los valores calculados producido en la salida no se puede buscar simplemente en todas las direcciones MAC posibles. Puede agregar una "sal" aleatoria como en el siguiente script ligeramente modificado:

awk -v pat='clientMac"\\s*"[[:xdigit:]]{12}' -v crypter='sha256sum' -- '
$0 ~ pat {
    for (i=1; i <= NF; i++)
        if (match($i, pat)) {
            addr = cache[$i]
            if (addr == "") {
                "(dd if=/dev/random bs=16 count=1 2>/dev/null; echo '\''" $i "'\'') | " crypter | getline addr
                cache[$i] = addr
            }
            $i = "MAC:" addr
        }
}
1
' file.log

Este último script utiliza un valor (pseudo) aleatorio de 16 bytes de longitud como "sal", lo que produce un valor hash diferente en cada ejecución sobre los mismos datos.