smbRpc 0.0.3

data/lib/smbRpc/samr/enumerateAliasesInDomain.rb

@@ -0,0 +1,61 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrEnumerateAliasesInDomainReq < BinData::Record
+      endian :little
+      request :request
+      string :domainHandle, :length => 20
+      uint32 :enumerationContext
+      uint32 :preferedMaximumLength, :value => 1024
+
+      def initialize_instance
+        super
+        domainHandle.value = get_parameter(:handle)
+        enumerationContext.value = get_parameter(:enumContext)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 15        #SamrEnumerateAliasesInDomain  
+      end
+    end
+
+    class SamrEnumerateAliasesInDomainRes  < BinData::Record
+      endian :little
+      request :request
+      uint32 :enumerationContext
+
+      uint32 :ref_id_buffer
+      uint32 :numberOfBuffer
+      uint32 :ref_id_sampr_enumeration_buffer
+      uint32 :entriesRead
+      #_SAMPR_RID_ENUMERATION declared in enumerateUsersInDomain.rb
+      array :name, :type => :sampr_rid_enumeration, :initial_length => :entriesRead
+      array :nameNdr, :type => :conformantandVaryingStrings, :initial_length => :entriesRead
+
+      uint32 :countReturned, :onlyif => lambda { entriesRead.value > 0 }
+      uint32 :windowsError
+    end
+
+    def enumerateAliasesInDomain
+      result = 0
+      enumerationContext = 0
+      out = []
+      loop do
+        samrEnumerateAliasesInDomainReq = SamrEnumerateAliasesInDomainReq.new(handle:@domainHandle, enumContext:enumerationContext)
+        samrEnumerateAliasesInDomainRes = @file.ioctl_send_recv(samrEnumerateAliasesInDomainReq).buffer
+        samrEnumerateAliasesInDomainRes = SamrEnumerateAliasesInDomainRes.read(samrEnumerateAliasesInDomainRes)
+        enumerationContext = samrEnumerateAliasesInDomainRes.enumerationContext
+        samrEnumerateAliasesInDomainRes.numberOfBuffer.times do |i|
+          h = {}
+          h[:rid] = samrEnumerateAliasesInDomainRes.name[i].relativeId
+          h[:aliasName] = samrEnumerateAliasesInDomainRes.nameNdr[i].str.unpack("v*").pack("c*")
+          out << h
+        end
+        result = samrEnumerateAliasesInDomainRes.windowsError
+        break if result != WindowsError::NTStatus::STATUS_MORE_ENTRIES #0x00000105
+      end
+      result == 0? result : (raise "enumerateAliasesInDomain Fail, WinError: %i"%[result])
+      return out
+    end
+
+end
+end
+

data/lib/smbRpc/samr/enumerateDomainsInSamServer.rb

@@ -0,0 +1,52 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrEnumerateDomainsInSamServerReq < BinData::Record
+      endian :little
+      request :request
+      string :serverHandle, :length => 20
+      uint32 :enumerationContext
+      uint32 :preferedMaximumLength, :value => 512
+
+      def initialize_instance
+        super
+        serverHandle.value = get_parameter(:handle)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 6        #SamrEnumerateDomainsInSamServer
+      end
+    end
+
+    class SamrEnumerateDomainsInSamServerRes < BinData::Record
+      endian :little
+      request :request
+      uint32 :enumerationContext
+      uint32 :ref_id_buffer
+      uint32 :numberOfBuffer
+      uint32 :ref_id_sampr_enumeration_buffer
+      uint32 :entriesRead
+      #sampr_rid_enumeration declared in samEnumerateUsersInDomain.rb
+      array :name, :type => :sampr_rid_enumeration, :initial_length => :entriesRead
+      array :nameNdr, :type => :conformantandVaryingStrings, :initial_length => :entriesRead
+
+      uint32 :countReturned
+      uint32 :windowsError
+    end
+
+    def enumerateDomainsInSamServer()
+      samrEnumerateDomainsInSamServerReq = SamrEnumerateDomainsInSamServerReq.new(handle:@serverHandle)
+      samrEnumerateDomainsInSamServerRes = @file.ioctl_send_recv(samrEnumerateDomainsInSamServerReq).buffer
+      samrEnumerateDomainsInSamServerRes.raise_not_error_success("enumerateDomainsInSamServer")
+      samrEnumerateDomainsInSamServerRes = SamrEnumerateDomainsInSamServerRes.read(samrEnumerateDomainsInSamServerRes)
+      out = []
+      samrEnumerateDomainsInSamServerRes.countReturned.times do |i|
+        h = {}
+        h[:rid] = samrEnumerateDomainsInSamServerRes.name[i].relativeId
+        h[:domainName] = samrEnumerateDomainsInSamServerRes.nameNdr[i].str.unpack("v*").pack("c*")
+        out << h
+      end
+      return out
+    end
+
+end
+end
+

