net-tns 1.0.0

data/lib/net/tti/crypto.rb

@@ -0,0 +1,189 @@
+require 'openssl'
+
+module Net::TTI
+  class Crypto
+    # Generates the encrypted password and encrypted client session key for
+    # authentication with a 10g server.
+    #
+    # @param username [String] The username for authentication.
+    # @param password [String] The password for authentication.
+    # @param enc_server_session_key [String] The encrypted server session key.
+    #   provided by the server. This should be a 32-byte binary packed string.
+    # @return [Array<String>] The encrypted password and the encrypted client
+    #   session key to use to authenticate with the server. These are returned
+    #   as binary packed strings.
+    def self.get_10g_auth_values( username, password, enc_server_session_key )
+      # Hash the password and pad it to 16 bytes. This will be used as the key
+      # for encrypting the client session key and decrypting the server session key.
+      password_hash = hash_password_10g( username, password )
+      password_hash += "\0" * 8
+
+      # TODO: make random client session key
+      client_session_key = "FAF5034314546426F329B1DAB1CDC5B8FF94349E0875623160350B0E13A0DA36".tns_unhexify
+
+      # Encrypt client session key and decrypt the server session key, using the
+      # password hash as a key.
+      enc_client_session_key = openssl_encrypt( "AES-128-CBC", password_hash, nil,     client_session_key )
+      server_session_key =     openssl_decrypt( "AES-128-CBC", password_hash, nil, enc_server_session_key )
+
+      # Make the combined session key hash. This is used as the key to encrypt
+      # the password.
+      combo_session_key = create_combined_session_key_hash_10g( server_session_key, client_session_key )
+
+      # TODO: make random salt
+      salt = "4C31AFE05F3B012C0AE9AB0CDFF0C508".tns_unhexify
+      # Encrypt the salted password
+      enc_password = openssl_encrypt( "AES-128-CBC", combo_session_key, nil, salt + password, true )
+
+      return enc_password, enc_client_session_key
+    end
+
+    # Generates the encrypted password and encrypted client session key for
+    # authentication with an 11g server.
+    #
+    # @param password [String] The password for authentication.
+    # @param enc_server_session_key [String] The encrypted server session key.
+    #   provided by the server. This should be a 48-byte binary packed string.
+    # @param auth_vfr_data [String] The value from the AUTH_VFR_DATA key-value
+    #   pair provided by the server.
+    # @return [Array<String>]  The encrypted password and the encrypted client
+    #   session key to use to authenticate with the server. These are returned
+    #   as binary packed strings.
+    def self.get_11g_auth_values( password, enc_server_session_key, auth_vfr_data )
+      # Hash the password and auth_vfr_data and pad it to 24 bytes. This will be
+      # used as the key for encrypting the client session key and decrypting the
+      # server session key.
+      password_hash = sha1_digest( password + auth_vfr_data ) + ("\0" * 4)
+
+      # TODO: make random client session key
+      client_session_key = "080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808080808".tns_unhexify
+
+      # Encrypt client session key and decrypt the server session key, using the
+      # password hash as a key.
+      enc_client_session_key = openssl_encrypt( "AES-192-CBC", password_hash, nil,     client_session_key )
+      server_session_key =     openssl_decrypt( "AES-192-CBC", password_hash, nil, enc_server_session_key )
+
+      # Make the combined session key hash. This is used as the key to encrypt
+      # the password.
+      combo_session_key = create_combined_session_key_hash_11g( server_session_key, client_session_key )
+
+      # TODO: make random salt
+      salt = "4C31AFE05F3B012C0AE9AB0CDFF0C508".tns_unhexify
+      # Encrypt the salted password
+      enc_password = openssl_encrypt( "AES-192-CBC", combo_session_key, nil, salt + password, true )
+
+      return enc_password, enc_client_session_key
+    end
+
+
+
+    # Generates the password hash for use in 10g authentication.
+    #
+    # @param username [String] The username for authentication.
+    # @param password [String] The password for authentication.
+    # @return [String] The password hash, as a binary packed string.
+    def self.hash_password_10g( username, password )
+      uspw = (username + password).upcase().encode( Encoding::UTF_16BE )
+      key = "0123456789abcdef".tns_unhexify   # fixed key used for 10g hashing
+
+      # Pad the username-password to an 8-byte boundary
+      if ( uspw.length % 4 > 0 )
+        padding_length = 4 - ( uspw.length % 4 )
+        uspw += ("\0".encode( Encoding::UTF_16BE )) * padding_length
+      end
+
+      key2 = openssl_encrypt( "DES-CBC", key, nil, uspw, false )
+      key2 = key2[-8,8]
+
+      pwhash = openssl_encrypt( "DES-CBC", key2, nil, uspw, false )
+      pwhash = pwhash[-8,8]
+    end
+
+    # Generates the combined session key hash, for use in encrypting the
+    # password in authentication.
+    #
+    # @param server_session_key [String] The unencrypted server session key, as
+    #   a binary packed string.
+    # @param client_session_key [String] The unencrypted client session key, as
+    #   a binary packed string.
+    # @return [String] The hash of the combined session key, as a binary packed
+    #   string.
+    def self.create_combined_session_key_hash_10g( server_session_key, client_session_key )
+      # Unpack the session keys into byte arrays
+      server_key_bytes = server_session_key.unpack( "C*" )
+      client_key_bytes = client_session_key.unpack( "C*" )
+      combo_session_key = ""
+
+      # XOR bytes 17-32 of the session keys to make the combined session key
+      for byte_itr in (16..31)
+        combo_session_key += (server_key_bytes[ byte_itr ] ^ client_key_bytes[ byte_itr ]).chr
+      end
+
+      # Hash the combined session key
+      return md5_digest( combo_session_key )
+    end
+
+    # Generates the combined session key hash, for use in encrypting the
+    # password in authentication.
+    #
+    # @param server_session_key [String] The unencrypted server session key, as
+    #   a binary packed string.
+    # @param client_session_key [String] The unencrypted client session key, as
+    #   a binary packed string.
+    # @return [String] The hash of the combined session key, as a binary packed
+    #   string.
+    def self.create_combined_session_key_hash_11g( server_session_key, client_session_key )
+      # make combined session key
+      server_key_bytes = server_session_key.unpack( "C*" )
+      client_key_bytes = client_session_key.unpack( "C*" )
+      combo_session_key = ""
+      for byte_itr in (16..39)
+        combo_session_key += (server_key_bytes[ byte_itr ] ^ client_key_bytes[ byte_itr ]).chr
+      end
+
+      # hash combined session key
+      combo_session_key = ( md5_digest(combo_session_key[0,16]) +
+                            md5_digest(combo_session_key[16,combo_session_key.length]) )
+      combo_session_key = combo_session_key[0,24]
+
+      return combo_session_key
+    end
+
+
+    # Helper function for encryption.
+    def self.openssl_encrypt( cipher, key, iv, data, padding=false )
+      cipher = OpenSSL::Cipher::Cipher.new( cipher )
+      cipher.encrypt
+      cipher.key = key
+      cipher.iv = iv unless iv.nil?
+      cipher.padding = 0 unless padding
+
+      ciphertext = cipher.update( data ) + cipher.final
+    end
+
+    # Helper function for decryption.
+    def self.openssl_decrypt( cipher, key, iv, data, padding=false )
+      cipher = OpenSSL::Cipher::Cipher.new( cipher )
+      cipher.decrypt
+      cipher.key = key
+      cipher.iv = iv unless iv.nil?
+      cipher.padding = 0 unless padding
+
+      ciphertext = cipher.update( data ) + cipher.final
+    end
+
+    # @return the MD5 digest (as a binary string) for the given input string
+    def self.md5_digest(input_str)
+      digester=Digest::MD5.new()
+      digester.update(input_str)
+      return digester.digest
+    end
+
+    # @return the SHA1 digest (as a binary string) for the given input string
+    def self.sha1_digest(input_str)
+      digester=Digest::SHA1.new()
+      digester.update(input_str)
+      return digester.digest
+    end
+  end
+end

