module Dnsruby

  #Dnsruby::IPv6 class

  class IPv6

    #IPv6 address format a:b:c:d:e:f:g:h

    Regex_8Hex = /\A

    #Compresses IPv6 format a::b

    # IPv4 mapped IPv6 address format a:b:c:d:e:f:w.x.y.z

    # Compressed IPv4 mapped IPv6 address format a::b:w.x.y.z

    # A composite IPv6 address RegExp

    # Created a new IPv6 address from +arg+ which may be:

    #

#

# This module provides common tools for IPv6

###

module Exploit::Remote::Ipv6

				OptString.new("SMAC", [ false, "The source MAC address"]),

				OptAddress.new("SHOST", [ false, "The source IPv6 address" ] ),

				OptInt.new("TIMEOUT", [ true, "Timeout when waiting for host response.", 5])

			], Msf::Exploit::Remote::Ipv6

	#

	def ipv6_interface(opts={})

	#

	def ipv6_link_address(opts={})

		Rex::Socket.ipv6_link_address(ipv6_interface(opts))

	end

	#

	def ipv6_mac(opts={})

		Rex::Socket.ipv6_mac(ipv6_interface(opts))

	# AddrIpv6 handles addressing for IPv6Header

	#  Int32 :a4

	class AddrIpv6 < Struct.new(:a1, :a2, :a3, :a4)

		# Reads in a string and casts it as an IPv6 address

		# Reads in a colon-delimited hex string and casts it as an IPv6 address.

	# IPv6Header is complete IPv6 struct, used in IPv6Packet. 

	#

	#  Fixnum (4 bits)   :ipv6_v      Default: 6     # Versiom

	#  Fixnum (8 bits)   :ipv6_class  Defualt: 0     # Class

	#  Fixnum (20 bits)  :ipv6_label  Defualt: 0     # Label

	#  Int16             :ipv6_len    Default: calc  # Payload length

	# AddrIpv6 handles addressing for IPv6Header

	#  Int32 :a4

	class AddrIpv6 < Struct.new(:a1, :a2, :a3, :a4)

		# Reads in a string and casts it as an IPv6 address

		# Reads in a colon-delimited hex string and casts it as an IPv6 address.

	# IPv6Header is complete IPv6 struct, used in IPv6Packet. 

	#

	#  Fixnum (4 bits)   :ipv6_v      Default: 6     # Versiom

	#  Fixnum (8 bits)   :ipv6_class  Defualt: 0     # Class

	#  Fixnum (20 bits)  :ipv6_label  Defualt: 0     # Label

	#  Int16             :ipv6_len    Default: calc  # Payload length

  # 

  # IPAddress::IPv6 - IP version 6 address manipulation library

  # 

  # Class IPAddress::IPv6 is used to handle IPv6 type addresses. 

  #

  # == IPv6 addresses

  #

  # IPv6 addresses are 128 bits long, in contrast with IPv4 addresses

  # which are only 32 bits long. An IPv6 address is generally written as

  # eight groups of four hexadecimal digits, each group representing 16

  # bits or two octect. For example, the following is a valid IPv6

  #

  # Letters in an IPv6 address are usually written downcase, as per

  # RFC. You can create a new IPv6 object using uppercase letters, but

  # they will be converted.

# Cookbook Name:: nginx

# Recipe:: ipv6

node.run_state['nginx_configure_flags'] =

  node.run_state['nginx_configure_flags'] | ['--with-ipv6']

#

# This module provides common tools for IPv6

###

module Exploit::Remote::Ipv6

        OptString.new("SMAC", [ false, "The source MAC address"]),

        OptAddress.new("SHOST", [ false, "The source IPv6 address" ] ),

        OptInt.new("TIMEOUT", [ true, "Timeout when waiting for host response.", 5])

      ], Msf::Exploit::Remote::Ipv6

  #

  def ipv6_interface(opts={})

  #

  def ipv6_link_address(opts={})

    Rex::Socket.ipv6_link_address(ipv6_interface(opts))

  end

  #

  def ipv6_mac(opts={})

    Rex::Socket.ipv6_mac(ipv6_interface(opts))

# $Id: ipv6.rb 14 2008-03-02 05:42:30Z warchild $

#

module L3

# Internet Protocol Version 6 (IPV6)

# RFC2460

