---
-- TNS Library supporting a very limited subset of Oracle operations
--
-- Summary
-- -------
-- The library currently provides functionality to connect and authenticate
-- to the Oracle database server. Some preliminary query support has been
-- added, which only works against a few specific versions. The library has
-- been tested against and known to work with Oracle 10g and 11g. Please check
-- the matrix below for tested versions that are known to work.
--
-- Due to the lack of documentation the library is based mostly on guesswork
-- with a lot of unknowns. Bug reports are therefore both welcome and
-- important in order to further improve this library. In addition, knowing
-- that the library works against versions not in the test matrix is valuable
-- as well.
--
-- Overview
-- --------
-- The library contains the following classes:
--
--   o Packet.*
--    - The Packet classes contain specific packets and function to serialize
--        them to strings that can be sent over the wire. Each class may also
--        contain a function to parse the servers response.
--
--   o Comm
--    - Implements a number of functions to handle communication
--
--   o Crypt
--     - Implements encryption algorithms and functions to support
--        authentication with Oracle 10G and Oracle 11G.
--
--   o Helper
--    - A helper class that provides easy access to the rest of the library
--
--
-- Example
-- -------
-- The following sample code illustrates how scripts can use the Helper class
-- to interface the library:
--
-- <code>
-- tnshelper = tns.Helper:new(host, port)
-- status, err = tnshelper:Connect()
-- status, res = tnshelper:Login("sys", "change_on_install")
-- status, err = tnshelper:Close()
-- </code>
--
-- Additional information
-- ----------------------
-- The implementation is based on the following documentation and through
-- analysis of packet dumps:
--
--  o Oracle 10g TNS AES-128 authentication details (Massimiliano Montoro)
--    x http://www.oxid.it/downloads/oracle_tns_aes128_check.txt
--  o Oracle 11g TNS AES-192 authentication details (Massimiliano Montoro)
--     x http://www.oxid.it/downloads/oracle_tns_aes192_check.txt
--  o Initial analysis of Oracle native authentication version 11g
--    (László Tóth)
--      x http://www.soonerorlater.hu/index.khtml?article_id=512
--  o Oracle native authentication version 9i and 10g (László Tóth)
--      x http://www.soonerorlater.hu/index.khtml?article_id=511
--
-- This implementation is tested and known to work against Oracle 10g and 11g
-- on both Linux and Windows. For details regarding what versions where tested
-- please consult the matrix below.
--
-- @copyright Same as Nmap--See https://nmap.org/book/man-legal.html
-- @author Patrik Karlsson <patrik@cqure.net>
--
-- @args tns.sid specifies the Oracle instance to connect to

--
-- Version 0.71
-- Created 07/12/2010 - v0.1 - created by Patrik Karlsson <patrik@cqure.net>
-- Revised 07/21/2010 - v0.2 - made minor changes to support 11gR2 on Windows
-- Revised 07/23/2010 - v0.3 - corrected incorrect example code in docs
--                           - removed ssl require
-- Revised 02/08/2011 - v0.4 - added basic query support <patrik@cqure.net>
-- Revised 17/08/2011 - v0.5 - fixed bug that would prevent connections from
--                             working on 64-bit oracle.
-- Revised 20/08/2011 - v0.6 - fixed a few bugs in connection and query code
--                           - changed so that connections against untested
--                             databases versions will fail
--                           - added some more documentation and fixed some
--                             indentation bugs
--                             <patrik@cqure.net>
-- Revised 26/08/2011 - v0.7 - applied patch from Chris Woodbury
--                             <patrik@cqure.net>
-- Revised 28/08/2011 - v0.71- fixed a bug that would prevent the library from
--                             authenticating against Oracle 10.2.0.1.0 XE
--                             <patrik@cqure.net>
--
-- The following versions have been tested and are known to work:
-- +--------+---------------+---------+-------+-------------------------------+
-- | OS     | DB Version    | Edition | Arch  | Functionality                 |
-- +--------+---------------+---------+-------+-------------------------------|
-- | Win    | 10.2.0.1.0    | EE      | 32bit | Authentication                |
-- | Win    | 10.2.0.1.0    | XE      | 32bit | Authentication, Queries       |
-- | Linux  | 10.2.0.1.0    | EE      | 32bit | Authentication                |
-- | Win    | 11.1.0.6.0    | EE      | 32bit | Authentication, Queries       |
-- | Win    | 11.1.0.6.0    | EE      | 64bit | Authentication                |
-- | Win    | 11.2.0.1.0    | EE      | 64bit | Authentication                |
-- | Win    | 11.2.0.2.0    | EE      | 64bit | Authentication                |
-- | Linux  | 11.2.0.1.0    | EE      | 64bit | Authentication                |
-- | Win    | 11.2.0.2.0    | XE      | 32bit | Authentication, Queries       |
-- | Win    | 11.2.0.2.0    | EE      | 64bit | Authentication, Queries       |
-- +--------+---------------+---------+-------+-------------------------------+
--

local bits = require "bits"
local math = require "math"
local match = require "match"
local nmap = require "nmap"
local stdnse = require "stdnse"
local string = require "string"
local table = require "table"
local openssl = stdnse.silent_require "openssl"
_ENV = stdnse.module("tns", stdnse.seeall)

-- Oracle version constants
ORACLE_VERSION_10G = 313
ORACLE_VERSION_11G = 314

-- Data type to number conversions
DataTypes = {
  NUMBER = 2,
  DATE = 12,
}

-- A class containing some basic authentication options
AuthOptions =
{

  -- Creates a new AuthOptions instance
  -- @return o new instance of AuthOptions
  new = function( self )
    local o = {
      auth_term = "pts/" .. math.random(255),
      auth_prog = ("sqlplus@nmap_%d (TNS V1-V3)"):format(math.random(32768)),
      auth_machine = "nmap_target",
      auth_pid = "" .. math.random(32768),
      auth_sid = "nmap_" .. math.random(32768)
    }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

}