data/lib/net/tti/data_types/chunked_string.rb

@@ -0,0 +1,63 @@
+require "bindata"
+
+module Net
+  module TTI
+    module DataTypes
+      class ChunkedString < BinData::BasePrimitive
+        # The marker to indicate that a string is being divided into multiple chunks
+        MULTI_CHUNK_MARKER = 0xFE
+        MULTI_CHUNK_TERMINATOR = 0x00
+        # The apparent maximum chunk length used by Oracle TNS implementations
+        MAX_CHUNK_LENGTH = 0x40
+
+        def sensible_default
+          return ""
+        end
+
+        def read_and_return_value(io)
+          begin
+            length = unmarshal_uint8(io)
+          rescue EOFError
+            return ""
+          end
+
+          if length == MULTI_CHUNK_MARKER
+            data = ""
+            while (length = unmarshal_uint8(io)) != MULTI_CHUNK_TERMINATOR
+              data += io.readbytes(length)
+            end
+
+            return data
+          else
+            return io.readbytes(length)
+          end
+        end
+
+        def value_to_binary_string(value)
+          return "" if value.empty?
+
+          if value.length > MAX_CHUNK_LENGTH
+            value_index = 0
+
+            binary_string = ""
+            binary_string << [MULTI_CHUNK_MARKER].pack("C")
+            while value_index < value.length
+              chunk = value[value_index, MAX_CHUNK_LENGTH]
+              binary_string << [chunk.length, chunk].pack("Ca*")
+              value_index += MAX_CHUNK_LENGTH
+            end
+            binary_string << [MULTI_CHUNK_TERMINATOR].pack("C")
+          else
+            return [value.length, value].pack("Ca*")
+          end
+        end
+
+        private
+        def unmarshal_uint8(io)
+          int_string = io.readbytes(1)
+          return int_string.unpack("C").first
+        end
+      end
+    end
+  end
+end