class IPv6 < RacketPart

    # Sets up resolution with IPv6 support if the address is an ip

    # @since 2.0.0

    class IPv6

      # The regular expression to use to match an IPv6 ip address.

      # Parse an IPv6 address into its host and port.

      # Initialize the IPv6 resolver.

      # @example Initialize the resolver.

      #   IPv6.new("::1", 28011, 'localhost')

      #

      # @example Get an IPv6 socket.

#

# This module provides common tools for IPv6

###

module Exploit::Remote::Ipv6

				OptString.new("SMAC", [ false, "The source MAC address"]),

				OptAddress.new("SHOST", [ false, "The source IPv6 address" ] ),

				OptInt.new("TIMEOUT", [ true, "Timeout when waiting for host response.", 5])

			], Msf::Exploit::Remote::Ipv6

	#

	def ipv6_interface(opts={})

	#

	def ipv6_link_address(opts={})

		Rex::Socket.ipv6_link_address(ipv6_interface(opts))

	end

	#

	def ipv6_mac(opts={})

		Rex::Socket.ipv6_mac(ipv6_interface(opts))

# Cookbook Name:: nginx

# Recipe:: ipv6

node.run_state['nginx_configure_flags'] =

  node.run_state['nginx_configure_flags'] | ["--with-ipv6"]

    # Given a long, convert it to an IPv6 address, 

    # optionally compressing the address returned

      ipv6[3] = (long >> 64) & (0xFFFF)

      ipv6[4] = (long >> 48) & (0xFFFF)

      ipv6[5] = (long >> 32) & (0xFFFF)

      ipv6[6] = (long >> 16) & (0xFFFF)

      ipv6[7] = long & (0xFFFF)

      ipv6 = ipv6.map { |o| o.to_s(16) }.join(":")

      compress ? Misc.compressipv6(ipv6) : ipv6

    end

    # Compress an IPv6 address

    # Inspired by Daniele Bellucci and jacked from ipaddr

    def Misc.compressipv6(ipv6)

# IPAddr provides a set of methods to manipulate an IP address.  Both IPv4 and

# IPv6 are supported.

#

#   p ipaddr1                   #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>

#

#   ipaddr2 = ipaddr1.mask(48)  #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0000/ffff:ffff:ffff:0000:0000:0000:0000:0000>

  # Returns true if the ipaddr is an IPv4-mapped IPv6 address.

  def ipv4_mapped?

    return ipv6? && (@addr >> 32) == 0xffff

  # Returns true if the ipaddr is an IPv4-compatible IPv6 address.

  def ipv4_compat?

    if !ipv6? || (@addr >> 32) != 0

  # Returns a new ipaddr built by converting the native IPv4 address

  # into an IPv4-mapped IPv6 address.

# IPAddr provides a set of methods to manipulate an IP address.  Both IPv4 and

# IPv6 are supported.

#

#   p ipaddr1                   #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>

#

#   ipaddr2 = ipaddr1.mask(48)  #=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0000/ffff:ffff:ffff:0000:0000:0000:0000:0000>

  # Returns true if the ipaddr is an IPv4-mapped IPv6 address.

  def ipv4_mapped?

    return ipv6? && (@addr >> 32) == 0xffff

  # Returns true if the ipaddr is an IPv4-compatible IPv6 address.

  def ipv4_compat?

    if !ipv6? || (@addr >> 32) != 0

  # Returns a new ipaddr built by converting the native IPv4 address

  # into an IPv4-mapped IPv6 address.

ipv6 = false

default_ipv6 = /mswin|cygwin|beos|haiku/ !~ RUBY_PLATFORM

if enable_config("ipv6", default_ipv6)

  if checking_for("ipv6") {try_link(<<EOF)}

#include <sys/types.h>

EOF

    $defs << "-DENABLE_IPV6" << "-DINET6"

    ipv6 = true

  end

