Comment générer une adresse MAC aléatoire valide avec le shell bash

Comment puis-je générer une adresse mac aléatoire valide avec bash.

La première moitié de l'adresse doit toujours rester la même comme celle-ci

00-60-2F-xx-xx-xx

juste la valeur x doit être générée au hasard?

Voici un poisson.

Ce script shell va générer la chaîne aléatoire que vous recherchez:

#!/bin/bash
hexchars="0123456789ABCDEF"
end=$( for i in {1..6} ; do echo -n ${hexchars:$(( $RANDOM % 16 )):1} ; done | sed -e 's/\(..\)/-\1/g' )
echo 00-60-2F$end

J'avais juste quelque chose ici qui montrait comment l'exécuter à partir de la ligne de commande, mais après avoir regardé la solution compliquée (mais votée) de Dennis Williamson, je vois que la réponse que les gens attendent est celle où ils n'ont pas à faire de travail se.

Dans le passé, je l'ai fait en utilisant:

echo 00-60-2F-$[RANDOM%10]$[RANDOM%10]-$[RANDOM%10]$[RANDOM%10]-$[RANDOM%10]$[RANDOM%10]

mais cela ne les rendra que dans la plage de 0 à 9. Pour mes besoins, c'était assez bon.

Une meilleure solution serait probablement d'utiliser printf:

printf '00-60-2F-%02X-%02X-%02X\n' $[RANDOM%256] $[RANDOM%256] $[RANDOM%256]

Voici comment cela fonctionne:

• Le programme printf est basé sur la fonction C "printf", qui prend une "chaîne de format" comme premier paramètre, puis des paramètres supplémentaires remplissent la chaîne de format.
• % dans la chaîne de format introduit un "spécificateur de format" qui peut être un ou plusieurs caractères indiquant comment formater les arguments.
• Un zéro de tête (0) dans un spécificateur de format signifie que la sortie numérique résultante doit être complétée avec des zéros de tête jusqu'à la largeur spécifiée.
• Le 2 indique que le spécificateur doit être affiché en prenant deux caractères de largeur.
• Le X termine le spécificateur et indique qu'il doit être interprété comme un nombre et affiché en hexadécimal. Parce qu'il s'agit de majuscules, les lettres af doivent être en majuscules.
• Le \ n est une nouvelle ligne - printf interprète la barre oblique inverse comme un code d'échappement qui peut être utilisé pour afficher d'autres caractères, souvent des caractères délicats comme la nouvelle ligne.
• Les caractères restants dans le spécificateur de format sont imprimés littéralement, cela inclut le "00-06-2F-" initial et les tirets entre les spécificateurs de format.
• Les arguments restants sont des substitutions de variables shell (désignées par $) et incluent une expression mathématique qui est un nombre aléatoire (RANDOM) modulo 256. Il en résulte un nombre aléatoire compris entre 0 et 255.

1. Générez un int de taille appropriée comme ceci: http://tldp.org/LDP/abs/html/randomvar.html
2. Convertissez en hexagone comme ceci: http://snipplr.com/view/2428/convert-from-int-to-hex/
3. Ajoutez les tirets entre trois morceaux générés aléatoirement

#!/bin/bash
RANGE=255
#set integer ceiling

number=$RANDOM
numbera=$RANDOM
numberb=$RANDOM
#generate random numbers

let "number %= $RANGE"
let "numbera %= $RANGE"
let "numberb %= $RANGE"
#ensure they are less than ceiling

octets='00-60-2F'
#set mac stem

octeta=`echo "obase=16;$number" | bc`
octetb=`echo "obase=16;$numbera" | bc`
octetc=`echo "obase=16;$numberb" | bc`
#use a command line tool to change int to hex(bc is pretty standard)
#they're not really octets.  just sections.

macadd="${octets}-${octeta}-${octetb}-${octetc}"
#concatenate values and add dashes

echo $macadd
#echo result to screen
#note: does not generate a leading zero on single character sections.  easily remediedm but that's an exercise for you

Ou en python:

from random import randint
def gen_mac_char():
  return hex((randint(0,16))).split('x')[1]
def gen_mac_pair():
  return ''.join([gen_mac_char(), gen_mac_char()])
def gen_last_half_mac(stem):
  return '-'.join([stem, gen_mac_pair(), gen_mac_pair(), gen_mac_pair()])
print(gen_last_half_mac('00-60-2F'))