data/lib/net/tti/data_types/key_value_pair.rb

@@ -0,0 +1,25 @@
+require "bindata"
+require "net/tti/data_types/chunked_string"
+
+module Net
+  module TTI
+    module DataTypes
+      class KeyValuePair < BinData::Record
+        # In earlier dialects, the 4 bytes before the strings appeared to contain
+        # the total length of the string. In more recent dialects, this no longer
+        # seems to be the case. However, a 32-bit null here still appears to
+        # signal that there is no value.
+        uint32le        :unknown1, :value => lambda {kvp_key.length}
+        chunked_string  :kvp_key, :onlyif => lambda {unknown1 != 0}
+        uint32le        :unknown2, :value => lambda {kvp_value.length}
+        chunked_string  :kvp_value, :onlyif => lambda {unknown2 != 0}
+        uint32le        :flags
+
+        def set(key, value)
+          self.kvp_key.data = key
+          self.kvp_value.data = value
+        end
+      end
+    end
+  end
+end

data/lib/net/tti/data_types.rb

@@ -0,0 +1,2 @@
+require "net/tti/data_types/chunked_string"
+require "net/tti/data_types/key_value_pair"

data/lib/net/tti/exceptions.rb

@@ -0,0 +1,62 @@
+module Net::TTI
+  module Exceptions
+    class TTIException < StandardError
+    end
+
+    class ProtocolException < TTIException
+    end
+
+    class UnsupportedTarget < TTIException
+    end
+
+    class UnsupportedPlatform < UnsupportedTarget
+      def initialize( platform )
+        super( "Unsupported platform: #{platform}" )
+      end
+    end
+
+    class UnsupportedTNSVersion < UnsupportedTarget
+      def initialize( version )
+        super( "Unsupported version: #{version}" )
+      end
+    end
+
+
+
+    class ErrorMessageReceived < TTIException
+      ERROR_REGEX = /ORA\-(\d+)(?:\:\ (.*))?/
+      ERROR_REGEX_INDEX_CODE = 1
+      ERROR_REGEX_INDEX_DESCRIPTION = 2
+
+      # Attempts to parse and return the "ORA-xxxxx" error code from the error message
+      # @return [Integer] A numeric error code, or nil if the code could not be determined
+      def error_code()
+        matches = ERROR_REGEX.match( self.message )
+        error_code = matches[ERROR_REGEX_INDEX_CODE] unless( matches.nil? or matches[ERROR_REGEX_INDEX_CODE].nil? )
+        error_code = error_code.to_i unless error_code.nil?
+        return error_code
+      end
+
+
+      # Attempts to parse and return the error description after the "ORA-xxxxx"
+      # error code in the error message
+      # @return [String] A string containing the error description, or nil if the description could not be determined
+      def error_description()
+        matches = ERROR_REGEX.match( self.message )
+        return matches[ERROR_REGEX_INDEX_DESCRIPTION] unless( matches.nil? or matches[ERROR_REGEX_INDEX_DESCRIPTION].nil? )
+      end
+    end
+
+    class AuthenticationError < ErrorMessageReceived
+    end
+
+    class InvalidCredentialsError < AuthenticationError
+    end
+
+    class AccountLockedOutError < AuthenticationError
+    end
+
+    class PasswordExpiredError < AuthenticationError
+    end
+  end
+end