data/lib/smbRpc/samr/enumerateGroupsInDomain.rb

@@ -0,0 +1,60 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrEnumerateGroupsInDomainReq < BinData::Record
+      endian :little
+      request :request
+      string :domainHandle, :length => 20
+      uint32 :enumerationContext
+      uint32 :preferedMaximumLength, :value => 1024
+
+      def initialize_instance
+        super
+        domainHandle.value = get_parameter(:handle)
+        enumerationContext.value = get_parameter(:enumContext)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 11        #SamrEnumerateGroupsInDomain 
+      end
+    end
+
+    class SamrEnumerateGroupsInDomainRes  < BinData::Record
+      endian :little
+      request :request
+      uint32 :enumerationContext
+
+      uint32 :ref_id_buffer
+      uint32 :numberOfBuffer
+      uint32 :ref_id_sampr_enumeration_buffer
+      uint32 :entriesRead
+      #_SAMPR_RID_ENUMERATION enumerateUsersInDomain.rb
+      array :name, :type => :sampr_rid_enumeration, :initial_length => :entriesRead
+      array :nameNdr, :type => :conformantandVaryingStrings, :initial_length => :entriesRead
+      uint32 :countReturned, :onlyif => lambda { entriesRead.value > 0 }
+      uint32 :windowsError
+    end
+
+    def enumerateGroupsInDomain()
+      result = 0
+      enumerationContext = 0
+      out = []
+      loop do
+        samrEnumerateGroupsInDomainReq = SamrEnumerateGroupsInDomainReq.new(handle:@domainHandle, enumContext:enumerationContext)
+        samrEnumerateGroupsInDomainRes = @file.ioctl_send_recv(samrEnumerateGroupsInDomainReq).buffer
+        samrEnumerateGroupsInDomainRes = SamrEnumerateGroupsInDomainRes.read(samrEnumerateGroupsInDomainRes)
+        enumerationContext = samrEnumerateGroupsInDomainRes.enumerationContext
+        samrEnumerateGroupsInDomainRes.numberOfBuffer.times do |i|
+          h = {}
+          h[:rid] = samrEnumerateGroupsInDomainRes.name[i].relativeId
+          h[:groupName] = samrEnumerateGroupsInDomainRes.nameNdr[i].str.unpack("v*").pack("c*")
+          out << h
+        end
+        result = samrEnumerateGroupsInDomainRes.windowsError
+        break if result != WindowsError::NTStatus::STATUS_MORE_ENTRIES #0x00000105
+      end
+      result == 0? result : (raise "enumerateGroupsInDomain Fail, WinError: %i"%[result])
+      return out
+    end
+
+end
+end
+

data/lib/smbRpc/samr/enumerateUsersInDomain.rb