Notez que la version python utilise uniquement un champ large de 16 pour générer un caractère hexadécimal, vous n'avez donc pas à vous soucier du remplissage nul - approche modifiée pour répondre à un commentaire.

À l'aide d'outils standard, soit

# output in capitals
hexdump -n3 -e'/3 "00-60-2F" 3/1 "-%02X"' /dev/random

ou

# output in lower case letters
echo 00-60-2f$(od -txC -An -N3 /dev/random|tr \  -)

pourrait être le plus court de tous.

#!/bin/bash
LC_CTYPE=C
MAC=00-60-2F
for i in {1..3}
do
    IFS= read -d '' -r -n 1 char < /dev/urandom
    MAC+=$(printf -- '-%02x\n' "'$char")
done
printf '%s\n' "$MAC"

Les clés du fonctionnement:

• LC_CTYPE=C - autorise les caractères> 0x7F
• IFS=- désactive l'interprétation de \t(tab), \n(nouvelle ligne) et de l'espace
• -d ''- permet les sauts de ligne
• -rpermet \(et devrait presque toujours être utilisé par habitude avecread )
• Le spécificateur de format -%02x\n fait que la sortie est un tiret littéral suivi d'un nombre hexadécimal à deux chiffres incluant un zéro de tête, le cas échéant. La nouvelle ligne est superflue ici et pourrait être omise.
• Le readobtient un seul octet ( -n 1) de /dev/urandom0 à 255 ( 00à FF).

• Le guillemet simple dans le dernier argument de printfdans la boucle fait que le caractère est sorti comme sa valeur numérique ("A" est sorti comme "65"). Voir la spécification POSIX pour savoirprintf où il est indiqué:

  Si le premier caractère est un guillemet simple ou un guillemet double, la valeur doit être la valeur numérique dans le jeu de codes sous-jacent du caractère suivant le guillemet simple ou le guillemet double.

Le moyen le plus court que j'ai pu trouver était d'utiliser directement hexdump

echo 00-60-2f$(hexdump -n3 -e '/1 "-%02X"' /dev/random)

• -n3 indique à hexdump de lire trois octets
• La chaîne de format imprime un tiret et une valeur hexadécimale à deux chiffres pour chaque octet
  • '/ 1' signifie appliquer le format pour chaque octet lu
  • "-% 02X" est une spécification printf pour imprimer un zéro, deux chiffres, une valeur hexadécimale en majuscule
• / dev / random est un octet aléatoire source

Testé sur GNU / Linux

Une autre solution en ligne

$ echo '00 60 2f'$(od -An -N3 -t xC /dev/urandom) | sed -e 's/ /-/g'

Même chose en majuscules

$ echo '00 60 2f'$(od -An -N3 -t xC /dev/urandom) | sed -e 's/ /-/g' | tr '[:lower:]' '[:upper:]'

Générez-le pour une variable d'environnement Bash

$ export MAC=$(echo '00 60 2f'$(od -An -N3 -t xC /dev/urandom) | sed -e 's/ /-/g')
$ echo $MAC

Détails:

• od (vidage octal)

  -AnSupprime la principale représentation d'adresse (bruit supplémentaire) de la sortie.
  -N3Limitez la sortie à trois octets.
  -t xCSortie en hexadécimal, style ASCII, comme vous le souhaitez.
  /dev/urandomPseudo-fichier à nombres aléatoires du noyau Linux.

• sed (éditeur de flux) Pour la substitution d'espace à trait d'union.

  -e <SCRIPT> exécutez le script sed.

• tr (traduction de chaîne) Facultatif, dans cet exemple. J'aime les adresses MAC majuscules dans mes scripts / environnement.

#!/bin/bash
#Creates an array containing all hexadecimal characters
HEX=(a b c d e f 0 1 2 3 4 5 6 7 8 9)
#Defines MAC string length as 0 (total SL will be 17)
SL=0
#Loop sequentially assigns random hex characters in pairs until a full
#MAC address is generated.
while [ $SL -lt 17 ]
do
        num=`shuf -i 0-15 -n 1` #Generates random number which will be used as array index
        RMAC="$RMAC""${HEX[$num]}" #Uses the randomly generated number to select a hex character
        num=`shuf -i 0-15 -n 1` #New random number
        RMAC="$RMAC""${HEX[$num]}" #Appends second hex character
        SL=$[`echo $RMAC | wc -c` - 1] #Calculates SL and stores in var SL
    if [ $SL -lt 17 ] #If string is uncomplete, appends : character
            then
            RMAC=""$RMAC":"
    fi
