Bash kabuğu ile geçerli bir rasgele MAC adresi nasıl oluşturulur

Nasıl bash ile geçerli bir rastgele mac adresi oluşturabilirim.

Adresin ilk yarısı her zaman böyle kalmalı

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

sadece x değeri rastgele oluşturulmalı mı?

İşte bir balık.

Bu kabuk betiği aradığınız rastgele dizeyi oluşturur:

#!/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

Burada sadece komut satırından nasıl çalıştırılacağını gösteren bir şeyim vardı, ancak Dennis Williamson kıvrımlı (ancak yükseltilmiş) çözümlere baktıktan sonra insanların bekledikleri cevabın herhangi bir iş yapmak zorunda kalmadıkları cevap olduğunu görüyorum. kendilerini.

Geçmişte bunu kullanarak yaptım:

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

ancak bu onları yalnızca 0-9 aralığında yapar. Benim amacım için bu yeterince iyiydi.

Muhtemelen daha iyi bir çözüm printf kullanmak olacaktır:

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

Bunun nasıl çalıştığı aşağıda açıklanmıştır:

• Printf programı, ilk parametre olarak bir "biçim dizesi" alan C "printf" işlevini temel alır ve daha sonra biçim dizesini ek parametreler doldurur.
• Biçim dizesindeki%, bağımsız değişkenlerin nasıl biçimlendirileceğini anlatan bir veya daha fazla karakter olabilen bir "biçim belirteci" sunar.
• Biçim belirleyicisindeki baştaki sıfır (0), sonuçta elde edilen sayısal çıktının belirtilen genişliğe kadar baştaki sıfırlarla doldurulması gerektiği anlamına gelir.
• 2, belirtecin iki karakter genişliğinde olacak şekilde görüntülenmesi gerektiğini söylüyor.
• X, belirteci bitirir ve bir sayı olarak yorumlanması ve onaltılık sayı olarak gösterilmesi gerektiğini belirtir. Büyük harf olduğundan, af harfleri büyük harf olmalıdır.
• \ N bir yeni satırdır - printf, ters eğik çizgiyi diğer satırları (genellikle satırsonu gibi zor karakterleri) görüntülemek için kullanılabilen bir çıkış kodu olarak yorumlar.
• Biçim belirticisindeki kalan karakterler kelimenin tam anlamıyla yazdırılır, buna ilk "00-06-2F-" ve biçim belirleyicileri arasındaki tire işaretleri dahildir.
• Kalan argümanlar kabuk değişkeni ikameleridir ($ ile gösterilir) ve rastgele bir sayı (RANDOM) modulo 256 olan bir matematik ifadesi içerir. Bu, 0 ile 255 arasında rastgele bir sayı ile sonuçlanır.

1. Şu şekilde uygun boyutlu bir int oluşturun: http://tldp.org/LDP/abs/html/randomvar.html
2. Şu şekilde onaltılık biçime dönüştürün: http://snipplr.com/view/2428/convert-from-int-to-hex/
3. Rastgele oluşturulmuş üç parça arasına tire ekleyin

#!/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

Veya python'da:

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'))

Python sürümünün yalnızca onaltılık bir karakter oluşturmak için 16 genişlik bir alan kullandığını unutmayın, bu nedenle sıfır doldurma konusunda endişelenmenize gerek yoktur - bir yorumu ele almak için değiştirilmiş yaklaşım.

Standart araçları kullanarak

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

veya

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

en kısa olabilir.

#!/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"

Bunun çalışma şeklinin anahtarları:

• LC_CTYPE=C - 0x7F karakterlerine izin verir
• IFS=- \t(sekme), \n(satırsonu) ve alanın yorumlanmasını devre dışı bırakır
• -d ''- yeni satırlara izin verir
• -rizin verir \(ve neredeyse her zaman alışkanlık tarafından kullanılmalıdır read)
• Biçim belirleyicisi -%02x\n, çıktının değişmez bir kısa çizgi ve ardından uygunsa, başında sıfır içeren iki basamaklı onaltılık bir sayı olmasını sağlar. Newline burada gereksiz ve ihmal edilebilir.
• readTek bir bayt (alır -n 1itibaren) /dev/urandom0 ila 255 (içinde 00için FF).