@@ -0,0 +1,67 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrEnumerateUsersInDomainReq < BinData::Record
+      endian :little
+      request :request
+      string :domainHandle, :length => 20
+      uint32 :enumerationContext
+      uint32 :userAccountControl
+      uint32 :preferedMaximumLength, :value => 1024
+
+      def initialize_instance
+        super
+        domainHandle.value = get_parameter(:handle)
+        enumerationContext.value = get_parameter(:enumContext)
+        userAccountControl.value = get_parameter(:accountControl)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 13        #SamrEnumerateUsersInDomain
+      end
+    end
+
+    class Sampr_rid_enumeration < BinData::Record
+      endian :little
+      uint32 :relativeId
+      rpc_unicode_string :name
+    end
+
+    class SamrEnumerateUsersInDomainRes < BinData::Record
+      endian :little
+      request :request
+      uint32 :enumerationContext
+      uint32 :ref_id_buffer
+      uint32 :numberOfBuffer
+      uint32 :ref_id_sampr_enumeration_buffer
+      uint32 :entriesRead
+      #_SAMPR_RID_ENUMERATION
+      array :name, :type => :sampr_rid_enumeration, :initial_length => :entriesRead
+      array :nameNdr, :type => :conformantandVaryingStrings, :initial_length => :entriesRead
+      uint32 :countReturned, :onlyif => lambda { entriesRead.value > 0 }
+      uint32 :windowsError
+    end
+
+    def enumerateUsersInDomain(userAccountControl:SAMR_USER_ACCOUNT["USER_NORMAL_ACCOUNT"])
+      result = 0
+      enumerationContext = 0
+      out = []
+      loop do
+        samrEnumerateUsersInDomainReq = SamrEnumerateUsersInDomainReq.new(handle:@domainHandle, accountControl:userAccountControl, enumContext:enumerationContext)
+        samrEnumerateUsersInDomainRes = @file.ioctl_send_recv(samrEnumerateUsersInDomainReq).buffer
+        samrEnumerateUsersInDomainRes = SamrEnumerateUsersInDomainRes.read(samrEnumerateUsersInDomainRes)
+        enumerationContext = samrEnumerateUsersInDomainRes.enumerationContext
+        samrEnumerateUsersInDomainRes.numberOfBuffer.times do |i|
+          h = {}
+          h[:rid] = samrEnumerateUsersInDomainRes.name[i].relativeId
+          h[:userName] = samrEnumerateUsersInDomainRes.nameNdr[i].str.unpack("v*").pack("c*")
+          out << h
+        end
+        result = samrEnumerateUsersInDomainRes.windowsError
+        break if result != WindowsError::NTStatus::STATUS_MORE_ENTRIES #0x00000105
+      end
+      result == 0? result : (raise "SamEnumerateUsersInDomain Fail, WinError: %i"%[result])
+      return out
+    end
+
+end
+end
+

data/lib/smbRpc/samr/getMembersInAlias.rb

@@ -0,0 +1,41 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrGetMembersInAliasReq < BinData::Record
+      endian :little
+      request :request
+      string :aliasHandle, :length => 20
+
+      def initialize_instance
+        super
+        aliasHandle.value = get_parameter(:handle)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 33        #SamrGetMembersInAlias
+      end
+    end
+
+    class SamrGetMembersInAliasRes < BinData::Record
+      endian :little
+      response :response
+      uint32 :numberOfSids
+      uint32 :ref_id_members
+
+      uint32 :numberOfMembers, :onlyif => lambda { numberOfSids.value > 0 }
+      array :ref_id_member, :type => :uint32, :initial_length => :numberOfMembers, :onlyif => lambda { numberOfSids.value > 0 }
+      array :member, :type => :sid_element, :initial_length => :numberOfMembers, :onlyif => lambda { numberOfSids.value > 0 }
+      uint32 :windowsError
+    end
+
+    def getMembersInAlias
+      samrGetMembersInAliasReq = SamrGetMembersInAliasReq.new(handle:@aliasHandle)
+      samrGetMembersInAliasRes = @file.ioctl_send_recv(samrGetMembersInAliasReq).buffer
+      samrGetMembersInAliasRes.raise_not_error_success("getMembersInAlias")
+      samrGetMembersInAliasRes = SamrGetMembersInAliasRes.read(samrGetMembersInAliasRes)
+      out = []
+      samrGetMembersInAliasRes.member.each{|e| out << e.sid.to_s}
+      return out
+    end
+
+end
+end
+