done
echo $RMAC #Displays randomly generated MAC address

Cela devrait fonctionner

echo 00-60-2f-`openssl rand -hex 3 | sed 's/\(..\)/\1-/g; s/.$//'`

end=$( echo $RANDOM | openssl md5 | sed 's/\(..\)/\1-/g' | cut -b-8 )
echo 00-60-2f-$end

Celui-ci fonctionne également. La sortie est tout en majuscules comme requis.

openssl rand -hex 3 | sed 's/\(..\)\(..\)\(..\)/00-60-2F-\1-\2-\3/' | tr [a-f] [A-F]

Cela fonctionne dans le #!/bin/shscript shell ( ) classique :

random_mac() {
    printf '%.2x\n' "$(shuf -i 0-281474976710655 -n 1)" | sed -r 's/(..)/\1:/g' | cut -d: -f -6
}

Ou, si vous souhaitez avoir un préfixe personnalisé:

random_mac_with_prefix() {
    echo -n "00:60:2f:" &&
    printf '%.2x\n' "$(shuf -i 0-281474976710655 -n 1)" | sed -r 's/(..)/\1:/g' | cut -d: -f -3
}

Exemple d'utilisation:

$ random_mac
96:ef:45:28:45:25
$ random_mac
7e:47:26:ae:ab:d4
$ random_mac_with_prefix 
00:60:2f:24:f4:18
$ random_mac_with_prefix 
00:60:2f:63:08:b2

Une autre option consiste à utiliser jot:

echo 00-60-2F-$(jot -w%02X -s- -r 3 0 256)

-wmodifie le format, -smodifie le séparateur et-r génère des nombres aléatoires.

Les commandes utilisant oddans les réponses publiées par artistoex et zero2cx ajoutent des tirets supplémentaires à la sortie avec OS X od, mais cela ne fait pas:

echo 00-60-2f-$(od -tx1 -An -N3 /dev/random|awk '$1=$1'|tr \  -)

OS X od( /usr/bin/odci-dessous) utilise un format de sortie différent de GNU od:

$ /usr/bin/od -N3 -tx1 -An /dev/random|tr ' ' -
-----------c7--fd--55----------------------------------------------------

$ god -N3 -tx1 -An /dev/random|tr ' ' -
-94-9e-5c

Sous Linux:

printf '00-60-2f-' && cut -b 7-11,24-26 /proc/sys/kernel/random/uuid

Explication:

Sous Linux, /proc/sys/kernel/random/uuidrenvoie un nouvel UUID de type 4 (aléatoire) chaque fois que vous le lisez. La plupart de ses caractères sont des chiffres hexadécimaux (pseudo) aléatoires, nous pouvons donc les utiliser. Par exemple:

$ cat /proc/sys/kernel/random/uuid
5501ab12-b530-4db5-a8ea-3df93043f172
$ #           ^    ^       Beware, these characters are not random.
$ #   ^^^^^            ^^^ Let's use characters on these positions.
$ cut -b 7-11,24-26 /proc/sys/kernel/random/uuid
6d-74-a1
$ cut -b 7-11,24-26 /proc/sys/kernel/random/uuid
13-f9-75

Il suffit maintenant d'imprimer 00-60-2f-(sans nouvelle ligne) en premier:

$ printf '00-60-2f-' && cut -b 7-11,24-26 /proc/sys/kernel/random/uuid
00-60-2f-86-f9-21

Avantages:

• chiffres hexadécimaux dès le début, aucune conversion / filtrage nécessaire;
• printfet cutsont des outils POSIX;
• (pour votre cas spécifique) des tirets déjà en UUID, nous les utilisons.

Les inconvénients:

• nous devons faire attention aux deux chiffres non aléatoires dans UUID;
• /proc/sys/kernel/random/uuid peut ne pas être disponible sur certains systèmes;
• seules les lettres minuscules sont si faciles (vous avez besoin d'une étape supplémentaire pour obtenir les lettres majuscules).

Un liner (bash)

mac=$(c=0;until [ $c -eq "6" ];do printf ":%02X" $(( $RANDOM % 256 ));let c=c+1;done|sed s/://)

résultat

$ echo $mac
93:72:71:0B:9E:89