Class: Net::NTLM::Message::Type2

Inherits:
Net::NTLM::Message show all
Defined in:
lib/net/ntlm.rb

Class Method Summary collapse

Instance Method Summary collapse

Methods inherited from Net::NTLM::Message

#data_edge, #data_size, decode64, #decode64, #deflag, #dump_flags, #encode64, #has_flag?, #head_size, #security_buffers, #serialize, #set_flag, #size

Methods inherited from FieldSet

#[], #[]=, #disable, #enable, #initialize, int16LE, int32LE, int64LE, names, opts, prototypes, security_buffer, #serialize, #size, string, types

Constructor Details

This class inherits a constructor from Net::NTLM::FieldSet

Class Method Details

.parse(str) ⇒ Type2

Parse a Type 2 packet

Parameters:

  • str (String) —

    A string containing Type 2 data

Returns:



711
712
713
714
715
 
# File 'lib/net/ntlm.rb', line 711

def parse(str)
  t = new
  t.parse(str)
  t
end

Instance Method Details

#challenge ⇒ Int64

Returns:

  • (Int64) 


702
 
# File 'lib/net/ntlm.rb', line 702

int64LE           :challenge,    {:value => 0}

#challenge= ⇒ Int64

Returns:

  • (Int64) 


702
 
# File 'lib/net/ntlm.rb', line 702

int64LE           :challenge,    {:value => 0}

#context ⇒ Int64

Returns:

  • (Int64) 


703
 
# File 'lib/net/ntlm.rb', line 703

int64LE           :context,      {:value => 0, :active => false}

#context= ⇒ Int64

Returns:

  • (Int64) 


703
 
# File 'lib/net/ntlm.rb', line 703

int64LE           :context,      {:value => 0, :active => false}

#flag ⇒ Int32LE

Returns:



701
 
# File 'lib/net/ntlm.rb', line 701

int32LE       :flag,         {:value => DEFAULT_FLAGS[:TYPE2]}

#flag= ⇒ Int32LE

Returns:



701
 
# File 'lib/net/ntlm.rb', line 701

int32LE       :flag,         {:value => DEFAULT_FLAGS[:TYPE2]}

#padding ⇒ String

Returns:



705
 
# File 'lib/net/ntlm.rb', line 705

string        :padding,   {:size => 0, :value => "", :active => false }

#padding= ⇒ String

Returns:



705
 
# File 'lib/net/ntlm.rb', line 705

string        :padding,   {:size => 0, :value => "", :active => false }

#response(arg, opt = {}) ⇒ Type3

Note:

An empty :domain option authenticates to the local machine.

Note:

The :use_default_target has presidence over the :domain option

Generates a Type 3 response based on the Type 2 Information

Parameters:

  • arg (Hash) —

    a customizable set of options

  • opt (Hash) (defaults to: {}) —

    a customizable set of options

Options Hash (arg):

  • :username (String) —

    The username to authenticate with

  • :password (String) —

    The user’s password

  • :domain (String) — default: '' —

    The domain to authenticate to

Options Hash (opt):

  • :workstation (String) — default: Socket.gethostname —

    The name of the calling workstation

  • :use_default_target (Boolean) — default: False —

    Use the domain supplied by the server in the Type 2 packet

Returns:



741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
 
# File 'lib/net/ntlm.rb', line 741

def response(arg, opt = {})
  usr = arg[:user]
  pwd = arg[:password]
  domain = arg[:domain] ? arg[:domain] : ""
  if usr.nil? or pwd.nil?
    raise ArgumentError, "user and password have to be supplied"
  end

  if opt[:workstation]
    ws = opt[:workstation]
  else
    ws = Socket.gethostname
  end

  if opt[:client_challenge]
    cc  = opt[:client_challenge]
  else
    cc = rand(MAX64)
  end
  cc = NTLM::pack_int64le(cc) if cc.is_a?(Integer)
  opt[:client_challenge] = cc

  if has_flag?(:OEM) and opt[:unicode]
    usr = NTLM::EncodeUtil.decode_utf16le(usr)
    pwd = NTLM::EncodeUtil.decode_utf16le(pwd)
    ws  = NTLM::EncodeUtil.decode_utf16le(ws)
    domain = NTLM::EncodeUtil.decode_utf16le(domain)
    opt[:unicode] = false
  end

  if has_flag?(:UNICODE) and !opt[:unicode]
    usr = NTLM::EncodeUtil.encode_utf16le(usr)
    pwd = NTLM::EncodeUtil.encode_utf16le(pwd)
    ws  = NTLM::EncodeUtil.encode_utf16le(ws)
    domain = NTLM::EncodeUtil.encode_utf16le(domain)
    opt[:unicode] = true
  end

  if opt[:use_default_target]
    domain = self.target_name
  end

  ti = self.target_info

  chal = self[:challenge].serialize

  if opt[:ntlmv2]
    ar = {:ntlmv2_hash => NTLM::ntlmv2_hash(usr, pwd, domain, opt), :challenge => chal, :target_info => ti}
    lm_res = NTLM::lmv2_response(ar, opt)
    ntlm_res = NTLM::ntlmv2_response(ar, opt)
  elsif has_flag?(:NTLM2_KEY)
    ar = {:ntlm_hash => NTLM::ntlm_hash(pwd, opt), :challenge => chal}
    lm_res, ntlm_res = NTLM::ntlm2_session(ar, opt)
  else
    lm_res = NTLM::lm_response(pwd, chal)
    ntlm_res = NTLM::ntlm_response(pwd, chal)
  end

  Type3.create({
  	:lm_response => lm_res,
  	:ntlm_response => ntlm_res,
  	:domain => domain,
    :user => usr,
    :workstation => ws,
    :flag => self.flag
  })
end

#sign ⇒ String

Returns:



698
 
# File 'lib/net/ntlm.rb', line 698

string        :sign,         {:size => 8, :value => SSP_SIGN}

#sign= ⇒ String

Returns:



698
 
# File 'lib/net/ntlm.rb', line 698

string        :sign,         {:size => 8, :value => SSP_SIGN}

#target_info ⇒ SecurityBuffer

Returns:



704
 
# File 'lib/net/ntlm.rb', line 704

security_buffer   :target_info,  {:value => "", :active => false}

#target_info= ⇒ SecurityBuffer

Returns:



704
 
# File 'lib/net/ntlm.rb', line 704

security_buffer   :target_info,  {:value => "", :active => false}

#target_name ⇒ SecurityBuffer

Returns:



700
 
# File 'lib/net/ntlm.rb', line 700

security_buffer   :target_name,  {:size => 0, :value => ""}

#target_name= ⇒ SecurityBuffer

Returns:



700
 
# File 'lib/net/ntlm.rb', line 700

security_buffer   :target_name,  {:size => 0, :value => ""}

#type ⇒ Int32LE

Returns:



699
 
# File 'lib/net/ntlm.rb', line 699

int32LE       :type,      {:value => 2}

#type= ⇒ Int32LE

Returns:



699
 
# File 'lib/net/ntlm.rb', line 699

int32LE       :type,      {:value => 2}