data/lib/smbRpc/samr/getMembersInGroup.rb

@@ -0,0 +1,45 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrGetMembersInGroupReq < BinData::Record
+      endian :little
+      request :request
+      string :groupHandle, :length => 20
+
+      def initialize_instance
+        super
+        groupHandle.value = get_parameter(:handle)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 25        #SamrGetMembersInGroup
+      end
+    end
+
+    class SamrGetMembersInGroupRes < BinData::Record
+      endian :little
+      response :response
+      uint32 :ref_id_members
+      uint32 :numberOfMembers
+      uint32 :ref_id_relativeId
+      uint32 :ref_id_attributes
+      uint32 :numberOfRelativeId, :onlyif => lambda { ref_id_relativeId.value > 0 }
+      array :relativeId, :type => :uint32, :initial_length => :numberOfMembers
+      uint32 :numberOfAttributes, :onlyif => lambda { ref_id_attributes.value > 0 }
+      array :attributes, :type => :uint32, :initial_length => :numberOfMembers
+      uint32 :windowsError
+    end
+
+    def getMembersInGroup
+      samrGetMembersInGroupReq = SamrGetMembersInGroupReq.new(handle:@groupHandle)
+      samrGetMembersInGroupRes = @file.ioctl_send_recv(samrGetMembersInGroupReq).buffer
+      samrGetMembersInGroupRes.raise_not_error_success("getMembersInGroup")
+      samrGetMembersInGroupRes = SamrGetMembersInGroupRes.read(samrGetMembersInGroupRes)
+      out = []
+      samrGetMembersInGroupRes.numberOfMembers.times do |i|
+        out << {:relativeId => samrGetMembersInGroupRes.relativeId[i], :attributes => samrGetMembersInGroupRes.attributes[i]}     
+      end
+      return out
+    end
+
+end
+end
+

data/lib/smbRpc/samr/lookupDomainInSamServer.rb

@@ -0,0 +1,41 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrLookupDomainInSamServerReq < BinData::Record
+      endian :little
+      request :request
+      string :serverHandle, :length => 20
+      rpc_unicode_string :name
+      conformantandVaryingStrings :nameNdr
+
+      def initialize_instance
+        super
+        serverHandle.value = get_parameter(:handle)
+        domainNameUni = "#{get_parameter(:domainName)}\x00".bytes.pack("v*")
+        name.len.value = domainNameUni.bytesize
+        name.maximumLength.value = domainNameUni.bytesize
+        nameNdr.str = domainNameUni
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 5        #SamrLookupDomainInSamServer
+      end
+    end
+
+    class SamrLookupDomainInSamServerRes < BinData::Record
+      endian :little
+      request :request
+      uint32 :ref_id_domainId
+      sid_element :domainId, :onlyif => lambda { ref_id_domainId != 0 } #declared in lsarpc/lsaEnumerateAccounts.rb
+      uint32 :windowsError
+    end
+
+    def lookupDomainInSamServer(domainName:)
+      samrLookupDomainInSamServerReq = SamrLookupDomainInSamServerReq.new(handle:@serverHandle, domainName:domainName)
+      samrLookupDomainInSamServerRes = @file.ioctl_send_recv(samrLookupDomainInSamServerReq).buffer
+      samrLookupDomainInSamServerRes.raise_not_error_success("lookupDomainInSamServer")
+      samrLookupDomainInSamServerRes = SamrLookupDomainInSamServerRes.read(samrLookupDomainInSamServerRes)
+      return samrLookupDomainInSamServerRes.domainId.sid.to_s
+    end
+
+end
+end
+

data/lib/smbRpc/samr/lookupIdsInDomain.rb