data/lib/net/tti/message.rb

@@ -0,0 +1,50 @@
+require "bindata"
+
+module Net
+  module TTI
+    class Message < BinData::Record
+      TTC_CODE_PROTOCOL_NEGOTIATION = 0x1
+      TTC_CODE_DATA_TYPE_NEGOTIATION = 0x2
+      TTC_CODE_FUNCTION_CALL = 0x3
+      TTC_CODE_ERROR = 0x4
+      TTC_CODE_OK = 0x8
+
+      # BinData fields
+      uint8     :ttc_code, :initial_value => :_ttc_code
+
+      def _ttc_code
+        raise NotImplementedError
+      end
+      private :_ttc_code
+
+      def self.handles_response_for_ttc_code(ttc_code)
+        @@ttc_classes ||= {}
+        @@ttc_codes ||= {}
+        if @@ttc_classes.has_key?(ttc_code)
+          existing_class = @@ttc_classes[ttc_code]
+          raise("Duplicate TTC response handlers defined: #{existing_class} and #{self} both have TTC code of #{ttc_code}")
+        end
+
+        @@ttc_classes[ttc_code] = self
+        @@ttc_codes[self] = ttc_code
+        return nil
+      end
+
+      def self.from_data_string( raw_message )
+        ttc_code = raw_message[0].unpack("C").first
+
+        unless message_class = @@ttc_classes[ ttc_code ]
+          raise Net::TNS::Exceptions::TnsException.new( "Unknown TTC code: #{ttc_code}" )
+        end
+
+        new_message = message_class.new
+        new_message.read( raw_message )
+
+        return new_message
+      end
+    end
+  end
+end
+
+require "pathname"
+Dir.glob("#{Pathname.new(__FILE__).dirname}/messages/**/*.rb") { |file| require file }

data/lib/net/tti/messages/data_type_negotiation_request.rb

