जवाबों:
यहाँ एक मछली है।
यह शेल स्क्रिप्ट आपके द्वारा खोजा जाने वाला यादृच्छिक स्ट्रिंग उत्पन्न करेगा:
#!/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
मेरे पास बस कुछ ऐसा था, जिसमें दिखाया गया था कि इसे कमांड लाइन से कैसे चलाया जाता है, लेकिन डेनिस विलियमसन को दृढ़ (लेकिन अपवर्तित) समाधान को देखने के बाद मैं देखता हूं कि लोगों को उम्मीद है कि जवाब वही है जहां उन्हें कोई काम नहीं करना है खुद को।
#!/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
या अजगर में:
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'))
ध्यान दें कि अजगर संस्करण केवल एक हेक्स चर उत्पन्न करने के लिए 16 विस्तृत क्षेत्र का उपयोग करता है, इसलिए आपको किसी टिप्पणी को संबोधित करने के लिए शून्य पैडिंग के बारे में चिंता करने की आवश्यकता नहीं है।
00-60-2F-8B-5-2C, 00-60-2F-A-71-97, 00-60-2F-82-F1-4।
अतीत में मैंने इसका उपयोग किया है:
echo 00-60-2F-$[RANDOM%10]$[RANDOM%10]-$[RANDOM%10]$[RANDOM%10]-$[RANDOM%10]$[RANDOM%10]लेकिन यह केवल उन्हें 0-9 की रेंज में बना देगा। मेरे उद्देश्यों के लिए, यह काफी अच्छा था।
संभवतः प्रिंटफ का उपयोग करने के लिए एक बेहतर समाधान होगा:
printf '00-60-2F-%02X-%02X-%02X\n' $[RANDOM%256] $[RANDOM%256] $[RANDOM%256]यहां बताया गया है कि यह कैसे काम करता है:
%02Xएक ऊपरी मामले पत्र देंगे।
या तो मानक उपकरण का उपयोग करना
# output in capitals
hexdump -n3 -e'/3 "00-60-2F" 3/1 "-%02X"' /dev/random
या
# output in lower case letters
echo 00-60-2f$(od -txC -An -N3 /dev/random|tr \ -)
सब से छोटा हो सकता है।
#!/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"
इस काम करने के तरीके की कुंजी:
LC_CTYPE=C - वर्ण> 0x7F की अनुमति देता हैIFS=- \t(टैब), \n(न्यूलाइन) और स्पेस की व्याख्या को निष्क्रिय करता है-d ''- newlines अनुमति देता है-rअनुमति देता है \(और लगभग हमेशा आदत से इस्तेमाल किया जाना चाहिए read)-%02x\nउचित हो, तो आउटपुट एक शाब्दिक हाइफ़न हो सकता है, जिसके बाद दो अंकों के हेक्साडेसिमल नंबर एक अग्रणी शून्य सहित हो, यदि उपयुक्त हो। यहां नईलाइन शानदार है और इसे छोड़ा जा सकता है।readएक एकल बाइट (हो जाता है -n 1) से /dev/urandomसीमा 0 से 255 (में 00करने के लिए FF)।printfलूप में अंतिम तर्क में एकल उद्धरण वर्ण को आउटपुट के रूप में इसका संख्यात्मक मान ("ए" आउटपुट "65") के रूप में उत्पन्न करता है। जहां यह कहता है, उसके लिए POSIX विनिर्देशprintf देखें :
यदि अग्रणी चरित्र एकल-उद्धरण या डबल-उद्धरण है, तो मूल्य एकल-उद्धरण या दोहरे-उद्धरण के बाद वर्ण के अंतर्निहित कोडसेट में संख्यात्मक मान होगा।
IFS= read …० ९ ० एए और २० (सामान्य आईएफएस चार्ट) को ०० में तह करने से बचने की आवश्यकता प्रतीत होती है।
-d ''। मैं अपना उत्तर ठीक करूंगा। मुझे बताने के लिए धन्यवाद।
-rकि `` बाहर गिर गया। मैं चाहता हूं कि शेल कार्यक्रमों में बाइनरी डेटा की उचित हैंडलिंग इतनी फ़िज़ूल नहीं थी। । स्ट्रिंग के मध्य में 00 का सही प्रतिनिधित्व करना असंभव लगता है। आपके एकल-चरित्र-ऑन-टाइम विधि 00 को सुविधाजनक (डिज़ाइन किए गए?) सहयोग read, स्ट्रिंग इंटरपोलेशन और कैसे printfएक-वर्ण तर्क का व्यवहार करता है , के द्वारा 00 हैंडल करता है '। आह।
hexdump -C।
सबसे छोटा तरीका जिससे मैं आ सकता था वह सीधे हेक्सडंप का उपयोग कर रहा था
echo 00-60-2f$(hexdump -n3 -e '/1 "-%02X"' /dev/random)जीएनयू / लिनक्स पर परीक्षण किया गया
hexdump -n3 -e'/3 "00-60-2F" 3/1 "-%02X"' /dev/randomथोड़ा छोटा है :-)
एक और एक लाइन समाधान
$ echo '00 60 2f'$(od -An -N3 -t xC /dev/urandom) | sed -e 's/ /-/g'ऊपरी मामले में एक ही बात
$ echo '00 60 2f'$(od -An -N3 -t xC /dev/urandom) | sed -e 's/ /-/g' | tr '[:lower:]' '[:upper:]'इसे बैश पर्यावरण चर के लिए उत्पन्न करें
$ export MAC=$(echo '00 60 2f'$(od -An -N3 -t xC /dev/urandom) | sed -e 's/ /-/g')
$ echo $MAC
विवरण:
ओडी (ओक्टल डंप)
-Anआउटपुट के प्रमुख पता प्रतिनिधित्व (अतिरिक्त शोर) को दबा देता है।
-N3आउटपुट को तीन बाइट्स तक सीमित करें।
-t xCवांछित के रूप में हेक्स, एएससीआईआई चरित्र शैली में आउटपुट।
/dev/urandomलिनक्स कर्नेल यादृच्छिक संख्या छद्म फ़ाइल।
sed (धारा संपादक) स्थान के लिए स्थानापन्न प्रतिस्थापन के लिए।
-e <SCRIPT> सिड स्क्रिप्ट निष्पादित करें।
tr (स्ट्रिंग अनुवाद) वैकल्पिक, इस उदाहरण में। मुझे अपनी स्क्रिप्ट्स / वातावरण में ऊपरी स्थिति मैक पते पसंद हैं।
#!/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
यह काम करना चाहिए
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
यह काम भी करता है। आउटपुट सभी ऊपरी मामले में आवश्यक है।
openssl rand -hex 3 | sed 's/\(..\)\(..\)\(..\)/00-60-2F-\1-\2-\3/' | tr [a-f] [A-F]यह क्लासिक शेल ( #!/bin/sh) स्क्रिप्ट में काम करता है :
random_mac() {
printf '%.2x\n' "$(shuf -i 0-281474976710655 -n 1)" | sed -r 's/(..)/\1:/g' | cut -d: -f -6
}
या, यदि आप कस्टम उपसर्ग करना चाहते हैं:
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
}
उदाहरण का उपयोग:
$ 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
एक अन्य विकल्प का उपयोग करना है jot:
echo 00-60-2F-$(jot -w%02X -s- -r 3 0 256)-wस्वरूप -sबदलता है, विभाजक बदलता है, और -rयादृच्छिक संख्या उत्पन्न करता है।
odआर्टिस्टोएक्स और जीरो 2 एक्सएक्सएक्स द्वारा पोस्ट किए गए उत्तरों में उपयोग करने वाले कमांड ओएस एक्स के साथ आउटपुट में अतिरिक्त डैश जोड़ते हैं od, लेकिन यह नहीं करता है:
echo 00-60-2f-$(od -tx1 -An -N3 /dev/random|awk '$1=$1'|tr \ -)OS X od( /usr/bin/odनीचे) GNU से भिन्न आउटपुट स्वरूप का उपयोग करता है od:
$ /usr/bin/od -N3 -tx1 -An /dev/random|tr ' ' -
-----------c7--fd--55----------------------------------------------------
$ god -N3 -tx1 -An /dev/random|tr ' ' -
-94-9e-5c
jot -w%02X -s- -r 3 1 256लिए उत्तर को संपादित किया jot -w%02X -s- -r 3 0 256।
लिनक्स में:
printf '00-60-2f-' && cut -b 7-11,24-26 /proc/sys/kernel/random/uuidस्पष्टीकरण:
लिनक्स में हर बार जब आप इसे पढ़ते हैं तो /proc/sys/kernel/random/uuidएक नया प्रकार 4 (यादृच्छिक) UUID देता है। इसके अधिकांश पात्र (छद्म) यादृच्छिक षोडश अंक हैं, इस प्रकार हम उनका उपयोग कर सकते हैं। उदाहरण के लिए:
$ 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
अब 00-60-2f-पहले प्रिंट करना (न्यूलाइन के बिना) करना काफी है :
$ printf '00-60-2f-' && cut -b 7-11,24-26 /proc/sys/kernel/random/uuid
00-60-2f-86-f9-21
पेशेवरों:
printfऔर cutPOSIX उपकरण हैं;विपक्ष:
/proc/sys/kernel/random/uuid कुछ सिस्टम पर उपलब्ध नहीं हो सकता है;
echo -n 00-60-2F; dd bs=1 count=3 if=/dev/random 2>/dev/null |hexdump -v -e '/1 "-%02X"'