librex 0.0.68 → 0.0.70

data/lib/rex/machscan.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 module Rex

data/lib/rex/machscan/scanner.rb

@@ -1,4 +1,3 @@
-#!/usr/bin/env ruby
 # -*- coding: binary -*-
 
 module Rex
@@ -6,210 +5,210 @@ module MachScan
 module Scanner
 class Generic
 
-	attr_accessor :mach, :fat, :regex
-
-	def initialize(binary)
-		if binary.class == Rex::MachParsey::Mach
-			self.mach = binary
-		else
-			self.fat = binary
-		end
-	end
-
-	def config(param)
-	end
-
-	def scan(param)
-			config(param)
-
-			$stdout.puts "[#{param['file']}]"
-
-			if !self.mach
-				for mach in fat.machos
-					if mach.mach_header.cputype == 0x7 #since we only support intel for the time being its all we process
-						self.mach = mach
-					end
-				end
-			end
-
-			self.mach.segments.each do |segment|
-				if segment.segname.include? "__TEXT"
-					scan_segment(segment, param).each do |hit|
-						vaddr  = hit[0]
-						message  = hit[1].is_a?(Array) ? hit[1].join(" ") : hit[1]
-						$stdout.puts self.mach.ptr_s(vaddr - self.mach.fat_offset) + " " + message
-					end
-				end
-			end
-
-	end
-
-	def scan_segment(segment, param={})
-		[]
-	end
+  attr_accessor :mach, :fat, :regex
+
+  def initialize(binary)
+    if binary.class == Rex::MachParsey::Mach
+      self.mach = binary
+    else
+      self.fat = binary
+    end
+  end
+
+  def config(param)
+  end
+
+  def scan(param)
+      config(param)
+
+      $stdout.puts "[#{param['file']}]"
+
+      if !self.mach
+        for mach in fat.machos
+          if mach.mach_header.cputype == 0x7 #since we only support intel for the time being its all we process
+            self.mach = mach
+          end
+        end
+      end
+
+      self.mach.segments.each do |segment|
+        if segment.segname.include? "__TEXT"
+          scan_segment(segment, param).each do |hit|
+            vaddr  = hit[0]
+            message  = hit[1].is_a?(Array) ? hit[1].join(" ") : hit[1]
+            $stdout.puts self.mach.ptr_s(vaddr - self.mach.fat_offset) + " " + message
+          end
+        end
+      end
+
+  end
+
+  def scan_segment(segment, param={})
+    []
+  end
 end
 
 class JmpRegScanner < Generic
 