@@ -0,0 +1,52 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrLookupIdsInDomainReq < BinData::Record
+      endian :little
+      request :request
+      string :domainHandle, :length => 20
+
+      uint32 :numberOfName, :value => 1
+      uint32 :maxCount, :value => 1000	#range max at 1000
+      uint32 :offset
+      uint32 :actualCont, :value => 1
+      uint32 :relativeId
+
+      def initialize_instance
+        super
+        domainHandle.value = get_parameter(:handle)
+        relativeId.value = get_parameter(:rid)
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 18        #SamrLookupIdsInDomain
+      end
+    end
+
+    class SamrLookupIdsInDomainRes < BinData::Record
+      endian :little
+      request :request
+      uint32 :numberOfRef_id_name
+      uint32 :ref_id_name
+      uint32 :numberOfName
+      rpc_unicode_string :name 		#declared in lsarpc/lsaQueryInformationPolicy.rb
+      conformantandVaryingStrings :nameNdr
+      uint32 :numberOfRef_id_use
+      uint32 :ref_id_use
+      uint32 :numberOfuse
+      uint32 :use
+      uint32 :windowsError
+    end
+
+    def lookupIdsInDomain(relativeId:)
+      samrLookupIdsInDomainReq = SamrLookupIdsInDomainReq.new(rid:relativeId, handle:@domainHandle)
+      samrLookupIdsInDomainRes = @file.ioctl_send_recv(samrLookupIdsInDomainReq).buffer
+      samrLookupIdsInDomainRes.raise_not_error_success("lookupIdsInDomain")
+      samrLookupIdsInDomainRes = SamrLookupIdsInDomainRes.read(samrLookupIdsInDomainRes)
+      return {
+        :name => samrLookupIdsInDomainRes.nameNdr.str.unpack("v*").pack("c*"), 
+        :type => samrLookupIdsInDomainRes.use
+      }
+      end
+
+end
+end
+

data/lib/smbRpc/samr/lookupNamesInDomain.rb

@@ -0,0 +1,55 @@
+module SmbRpc
+  class Samr < Rpc
+
+    class SamrLookupNamesInDomainReq < BinData::Record
+      endian :little
+      request :request
+      string :domainHandle, :length => 20
+      uint32 :numberOfName, :value => 1
+      uint32 :maxCount, :value => 1000	#range max at 1000
+      uint32 :offset
+      uint32 :actualCont, :value => 1
+      rpc_unicode_string :name 		#declared in lsarpc/lsaQueryInformationPolicy.rb
+      conformantandVaryingStrings :nameNdr
+
+      def initialize_instance
+        super
+        domainHandle.value = get_parameter(:handle)
+
+        nameNdr.str = get_parameter(:accName).bytes.pack("v*")
+        numBytes = nameNdr.actual_count * 2
+        name.len.value = numBytes
+        name.maximumLength.value = numBytes
+        request.pduHead.frag_length = self.num_bytes
+        request.opnum.value = 17        #SamrLookupNamesInDomain
+      end
+    end
+
+    class SamrLookupNamesInDomainRes < BinData::Record
+      endian :little
+      request :request
+      uint32 :numberOfRef_id_relativeId
+      uint32 :ref_id_relativeId
+      uint32 :numberOfRelativeId
+      uint32 :relativeId
+      uint32 :numberOfRef_id_use
+      uint32 :ref_id_use
+      uint32 :numberOfuse
+      uint32 :use
+      uint32 :windowsError
+    end
+
+    def lookupNamesInDomain(name:)
+      samrLookupNamesInDomainReq = SamrLookupNamesInDomainReq.new(accName:name, handle:@domainHandle)
+      samrLookupNamesInDomainRes = @file.ioctl_send_recv(samrLookupNamesInDomainReq).buffer
+      samrLookupNamesInDomainRes.raise_not_error_success("lookupNamesInDomain")
+      samrLookupNamesInDomainRes = SamrLookupNamesInDomainRes.read(samrLookupNamesInDomainRes)
+      return {
+        :relativeId => samrLookupNamesInDomainRes.relativeId.to_i, 
+        :type => samrLookupNamesInDomainRes.use.to_i
+      }
+      end
+
+end
+end
+