Class: SmbRpc::Winreg

Inherits:
Rpc
  • Object
show all
Defined in:
lib/smbRpc/winreg.rb,
lib/smbRpc/winreg/openUsers.rb,
lib/smbRpc/winreg/baseRegEnumKey.rb,
lib/smbRpc/winreg/baseRegOpenKey.rb,
lib/smbRpc/winreg/baseRegSaveKey.rb,
lib/smbRpc/winreg/baseRegCloseKey.rb,
lib/smbRpc/winreg/baseRegSetValue.rb,
lib/smbRpc/winreg/openClassesRoot.rb,
lib/smbRpc/winreg/openCurrentUser.rb,
lib/smbRpc/winreg/baseRegCreateKey.rb,
lib/smbRpc/winreg/baseRegDeleteKey.rb,
lib/smbRpc/winreg/baseRegEnumValue.rb,
lib/smbRpc/winreg/openLocalMachine.rb,
lib/smbRpc/winreg/baseRegQueryValue.rb,
lib/smbRpc/winreg/openCurrentConfig.rb,
lib/smbRpc/winreg/baseRegDeleteValue.rb,
lib/smbRpc/winreg/baseRegQueryInfoKey.rb

Defined Under Namespace

Classes: BaseRegCloseKeyReq, BaseRegCloseKeyRes, BaseRegCreateKeyReq, BaseRegCreateKeyRes, BaseRegDeleteKeyReq, BaseRegDeleteKeyRes, BaseRegDeleteValueReq, BaseRegDeleteValueRes, BaseRegEnumKeyReq, BaseRegEnumKeyRes, BaseRegEnumValueReq, BaseRegEnumValueRes, BaseRegOpenKeyReq, BaseRegOpenKeyRes, BaseRegQueryInfoKeyReq, BaseRegQueryInfoKeyRes, BaseRegQueryValueReq, BaseRegQueryValueRes, BaseRegSaveKeyReq, BaseRegSaveKeyRes, BaseRegSetValueReq, BaseRegSetValueRes, OpenClassesRootReq, OpenClassesRootRes, OpenCurrentConfigReq, OpenCurrentConfigRes, OpenCurrentUserReq, OpenCurrentUserRes, OpenLocalMachineReq, OpenLocalMachineRes, OpenUsersReq, OpenUsersRes

Instance Attribute Summary collapse

Attributes inherited from Rpc

#smb

Instance Method Summary collapse

Methods inherited from Rpc

#bind, #connect

Constructor Details

#initialize(**argv) ⇒ Winreg

Returns a new instance of Winreg.



21
22
23
24
25
 
# File 'lib/smbRpc/winreg.rb', line 21

def initialize(**argv)
  super(argv)
  self.connect
  self.bind(pipe:"winreg")
end

Instance Attribute Details

#disposition ⇒ Object (readonly)

Returns the value of attribute disposition.



3
4
5
 
# File 'lib/smbRpc/winreg/baseRegCreateKey.rb', line 3

def disposition
  @disposition
end

#subKeyHandle ⇒ Object

Returns the value of attribute subKeyHandle.



4
5
6
 
# File 'lib/smbRpc/winreg/baseRegOpenKey.rb', line 4

def subKeyHandle
  @subKeyHandle
end

Instance Method Details

#baseRegCreateKey(subKey:, samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"], options: WINREG_OPTIONS["NONE"]) ⇒ Object

msdn.microsoft.com/en-us/library/cc244922.aspx can not create remote key imediately under HKLM/HKU, will get ERROR_INVALID_PARAMETER



46
47
48
49
50
51
52
53
54
 
# File 'lib/smbRpc/winreg/baseRegCreateKey.rb', line 46