-	def config(param)
-		regnums = param['args']
-
-		# build a list of the call bytes
-		calls  = _build_byte_list(0xd0, regnums - [4]) # note call esp's don't work..
-		jmps   = _build_byte_list(0xe0, regnums)
-		pushs1 = _build_byte_list(0x50, regnums)
-		pushs2 = _build_byte_list(0xf0, regnums)
-
-		regexstr = '('
-		if !calls.empty?
-				regexstr += "\xff[#{calls}]|"
-		end
-
-		regexstr += "\xff[#{jmps}]|([#{pushs1}]|\xff[#{pushs2}])(\xc3|\xc2..))"
-
-		self.regex = Regexp.new(regexstr, nil, 'n')
-	end
-
-	# build a list for regex of the possible bytes, based on a base
-	# byte and a list of register numbers..
-	def _build_byte_list(base, regnums)
-		regnums.collect { |regnum| Regexp.escape((base | regnum).chr) }.join('')
-	end
-
-	def _ret_size(offset)
-		case mach.read(offset, 1)
-		when "\xc3"
-				return 1
-		when "\xc2"
-				return 3
-		end
-		$stderr.puts("Invalid return instruction")
-	end
-
-	def _parse_ret(data)
-		if data.length == 1
-			return "ret"
-		else
-			return "retn 0x%04x" % data[1, 2].unpack('v')[0]
-		end
-	end
-
-	def scan_segment(segment, param={})
-		base_addr = segment.vmaddr
-		segment_offset = segment.fileoff
-		offset = segment_offset
-
-		hits = []
-
-		while (offset = mach.index(regex, offset)) != nil
-
-			vaddr = base_addr + (offset - segment_offset)
-			message = ''
-
-			parse_ret = false
-
-			byte1 = mach.read(offset, 1).unpack("C*")[0]
-
-			if byte1 == 0xff
-				byte2   = mach.read(offset+1, 1).unpack("C*")[0]
-				regname = Rex::Arch::X86.reg_name32(byte2 & 0x7)
-
-				case byte2 & 0xf8
-				when 0xd0
-						message = "call #{regname}"
-						offset += 2
-				when 0xe0
-						message = "jmp #{regname}"
-						offset += 2
-				when 0xf0
-						retsize = _ret_size(offset+2)
-						message = "push #{regname}; " + _parse_ret(mach.read(offset+2, retsize))
-						offset += 2 + retsize
-				else
-						raise "wtf"
-				end
-			else
-				regname = Rex::Arch::X86.reg_name32(byte1 & 0x7)
-				retsize = _ret_size(offset+1)
-				message = "push #{regname}; " + _parse_ret(mach.read(offset+1, retsize))
-				offset += 1 + retsize
-			end
-
-			hits << [ vaddr, message ]
-		end
-
-		return hits
-	end
+  def config(param)
+    regnums = param['args']
+
+    # build a list of the call bytes
+    calls  = _build_byte_list(0xd0, regnums - [4]) # note call esp's don't work..
+    jmps   = _build_byte_list(0xe0, regnums)
+    pushs1 = _build_byte_list(0x50, regnums)
+    pushs2 = _build_byte_list(0xf0, regnums)
+
+    regexstr = '('
+    if !calls.empty?
+        regexstr += "\xff[#{calls}]|"
+    end
+
+    regexstr += "\xff[#{jmps}]|([#{pushs1}]|\xff[#{pushs2}])(\xc3|\xc2..))"
+
+    self.regex = Regexp.new(regexstr, nil, 'n')
+  end
+
+  # build a list for regex of the possible bytes, based on a base
+  # byte and a list of register numbers..
+  def _build_byte_list(base, regnums)
+    regnums.collect { |regnum| Regexp.escape((base | regnum).chr) }.join('')
+  end
+
+  def _ret_size(offset)
+    case mach.read(offset, 1)
+    when "\xc3"
+        return 1
+    when "\xc2"
+        return 3
+    end
+    $stderr.puts("Invalid return instruction")
+  end
+
+  def _parse_ret(data)
+    if data.length == 1
+      return "ret"
+    else
+      return "retn 0x%04x" % data[1, 2].unpack('v')[0]
+    end
+  end
+
+  def scan_segment(segment, param={})
+    base_addr = segment.vmaddr
+    segment_offset = segment.fileoff
+    offset = segment_offset
+
+    hits = []
+
+    while (offset = mach.index(regex, offset)) != nil
+
+      vaddr = base_addr + (offset - segment_offset)
+      message = ''
+
+      parse_ret = false
+
+      byte1 = mach.read(offset, 1).unpack("C*")[0]
+
+      if byte1 == 0xff
+        byte2   = mach.read(offset+1, 1).unpack("C*")[0]
+        regname = Rex::Arch::X86.reg_name32(byte2 & 0x7)
+
+        case byte2 & 0xf8
+        when 0xd0
+            message = "call #{regname}"
+            offset += 2
+        when 0xe0
+            message = "jmp #{regname}"
+            offset += 2
+        when 0xf0
+            retsize = _ret_size(offset+2)
+            message = "push #{regname}; " + _parse_ret(mach.read(offset+2, retsize))
+            offset += 2 + retsize
+        else
+            raise "wtf"
+        end
+      else
+        regname = Rex::Arch::X86.reg_name32(byte1 & 0x7)
+        retsize = _ret_size(offset+1)
+        message = "push #{regname}; " + _parse_ret(mach.read(offset+1, retsize))
+        offset += 1 + retsize
+      end
+
+      hits << [ vaddr, message ]
+    end
+
+    return hits
+  end
 end
 
 class PopPopRetScanner < JmpRegScanner
 
