Le perl suivant le script utilise soit le Digest::MD5 ou Digest::SHA module pour transformer une adresse MAC en un hachage, en utilisant un sel secret. Voir les pages de manuel des modules pour plus de détails à leur sujet. Il convient de noter que Digest::SHA propose plusieurs autres algorithmes parmi lesquels choisir.
Le code est écrit pour faciliter le choix d'un algorithme de hachage différent - décommentez-en un et commentez les autres pour choisir celui qui vous convient le mieux. BTW, la sortie du _base64 versions des fonctions est un peu plus courte que le _hex fonctions mais ressemblent plus à du bruit de ligne.
J'ai simplifié votre regex fourni (je n'ai pas vu la nécessité d'un regard en arrière). Vous devrez peut-être modifier un peu cela pour travailler avec vos données d'entrée .... vous n'avez fourni aucun échantillon, alors j'ai juste deviné.
#!/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;
};
Comme demandé dans le commentaire, voici un exemple comment effectuer une telle substitution avec sed . Vous avez utilisé la balise /linux, il devrait donc être sûr d'utiliser GNU sed avec son e drapeau pour le s commande :
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
Explication :
- Le
hLa commande enregistre la ligne dans l'espace de maintien, afin que nous puissions la restaurer après avoir gâché la ligne (- ; s/.*clientMac":\s"([A-Z0-9]{12}).*/echo secretKey\1|md5sum/ecorrespond à toute la ligne, en mettant le MAC réel dans()à réutiliser dans le remplacement. Le remplacement forme la commande à exécuter :echoing le MCA avec le "sel" et le canaliser dansmd5sum. Leele drapeau faitsedexécutez ceci dans le shell et remettez le résultat dans le tamponTbranches à la fin du script si aucun remplacement n'a été effectué. Il s'agit d'imprimer des lignes sans MAC non modifié. Les lignes suivantes ne sont exécutées que si un remplacement a été effectuéGajoute la ligne d'origine du tampon de maintien, nous avons donc maintenant lemd5sumsortie, une nouvelle ligne et la ligne d'origine dans le tampons/(.*)\s*-\n(.*clientMac":\s")[A-Z0-9]{12}(.*)/\2\1\3/capture le MD5 dans la première paire de(), la ligne avant le MAC dans le second et le reste de la ligne après le MAC dans le troisième, donc\2\1\3remplace le MAC par le MD5
Comme approche alternative, j'ai parfois utilisé des numéros de ligne simples comme valeur d'obscurcissement. Cela rend la sortie plus compacte et plus lisible.
Aussi, awk est un bon outil quand on a besoin d'effectuer des opérations "intelligentes" sur un fichier texte, ayant un langage plus lisible que sed . L'opération "intelligente" à effectuer dans ce cas est d'éviter de ré-exécuter l'algorithme d'obscurcissement lorsqu'une même adresse MAC est rencontrée plus d'une fois. Cela peut considérablement accélérer les opérations si vous avez des milliers de lignes faisant référence à un petit nombre d'adresses MAC.
En pratique, considérez le script suivant, qui gère également les multiples adresses MAC possibles apparaissant sur une même ligne, identifiant et remplaçant chaque occurrence, puis imprime une table de mappage à la fin :
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
Le tableau à la fin peut être facilement séparé de la sortie principale par une étape d'édition supplémentaire, ou en faisant simplement la chaîne de commande dans le -v table= l'argument redirige sa sortie vers un fichier, comme dans -v table='sort -k 1,1n | column -t > table' . Il peut également être supprimé complètement en supprimant simplement l'intégralité du END{ … } bloquer.
En variante, utiliser un vrai moteur de chiffrement pour calculer les valeurs d'obfuscation et donc sans table de mapping à la fin :
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
Ici, j'ai utilisé openssl comme moteur de chiffrement en sélectionnant son aes-256-cbc cipher (avec également une sortie encodée en base64 afin d'être compatible avec le texte), et en lui faisant lire le secret de chiffrement à partir d'un fichier nommé mypassfile .
Chaînes chiffrées avec un chiffrement symétrique (comme aes-256-cbc ) peut être déchiffré en connaissant le secret utilisé (le contenu de mypassfile , que vous souhaitez garder pour vous), elles peuvent donc être inversées. Aussi, depuis openssl utilise un sel aléatoire par défaut, chaque exécution produit des valeurs différentes pour la même entrée. Ne pas utiliser de sel (option -nosalt ) ferait openssl produirait la même valeur à chaque exécution, donc moins sécurisé, mais produirait en revanche des textes plus courts tout en étant cryptés.
Le même awk le script fonctionnerait pour d'autres commandes externes au lieu de openssl en remplaçant simplement la commande dans le -v crypter= argument de awk , tant que la commande externe que vous choisissez peut accepter l'entrée de stdin et imprimer la sortie sur stdout.
Les chaînes hachées avec des algorithmes comme MD5 ou SHA sont à sens unique (c'est-à-dire qu'elles ne peuvent pas être inversées) et produisent toujours la même valeur pour la même entrée, donc vous voudriez les "saler" pour que les valeurs calculées produit en sortie ne peut pas simplement être recherché sur toutes les adresses MAC possibles. Vous pouvez ajouter un "sel" aléatoire comme dans le script légèrement modifié suivant :
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
Ce dernier script utilise une valeur (pseudo-)aléatoire de 16 octets de long comme "sel", produisant ainsi une valeur de hachage différente à chaque exécution sur les mêmes données.