@@ -0,0 +1,133 @@
+module Net
+  module TTI
+    class DataTypeNegotiationRequest < Message
+      # BinData fields
+
+      # Not sure why this is duplicated, but clients always send the same
+      # character set in both fields.
+      # Character sets:
+      #  0x00b2 (178) - US-ASCII
+      #  0x0369 (873) - UTF-8
+      uint16le  :charset1
+      uint16le  :charset2
+      uint8     :unknown1
+      uint8     :unknown2_length, :value => lambda { unknown2.length }
+      string    :unknown2
+      uint8     :unknown3_length, :value => lambda { unknown3.length }
+      string    :unknown3
+      string    :unknown4
+
+      UNKNOWN4_LINUX = (
+        "800000003c3c3c80000000d007000100010001000000020002000a0000000800" +
+        "0800010000000c000c000a000000170017000100000018001800010000001900" +
+        "190018001900010000001a001a0019001a00010000001b001b000a001b000100" +
+        "00001c001c0016001c00010000001d001d0017001d00010000001e001e001700" +
+        "1e00010000001f001f0019001f0001000000200020000a002000010000002100" +
+        "21000a002100010000000a000a00010000000b000b0001000000280028000100" +
+        "0000290029000100000075007500010000007800780001000001220122000100" +
+        "0001230123000101230001000001240124000100000125012500010000012601" +
+        "2600010000012a012a00010000012b012b00010000012c012c00010000012d01" +
+        "2d00010000012e012e00010000012f012f000100000130013000010000013101" +
+        "3100010000013201320001000001330133000100000134013400010000013501" +
+        "3500010000013601360001000001370137000100000138013800010000013901" +
+        "3900010000013b013b00010000013c013c00010000013d013d00010000013e01" +
+        "3e00010000013f013f0001000001400140000100000141014100010000014201" +
+        "4200010000014301430001000001470147000100000148014800010000014901" +
+        "4900010000014b014b00010000014d014d00010000014e014e00010000014f01" +
+        "4f00010000015001500001000001510151000100000152015200010000015301" +
+        "5300010000015401540001000001550155000100000156015600010000015701" +
+        "57000101570001000001580158000100000159015900010000015a015a000100" +
+        "00015c015c00010000015d015d00010000016201620001000001630163000100" +
+        "000167016700010000016b016b00010000017c017c0001014200010000017d01" +
+        "7d00010000017e017e00010000017f017f000100000180018000010000018101" +
+        "8100010000018201820001000001830183000100000184018400010000018501" +
+        "8500010000018601860001000001870187000100000189018900010000018a01" +
+        "8a00010000018b018b00010000018c018c00010000018d018d00010000018e01" +
+        "8e00010000018f018f0001000001900190000100000191019100010000019401" +
+        "9400010125000100000195019500010000019601960001000001970197000100" +
+        "00019d019d00010000019e019e00010000019f019f0001000001a001a0000100" +
+        "0001a101a10001000001a201a20001000001a301a30001000001a401a4000100" +
+        "0001a501a50001000001a601a60001000001a701a70001000001a801a8000100" +
+        "0001a901a90001000001aa01aa0001000001ab01ab0001000001ad01ad000100" +
+        "0001ae01ae0001000001af01af0001000001b001b00001000001b101b1000100" +
+        "0001c101c10001000001c201c2000101250001000001c601c60001000001c701" +
+        "c70001000001c801c80001000001c901c90001000001ca01ca0001019f000100" +
+        "0001cb01cb000101a00001000001cc01cc000101a20001000001cd01cd000101" +
+        "a30001000001ce01ce000101b10001000001cf01cf000101220001000001d201" +
+        "d20001000001d301d3000101ab0001000001d401d40001000001d501d5000100" +
+        "0001d601d60001000001d701d70001000001d801d80001000001d901d9000100" +
+        "0001da01da0001000001db01db0001000001dc01dc0001000001dd01dd000100" +
+        "0001de01de0001000001df01df0001000001e001e00001000001e101e1000100" +
+        "0001e201e20001000001e301e30001016b0001000001e401e40001000001e501" +
+        "e50001000001e601e60001000001ea01ea0001000001eb01eb0001000001ec01" +
+        "ec0001000001ed01ed0001000001ee01ee0001000001ef01ef0001000001f001" +
+        "f00001000001f201f20001000001f301f30001000001f401f40001000001f501" +
+        "f50001000001f601f60001000001fd01fd0001000001fe01fe00010000020102" +
+        "0100010000020202020001000002040204000100000205020500010000020602" +
+        "0600010000020702070001000002080208000100000209020900010000020a02" +
+        "0a00010000020b020b00010000020c020c00010000020d020d00010000020e02" +
+        "0e00010000020f020f0001000002100210000100000211021100010000021202" +
+        "1200010000021302130001000002140214000100000215021500010000021602" +
+        "1600010000021702170001000002180218000100000219021900010000021a02" +
+        "1a00010000021b021b00010000021c021c00010000021d021d00010000021e02" +
+        "1e00010000021f021f0001000002200220000100000221022100010000022202" +
+        "2200010000022302230001000002240224000100000225022500010000022602" +
+        "2600010000022702270001000002280228000100000229022900010000022a02" +
+        "2a00010000022b022b00010000022c022c00010000022d022d00010000022e02" +
+        "2e00010000022f022f0001000002310231000100000232023200010000023302" +
+        "3300010000023402340001000002370237000100000238023800010000023902" +
+        "3900010000023a023a00010000023b023b00010000023c023c00010000023d02" +
+        "3d00010000023e023e00010000023f023f000100000240024000010000024102" +
+        "4100010000024202420001000002430243000100000244024400010000024502" +
+        "4500010000024602460001000002470247000100000248024800010000024902" +
+        "490001000000030002000a000000040002000a00000005000100010000000600" +
+        "02000a000000070002000a00000009000100010000000d0000000e0000000f00" +
+        "1700010000001000000011000000120000001300000014000000150000001600" +
+        "00002700780001015d0001012600010000003a003a0001000000440002000a00" +
+        "000045000000460000004a006d00010000004c0000005b0002000a0000005e00" +
+        "0100010000005f00170001000000600060000100000061006000010000006400" +
+        "6400010000006500650001000000660066000100000068000000690000006a00" +
+        "6a00010000006c006d00010000006d006d00010000006e006f00010000006f00" +
+        "6f00010000007000700001000000710071000100000072007200010000007300" +
+        "7300010000007400660001000000760000007700000079007900010000007a00" +
+        "7a00010000007b007b0001000000880000009200920001000000930093000100" +
+        "0000980002000a000000990002000a0000009a0002000a0000009b0001000100" +
+        "00009c000c000a000000ac0002000a000000b200b20001000000b300b3000100" +
+        "0000b400b40001000000b500b50001000000b600b60001000000b700b7000100" +
+        "0000b8000c000a000000b900b20001000000ba00b30001000000bb00b4000100" +
+        "0000bc00b50001000000bd00b60001000000be00b70001000000bf000000c000" +
+        "0000c300700001000000c400710001000000c500720001000000d000d0000100" +
+        "0000d1000000e700e70001000000e800e70001000000e900e90001000000f100" +
+        "6d0001000002030203000100000000").tns_unhexify
+
+      def _ttc_code()
+        TTC_CODE_DATA_TYPE_NEGOTIATION
+      end
+      private :_ttc_code
+
+      def self.create_request(platform)
+        request = self.new
+        request.character_set = 0x00b2
+        request.unknown1 = 0x02
+        request.unknown2 = "060101010d01010401010101010101ffff0308030001003f01073f010101010301".tns_unhexify
+        request.unknown3 = "0201000018".tns_unhexify
+
+        case platform
+        when :linux
+          request.unknown4 = UNKNOWN4_LINUX
+        when :windows
+          request.unknown4 = "800000003c3c3c80000000d007".tns_unhexify
+        else
+          raise Net::TTI::Exceptions::UnsupportedPlatform.new( platform )
+        end
+
+        return request
+      end
+
+      def character_set=(charset)
+        self.charset1 = charset
+        self.charset2 = charset
+      end
+    end
+  end
+end