if ipv6

  end

  ipv6lib = nil

  idirs, ldirs = dir_config("inet6", %w[/usr/inet6 /usr/local/v6].find {|d| File.directory?(d)})

  checking_for("ipv6 type", fmt) do

    if have_macro("IPV6_INRIA_VERSION", "netinet/in.h")

        expect( service('iptables')).to be_running

        if $environment['ipv6Enabled']

    # STIG Viewer Link: http://www.stigviewer.com/check/V-38546

    it "V-38546 The IPv6 protocol handler must not be bound to the network stack unless needed." do

        # Check: If the system uses IPv6, this is not applicable.

        #       If the system is configured to prevent the loading of the "ipv6" kernel module, it will contain a line of the form: 

        #       options ipv6 disable=1

        #       Such lines may be inside any file in "/etc/modprobe.d" or the deprecated "/etc/modprobe.conf". This permits insertion of the IPv6 kernel module (which other parts of the system expect to be present), but otherwise keeps it inactive. Run the following command to search for such lines in all files in "/etc/modprobe.d" and the deprecated "/etc/modprobe.conf": 

        #       $ grep -r ipv6 /etc/modprobe.conf /etc/modprobe.d

        #       If the IPv6 kernel module is loaded, this is a finding.

        if $environment['ipv6Enabled']

            pending("Not applicable")

        else

            expect( command('grep -r ipv6 /etc/modprobe.d') ).not_to return_stdout ""

        end

    it "should accept long IPv6 addresses" do

      # Taken from wikipedia article about ipv6

      proc { @class.new(:name => "foo", :ip => '2001:0db8:85a3:08d3:1319:8a2e:0370:7344') }.should_not raise_error

    it "should accept shortened IPv6 addresses" do

     "::ffff:192.168.1.1",

     "0:0:0:0:0:0:13.1.68.3", # IPv4-compatible IPv6 address, full, deprecated

     "0:0:0:0:0:FFFF:129.144.52.38", # IPv4-mapped IPv6 address, full

     "::13.1.68.3",             # IPv4-compatible IPv6 address, compressed, deprecated

     "::FFFF:129.144.52.38",    # IPv4-mapped IPv6 address, compressed

     "fe80:0:0:0:204:61ff:254.157.241.86",

     # Additional cases: http://crisp.tweakblogs.net/blog/2031/ipv6-validation-%28and-caveats%29.html

    ].each do |ip|

      it "should accept #{ip.inspect} as an IPv6 address" do

describe 'PostgreSQL inet/cidr types' do

  ipv6_broken = (IPAddr.new('::1'); false) rescue true

    @ipv4nm = IPAddr.new(@v4nm)

    unless ipv6_broken

      @ipv6 = IPAddr.new(@v6)

    @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).should == {:i=>@ipv4, :c=>@ipv4nm}

    @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).should == nil

    unless ipv6_broken

      @ds.call(:insert, {:i=>@ipv6, :c=>@ipv6nm}, {:i=>:$i, :c=>:$c})

      @ds.get(:i).should == @ipv6

      @ds.get(:c).should == @ipv6nm

      @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv6, :c=>@ipv6nm).should == {:i=>@ipv6, :c=>@ipv6nm}

      @ds.filter(:i=>:$i, :c=>:$c).call(:first, :i=>@ipv4, :c=>@ipv4nm).should == nil

      @ds.filter(:i=>:$i, :c=>:$c).call(:delete, :i=>@ipv6, :c=>@ipv6nm).should == 1

describe 'PostgreSQL inet/cidr types' do

  ipv6_broken = (IPAddr.new('::1'); false) rescue true

    @ipv4nm = IPAddr.new(@v4nm)

    unless ipv6_broken

      @ipv6 = IPAddr.new(@v6)

      @ipv6nm = IPAddr.new(@v6nm)

    end

    unless ipv6_broken

      @ds.delete

      @ds.insert(@ipv6, @ipv6nm)

        v = rs.first[:j]

        rs.first[:i].should == @ipv6

        rs.first[:c].should == @ipv6nm

        rs.first[:i].should be_a_kind_of(IPAddr)

    def valid_v6?(addr)

      # IPv6 (normal)

      return true if /\A::([\dA-Fa-f]{1,4}(:[\dA-Fa-f]{1,4})*)?\Z/ =~ addr

      # IPv6 (IPv4 compat)

# IPAddr provides a set of methods to manipulate an IP address.  Both IPv4 and

# IPv6 are supported.

#

#   p ipaddr1			#=> #<IPAddr: IPv6:3ffe:0505:0002:0000:0000:0000:0000:0001/ffff:ffff:ffff:ffff:ffff:ffff:ffff:ffff>

  # Returns a new ipaddr built by converting the native IPv4 address

  # into an IPv4-mapped IPv6 address.

  # Returns a new ipaddr built by converting the native IPv4 address

  # into an IPv4-compatible IPv6 address.

  # Returns a new ipaddr built by converting the IPv6 address into a

  # native IPv4 address.  If the IP address is not an IPv4-mapped or

  # IPv4-compatible IPv6 address, returns self.