-	def config(param)
-		pops = _build_byte_list(0x58, (0 .. 7).to_a - [4]) # we don't want pop esp's...
-		self.regex = Regexp.new("[#{pops}][#{pops}](\xc3|\xc2..)", nil, 'n')
-	end
+  def config(param)
+    pops = _build_byte_list(0x58, (0 .. 7).to_a - [4]) # we don't want pop esp's...
+    self.regex = Regexp.new("[#{pops}][#{pops}](\xc3|\xc2..)", nil, 'n')
+  end
 
-	def scan_segment(segment, param={})
-		base_addr = segment.vmaddr
-		segment_offset = segment.fileoff
-		offset = segment_offset
+  def scan_segment(segment, param={})
+    base_addr = segment.vmaddr
+    segment_offset = segment.fileoff
+    offset = segment_offset
 
-		hits = []
+    hits = []
 
-		while offset < segment.fileoff + segment.filesize && (offset = mach.index(regex, offset)) != nil
+    while offset < segment.fileoff + segment.filesize && (offset = mach.index(regex, offset)) != nil
 
-			vaddr = base_addr + (offset - segment_offset)
-			message = ''
+      vaddr = base_addr + (offset - segment_offset)
+      message = ''
 
-			pops = mach.read(offset, 2)
-			reg1 = Rex::Arch::X86.reg_name32(pops[0,1].unpack("C*")[0] & 0x7)
-			reg2 = Rex::Arch::X86.reg_name32(pops[1,1].unpack("C*")[0] & 0x7)
+      pops = mach.read(offset, 2)
+      reg1 = Rex::Arch::X86.reg_name32(pops[0,1].unpack("C*")[0] & 0x7)
+      reg2 = Rex::Arch::X86.reg_name32(pops[1,1].unpack("C*")[0] & 0x7)
 
-			message = "pop #{reg1}; pop #{reg2}; "
+      message = "pop #{reg1}; pop #{reg2}; "
 
-			retsize = _ret_size(offset+2)
-			message += _parse_ret(mach.read(offset+2, retsize))
+      retsize = _ret_size(offset+2)
+      message += _parse_ret(mach.read(offset+2, retsize))
 
-			offset += 2 + retsize
+      offset += 2 + retsize
 
-			hits << [ vaddr, message ]
-		end
+      hits << [ vaddr, message ]
+    end
 
-		return hits
-	end
+    return hits
+  end
 end
 
 class RegexScanner < JmpRegScanner
 
-	def config(param)
-		self.regex = Regexp.new(param['args'], nil, 'n')
-	end
+  def config(param)
+    self.regex = Regexp.new(param['args'], nil, 'n')
+  end
 
-	def scan_segment(segment, param={})
-		base_addr = segment.vmaddr
-		segment_offset = segment.fileoff
-		offset = segment_offset
+  def scan_segment(segment, param={})
+    base_addr = segment.vmaddr
+    segment_offset = segment.fileoff
+    offset = segment_offset
 
-		hits = []
+    hits = []
 
-		while offset < segment.fileoff + segment.filesize && (offset = mach.index(regex, offset)) != nil
+    while offset < segment.fileoff + segment.filesize && (offset = mach.index(regex, offset)) != nil
 
-			idx = offset
-			buf = ''
-			mat = nil
+      idx = offset
+      buf = ''
+      mat = nil
 
-			while (! (mat = buf.match(regex)))
-				buf << mach.read(idx, 1)
-				idx += 1
-			end
+      while (! (mat = buf.match(regex)))
+        buf << mach.read(idx, 1)
+        idx += 1
+      end
 
-			vaddr = base_addr + (offset - segment_offset)
+      vaddr = base_addr + (offset - segment_offset)
 