data/lib/net/tti/messages/data_type_negotiation_response.rb

@@ -0,0 +1,9 @@
+module Net
+  module TTI
+    class DataTypeNegotiationResponse < Message
+      handles_response_for_ttc_code TTC_CODE_DATA_TYPE_NEGOTIATION
+      # BinData fields
+      rest    :data
+    end
+  end
+end

data/lib/net/tti/messages/error_message.rb

@@ -0,0 +1,14 @@
+module Net
+  module TTI
+    class ErrorMessage < Message
+      handles_response_for_ttc_code TTC_CODE_ERROR
+
+      # BinData fields
+      string    :unknown1,        :read_length => 6
+      uint16le  :unknown2
+      string    :unknown3,        :read_length => lambda { unknown2 == 0x01 ? 87 : 57 }
+      uint8     :message_length
+      string    :message,         :read_length => lambda { message_length }
+    end
+  end
+end

data/lib/net/tti/messages/function_call.rb

@@ -0,0 +1,46 @@
+module Net
+  module TTI
+    class FunctionCall < Message
+      handles_response_for_ttc_code TTC_CODE_FUNCTION_CALL
+
+      FUNCTION_CODE_PRE_AUTH = 0x76
+      FUNCTION_CODE_AUTH = 0x73
+
+      # BinData fields
+      # The function code: 0x76 => preauth, 0x73 => auth
+      uint8     :function_code, :initial_value => :_function_code
+      uint8     :sequence_number, :initial_value => :_sequence_number
+
+      def _ttc_code
+        return TTC_CODE_FUNCTION_CALL
+      end
+      private :_ttc_code
+
+      def _function_code
+        raise NotImplementedError
+      end
+      private :_function_code
+
+      def _sequence_number
+        @@seq_num ||= 0
+        @@seq_num += 1
+        return @@seq_num
+      end
+      private :_sequence_number
+
+      def to_binary_s
+        if sequence_number == 0
+          sequence_number = FunctionCall.next_sequence_number
+        end
+
+        super
+      end
+
+      def self.next_sequence_number
+        @@last_sequence_number ||= 0
+        @@last_sequence_number = (@@last_sequence_number + 1) % 256
+        return @@last_sequence_number
+      end
+    end
+  end
+end

