How to generate a valid random MAC Address with bash shell

Question

How can i generate a valid random mac adress with bash.

The first half of the adress should always stay same like this

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

just the x value should be generated random?

Answer 1

1. Generate an appropriately sized int like so: http://tldp.org/LDP/abs/html/randomvar.html
2. Convert to hex like so: http://snipplr.com/view/2428/convert-from-int-to-hex/
3. Add the dashes between three randomly generated chunks

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

Answer 2

Here is a fish.

This shell script will generate the random string you seek:

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

I did just have something here that showed how to run it from the command line, but after looking at Dennis Williamson convoluted (but upvoted) solution I see that the answer that people expect is the one where they don't have to do any work themselves.

Answer 3

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

The keys to the way this works:

• LC_CTYPE=C - allows characters > 0x7F
• IFS= - disables interpretation of \t (tab), \n (newline) and space
• -d ''- allows newlines
• -r allows \ (and should almost always be used by habit with read)
• The format specifier -%02x\n causes the output to be a literal hyphen followed by a two-digit hexadecimal number including a leading zero, if appropriate. The newline is superfluous here and could be omitted.
• The read gets a single byte (-n 1) from /dev/urandom in the range 0 to 255 (00 to FF).

• The single quote in the last argument to the printf in the loop causes the character to be output as its numeric value ("A" is output as "65"). See the POSIX specification for printf where it says:

  If the leading character is a single-quote or double-quote, the value shall be the numeric value in the underlying codeset of the character following the single-quote or double-quote.

Answer 4

In the past I've done this using:

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

but that will only make them in the range 0-9. For my purposes, that was good enough.

Probably a better solution would be to use printf:

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

Here's how that works:

• The printf program is based on the C "printf" function, which takes a "format string" as the first parameter and then additional parameters fill in the format string.
• % in the format string introduces a "format specifier" which can be one or more characters telling how to format the arguments.
• A leading zero (0) in a format specifier means that the resulting numeric output should be padded with leading zeros up to the specified width.
• The 2 says that the specifier should be displayed taking up two characters worth of width.
• The X ends the specifier and denotes that it should be interpreted as a number and displayed as hexidecimal. Because it's upper-case, the letters a-f should be upper case.
• The \n is a newline -- printf interprets backslash as an escape code which can be used to display other characters, often tricky characters like the newline.
• The remaining characters in the format specifier are printed out literally, this includes the initial "00-06-2F-" and the dashes between the format specifiers.
• The remaining arguments are shell variable substitutions (denoted by the $) and include a math expression which is a random number (RANDOM) modulo 256. This results in a random number between 0 and 255.

Answer 5

The shortest way I could come up with was using hexdump directly

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

• -n3 tells hexdump to read three byytes
• The format string prints a dash and a two digit hex value for each byte
  • '/1' means apply format for every read byte
  • "-%02X" is a printf spec for printing a leading zero, two digit, upper case hex value
• /dev/random is a source random bytes

Tested on GNU/Linux

Answer 6

Another one line solution

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

Same thing in upper case

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

Generate it for a Bash environment variable

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

---

Details:

• od (octal dump)

  -An Suppresses the leading address representation (extra noise) of the output.
  -N3 Limit the output to three bytes.
  -t xC Output in hex, ASCII character style, as desired.
  /dev/urandom Linux kernel random number pseudo-file.

• sed (stream editor) For space to hyphen substitution.

  -e <SCRIPT> execute the sed script.

• tr (string translation) Optional, in this example. I like upper case MAC addresses in my scripts/environment.

Answer 7

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

Answer 8

Using standard tools, either

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

or

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

might be the shortest of all.

Answer 9

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