-			hits << [ vaddr, buf.unpack("H*") ]
-			offset += buf.length
-		end
-		return hits
-	end
+      hits << [ vaddr, buf.unpack("H*") ]
+      offset += buf.length
+    end
+    return hits
+  end
 end
 
 end

data/lib/rex/mime/encoding.rb

@@ -0,0 +1,17 @@
+# -*- coding: binary -*-
+module Rex
+module MIME
+# Set of helpers methods to deal with SMTP encoding related topics.
+module Encoding
+
+  # Enforces CRLF on the input data
+  #
+  # @param data [String] The data to CRLF enforce.
+  # @return [String] CRLF enforced data.
+  def force_crlf(data)
+    data.gsub("\r", '').gsub("\n", "\r\n")
+  end
+
+end
+end
+end

data/lib/rex/mime/header.rb

@@ -3,74 +3,74 @@ module Rex
 module MIME
 class Header
 
-	require 'rex/text'
+  require 'rex/text'
 
-	attr_accessor :headers
+  attr_accessor :headers
 
-	def initialize(data='')
-		self.headers = []
-		parse(data)
-	end
+  def initialize(data='')
+    self.headers = []
+    parse(data)
+  end
 
-	def parse(data)
-		prev = nil
-		data.gsub("\r", '').split("\n").each do |line|
+  def parse(data)
+    prev = nil
+    data.gsub("\r", '').split("\n").each do |line|
 
-			# Handle header folding
-			if (line =~ /^\s+/)
-				# Ignore if there is no previous header
-				next if not prev
-				next if not self.headers[prev]
-				self.headers[prev][1] << line.strip
-				next
-			end
+      # Handle header folding
+      if (line =~ /^\s+/)
+        # Ignore if there is no previous header
+        next if not prev
+        next if not self.headers[prev]
+        self.headers[prev][1] << line.strip
+        next
+      end
 
-			var,val = line.split(':')
-			next if not val
-			self.headers << [ var.to_s.strip, val.to_s.strip ]
-			prev = self.headers.length - 1
-		end
-	end
+      var,val = line.split(':')
+      next if not val
+      self.headers << [ var.to_s.strip, val.to_s.strip ]
+      prev = self.headers.length - 1
+    end
+  end
 
-	def to_s
-		self.headers.map{ |pair| "#{pair[0]}: #{pair[1]}\r\n" }.join
-	end
+  def to_s
+    self.headers.map{ |pair| "#{pair[0]}: #{pair[1]}\r\n" }.join
+  end
 
-	def find(idx)
-		if (idx.class == ::Fixnum)
-			return self.headers[idx]
-		else
-			self.headers.each do |pair|
-				if (pair[0] == idx.to_s)
-					return pair
-				end
-			end
-		end
-		nil
-	end
+  def find(idx)
+    if (idx.class == ::Fixnum)
+      return self.headers[idx]
+    else
+      self.headers.each do |pair|
+        if (pair[0] == idx.to_s)
+          return pair
+        end
+      end
+    end
+    nil
+  end
 
-	def set(var, val)
-		hdr = self.find(var) || self.add(var, '')
-		hdr[1] = val
-	end
+  def set(var, val)
+    hdr = self.find(var) || self.add(var, '')
+    hdr[1] = val
+  end
 
-	def add(var, val)
-		self.headers << [var, val]
-		self.headers[-1]
-	end
+  def add(var, val)
+    self.headers << [var, val]
+    self.headers[-1]
+  end
 
-	def remove(idx)
-		if (idx.class == ::Fixnum)
-			self.headers.delete_at(idx)
-		else
-			self.headers.each_index do |i|
-				pair = self.headers[i]
-				if (pair[0] == idx.to_s)
-					self.headers.delete_at(i)
-				end
-			end
-		end
-	end
+  def remove(idx)
+    if (idx.class == ::Fixnum)
+      self.headers.delete_at(idx)
+    else
+      self.headers.each_index do |i|
+        pair = self.headers[i]
+        if (pair[0] == idx.to_s)
+          self.headers.delete_at(i)
+        end
+      end
+    end
+  end
 
 end
 end