• printfDöngüdeki son bağımsız değişkende yer alan tek tırnak , karakterin sayısal değeri olarak çıkmasına neden olur ("A", "65" olarak çıkar). Yazdığı yerprintf için POSIX spesifikasyonuna bakın :

  Baştaki karakter tek tırnak veya çift tırnak ise, değer tek tırnak veya çift tırnaktan sonraki karakterin temel kod kümesindeki sayısal değer olmalıdır.

Gelebildiğim en kısa yol doğrudan hexdump kullanmaktı

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

• -n3, hexdump'a üç bayt okumasını söyler
• Biçim dizesi, her bayt için bir tire ve iki basamaklı onaltılık bir değer yazdırır
  • '/ 1', her okunan bayt için biçim uygulama anlamına gelir
  • "-% 02X" baştaki sıfır, iki basamaklı, büyük harf onaltılık değer yazdırmak için bir printf spesifikasyonudur
• / dev / random, rastgele bir bayt kaynağıdır

GNU / Linux üzerinde test edildi

Başka bir tek çözüm

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

Büyük harfle aynı şey

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

Bash ortam değişkeni için üret

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

Detaylar:

• od (sekizli dökümü)

  -AnÇıktının önde gelen adres gösterimini (ekstra gürültü) bastırır.
  -N3Çıkışı üç bayt ile sınırlayın.
  -t xCÇıktı, istendiği gibi onaltılık, ASCII karakter stilinde.
  /dev/urandomLinux çekirdek rasgele sayı sözde dosya.

• sed (akış düzenleyici) Tire ile yer değiştirme için alan.

  -e <SCRIPT> sed komut dosyasını yürütün.

• tr (dize çevirisi) Bu örnekte isteğe bağlı. Komut dosyalarımda / ortamımda büyük MAC adreslerini seviyorum.

#!/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

Bu çalışmalı

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

Bu da işe yarıyor. Çıktının tamamı gerektiği gibi büyük harflidir.

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

Bu klasik shell ( #!/bin/sh) betiğinde çalışır:

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

Veya, özel önek istiyorsanız:

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
}

Örnek kullanım:

$ 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

Başka bir seçenek kullanmaktır jot:

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

-wbiçimi -sdeğiştirir, ayırıcıyı değiştirir ve -rrasgele sayılar üretir.

odArtistoex ve zero2cx tarafından gönderilen cevaplarda kullanılan komutlar , OS X'lerle çıktıya ekstra tire eklerod , ancak bu yapmaz:

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

OS X'ler od( /usr/bin/odaşağıda) GNU'dan farklı bir çıktı biçimi kullanır od:

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

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

Linux'ta:

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

Açıklama:

Linux'ta her okuduğunuzda /proc/sys/kernel/random/uuidyeni bir tip 4 (rastgele) UUID döndürür . Karakterlerinin çoğu (sözde) rastgele onaltılık sayılardır, böylece bunları kullanabiliriz. Örneğin:

$ 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

Şimdi önce 00-60-2f-(satırsonu olmadan) yazdırmak yeterlidir :

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

Artıları:

• en başından onaltılık basamaklar, dönüşüm / filtreleme gerekmez;
• printfve cutPOSIX araçlarıdır;
• (özel durumunuz için) zaten UUID'de bulunan tire işaretleri kullanırız.

Eksileri:

• UUID'deki rastgele olmayan iki basamağı dikkate almamız gerekir;
• /proc/sys/kernel/random/uuid bazı sistemlerde bulunmayabilir;
• sadece küçük harfler çok kolay gelir (büyük harfleri almak için ek bir adım gerekir).

Bir astar (bash)

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

sonuç

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