def baseRegCreateKey(subKey:, samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"], options:WINREG_OPTIONS["NONE"])
  baseRegCreateKeyReq = BaseRegCreateKeyReq.new(handle:(@subKeyHandle || @rootKeyHandle), name:subKey, desired:samDesired, options:options)
  baseRegCreateKeyRes = @file.ioctl_send_recv(baseRegCreateKeyReq).buffer
  baseRegCreateKeyRes.raise_not_error_success("baseRegCreateKey")
  baseRegCreateKeyRes = BaseRegCreateKeyRes.read(baseRegCreateKeyRes)
  @disposition = baseRegCreateKeyRes.lpdwDisposition
  @subKeyHandle = baseRegCreateKeyRes.phkResult
  return self
end

#baseRegDeleteKey(subKey:) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/smbRpc/winreg/baseRegDeleteKey.rb', line 29

def baseRegDeleteKey(subKey:)
  baseRegDeleteKeyReq = BaseRegDeleteKeyReq.new(handle:@subKeyHandle, subKey:subKey)
  baseRegDeleteKeyRes = @file.ioctl_send_recv(baseRegDeleteKeyReq).buffer
  baseRegDeleteKeyRes.raise_not_error_success("baseRegDeleteKey")
  return self
end

#baseRegDeleteValue(valueName:) ⇒ Object 



29
30
31
32
33
34
 
# File 'lib/smbRpc/winreg/baseRegDeleteValue.rb', line 29

def baseRegDeleteValue(valueName:)
  baseRegDeleteValueReq = BaseRegDeleteValueReq.new(handle:(@subKeyHandle || @rootKeyHandle), valueName:valueName)
  baseRegDeleteValueRes = @file.ioctl_send_recv(baseRegDeleteValueReq).buffer
  baseRegDeleteValueRes.raise_not_error_success("baseRegDeleteValue")
  return self
end

#baseRegEnumKey(index:) ⇒ Object 



42
43
44
45
46
47
48
49
 
# File 'lib/smbRpc/winreg/baseRegEnumKey.rb', line 42

def baseRegEnumKey(index:)
  baseRegEnumKeyReq = BaseRegEnumKeyReq.new(handle:(@subKeyHandle || @rootKeyHandle), index:index)
  baseRegEnumKeyRes = @file.ioctl_send_recv(baseRegEnumKeyReq).buffer
  baseRegEnumKeyRes.raise_not_error_success("baseRegEnumKey")
  baseRegEnumKeyRes = BaseRegEnumKeyRes.read(baseRegEnumKeyRes)
  out = baseRegEnumKeyRes.lpNameOutNdr.str.unpack("v*").pack("c*")
  return out.chop if out[-1] == "\x00"
end

#baseRegEnumValue(index:) ⇒ Object 



44
45
46
47
48
49
50
51
52
53
 
# File 'lib/smbRpc/winreg/baseRegEnumValue.rb', line 44

def baseRegEnumValue(index:)
  baseRegEnumValueReq = BaseRegEnumValueReq.new(handle:(@subKeyHandle || @rootKeyHandle), index:index)
  baseRegEnumValueRes = @file.ioctl_send_recv(baseRegEnumValueReq).buffer
  baseRegEnumValueRes.raise_not_error_success("baseRegEnumValue")
  baseRegEnumValueRes = BaseRegEnumValueRes.read(baseRegEnumValueRes)
  valueName = baseRegEnumValueRes.lpValueNameOutNdr.str.unpack("v*").pack("c*").chop
  return { :valueName => valueName,
           :type => baseRegEnumValueRes.lpType.to_i
  }
end

#baseRegOpenKey(subKey:, samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"], options: WINREG_OPTIONS["NONE"]) ⇒ Object 



36
37
38
39
40
41
42
43
 
# File 'lib/smbRpc/winreg/baseRegOpenKey.rb', line 36

def baseRegOpenKey(subKey:, samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"], options:WINREG_OPTIONS["NONE"])
  baseRegOpenKeyReq = BaseRegOpenKeyReq.new(handle:@rootKeyHandle, subKey:subKey, desired:samDesired, options:options)
  baseRegOpenKeyRes = @file.ioctl_send_recv(baseRegOpenKeyReq).buffer
  baseRegOpenKeyRes.raise_not_error_success("baseRegOpenKey")
  baseRegOpenKeyRes = BaseRegOpenKeyRes.read(baseRegOpenKeyRes)
  @subKeyHandle = baseRegOpenKeyRes.phkResult
  return self
end

#baseRegQueryInfoKey ⇒ Object 



37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
 
# File 'lib/smbRpc/winreg/baseRegQueryInfoKey.rb', line 37

def baseRegQueryInfoKey
  baseRegQueryInfoKeyReq = BaseRegQueryInfoKeyReq.new(handle:(@subKeyHandle || @rootKeyHandle))
  baseRegQueryInfoKeyRes = @file.ioctl_send_recv(baseRegQueryInfoKeyReq).buffer
  baseRegQueryInfoKeyRes.raise_not_error_success("baseRegQueryInfoKey")
  baseRegQueryInfoKeyRes = BaseRegQueryInfoKeyRes.read(baseRegQueryInfoKeyRes)
  k = baseRegQueryInfoKeyRes
  return { :numberOfSubkeys => k.lpcSubKeys,
           :maxSubkeySize => k.lpcbMaxSubKeyLen,
           :maxClassSize => k.lpcbMaxClassLen,
           :numberOfValues => k.lpcValues,
           :maxValueNameSize => k.lpcbMaxValueNameLen,
           :maxValueSize => k.lpcbMaxValueLen,
           :securityDescriptorSize => k.lpcbSecurityDescriptor,
           :lastWriteTime => k.lpftLastWriteTime
  }
end

#baseRegQueryValue(valueName:, type: WINREG_REG_VALUE_TYPE["UNDEF"]) ⇒ Object 



52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
 
# File 'lib/smbRpc/winreg/baseRegQueryValue.rb', line 52

def baseRegQueryValue(valueName:, type:WINREG_REG_VALUE_TYPE["UNDEF"])
  baseRegQueryValueReq = BaseRegQueryValueReq.new(handle:(@subKeyHandle || @rootKeyHandle), vName:valueName, type:type)
  baseRegQueryValueRes = @file.ioctl_send_recv(baseRegQueryValueReq).buffer
  baseRegQueryValueRes.raise_not_error_success("baseRegQueryValue")
  baseRegQueryValueRes = BaseRegQueryValueRes.read(baseRegQueryValueRes)
  type = baseRegQueryValueRes.lpType
  data = baseRegQueryValueRes.lpData.str
  case type
    when 0
      return data
    when 1
      return data.unpack("v*").pack("c*").chop
    when 2
      return data.unpack("v*").pack("c*").chop
    when 3
      return data
    when 4
      return data.unpack("V")[0]
    when 5
      return data.unpack("N")[0] 
    when 7
      return data.unpack("v*").pack("c*").split("\x00")
    when 11
      return data.unpack("Q<")[0]
  end
end

#baseRegSaveKey(file:) ⇒ Object 



30
31
32
33
34
35
 
# File 'lib/smbRpc/winreg/baseRegSaveKey.rb', line 30

def baseRegSaveKey(file:)
  baseRegSaveKeyReq = BaseRegSaveKeyReq.new(handle:(@subKeyHandle || @rootKeyHandle), file:file)
  baseRegSaveKeyRes = @file.ioctl_send_recv(baseRegSaveKeyReq).buffer
  baseRegSaveKeyRes.raise_not_error_success("baseRegSaveKey")
  return self
end

#baseRegSetValue(valueName:, type:, data:) ⇒ Object 



37
38
39
40
41
42
 
# File 'lib/smbRpc/winreg/baseRegSetValue.rb', line 37

def baseRegSetValue(valueName:, type:, data:)
  baseRegSetValueReq = BaseRegSetValueReq.new(handle:(@subKeyHandle || @rootKeyHandle), valueName:valueName, type:type, data:data)
  baseRegSetValueRes = @file.ioctl_send_recv(baseRegSetValueReq).buffer
  baseRegSetValueRes.raise_not_error_success("baseRegSetValue")
  return self
end

#close ⇒ Object 



44
45
46
47
48
 
# File 'lib/smbRpc/winreg/baseRegCloseKey.rb', line 44

def close()
  closeSubKey()
  closeRootKey()
  super
end

#closeRootKey ⇒ Object 



24
25
26
27
28
29
30
31
32
 
# File 'lib/smbRpc/winreg/baseRegCloseKey.rb', line 24

def closeRootKey()
  if !@rootKeyHandle.nil?
    baseRegCloseKeyReq = BaseRegCloseKeyReq.new(handle:@rootKeyHandle)
    baseRegCloseKeyRes = @file.ioctl_send_recv(baseRegCloseKeyReq).buffer
    baseRegCloseKeyRes.raise_not_error_success("closeRootKey")
    baseRegCloseKeyRes = BaseRegCloseKeyRes.read(baseRegCloseKeyRes)
    @rootKeyHandle = nil
  end
end

#closeSubKey ⇒ Object 



34
35
36
37
38
39
40
41
42
 
# File 'lib/smbRpc/winreg/baseRegCloseKey.rb', line 34

def closeSubKey()
  if !@subKeyHandle.nil?
    baseRegCloseKeyReq = BaseRegCloseKeyReq.new(handle:@subKeyHandle)
    baseRegCloseKeyRes = @file.ioctl_send_recv(baseRegCloseKeyReq).buffer
    baseRegCloseKeyRes.raise_not_error_success("closeSubKey")
    baseRegCloseKeyRes = BaseRegCloseKeyRes.read(baseRegCloseKeyRes)
    @subKeyHandle = nil
  end
end

#openClassesRoot(samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"]) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/smbRpc/winreg/openClassesRoot.rb', line 26

def openClassesRoot(samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"])
  openClassesRootReq = OpenClassesRootReq.new(access:samDesired)
  openClassesRootRes = @file.ioctl_send_recv(openClassesRootReq).buffer
  openClassesRootRes.raise_not_error_success("openClassesRoot")
  openClassesRootRes = OpenClassesRootRes.read(openClassesRootRes)
  @rootKeyHandle = openClassesRootRes.phKey
  return self
end

#openCurrentConfig(samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"]) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/smbRpc/winreg/openCurrentConfig.rb', line 26

def openCurrentConfig(samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"])
  openCurrentConfigReq = OpenCurrentConfigReq.new(access:samDesired)
  openCurrentConfigRes = @file.ioctl_send_recv(openCurrentConfigReq).buffer
  openCurrentConfigRes.raise_not_error_success("openCurrentConfig")
  openCurrentConfigRes = OpenCurrentConfigRes.read(openCurrentConfigRes)
  @rootKeyHandle = openCurrentConfigRes.phKey
  return self
end

#openCurrentUser(samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"]) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/smbRpc/winreg/openCurrentUser.rb', line 26

def openCurrentUser(samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"])
  openCurrentUserReq = OpenCurrentUserReq.new(access:samDesired)
  openCurrentUserRes = @file.ioctl_send_recv(openCurrentUserReq).buffer
  openCurrentUserRes.raise_not_error_success("openCurrentUser")
  openCurrentUserRes = OpenCurrentUserRes.read(openCurrentUserRes)
  @rootKeyHandle = openCurrentUserRes.phKey
  return self
end

#openLocalMachine(samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"]) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/smbRpc/winreg/openLocalMachine.rb', line 26

def openLocalMachine(samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"])
  openLocalMachineReq = OpenLocalMachineReq.new(access:samDesired)
  openLocalMachineRes = @file.ioctl_send_recv(openLocalMachineReq).buffer
  openLocalMachineRes.raise_not_error_success("openLocalMachine")
  openLocalMachineRes = OpenLocalMachineRes.read(openLocalMachineRes)
  @rootKeyHandle = openLocalMachineRes.phKey
  return self
end

#openUsers(samDesired: WINREG_REGSAM["MAXIMUM_ALLOWED"]) ⇒ Object 



26
27
28
29
30
31
32
33
 
# File 'lib/smbRpc/winreg/openUsers.rb', line 26

def openUsers(samDesired:WINREG_REGSAM["MAXIMUM_ALLOWED"])
  openUsersReq = OpenUsersReq.new(access:samDesired)
  openUsersRes = @file.ioctl_send_recv(openUsersReq).buffer
  openUsersRes.raise_not_error_success("openUsers")
  openUsersRes = OpenUsersRes.read(openUsersRes)
  @rootKeyHandle = openUsersRes.phKey
  return self
end