-- Decodes different datatypes from the byte arrays or strings read from the
-- tns data packets
DataTypeDecoders = {

  -- Decodes a number
  [DataTypes.NUMBER] = function(val)
    if ( #val == 0 ) then return "" end
    if ( #val == 1 and val == '\128' ) then return 0 end

    local bytes = {string.byte(val, 1, #val)}

    local positive = ( (bytes[1] & 0x80) ~= 0 )

    local function convert_bytes(bytes, positive)
      local ret_bytes = {}
      local len = #bytes

      if ( positive ) then
        ret_bytes[1] = (bytes[1] & 0x7F) - 65
        for i=2, len do ret_bytes[i] = bytes[i] - 1 end
      else
        ret_bytes[1] = ((bytes[1] ~ 0xFF) & 0x7F) - 65
        for i=2, len do ret_bytes[i] = 101 - bytes[i] end
      end

      return ret_bytes
    end

    bytes = convert_bytes(bytes, positive)

    local k = ( #bytes - 1 > bytes[1] +1 ) and ( bytes[1] + 1 ) or #bytes - 1
    local l = 0
    for m=1, k do l = l * 100 + bytes[m+1] end
    for m=bytes[1]-#bytes - 1, 0, -1 do l = l * 100 end

    return (positive and l or -l)
  end,

  -- Decodes a date
  [DataTypes.DATE] = function(val)
    local bytes = {}

    if (#val == 0) then
      return ""
    elseif( #val ~= 7 ) then
      return "ERROR: Failed to decode date"
    end

    local bytes = {string.byte(val, 1, 7)}

    return ("%d-%02d-%02d"):format( (bytes[1] - 100 ) * 100 + bytes[2] - 100, bytes[3], bytes[4] )
  end,



}

-- Packet class table
--
-- Each Packet type SHOULD implement:
--  o tns_type - A variable indicating the TNS Type of the Packet
--  o toString - A function that serializes the object to string
--
-- Each Packet MAY also optionally implement:
--  o parseResponse
--     x An optional function that parses the servers response
--     x The function should return status and an undefined second return value
--
Packet = {}

-- Contains the TNS header and basic functions for decoding and reading the
-- TNS packet.
Packet.TNS = {

  checksum = 0,
  hdr_checksum = 0,
  length = 0,
  reserved = 0,

  Type =
  {
    CONNECT = 1,
    ACCEPT = 2,
    REFUSE = 4,
    DATA = 6,
    RESEND = 11,
    MARKER = 12,
  },

  new = function( self, typ )
    local o = {
      type = typ
    }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Read a TNS packet of the socket
  --
  -- @return true on success, false on failure
  -- @return err string containing error message on failure
  recv = function( self )
    local status, data = self.socket:receive_buf( match.numbytes(2), true )

    if ( not(status) ) then
      return status, data
    end

    self.length = string.unpack(">I2", data )

    status, data = self.socket:receive_buf( match.numbytes(6), true )
    if ( not(status) ) then
      return status, data
    end

    self.checksum, self.type, self.reserved, self.hdr_checksum = string.unpack(">I2BBI2", data)

    status, data = self.socket:receive_buf( match.numbytes(self.length - 8), true )
    if ( status ) then
      self.data = data
    end

    return true
  end,

  parse = function(data)
    local tns = Packet.TNS:new()
    local pos
    tns.length, tns.checksum, tns.type, tns.reserved, tns.hdr_checksum, pos = string.unpack(">I2I2BBI2", data)
    tns.data, pos = string.unpack("c" .. ( tns.length - 8 ), data, pos)
    return tns
  end,

  --- Converts the TNS packet to string suitable to be sent over the socket
  --
  -- @return string containing the TNS packet
  __tostring = function( self )
    local data = string.pack(">I2I2BBI2", self.length, self.checksum, self.type, self.reserved, self.hdr_checksum) .. self.data
    return data
  end,

}

-- Initiates the connection to the listener
Packet.Connect = {

  CONN_STR = [[
  (DESCRIPTION=(ADDRESS=(PROTOCOL=TCP)(HOST=%s)(PORT=%d))
  (CONNECT_DATA=(SERVER=DEDICATED)(SERVICE_NAME=%s)(CID=
  (PROGRAM=sqlplus)(HOST=%s)(USER=nmap))))]],

  version = 314,
  version_comp = 300,
  svc_options = 0x0c41,
  sess_dus = 8192,
  max_trans_dus = 32767,
  nt_proto_char = 0x7f08,
  line_turnaround = 0,
  value_of_1_in_hw = 0x0100,
  conn_data_len = 0,
  conn_data_offset = 58,
  conn_data_max_recv = 512,
  conn_data_flags_0 = 0x41,
  conn_data_flags_1 = 0x41,
  trace_cross_1 = 0,
  trace_cross_2 = 0,
  trace_unique_conn = 0,
  tns_type = Packet.TNS.Type.CONNECT,

  -- Creates a new Connect instance
  -- @param rhost string containing host or ip
  -- @param rport string containing the port number
  -- @param dbinstance string containing the instance name
  -- @return o containing new Connect instance
  new = function( self, rhost, rport, dbinstance )
    local o = {
      rhost = rhost,
      rport = rport,
      conn_data = Packet.Connect.CONN_STR:format( rhost, rport, dbinstance, rhost ),
      dbinstance = dbinstance:upper()
    }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  setCmd = function( self, cmd )
    local tmp = [[
    (DESCRIPTION=(CONNECT_DATA=(CID=(PROGRAM=)(HOST=%s)(USER=nmap))(COMMAND=%s)(ARGUMENTS=64)(SERVICE=%s:%d)(VERSION=185599488)))
    ]]
    self.conn_data = tmp:format( self.rhost, cmd, self.rhost, self.rport )
  end,

  --- Parses the server response from the CONNECT
  --
  -- @param tns Packet.TNS containing the TNS packet received from the
  --        server
  -- @return true on success, false on failure
  -- @return version number containing the version supported by the
  --         server or an error message on failure
  parseResponse = function( self, tns )
    if ( tns.type ~= Packet.TNS.Type.ACCEPT ) then
      if ( tns.data:match("ERR=12514") ) then
        return false, ("TNS: The listener could not resolve \"%s\""):format(self.dbinstance)
      end
      return false, tns.data:match("%(ERR=(%d*)%)")
    end

    local version = string.unpack(">I2", tns.data )
    return true, version
  end,

  --- Converts the CONNECT packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    self.conn_data_len = #self.conn_data

    return string.pack(">I2I2I2I2I2I2I2I2I2I2I4 BBI4 I4 I8I8", self.version, self.version_comp, self.svc_options,
    self.sess_dus, self.max_trans_dus, self.nt_proto_char,
    self.line_turnaround, self.value_of_1_in_hw, self.conn_data_len,
    self.conn_data_offset, self.conn_data_max_recv, self.conn_data_flags_0,
    self.conn_data_flags_1, self.trace_cross_1, self.trace_cross_2,
    self.trace_unique_conn, 0) .. self.conn_data
  end,


}

-- A TNS data packet, one of the most common packets
Packet.Data = {

  flag = 0,

  -- Createas a new Data instance
  -- @return o new instance of Data
  new = function( self, data )
    local o = {
      TNS = Packet.TNS:new( Packet.TNS.Type.DATA ),
      data = data
    }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    local data = string.pack( ">I2", self.flag ) .. self.data
    self.TNS.length = #data + 8
    return tostring(self.TNS) .. data
  end,

}

-- Packet received by the server to indicate errors or end of
-- communication.
Packet.Attention = {

  tns_type = Packet.TNS.Type.MARKER,

  -- Creates a new instance of the Attention packet
  -- @return o new instance of Attention
  new = function( self, typ, data )
    local o = { data = data, att_type = typ }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the MARKER packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    return string.pack( ">B", self.att_type ) .. self.data
  end,

}

-- Packet initializing challenge response authentication
Packet.PreAuth = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0,
  param_order = {
    { ["AUTH_TERMINAL"] = "auth_term" },
    { ["AUTH_PROGRAM_NM"] = "auth_prog" },
    { ["AUTH_MACHINE"] = "auth_machine" },
    { ["AUTH_PID"] = "auth_pid" },
    { ["AUTH_SID"] = "auth_sid" }
  },

  --- Creates a new PreAuth packet
  --
  -- @param user string containing the user name
  -- @return a new instance of Packet.PreAuth
  new = function(self, user, options, ver)
    local o = { auth_user = user, auth_options = options, version = ver }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    local packet_type = 0x0376
    local UNKNOWN_MAP = {
      ["Linuxi386/Linux-2.0.34-8.1.0"] = stdnse.fromhex("0238be0808") .. string.char(#self.auth_user) .. stdnse.fromhex("00000001000000a851bfbf05000000504ebfbf7853bfbf"),
      ["IBMPC/WIN_NT-8.1.0"] = stdnse.fromhex("0238be0808") .. string.char(#self.auth_user) .. stdnse.fromhex("00000001000000a851bfbf05000000504ebfbf7853bfbf"),
      ["IBMPC/WIN_NT64-9.1.0"] = stdnse.fromhex("0201040000000100000001050000000101"),
      ["x86_64/Linux 2.4.xx"] = stdnse.fromhex("0201040000000100000001050000000101"),
    }
    local unknown = UNKNOWN_MAP[self.version] or ""
    local data = {
      string.pack(">I2I2", self.flags, packet_type),
      unknown,
      string.pack("s1", self.auth_user),
    }

    for _, v in ipairs( Packet.PreAuth.param_order ) do
      for k, v2 in pairs(v) do
        data[#data+1] = Marshaller.marshalKvp( k, self.auth_options[v2] )
      end
    end

    return table.concat(data)
  end,

  --- Parses the PreAuth packet response and extracts data needed to
  --  perform authentication
  --
  -- @param tns Packet.TNS containing the TNS packet received from the server
  -- @return table containing the keys and values returned by the server
  parseResponse = function( self, tns )
    local kvps = {}
    local kvp_count = string.unpack( "B", tns.data, 4 )
    local pos = 6

    for kvp_itr=1, kvp_count do
      local key, val, kvp_flags
      pos, key, val, kvp_flags = Marshaller.unmarshalKvp( tns.data, pos )
      -- we don't actually do anything with the flags currently, but they're there
      kvps[key] = val
    end

    return true, kvps
  end,

}

-- Packet containing authentication data
Packet.Auth = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0,
  param_order = {
    { ['key'] = "AUTH_RTT", ['def'] = "25456" },
    { ['key'] = "AUTH_CLNT_MEM", ['def'] = "4096" },
    { ['key'] = "AUTH_TERMINAL", ['var'] = "auth_term" },
    { ['key'] = "AUTH_PROGRAM_NM", ['var'] = "auth_prog" },
    { ['key'] = "AUTH_MACHINE", ['var'] = "auth_machine" },
    { ['key'] = "AUTH_PID", ['var'] = "auth_pid" },
    { ['key'] = "AUTH_SID", ['var'] = "auth_sid" },
    { ['key'] = "AUTH_ACL", ['def'] = "4400" },
    { ['key'] = "AUTH_ALTER_SESSION", ['def'] = "ALTER SESSION SET TIME_ZONE='+02:00'\0" },
    { ['key'] = "AUTH_LOGICAL_SESSION_ID", ['def'] = stdnse.tohex(openssl.rand_pseudo_bytes(16)) },
    { ['key'] = "AUTH_FAILOVER_ID", ['def'] = "" },
  },

  --- Creates a new Auth packet
  --
  -- @param auth_sesskey the encrypted session key
  -- @param auth_pass the encrypted user password
  -- @return a new instance of Packet.Auth
  new = function(self, user, options, auth_sesskey, auth_pass, ver)
    local o = {
      auth_sesskey = auth_sesskey,
      auth_pass = auth_pass,
      auth_options = options,
      user = user,
      version = ver
    }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    local UNKNOWN_MAP = {
      ["Linuxi386/Linux-2.0.34-8.1.0"] = stdnse.fromhex("0338be0808") .. string.char(#self.user) .. stdnse.fromhex("00000001010000cc7dbfbf0d000000747abfbf608abfbf"),
      ["IBMPC/WIN_NT-8.1.0"] = stdnse.fromhex("0338be0808") .. string.char(#self.user) .. stdnse.fromhex("00000001010000cc7dbfbf0d000000747abfbf608abfbf"),
      ["IBMPC/WIN_NT64-9.1.0"] = stdnse.fromhex("03010400000001010000010d0000000101"),
      ["x86_64/Linux 2.4.xx"] = stdnse.fromhex("03010400000001010000010d0000000101")
    }

    local sess_id = stdnse.tohex(openssl.rand_pseudo_bytes(16))
    local unknown = UNKNOWN_MAP[self.version] or ""
    local data = {
      string.pack(">I2I2", self.flags, 0x0373),
      unknown,
      string.pack("s1", self.user),
      Marshaller.marshalKvp( "AUTH_SESSKEY", self.auth_sesskey, 1 ),
      Marshaller.marshalKvp( "AUTH_PASSWORD", self.auth_pass ),
    }

    for k, v in ipairs( self.param_order ) do
      if ( v['def'] ) then
        data[#data+1] = Marshaller.marshalKvp( v['key'], v['def'] )
      elseif ( self.auth_options[ v['var'] ] ) then
        data[#data+1] = Marshaller.marshalKvp( v['key'], self.auth_options[ v['var'] ] )
      elseif ( self[ v['var'] ] ) then
        data[#data+1] = Marshaller.marshalKvp( v['key'], self[ v['var'] ] )
      end
    end
    return table.concat(data)
  end,

  -- Parses the response of an Auth packet
  --
  -- @param tns Packet.TNS containing the TNS packet received from the server
  -- @return table containing the key pair values from the Auth packet
  parseResponse = function( self, tns )
    local kvps = {}
    local kvp_count = string.unpack( "B", tns.data, 4 )
    local pos = 6

    for kvp_itr=1, kvp_count do
      local key, val, kvp_flags
      pos, key, val, kvp_flags = Marshaller.unmarshalKvp( tns.data, pos )
      -- we don't actually do anything with the flags currently, but they're there
      kvps[key] = val
    end

    return true, kvps
  end,

}

Packet.SNS = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0,

  -- Creates a new SNS instance
  --
  -- @return o new instance of the SNS packet
  new = function(self)
    local o = {}
    setmetatable(o, self)
    self.__index = self
    return o
  end,


  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    return string.pack(">I2", self.flags) .. stdnse.fromhex(
    [[
    deadbeef00920b1006000004000004000300000000000400050b10060000080
    001000015cb353abecb00120001deadbeef0003000000040004000100010002
    0001000300000000000400050b10060000020003e0e100020006fcff0002000
    200000000000400050b100600000c0001001106100c0f0a0b08020103000300
    0200000000000400050b10060000030001000301
    ]] )
  end,
}

-- Packet containing protocol negotiation
Packet.ProtoNeg = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0,

  new = function(self)
    local o = {}
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    return string.pack(">I2", self.flags) .. stdnse.fromhex("0106050403020100")
    .. "Linuxi386/Linux-2.0.34-8.1.0\0"
  end,

  --- Parses and verifies the server response
  --
  -- @param tns Packet.TNS containing the response from the server
  parseResponse = function( self, tns )
    local flags, neg, ver, srv = string.unpack(">I2BBxz", tns.data)
    if ( neg ~= 1 ) then
      return false, "Error protocol negotiation failed"
    end

    if ( ver ~= 6 ) then
      return false, ("Error protocol version (%d) not supported"):format(ver)
    end
    return true, srv
  end

}

Packet.Unknown1 = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0,

  --- Creates a new Packet.Unknown1
  --
  -- @param os string containing the version of the packet to send
  -- @return new instance of Packet.Unknown1
  new = function(self, os)
    local o = { os = os }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )

    if (  self.os:match("IBMPC/WIN_NT[64]*[-]%d%.%d%.%d") ) then
      return string.pack(">I2", self.flags) .. stdnse.fromhex([[
[encoded data, 4410 characters]
      002430243000100000244024400010000
      ]])
    elseif ( "x86_64/Linux 2.4.xx" == self.os ) then
      return string.pack(">I2", self.flags) .. stdnse.fromhex([[
[encoded data, 4410 characters]
      100000076000000770000007900790001
      ]])
    else
      return string.pack(">I2", self.flags) .. stdnse.fromhex( [[
      02b200b2004225060101010d010105010101010101017fff0309030301007f011
      fff010301013f01010500010702010000180001800000003c3c3c80000000d007
    ]])
    end
  end,

}


--- This packet is only used by Oracle10 and older
Packet.Unknown2 = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0,

  new = function(self, os)
    local o = { os = os }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    if ( "x86_64/Linux 2.4.xx" == self.os ) then
      return string.pack(">I2", self.flags) .. stdnse.fromhex([[
      0000007a007a00010000007b007b00010000008800000092009200010000009
      300930001000000980002000a000000990002000a0000009a0002000a000000
      9b000100010000009c000c000a000000ac0002000a000000b200b2000100000
      0b300b30001000000b400b40001000000b500b50001000000b600b600010000
      00b700b70001000000b8000c000a000000b900b20001000000ba00b30001000
      000bb00b40001000000bc00b50001000000bd00b60001000000be00b7000100
      0000bf000000c0000000c300700001000000c400710001000000c5007200010
      00000d000d00001000000d1000000e700e70001000000e800e70001000000e9
      00e90001000000f1006d0001000002030203000100000000]]
      )
    else
      return string.pack(">I2", self.flags) .. stdnse.fromhex([[
      024502450001000002460246000100000247024700010000024802480001000
      0024902490001000000030002000a000000040002000a000000050001000100
      0000060002000a000000070002000a00000009000100010000000d0000000e0
      000000f00170001000000100000001100000012000000130000001400000015
      000000160000002700780001015d0001012600010000003a003a00010000004
      40002000a00000045000000460000004a006d00010000004c0000005b000200
      0a0000005e000100010000005f0017000100000060006000010000006100600
      001000000640064000100000065006500010000006600660001000000680000
      00690000006a006a00010000006c006d00010000006d006d00010000006e006
      f00010000006f006f0001000000700070000100000071007100010000007200
      720001000000730073000100000074006600010000007600000077000000790
      07900010000007a007a00010000007b007b0001000000880000009200920001
      0000009300930001000000980002000a000000990002000a0000009a0002000
      a0000009b000100010000009c000c000a000000ac0002000a000000b200b200
      01000000b300b30001000000b400b40001000000b500b50001000000b600b60
      001000000b700b70001000000b8000c000a000000b900b20001000000ba00b3
      0001000000bb00b40001000000bc00b50001000000bd00b60001000000be00b
      70001000000bf000000c0000000c300700001000000c400710001000000c500
      720001000000d000d00001000000d1000000e700e70001000000e800e700010
      00000e900e90001000000f1006d0001000002030203000100000000
      ]])
    end
  end,

}

-- Signals that we're about to close the connection
Packet.EOF = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0x0040,

  new = function(self)
    local o = {}
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    return string.pack(">I2", self.flags )
  end
}

Packet.PostLogin = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0x0000,

  -- Creates a new PostLogin instance
  --
  -- @param sessid number containing session id
  -- @return o a new instance of PostLogin
  new = function(self, sessid)
    local o = { sessid = sessid }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    local unknown1 = "116b04"
    local unknown2 = "0000002200000001000000033b05fefffffff4010000fefffffffeffffff"
    return string.pack(">I2", self.flags) .. stdnse.fromhex(unknown1) .. string.char(self.sessid) .. stdnse.fromhex(unknown2)
  end

}

-- Class responsible for sending queries to the server and handling the first
-- row returned by the server. This class is 100% based on packet captures and
-- guesswork.
Packet.Query = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0x0000,

  --- Creates a new instance of Query
  -- @param query string containing the SQL query
  -- @return instance of Query
  new = function(self, query)
    local o = { query = query, counter = 0 }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Gets the current counter value
  -- @return counter number containing the current counter value
  getCounter = function(self) return self.counter end,

  --- Sets the current counter value
  -- This function is called from sendTNSPacket
  -- @param counter number containing the counter value to set
  setCounter = function(self, counter) self.counter = counter end,

  --- Converts the DATA packet to string
  --
  -- @return string containing the packet
  __tostring = function( self )
    local unknown1 = "035e"
    local unknown2 = "6180000000000000feffffff"
    local unknown3 = "000000feffffff0d000000fefffffffeffffff000000000100000000000000000000000000000000000000feffffff00000000fefffffffeffffff54d25d020000000000000000fefffffffeffffff0000000000000000000000000000000000000000"
    local unknown4 = "01000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000"
    return string.pack(">I2", self.flags)
    .. stdnse.fromhex(unknown1)
    .. string.char(self.counter)
    .. stdnse.fromhex(unknown2)
    .. string.char(#self.query)
    .. stdnse.fromhex(unknown3)
    .. string.pack("s1", self.query)
    .. stdnse.fromhex(unknown4)
  end,

  --- Parses the Query response from the server
  -- @param tns response as received from the <code>Comm.recvTNSPacket</code>
  --        function.
  -- @return result table containing:
  --  <code>columns</code> - a column indexed table with the column names
  --  <code>types</code>   - a column indexed table with the data types
  --  <code>rows</code>    - a table containing a row table for each row
  --                         the row table is a column indexed table of
  --                         column values.
  parseResponse = function( self, tns )
    local data = tns.data
    local result = {}

    local columns = string.unpack("B", tns.data, 35)

    local pos = 40
    for i=1, columns do
      local sql_type
      sql_type, pos = string.unpack("B", data, pos)
      pos = pos + 34
      local name
      name, pos = string.unpack("s1", tns.data, pos)
      result.columns = result.columns or {}
      result.types = result.types or {}
      table.insert(result.columns, name)
      table.insert(result.types, sql_type)
      pos = pos + 10
    end

    pos = pos + 55

    result.rows = {}
    local row = {}
    for i=1, columns do
      local val
      val, pos = string.unpack("s1", tns.data, pos)

      -- if we're at the first row and first column and the len is 0
      -- assume we got an empty resultset
      if ( #val == 0 and #result.rows == 0 and i == 1 ) then
        return true, { data = result, moredata = false }
      end

      local sql_type = result.types[i]
      if ( DataTypeDecoders[sql_type] ) then
        val = DataTypeDecoders[sql_type](val)
      end
      table.insert(row, val)
    end
    table.insert(result.rows, row)

    local moredata = true
    -- check if we've got any more data?
    if ( #data > pos + 97 ) then
      local len, err
      err, pos = string.unpack(">s2", data, pos + 97)
      if ( err:match("^ORA%-01403") ) then
        moredata = false
      end
    end

    return true, { data = result, moredata = moredata }
  end,
}

-- Class responsible for acknowledging a query response from the server
-- and handles the next several rows returned by the server. This class
-- is mostly based on packet captures and guesswork.
Packet.QueryResponseAck = {

  tns_type = Packet.TNS.Type.DATA,
  flags = 0x0000,

  --- Creates a new QueryResponseAck instance
  -- @param result table containing the results as received from the
  --        <code>Query.parseResponse</code> function.
  -- @return instance new instance of QueryResponseAck
  new = function(self, result)
    local o = { result = result }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Gets the current counter value
  -- @return counter number containing the current counter value
  getCounter = function(self) return self.counter end,

  --- Sets the current counter value
  -- This function is called from sendTNSPacket
  -- @param counter number containing the counter value to set
  setCounter = function(self, counter) self.counter = counter end,

  --- Serializes the packet into a string suitable to be sent to the DB
  -- server.
  -- @return str string containing the serialized packet
  __tostring = function(self)
    return string.pack(">I2BBB", self.flags, 3, 5, self.counter) .. stdnse.fromhex("030000000f000000")
  end,

  --
  -- This is how I (Patrik Karlsson) think this is supposed to work
  -- At this point we have the 2nd row (the query response has the first)
  -- Every row looks like this, where the leading mask marker (0x15) and mask
  -- is optional.
  -- | (mask mark)| (bytes) | sor  | byte | len * bytes | ... next_column |
  -- |  0x15      | [mask]  | 0x07 | [len]| [column_val]| ... next_column |

  -- The mask is used in order to achieve "compression" and is essentially
  -- at a bit mask that decides what columns should be fetched from the
  -- preceding row. The mask is provided in reverse order and a set bit
  -- indicates that data is provided while an unset bit indicates that the
  -- column data should be fetched from the previous row.
  --
  -- Once a value is fetched the sql data type is verified against the
  -- DataTypeDecoder table. If there's a function registered for the fetched
  -- data it is run through a decoder, that decodes the *real* value from
  -- the encoded data.
  --
  parseResponse = function( self, tns )
    local data = tns.data
    local len, pos = string.unpack("B", data, 21)
    local mask = ""

    -- calculate the initial mask
    if ( len > 0 ) then
      while( len > 0) do
        local mask_part
        mask_part, pos = string.unpack("B", data, pos)
        mask_part = stdnse.tobinary(bits.reverse(mask_part))
        assert(#mask_part <= 8)
        mask_part = ("0"):rep(8-#mask_part)..mask_part
        mask = mask .. mask_part
        len = len - 1
      end
      pos = pos + 4
    else
      pos = pos +3
    end

    while(true) do
      local row = {}
      local result = self.result
      local cols = #result.columns

      -- check for start of data marker
      local marker
      marker, pos = string.unpack("B", data, pos)
      if ( marker == 0x15 ) then
        mask = ""
        -- not sure what this 2-byte value is
        pos = pos + 2

        -- calculate the bitmask for the columns that do contain
        -- data.
        len = cols
        while( len > 0 ) do
          local mask_part
          mask_part, pos = string.unpack("B", data, pos)
          mask_part = stdnse.tobinary(bits.reverse(mask_part))
          assert(#mask_part <= 8)
          mask_part = ("0"):rep(8-#mask_part)..mask_part
          mask = mask .. mask_part
          len = len - 8
        end
        marker, pos = string.unpack("B", data, pos)
      end
      if ( marker ~= 0x07 ) then
        stdnse.debug2("Encountered unknown marker: %d", marker)
        break
      end

      local val
      local rows = self.result.rows
      for col=1, cols do
        if ( #mask > 0 and mask:sub(col, col) == '0' ) then
          val = rows[#rows][col]
        else
          val, pos = string.unpack("s1", data, pos)

          local sql_type = result.types[col]
          if ( DataTypeDecoders[sql_type] ) then
            val = DataTypeDecoders[sql_type](val)
          end
        end
        table.insert(row, val)
      end

      -- add row to result
      table.insert(rows, row)
    end

    return true, tns.data
  end,

}

Marshaller = {
  --- Marshals a TNS key-value pair data structure
  --
  -- @param key The key
  -- @param value The value
  -- @param flags The flags
  -- @return A binary packed string representing the KVP structure
  marshalKvp = function( key, value, flags )
    return Marshaller.marshalKvpComponent( key ) ..
    Marshaller.marshalKvpComponent( value ) ..
    string.pack( "<I4", ( flags or 0 ) )
  end,

  --- Parses a TNS key-value pair data structure.
  --
  -- @param data Packed string to parse
  -- @param pos Position in the string at which the KVP begins
  -- @return table containing the last position read, the key, the value, and the KVP flags
  unmarshalKvp = function( data, pos )
    local key, value, flags

    pos, key   = Marshaller.unmarshalKvpComponent( data, pos )
    pos, value = Marshaller.unmarshalKvpComponent( data, pos )
    flags, pos = string.unpack("<I4", data, pos )

    return pos, key, value, flags
  end,

  --- Marshals a key or value element from a TNS key-value pair data structure
  --
  -- @param value The key or value
  -- @return A binary packed string representing the element
  marshalKvpComponent = function( value )
    value = value or ""

    local sb4len = string.pack("<I4", #value)
    if #value == 0 then return sb4len end
    local result = {sb4len}
    -- 64 bytes is the maximum before Oracle starts chunking strings
    local MAX_CHUNK_LENGTH = 64
    if #value > MAX_CHUNK_LENGTH then
      -- First, write the multiple-chunk indicator
      table.insert(result, "\xFE")
      -- Loop through the string value, chunk by chunk
      local pos = 1
      repeat
        local nextpos = pos + MAX_CHUNK_LENGTH
        table.insert(result, string.pack("s1", value:sub(pos, nextpos - 1)))
        pos = nextpos
      until pos > #value
      -- Finish with an empty chunk
      table.insert(result, "\0")
    else
      table.insert(result, string.pack("s1", value))
    end

    return table.concat(result)
  end,

  --- Parses a key or value element from a TNS key-value pair data structure.
  --
  -- @param data Packed string to parse
  -- @param pos Position in the string at which the element begins
  -- @return table containing the last position read and the value parsed
  unmarshalKvpComponent = function( data, pos )
    -- read the 32-bit total length of the value
    local value_len
    value_len, pos = string.unpack("<I4", data, pos)
    if value_len == 0 then return pos, "" end
    -- Look at the first byte after the total length. If the value is
    -- broken up into multiple chunks, this will be indicated by this
    -- byte being 0xFE. Otherwise this is the length of the only chunk.
    local chunked = string.unpack("B", data, pos) == 0xFE
    if chunked then
      pos = pos + 1
    end
    -- Loop through the chunks until we read the whole value
    local chunks = {}
    repeat
      local chunk
      chunk, pos = string.unpack("s1", data, pos)
      table.insert(chunks, chunk)
    until #chunk == 0 or not chunked -- last chunk is zero-length
    return pos, table.concat(chunks)
  end,
}


-- The TNS communication class uses the TNSSocket to transmit data
Comm = {

  --- Creates a new instance of the Comm class
  --
  -- @param socket containing a TNSSocket
  -- @return new instance of Comm
  new = function(self, socket)
    local o = {
      socket = socket,
      data_counter = 06
    }
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Attemts to send a TNS packet over the socket
  --
  -- @param pkt containing an instance of a Packet.*
  -- @return Status (true or false).
  -- @return Error code (if status is false).
  sendTNSPacket = function( self, pkt )
    local tns = Packet.TNS:new( pkt.tns_type )
    if ( pkt.setCounter ) then
      pkt:setCounter(self.data_counter)
      self.data_counter = self.data_counter + 1
    end
    tns.data = tostring(pkt)
    tns.length = #tns.data + 8

    -- buffer incase of RESEND
    self.pkt = pkt

    return self.socket:send( tostring(tns) )
  end,

  --- Handles communication when a MARKER packet is received and retrieves
  --  the following error message
  --
  -- @return false always to indicate that an error occurred
  -- @return msg containing the error message
  handleMarker = function( self )
    local status, tns = self:recvTNSPacket()

    if ( not(status) or tns.type ~= Packet.TNS.Type.MARKER ) then
      return false, "ERROR: failed to handle marker sent by server"
    end

    -- send our marker
    status = self:sendTNSPacket( Packet.Attention:new( 1, "\x00\x02") )
    if ( not(status) ) then
      return false, "ERROR: failed to send marker to server"
    end

    status, tns = self:recvTNSPacket()
    if ( not(status) or tns.type ~= Packet.TNS.Type.DATA ) then
      return false, "ERROR: expecting DATA packet"
    end

    -- check if byte 12 is set or not, this should help us distinguish the offset
    -- to the error message in Oracle 10g and 11g
    local b1 = string.unpack("B", tns.data, 10)
    local pos = (b1 == 1) and 99 or 69

    -- fetch the oracle error and return it
    local msg = string.unpack("s1", tns.data, pos )

    return false, msg
  end,

  --- Receives a TNS packet and handles TNS-resends
  --
  -- @return status true on success, false on failure
  -- @return tns Packet.TNS containing the received packet or err on failure
  recvTNSPacket = function( self )
    local tns
    local retries = 5

    repeat
      local function recv()
        local status, header = self.socket:receive_buf( match.numbytes(8), true )
        if ( not(status) ) then return status, header end

        local length = string.unpack(">I2", header )
        local status, data = self.socket:receive_buf( match.numbytes(length - 8), true )
        if ( not(status) ) then
          return false, data
        else
          return status, Packet.TNS.parse(header .. data)
        end
      end

      local status
      status, tns = recv()
      if ( not(status) ) then
        if ( retries == 0 ) then
          return false, "ERROR: recvTNSPacket failed to receive TNS headers"
        end
        retries = retries - 1
      elseif ( tns.type == Packet.TNS.Type.RESEND ) then
        self:sendTNSPacket( self.pkt )
      end
    until ( status and tns.type ~= Packet.TNS.Type.RESEND )

    return true, tns
  end,

  --- Sends a TNS packet and receives (and handles) the response
  --
  -- @param pkt containing the Packet.* to send to the server
  -- @return status true on success, false on failure
  -- @return the parsed response as return from the respective parseResponse
  --         function or error message if status was false
  exchTNSPacket = function( self, pkt )
    local status = self:sendTNSPacket( pkt )
    local tns, response

    if ( not(status) ) then
      return false, "sendTNSPacket failed"
    end

    status, tns = self:recvTNSPacket()
    if ( not(status) ) then
      return false, tns
    end

    --- handle TNS MARKERS
    if ( tns.type == Packet.TNS.Type.MARKER ) then
      return self:handleMarker()
    end

    if ( pkt.parseResponse ) then
      status, response = pkt:parseResponse( tns )
    end

    return status, response
  end

}

--- Class that handles all Oracle encryption
Crypt = {

  -- Test function, not currently in use
  Decrypt11g = function(self, c_sesskey, s_sesskey, auth_password, pass, salt )
    local sha1 = openssl.sha1(pass .. salt) .. "\0\0\0\0"
    local auth_sesskey = s_sesskey
    local auth_sesskey_c = c_sesskey
    local server_sesskey = openssl.decrypt( "aes-192-cbc", sha1, nil, auth_sesskey )
    local client_sesskey = openssl.decrypt( "aes-192-cbc", sha1, nil, auth_sesskey_c )

    local combined_sesskey = {}
    for i=17, 40 do
      combined_sesskey[#combined_sesskey+1] = string.char( string.byte(server_sesskey, i) ~ string.byte(client_sesskey,i) )
    end
    combined_sesskey = table.concat(combined_sesskey)
    combined_sesskey = ( openssl.md5( combined_sesskey:sub(1,16) ) .. openssl.md5( combined_sesskey:sub(17) ) ):sub(1, 24)

    local p = openssl.decrypt( "aes-192-cbc", combined_sesskey, nil, auth_password, false )
    return p:sub(17)
  end,

  --- Creates an Oracle 10G password hash
  --
  -- @param username containing the Oracle user name
  -- @param password containing the Oracle user password
  -- @return hash containing the Oracle hash
  HashPassword10g = function( self, username, password )
    local uspw = (username .. password):upper():gsub(".", "\0%1")
    local key = stdnse.fromhex("0123456789abcdef")

    -- do padding
    uspw = uspw .. string.rep('\0', (8 - (#uspw % 8)) % 8)

    local iv2 = openssl.encrypt( "DES-CBC", key, nil, uspw, false ):sub(-8)
    local enc = openssl.encrypt( "DES-CBC", iv2, nil, uspw, false ):sub(-8)
    return enc
  end,

  -- Test function, not currently in use
  Decrypt10g = function(self, user, pass, srv_sesskey_enc )
    local pwhash = self:HashPassword10g( user, pass ) .. "\0\0\0\0\0\0\0\0"
    local cli_sesskey_enc = stdnse.fromhex("7B244D7A1DB5ABE553FB9B7325110024911FCBE95EF99E7965A754BC41CF31C0")
    local srv_sesskey = openssl.decrypt( "AES-128-CBC", pwhash, nil, srv_sesskey_enc )
    local cli_sesskey = openssl.decrypt( "AES-128-CBC", pwhash, nil, cli_sesskey_enc )
    local auth_pass = stdnse.fromhex("4C5E28E66B6382117F9D41B08957A3B9E363B42760C33B44CA5D53EA90204ABE")
    local pass

    local combined_sesskey = {}
    for i=17, 32 do
      combined_sesskey[#combined_sesskey+1] = string.char( string.byte(srv_sesskey, i) ~ string.byte(cli_sesskey, i) )
    end
    combined_sesskey = openssl.md5( table.concat(combined_sesskey) )

    pass = openssl.decrypt( "AES-128-CBC", combined_sesskey, nil, auth_pass ):sub(17)

    print( stdnse.tohex( srv_sesskey ))
    print( stdnse.tohex( cli_sesskey ))
    print( stdnse.tohex( combined_sesskey ))
    print( "pass=" .. pass )
  end,

  --- Performs the relevant encryption needed for the Oracle 10g response
  --
  -- @param user containing the Oracle user name
  -- @param pass containing the Oracle user password
  -- @param srv_sesskey_enc containing the encrypted server session key as
  --        received from the PreAuth packet
  -- @return cli_sesskey_enc the encrypted client session key
  -- @return auth_pass the encrypted Oracle password
  Encrypt10g = function( self, user, pass, srv_sesskey_enc )

    local pwhash = self:HashPassword10g( user, pass ) .. "\0\0\0\0\0\0\0\0"
    -- We're currently using a static client session key, this should
    -- probably be changed to a random value in the future
    local cli_sesskey = stdnse.fromhex("FAF5034314546426F329B1DAB1CDC5B8FF94349E0875623160350B0E13A0DA36")
    local srv_sesskey = openssl.decrypt( "AES-128-CBC", pwhash, nil, srv_sesskey_enc )
    local cli_sesskey_enc = openssl.encrypt( "AES-128-CBC", pwhash, nil, cli_sesskey )
    -- This value should really be random, not this static cruft
    local rnd = stdnse.fromhex("4C31AFE05F3B012C0AE9AB0CDFF0C508")
    local auth_pass

    local combined_sesskey = {}
    for i=17, 32 do
      combined_sesskey[#combined_sesskey+1] = string.char( string.byte(srv_sesskey, i) ~ string.byte(cli_sesskey, i) )
    end
    combined_sesskey = openssl.md5( table.concat(combined_sesskey) )
    auth_pass = openssl.encrypt("AES-128-CBC", combined_sesskey, nil, rnd .. pass, true )
    auth_pass = stdnse.tohex(auth_pass)
    cli_sesskey_enc = stdnse.tohex(cli_sesskey_enc)
    return cli_sesskey_enc, auth_pass
  end,

  --- Performs the relevant encryption needed for the Oracle 11g response
  --
  -- @param pass containing the Oracle user password
  -- @param srv_sesskey_enc containing the encrypted server session key as
  --        received from the PreAuth packet
  -- @param auth_vrfy_data containing the password salt as received from the
  --        PreAuth packet
  -- @return cli_sesskey_enc the encrypted client session key
  -- @return auth_pass the encrypted Oracle password
  Encrypt11g = function( self, pass, srv_sesskey_enc, auth_vrfy_data )

    -- This value should really be random, not this static cruft
    local rnd = openssl.rand_pseudo_bytes(16)
    local cli_sesskey = openssl.rand_pseudo_bytes(40) .. stdnse.fromhex("0808080808080808")
    local pw_hash = openssl.sha1(pass .. auth_vrfy_data) .. "\0\0\0\0"
    local srv_sesskey = openssl.decrypt( "aes-192-cbc", pw_hash, nil, srv_sesskey_enc )
    local auth_password
    local cli_sesskey_enc
    local data = ""

    local combined_sesskey = {}
    for i=17, 40 do
      combined_sesskey[#combined_sesskey+1] = string.char( string.byte(srv_sesskey, i) ~ string.byte(cli_sesskey, i) )
    end
    combined_sesskey = table.concat(combined_sesskey)
    combined_sesskey = ( openssl.md5( combined_sesskey:sub(1,16) ) .. openssl.md5( combined_sesskey:sub(17) ) ):sub(1, 24)

    cli_sesskey_enc = openssl.encrypt( "aes-192-cbc", pw_hash, nil, cli_sesskey )
    cli_sesskey_enc = stdnse.tohex(cli_sesskey_enc)

    auth_password = openssl.encrypt( "aes-192-cbc", combined_sesskey, nil, rnd .. pass, true )
    auth_password = stdnse.tohex(auth_password)

    return cli_sesskey_enc, auth_password
  end,

}

Helper = {

  --- Creates a new Helper instance
  --
  -- @param host table containing the host table as received by action
  -- @param port table containing the port table as received by action
  -- @param instance string containing the instance name
  -- @return o new instance of Helper
  new = function(self, host, port, instance, socket )
    local o = {
      host = host,
      port = port,
      socket = socket or nmap.new_socket(),
      dbinstance = instance or stdnse.get_script_args('tns.sid') or "orcl"
    }
    o.socket:set_timeout(30000)
    setmetatable(o, self)
    self.__index = self
    return o
  end,

  --- Connects and performs protocol negotiation with the Oracle server
  --
  -- @return true on success, false on failure
  -- @return err containing error message when status is false
  Connect = function( self )
    local SUPPORTED_VERSIONS = {
      "IBMPC/WIN_NT64-9.1.0",
      "IBMPC/WIN_NT-8.1.0",
      "Linuxi386/Linux-2.0.34-8.1.0",
      "x86_64/Linux 2.4.xx"
    }
    local status, data = self.socket:connect( self.host.ip, self.port.number, "tcp" )
    local conn, packet, tns

    if( not(status) ) then return status, data end

    self.comm = Comm:new( self.socket )

    status, self.version = self.comm:exchTNSPacket( Packet.Connect:new( self.host.ip, self.port.number, self.dbinstance ) )
    if ( not(status) ) then return false, self.version end

    if ( self.version ~= ORACLE_VERSION_11G and self.version ~= ORACLE_VERSION_10G ) then
      return false, ("Unsupported Oracle Version (%d)"):format(self.version)
    end

    status = self.comm:exchTNSPacket( Packet.SNS:new( self.version ) )
    if ( not(status) ) then return false, "ERROR: Helper.Connect failed" end

    status, self.os = self.comm:exchTNSPacket( Packet.ProtoNeg:new( self.version ) )
    if ( not(status) ) then
      return false, data
    end

    -- used for testing unsupported versions
    self.os = stdnse.get_script_args("tns.forceos") or self.os

    status = false
    for _, ver in pairs(SUPPORTED_VERSIONS) do
      if ( self.os == ver ) then
        status = true
        break
      end
    end

    if ( not(status) ) then
      stdnse.debug2("ERROR: Version %s is not yet supported", self.os)
      return false, ("ERROR: Connect to version %s is not yet supported"):format(self.os)
    end

    if ( self.os:match("IBMPC/WIN_NT") ) then
      status = self.comm:sendTNSPacket( Packet.Unknown1:new( self.os ) )
      if ( not(status) ) then
        return false, "ERROR: Helper.Connect failed"
      end
      status, data = self.comm:sendTNSPacket( Packet.Unknown2:new( self.os ) )
      if ( not(status) ) then return false, data end

      status, data = self.comm:recvTNSPacket( Packet.Unknown2:new( ) )
      if ( not(status) ) then return false, data end
      -- Oracle 10g under Windows needs this additional read, there's
      -- probably a better way to detect this by analysing the packets
      -- further.
      if ( self.version == ORACLE_VERSION_10G ) then
        status, data = self.comm:recvTNSPacket( Packet.Unknown2:new( ) )
        if ( not(status) ) then return false, data end
      end
    elseif ( "x86_64/Linux 2.4.xx" == self.os ) then
      status = self.comm:sendTNSPacket( Packet.Unknown1:new( self.os ) )
      if ( not(status) ) then
        return false, "ERROR: Helper.Connect failed"
      end

      status = self.comm:sendTNSPacket( Packet.Unknown2:new( self.os ) )
      if ( not(status) ) then
        return false, "ERROR: Helper.Connect failed"
      end

      status, data = self.comm:recvTNSPacket( Packet.Unknown2:new( ) )
      if ( not(status) ) then
        return false, data
      end

    else
      status = self.comm:exchTNSPacket( Packet.Unknown1:new( self.os ) )
      if ( not(status) ) then
        return false, "ERROR: Helper.Connect failed"
      end
    end

    return true
  end,

  --- Sends a command to the TNS lsnr
  -- It currently accepts and tries to send all commands received
  --
  -- @param cmd string containing the command to send to the server
  -- @return data string containing the result received from the server
  lsnrCtl = function( self, cmd )
    local status, data = self.socket:connect( self.host.ip, self.port.number, "tcp" )
    local conn, packet, tns, pkt

    if( not(status) ) then
      return status, data
    end

    self.comm = Comm:new( self.socket )
    pkt = Packet.Connect:new( self.host.ip, self.port.number, self.dbinstance )
    pkt:setCmd(cmd)

    if ( not(self.comm:exchTNSPacket( pkt )) ) then
      return false, self.version
    end

    data = {}
    repeat
      status, tns = self.comm:recvTNSPacket()
      if ( not(status) ) then
        self:Close()
        return status, tns
      end
      local flags = string.unpack(">I2", tns.data )
      data[#data+1] = tns.data:sub(3)
    until ( flags ~= 0 )
    self:Close()

    return true, table.concat(data)
  end,

  --- Authenticates to the database
  --
  -- @param user containing the Oracle user name
  -- @param password containing the Oracle user password
  -- @return true on success, false on failure
  -- @return err containing error message when status is false
  Login = function( self, user, password )
    local data, packet, status, tns, parser
    local sesskey_enc, auth_pass, auth
    local auth_options = AuthOptions:new()

    status, auth = self.comm:exchTNSPacket( Packet.PreAuth:new( user, auth_options, self.os ) )
    if ( not(status) ) then
      return false, auth
    end

    -- Check what version of the DB to authenticate against AND verify whether
    -- case sensitive login is enabled or not. In case-sensitive mode the salt
    -- is longer, so we check the length of auth["AUTH_VFR_DATA"]
    if ( self.version == ORACLE_VERSION_11G and #auth["AUTH_VFR_DATA"] > 2 ) then
      sesskey_enc, auth_pass = Crypt:Encrypt11g( password, stdnse.fromhex(auth["AUTH_SESSKEY"]), stdnse.fromhex(auth["AUTH_VFR_DATA"]) )
    else
      sesskey_enc, auth_pass = Crypt:Encrypt10g( user, password, stdnse.fromhex(auth["AUTH_SESSKEY"]) )
    end

    status, data = self.comm:exchTNSPacket( Packet.Auth:new( user, auth_options, sesskey_enc, auth_pass, self.os ) )
    if ( not(status) ) then return false, data end
    self.auth_session = data["AUTH_SESSION_ID"]
    return true
  end,

  --- Steal auth data from database
  -- @param user containing the Oracle user name
  -- @param password containing the Oracle user password
  -- @return true on success, false on failure
  -- @return err containing error message when status is false
  StealthLogin = function( self, user, password )
    local data, packet, status, tns, parser
    local sesskey_enc, auth_pass, auth
    local auth_options = AuthOptions:new()

    status, auth = self.comm:exchTNSPacket( Packet.PreAuth:new( user, auth_options, self.os ) )
    if ( not(status) ) then
      return false, auth
    elseif ( auth["AUTH_SESSKEY"] ) then
      return true, auth
    else
      return false
    end
  end,

  --- Queries the database
  --
  -- @param query string containing the SQL query
  -- @return true on success, false on failure
  -- @return result table containing fields
  --          <code>rows</code>
  --          <code>columns</code>
  -- @return err containing error message when status is false
  Query = function(self, query)

    local SUPPORTED_VERSIONS = {
      "IBMPC/WIN_NT-8.1.0",
    }

    local status = false
    for _, ver in pairs(SUPPORTED_VERSIONS) do
      if ( self.os == ver ) then
        status = true
        break
      end
    end

    if ( not(status) ) then
      stdnse.debug2("ERROR: Version %s is not yet supported", self.os)
      return false, ("ERROR: Querying version %s is not yet supported"):format(self.os)
    end

    if ( not(query) ) then return false, "No query was supplied by user" end

    local data
    status, data = self.comm:exchTNSPacket( Packet.PostLogin:new(self.auth_session) )
    if ( not(status) ) then
      return false, "ERROR: Postlogin packet failed"
    end

    local status, result = self.comm:exchTNSPacket( Packet.Query:new(query) )
    if ( not(status) ) then return false, result end

    if ( not(result.moredata) ) then return true, result.data end
    result = result.data

    repeat
      status, data = self.comm:exchTNSPacket( Packet.QueryResponseAck:new(result) )
    until(not(status) or data:match(".*ORA%-01403: no data found\n$"))

    return true, result
  end,

  --- Ends the Oracle communication
  Close = function( self )
    -- We should probably stick some slick sqlplus termination stuff in here
    local status = self.comm:sendTNSPacket( Packet.EOF:new( ) )
    self.socket:close()
  end,

}

return _ENV;