data/lib/net/tti/messages/function_calls/authentication.rb

@@ -0,0 +1,45 @@
+require "net/tti/data_types"
+
+module Net
+  module TTI
+    class Authentication < FunctionCall
+      LOGON_MODE_PRE_AUTH   = 0x00000001
+      LOGON_MODE_AUTH       = 0x00000101
+
+      def self.create_pre_auth_request(target_architecture)
+        case target_architecture
+        when :x86
+          return PreAuthenticationX86.new
+        when :x64
+          return PreAuthenticationX64.new
+        else
+          raise Net::TTI::Exceptions::UnsupportedPlatform.new(target_architecture)
+        end
+      end
+
+      def self.create_auth_request(target_architecture)
+        case target_architecture
+        when :x86
+          return AuthenticationX86.new
+        when :x64
+          return AuthenticationX64.new
+        else
+          raise Net::TTI::Exceptions::UnsupportedPlatform.new(target_architecture)
+        end
+      end
+
+      def add_parameter( key, value, flags=0 )
+        kvp = DataTypes::KeyValuePair.new( :kvp_key => key, :kvp_value => value, :flags => flags )
+        self.parameters << kvp
+      end
+
+      def enc_client_session_key=(enc_client_session_key)
+        add_parameter( "AUTH_SESSKEY", enc_client_session_key.tns_hexify.upcase, 1 )
+      end
+
+      def enc_password=(enc_password)
+        add_parameter( "AUTH_PASSWORD", enc_password.tns_hexify.upcase )
+      end
+    end
+  end
+end