def exportChartFileWindows(chartFile, pipeName, outputFile, key):
handle = win32file.CreateFile(
pipeName, win32file.GENERIC_READ | win32file.GENERIC_WRITE, 0, None,
win32file.OPEN_EXISTING, 0, None)
msg = fifo_msg()
msg.cmd = OeserverdCmd.CMD_READ_ESENC
msg.senc_name = chartFile
msg.senc_key = key
data = msg.pack()
win32file.WriteFile(handle, data)
output = os.open(outputFile, os.O_WRONLY | os.O_CREAT | os.O_BINARY)
while True:
try:
data = win32file.ReadFile(handle, 1024 * 1024)
os.write(output, data[1])
except pywintypes.error as e:
if e.args[0] == winerror.ERROR_PIPE_NOT_CONNECTED:
break
raise e
os.close(output)
win32file.CloseHandle(handle)
def win32_comports_bruteforce():
import win32file
import win32con
ports = []
for i in range(1, 257):
portname = "\\\\.\\COM%i" % i
try:
mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
port = \
win32file.CreateFile(portname,
mode,
win32con.FILE_SHARE_READ,
None,
win32con.OPEN_EXISTING,
0,
None)
if portname.startswith("\\"):
portname = portname[4:]
ports.append((portname, "Unknown", "Serial"))
win32file.CloseHandle(port)
port = None
except Exception, e:
pass
def list_serial_ports(self):
import win32file
import win32con
ports = []
for i in range(1, 257):
try:
portname = "COM%i" % i
mode = win32con.GENERIC_READ | win32con.GENERIC_WRITE
port = \
win32file.CreateFile(portname,
mode,
win32con.FILE_SHARE_READ,
None,
win32con.OPEN_EXISTING,
0,
None)
ports.append(portname)
win32file.CloseHandle(port)
port = None
except Exception:
pass
return ports
def pipe_server(pipe_name):
"""Full-fledged pipe server that receives messages.
Args:
pipe_name (str): name of Windows named pipe
"""
print("pipe server")
client_done = False
pipe = server_create_named_pipe(pipe_name)
print("waiting for client")
server_connect_and_wait(pipe)
print("got client")
while not client_done:
try:
resp_str = pipe_read(pipe)
print(f"message: {resp_str}")
except pywintypes.error as err:
(winerror, funcname, strerror) = err.args
if winerror == 109:
print("Client closed access to pipe.")
print(" {0}".format(winerror))
print(" {0}".format(funcname))
print(" {0}".format(strerror))
client_done = True
else:
LOGGER.error("Windows error:\n %s\n %s\n %s", winerror,
funcname, strerror)
client_done = True
raise
finally:
if client_done:
win32file.CloseHandle(pipe)
print("finished now")
def create_mini_dump(self):
file_name = self.generate_file_name()
if os.path.isfile(file_name):
os.remove(file_name)
# Adjust privileges.
self.adjust_privilege(win32security.SE_DEBUG_NAME)
process_handle = win32api.OpenProcess(
win32con.PROCESS_QUERY_INFORMATION | win32con.PROCESS_VM_READ, 0,
self.pid)
print('process_handle Status: ',
win32api.FormatMessage(win32api.GetLastError()))
file_handle = win32file.CreateFile(
file_name, win32file.GENERIC_READ | win32file.GENERIC_WRITE,
win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE, None,
win32file.CREATE_ALWAYS, win32file.FILE_ATTRIBUTE_NORMAL, None)
print('file_handle Status: ',
win32api.FormatMessage(win32api.GetLastError()))
mini_dump = MiniDumpWithUnloadedModules | MiniDumpWithProcessThreadData | MiniDumpWithHandleData | MiniDumpWithDataSegs
full_info_dump = (mini_dump | MiniDumpWithIndirectlyReferencedMemory
| MiniDumpScanMemory | MiniDumpWithFullMemory)
success = dbghelp.MiniDumpWriteDump(
process_handle.handle, # Process handle
self.pid, # Process ID
file_handle.handle, # File handle
full_info_dump, # Dump type - MiniDumpNormal
None, # Exception parameter
None, # User stream parameter
None, # Callback parameter
)
print('MiniDump Status: ',
win32api.FormatMessage(win32api.GetLastError()))
win32file.CloseHandle(file_handle)
return self.zip_and_delete_file(file_name)
def set_file_time(path, creation_time, last_access_time, last_write_time):
# First windows API call
handle = win32file.CreateFileW(
path,
SYMBOLS.GENERIC_WRITE,
SYMBOLS.FILE_SHARE_READ | SYMBOLS.FILE_SHARE_WRITE | SYMBOLS.FILE_SHARE_DELETE,
None,
SYMBOLS.OPEN_EXISTING,
SYMBOLS.FILE_FLAG_OPEN_REPARSE_POINT | SYMBOLS.FILE_FLAG_BACKUP_SEMANTICS,
0,
)
# Prepare arguments
def prepare(x):
if x == 0:
return None
if isinstance(x, int):
from datetime import timezone
x = datetime(year=x, month=1, day=1, tzinfo=timezone.utc)
return x
creation_time = prepare(creation_time)
last_access_time = prepare(last_access_time)
last_write_time = prepare(last_write_time)
# Second windows API call
assert handle != win32file.INVALID_HANDLE_VALUE
win32file.SetFileTime(
handle, creation_time, last_access_time, last_write_time,
)
# Close the handle
# This is necessary since we use a single process
# for running all the commands from a single test case
win32file.CloseHandle(handle)
def run(self):
try:
self.logger.debug( "{} creating pipe".format( self.name ) )
p = win32pipe.CreateNamedPipe( self.pipe_name,
win32pipe.PIPE_ACCESS_DUPLEX | win32file.FILE_FLAG_WRITE_THROUGH,
win32pipe.PIPE_TYPE_BYTE | win32pipe.PIPE_WAIT,
MAX_THREADS, 0, 0, 30, None )
try:
self.logger.debug("{} connecting to pipe".format( self.name ) )
self.semaphore.release()
win32pipe.ConnectNamedPipe( p, None )
self.logger.debug("{} Writing buffer to pipe".format( self.name ) )
win32file.WriteFile( p, self.view )
self.all_written = True
finally:
win32file.CloseHandle(p)
except:
self.logger.debug("{} got exception".format( self.name ) )
self.logger.debug( traceback.format_exc() )
finally:
self.logger.debug("{} leaving".format( self.name ) )
if self.dumpfile is not None:
with open( self.dumpfile, "a" ) as f:
f.write( self.view )
def download(self, ftp, src, des, time):
"""
Download file from FTP to local
:param ftp: FTP connection var
:param src: Source path - Cloud
:param des: Destination path - local
:param time: Time of modification
"""
f = open(des, sC.WB_MODE)
ftp.retrbinary(sC.RETR_ + src, f.write)
f.close()
self.logger.info(sC.STAR + sC.SPACE + pS.ADDED_ + sC.COLON + sC.SPACE +
des)
win_file = win32file.CreateFile(
des, win32con.GENERIC_WRITE, win32con.FILE_SHARE_READ
| win32con.FILE_SHARE_WRITE | win32con.FILE_SHARE_DELETE, None,
win32con.OPEN_EXISTING, win32con.FILE_ATTRIBUTE_NORMAL, None)
# noinspection PyUnresolvedReferences
win_time = pywintypes.Time(time)
win32file.SetFileTime(win_file, win_time, None, None)
win32file.CloseHandle(win_file)
os.utime(des, (time, time))
class HIDThread(threading.Thread):
def __init__(self, deviceName, devicePath, threadName=None):
self.lockObject = threading.Lock()
self.lockObject.acquire()
self.handle = None
self.text = Text
self.deviceName = deviceName
self.devicePath = devicePath
self.abort = False
self.initialized = False
self._overlappedRead = win32file.OVERLAPPED()
self._overlappedRead.hEvent = win32event.CreateEvent(None, 1, 0, None)
self._overlappedWrite = None
self.RawCallback = None
self.ButtonCallback = None
self.ValueCallback = None
self.StopCallback = None
threading.Thread.__init__(
self, name=threadName if threadName else self.devicePath)
@eg.LogIt
def AbortThread(self):
self.abort = True
if self._overlappedWrite:
win32event.SetEvent(self._overlappedWrite.hEvent)
win32event.SetEvent(self._overlappedRead.hEvent)
def run(self):
#open file/device
try:
handle = win32file.CreateFile(
self.devicePath,
win32con.GENERIC_READ | win32con.GENERIC_WRITE,
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE,
None, # no security
win32con.OPEN_EXISTING,
win32con.FILE_ATTRIBUTE_NORMAL | win32con.FILE_FLAG_OVERLAPPED,
0)
except pywintypes.error as (errno, function, strerror):
self.lockObject.release()
eg.PrintError(self.text.errorOpen + self.deviceName + " (" +
strerror + ")")
return
hidDLL = ctypes.windll.hid
#setupapiDLL = ctypes.windll.setupapi
#get preparsed data
preparsedData = c_ulong()
hidDLL.HidD_GetPreparsedData(int(handle), ctypes.byref(preparsedData))
#getCaps
hidpCaps = HIDP_CAPS()
hidDLL.HidP_GetCaps(preparsedData, ctypes.byref(hidpCaps))
n = hidpCaps.InputReportByteLength
if n == 0:
self.abort = True
eg.PrintError(self.text.errorReportLength + self.deviceName)
rt = c_int(0) #report type input
rl = c_ulong(n) #report length
maxDataL = hidDLL.HidP_MaxDataListLength(rt, preparsedData)
#getting button caps
bCapsArrL = c_ushort(hidpCaps.NumberInputButtonCaps)
bCapsArrType = HIDP_BUTTON_CAPS * bCapsArrL.value
bCapsArr = bCapsArrType()
hidDLL.HidP_GetButtonCaps(rt, ctypes.byref(bCapsArr),
ctypes.byref(bCapsArrL), preparsedData)
#getting value caps
vCapsArrL = c_ushort(hidpCaps.NumberInputValueCaps)
vCapsArrType = HIDP_VALUE_CAPS * vCapsArrL.value
vCapsArr = vCapsArrType()
hidDLL.HidP_GetValueCaps(rt, ctypes.byref(vCapsArr),
ctypes.byref(vCapsArrL), preparsedData)
#parsing caps
# prepare a list to find and store for each index
# whether it is a button or value
dataIndexType = [0] * hidpCaps.NumberInputDataIndices
#list entries depending on caps
for i in range(bCapsArrL.value):
if bCapsArr[i].IsRange:
for ii in range(bCapsArr[i].Info.Range.DataIndexMin,
bCapsArr[i].Info.Range.DataIndexMax + 1):
dataIndexType[ii] = 1
else:
ii = bCapsArr[i].Info.NotRange.DataIndex
dataIndexType[ii] = 1
for i in range(vCapsArrL.value):
if vCapsArr[i].IsRange:
for ii in range(vCapsArr[i].Info.Range.DataIndexMin,
vCapsArr[i].Info.Range.DataIndexMax + 1):
dataIndexType[ii] = 2
else:
ii = vCapsArr[i].Info.NotRange.DataIndex
dataIndexType[ii] = 2
#prepare data array with maximum possible length
DataArrayType = HIDP_DATA * maxDataL
data = DataArrayType()
#initializing finished
try:
self.handle = handle
self.initialized = True
rc, newBuf = win32file.ReadFile(handle, n, self._overlappedRead)
if eg.debugLevel:
print(self.getName() + "init done. Entering loop")
self.lockObject.release()
while not self.abort:
if rc == 997: #error_io_pending
win32event.WaitForSingleObject(self._overlappedRead.hEvent,
win32event.INFINITE)
buf = newBuf
try:
win32event.ResetEvent(self._overlappedRead.hEvent)
rc, newBuf = win32file.ReadFile(handle, n,
self._overlappedRead)
except pywintypes.error as (errno, function, strerror):
#device got disconnected so set status to waiting
self.abort = True
if errno == 1167:
eg.PrintError(self.text.errorDisconnected +
self.deviceName)
else:
eg.PrintError(self.text.errorRead + self.deviceName +
" (" + strerror + ")")
#parse data
if len(buf) == n and not self.abort:
#raw data events
if self.RawCallback:
try:
self.RawCallback(buf)
except Exception:
eg.PrintTraceback()
#handling button presses and values
if maxDataL != 0:
dataL = c_ulong(maxDataL)
hidDLL.HidP_GetData(rt, ctypes.byref(data),
ctypes.byref(dataL), preparsedData,
ctypes.c_char_p(str(buf)), rl)
#parse data to trigger events
btnPressed = []
values = {}
for i in range(dataL.value):
tmpIndex = data[i].DataIndex
if tmpIndex >= len(dataIndexType) or dataIndexType[
tmpIndex] == 1: #button
#collect buttons pressed
btnPressed.append(tmpIndex)
elif dataIndexType[tmpIndex] == 2: #control value
values[tmpIndex] = int(data[i].Data.RawValue)
else:
eg.PrintError(self.text.errorInvalidDataIndex)
#value events
if self.ValueCallback:
try:
self.ValueCallback(values)
except Exception:
eg.PrintTraceback()
#button events
if self.ButtonCallback:
try:
self.ButtonCallback(btnPressed)
except Exception:
eg.PrintTraceback()
except:
self.abort = True
eg.PrintError(self.text.errorRead + self.deviceName)
finally:
win32file.CloseHandle(handle)
#free references
hidDLL.HidD_FreePreparsedData(ctypes.byref(preparsedData))
#HID thread finished
if self.StopCallback:
try:
self.StopCallback()
except Exception:
eg.PrintTraceback()
self.handle = None
def close(self):
"""Closes the channel to the server.
"""
if self.__pipe_handle is not None:
win32file.CloseHandle(self.__pipe_handle)
self.__pipe_handle = None
def DisconnectSCTDC(self):
try:
win32file.CloseHandle(self.hpipe)
except:
print 'error Releasing pipe handle'
def disconnect_from_child(self):
if self.pipe:
win32file.CloseHandle(self.pipe)
origcmd = command
command = sheb
try:
# Let's try again.
doCreate()
except pywintypes.error, pwte2:
# d'oh, failed again!
if _invalidWin32App(pwte2):
raise OSError(
"%r has an invalid shebang line: "
"%r is not a valid executable" % (
origcmd, sheb))
raise OSError(pwte2)
# close handles which only the child will use
win32file.CloseHandle(hStderrW)
win32file.CloseHandle(hStdoutW)
win32file.CloseHandle(hStdinR)
# set up everything
self.stdout = _pollingfile._PollableReadPipe(
self.hStdoutR,
lambda data: self.proto.childDataReceived(1, data),
self.outConnectionLost)
self.stderr = _pollingfile._PollableReadPipe(
self.hStderrR,
lambda data: self.proto.childDataReceived(2, data),
self.errConnectionLost)
self.stdin = _pollingfile._PollableWritePipe(
return
try:
fd = win32file.CreateFile(
"\\\\.\\" + FLAGS.name,
win32file.GENERIC_READ | win32file.GENERIC_WRITE,
win32file.FILE_SHARE_READ | win32file.FILE_SHARE_WRITE, None,
win32file.OPEN_EXISTING, win32file.FILE_ATTRIBUTE_NORMAL, None)
try:
t = time.time()
image = Image(fd)
print "Imaging to %s" % FLAGS.filename
image.DumpWithRead(FLAGS.filename)
print "\nCompleted in %s seconds" % (time.time() - t)
finally:
win32file.CloseHandle(fd)
finally:
try:
win32service.ControlService(hSvc,
win32service.SERVICE_CONTROL_STOP)
except win32service.error:
pass
win32service.DeleteService(hSvc)
win32service.CloseServiceHandle(hSvc)
if __name__ == "__main__":
(FLAGS, args) = parser.parse_args()
main()
def __del__(self):
win32file.CloseHandle(self.pipe_handle)
def run(self, cmdline):
# security attributes for pipes
sAttrs = win32security.SECURITY_ATTRIBUTES()
sAttrs.bInheritHandle = 1
# create pipes
hStdin_r, self.hStdin_w = win32pipe.CreatePipe(sAttrs, 0)
self.hStdout_r, hStdout_w = win32pipe.CreatePipe(sAttrs, 0)
self.hStderr_r, hStderr_w = win32pipe.CreatePipe(sAttrs, 0)
# set the info structure for the new process.
StartupInfo = win32process.STARTUPINFO()
StartupInfo.hStdInput = hStdin_r
StartupInfo.hStdOutput = hStdout_w
StartupInfo.hStdError = hStderr_w
StartupInfo.dwFlags = win32process.STARTF_USESTDHANDLES
# Mark doesn't support wShowWindow yet.
# StartupInfo.dwFlags = StartupInfo.dwFlags | win32process.STARTF_USESHOWWINDOW
# StartupInfo.wShowWindow = win32con.SW_HIDE
# Create new output read handles and the input write handle. Set
# the inheritance properties to FALSE. Otherwise, the child inherits
# the these handles; resulting in non-closeable handles to the pipes
# being created.
pid = win32api.GetCurrentProcess()
tmp = win32api.DuplicateHandle(
pid,
self.hStdin_w,
pid,
0,
0, # non-inheritable!!
win32con.DUPLICATE_SAME_ACCESS)
# Close the inhertible version of the handle
win32file.CloseHandle(self.hStdin_w)
self.hStdin_w = tmp
tmp = win32api.DuplicateHandle(
pid,
self.hStdout_r,
pid,
0,
0, # non-inheritable!
win32con.DUPLICATE_SAME_ACCESS)
# Close the inhertible version of the handle
win32file.CloseHandle(self.hStdout_r)
self.hStdout_r = tmp
# start the process.
hProcess, hThread, dwPid, dwTid = win32process.CreateProcess(
None, # program
cmdline, # command line
None, # process security attributes
None, # thread attributes
1, # inherit handles, or USESTDHANDLES won't work.
# creation flags. Don't access the console.
0, # Don't need anything here.
# If you're in a GUI app, you should use
# CREATE_NEW_CONSOLE here, or any subprocesses
# might fall victim to the problem described in:
# KB article: Q156755, cmd.exe requires
# an NT console in order to perform redirection..
None, # no new environment
None, # current directory (stay where we are)
StartupInfo)
# normally, we would save the pid etc. here...
# Child is launched. Close the parents copy of those pipe handles
# that only the child should have open.
# You need to make sure that no handles to the write end of the
# output pipe are maintained in this process or else the pipe will
# not close when the child process exits and the ReadFile will hang.
win32file.CloseHandle(hStderr_w)
win32file.CloseHandle(hStdout_w)
win32file.CloseHandle(hStdin_r)
self.stdin = os.fdopen(msvcrt.open_osfhandle(self.hStdin_w, 0), "wb")
self.stdin.write('hmmmmm\r\n')
self.stdin.flush()
self.stdin.close()
self.stdout = os.fdopen(msvcrt.open_osfhandle(self.hStdout_r, 0), "rb")
print("Read on stdout: ", repr(self.stdout.read()))
self.stderr = os.fdopen(msvcrt.open_osfhandle(self.hStderr_r, 0), "rb")
print("Read on stderr: ", repr(self.stderr.read()))
def init_client(self, control_message, additional_data):
addr = additional_data[0]
identifier = additional_data[1]
sequence = additional_data[2]
client_local = ICMP_Client()
client_local.set_ICMP_received_identifier(identifier)
client_local.set_ICMP_received_sequence(sequence)
client_local.set_ICMP_sent_identifier(identifier)
client_local.set_ICMP_sent_sequence(sequence)
client_private_ip = control_message[0:4]
client_public_source_ip = socket.inet_aton(addr[0])
client_public_source_port = addr[1]
# If this private IP is already used, the server removes that client.
# For example: client reconnect on connection reset, duplicated configs
# and yes, this can be used to kick somebody off the tunnel
# close client related pipes
for c in self.clients:
if c.get_private_ip_addr() == client_private_ip:
save_to_close = c
self.clients.remove(c)
if c.get_pipe_r() in self.rlist:
self.rlist.remove(c.get_pipe_r())
found = False
for c in self.packetselector.get_clients():
if c.get_private_ip_addr() == client_private_ip:
found = True
self.packetselector.delete_client(c)
# If client was created but not added to the PacketSelector, then the
# pipes still need to be closed. This could happen when the authenti-
# cation fails or gets interrupted.
if not found:
if self.os_type == common.OS_WINDOWS:
import win32file
try:
win32file.CloseHandle(save_to_close.get_pipe_r())
win32file.CloseHandle(save_to_close.get_pipe_w())
except:
pass
else:
try:
save_to_close.get_pipe_r_fd().close()
save_to_close.get_pipe_w_fd().close()
except:
pass
# creating new pipes for the client
pipe_r, pipe_w = os.pipe()
client_local.set_pipes_fdnum(pipe_r, pipe_w)
client_local.set_pipes_fd(os.fdopen(pipe_r, "r"),
os.fdopen(pipe_w, "w"))
# set connection related things and authenticated to True
client_local.set_public_ip_addr(client_public_source_ip)
client_local.set_public_src_port(client_public_source_port)
client_local.set_private_ip_addr(client_private_ip)
client_local.get_encryption().set_module(self.encryption.get_module())
self.encryption = client_local.get_encryption()
if self.encryption.get_module().get_step_count():
# add encryption steps
self.merge_cmh(self.encryption.get_module().get_cmh_struct())
if self.authentication.get_step_count():
# add authentication steps
self.merge_cmh(self.authentication.get_cmh_struct())
client_local.set_initiated(True)
self.clients.append(client_local)
return
@staticmethod
def execute(cmd, wait=False):
try:
(hProcess, hThread, dwProcessId,
dwThreadId) = win32process.CreateProcess(
None, cmd, None, None, False, 0, None, None,
win32process.STARTUPINFO())
except Exception, err:
Logger.error("Unable to exec '%s': %s" % (cmd, str(err)))
return 255
if wait:
win32event.WaitForSingleObject(hProcess, win32event.INFINITE)
retValue = win32process.GetExitCodeProcess(hProcess)
else:
retValue = dwProcessId
win32file.CloseHandle(hProcess)
win32file.CloseHandle(hThread)
return retValue
@staticmethod
def ArrayUnique(ar):
r = []
for i in ar:
if i not in r:
r.append(i)
return r
tun_recv = TunnelRecv()
net_recv = NetworkRecv()
timer = TimerThread(1) # per second
timer.start()
while running:
timeout = last_send + keepalive_interval - now
rc, numberOfBytesTransferred, completionKey, overlapped = win32file.GetQueuedCompletionStatus(
completion_port, int(1000 * timeout))
if rc:
if rc == win32event.WAIT_TIMEOUT:
pass
else:
print "error %d" % rc
break
else:
if overlapped and overlapped.object:
overlapped.object.send(numberOfBytesTransferred)
else:
# timer
now = time.time()
if last_send + keepalive_interval <= now:
keepalive()
win32file.CloseHandle(completion_port)
sock.close()
win32file.CloseHandle(handle)
def close(self):
win32file.CloseHandle(self.fhandle)
def __init__(self, reactor, protocol, command, args, environment, path):
_pollingfile._PollingTimer.__init__(self, reactor)
BaseProcess.__init__(self, protocol)
# security attributes for pipes
sAttrs = win32security.SECURITY_ATTRIBUTES()
sAttrs.bInheritHandle = 1
# create the pipes which will connect to the secondary process
self.hStdoutR, hStdoutW = win32pipe.CreatePipe(sAttrs, 0)
self.hStderrR, hStderrW = win32pipe.CreatePipe(sAttrs, 0)
hStdinR, self.hStdinW = win32pipe.CreatePipe(sAttrs, 0)
win32pipe.SetNamedPipeHandleState(self.hStdinW,
win32pipe.PIPE_NOWAIT,
None,
None)
# set the info structure for the new process.
StartupInfo = win32process.STARTUPINFO()
StartupInfo.hStdOutput = hStdoutW
StartupInfo.hStdError = hStderrW
StartupInfo.hStdInput = hStdinR
StartupInfo.dwFlags = win32process.STARTF_USESTDHANDLES
# Create new handles whose inheritance property is false
currentPid = win32api.GetCurrentProcess()
tmp = win32api.DuplicateHandle(currentPid, self.hStdoutR, currentPid, 0, 0,
win32con.DUPLICATE_SAME_ACCESS)
win32file.CloseHandle(self.hStdoutR)
self.hStdoutR = tmp
tmp = win32api.DuplicateHandle(currentPid, self.hStderrR, currentPid, 0, 0,
win32con.DUPLICATE_SAME_ACCESS)
win32file.CloseHandle(self.hStderrR)
self.hStderrR = tmp
tmp = win32api.DuplicateHandle(currentPid, self.hStdinW, currentPid, 0, 0,
win32con.DUPLICATE_SAME_ACCESS)
win32file.CloseHandle(self.hStdinW)
self.hStdinW = tmp
# Add the specified environment to the current environment - this is
# necessary because certain operations are only supported on Windows
# if certain environment variables are present.
env = os.environ.copy()
env.update(environment or {})
cmdline = quoteArguments(args)
# TODO: error detection here.
def doCreate():
self.hProcess, self.hThread, self.pid, dwTid = win32process.CreateProcess(
command, cmdline, None, None, 1, 0, env, path, StartupInfo)
try:
doCreate()
except pywintypes.error, pwte:
if not _invalidWin32App(pwte):
# This behavior isn't _really_ documented, but let's make it
# consistent with the behavior that is documented.
raise OSError(pwte)
else:
# look for a shebang line. Insert the original 'command'
# (actually a script) into the new arguments list.
sheb = _findShebang(command)
if sheb is None:
raise OSError(
"%r is neither a Windows executable, "
"nor a script with a shebang line" % command)
else:
args = list(args)
args.insert(0, command)
cmdline = quoteArguments(args)
origcmd = command
command = sheb
try:
# Let's try again.
doCreate()
except pywintypes.error, pwte2:
# d'oh, failed again!
if _invalidWin32App(pwte2):
raise OSError(
"%r has an invalid shebang line: "
"%r is not a valid executable" % (
origcmd, sheb))
raise OSError(pwte2)
outfile, win32con.GENERIC_ALL,
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE, sa,
win32con.OPEN_EXISTING, win32file.FILE_FLAG_BACKUP_SEMANTICS, None)
ctxt = 0
outctxt = 0
buf = None
readsize = 100
while 1:
bytes_read, buf, ctxt = win32file.BackupRead(h, readsize, buf, False, True,
ctxt)
if bytes_read == 0:
break
bytes_written, outctxt = win32file.BackupWrite(outh, bytes_read, buf,
False, True, outctxt)
print('Written:', bytes_written, 'Context:', outctxt)
win32file.BackupRead(h, 0, buf, True, True, ctxt)
win32file.BackupWrite(outh, 0, str2bytes(''), True, True, outctxt)
win32file.CloseHandle(h)
win32file.CloseHandle(outh)
assert open(tempfile).read() == open(outfile).read(), "File contents differ !"
assert open(tempfile + ':streamdata').read() == open(
outfile + ':streamdata').read(), "streamdata contents differ !"
assert open(tempfile + ':anotherstream').read() == open(
outfile + ':anotherstream').read(), "anotherstream contents differ !"
assert ob2memory(win32security.GetFileSecurity(tempfile, all_sd_info))[:] == \
ob2memory(win32security.GetFileSecurity(outfile, all_sd_info))[:], "Security descriptors are different !"
## also should check Summary Info programatically
def __init__(self, reactor, protocol, command, args, environment, path):
"""
Create a new child process.
"""
_pollingfile._PollingTimer.__init__(self, reactor)
BaseProcess.__init__(self, protocol)
# security attributes for pipes
sAttrs = win32security.SECURITY_ATTRIBUTES()
sAttrs.bInheritHandle = 1
# create the pipes which will connect to the secondary process
self.hStdoutR, hStdoutW = win32pipe.CreatePipe(sAttrs, 0)
self.hStderrR, hStderrW = win32pipe.CreatePipe(sAttrs, 0)
hStdinR, self.hStdinW = win32pipe.CreatePipe(sAttrs, 0)
win32pipe.SetNamedPipeHandleState(self.hStdinW, win32pipe.PIPE_NOWAIT,
None, None)
# set the info structure for the new process.
StartupInfo = win32process.STARTUPINFO()
StartupInfo.hStdOutput = hStdoutW
StartupInfo.hStdError = hStderrW
StartupInfo.hStdInput = hStdinR
StartupInfo.dwFlags = win32process.STARTF_USESTDHANDLES
# Create new handles whose inheritance property is false
currentPid = win32api.GetCurrentProcess()
tmp = win32api.DuplicateHandle(currentPid, self.hStdoutR, currentPid,
0, 0, win32con.DUPLICATE_SAME_ACCESS)
win32file.CloseHandle(self.hStdoutR)
self.hStdoutR = tmp
tmp = win32api.DuplicateHandle(currentPid, self.hStderrR, currentPid,
0, 0, win32con.DUPLICATE_SAME_ACCESS)
win32file.CloseHandle(self.hStderrR)
self.hStderrR = tmp
tmp = win32api.DuplicateHandle(currentPid, self.hStdinW, currentPid, 0,
0, win32con.DUPLICATE_SAME_ACCESS)
win32file.CloseHandle(self.hStdinW)
self.hStdinW = tmp
# Add the specified environment to the current environment - this is
# necessary because certain operations are only supported on Windows
# if certain environment variables are present.
env = os.environ.copy()
env.update(environment or {})
env = {
os.fsdecode(key): os.fsdecode(value)
for key, value in env.items()
}
# Make sure all the arguments are Unicode.
args = [os.fsdecode(x) for x in args]
cmdline = quoteArguments(args)
# The command, too, needs to be Unicode, if it is a value.
command = os.fsdecode(command) if command else command
path = os.fsdecode(path) if path else path
# TODO: error detection here. See #2787 and #4184.
def doCreate():
flags = win32con.CREATE_NO_WINDOW
self.hProcess, self.hThread, self.pid, dwTid = win32process.CreateProcess(
command, cmdline, None, None, 1, flags, env, path, StartupInfo)
try:
doCreate()
except pywintypes.error as pwte:
if not _invalidWin32App(pwte):
# This behavior isn't _really_ documented, but let's make it
# consistent with the behavior that is documented.
raise OSError(pwte)
else:
# look for a shebang line. Insert the original 'command'
# (actually a script) into the new arguments list.
sheb = _findShebang(command)
if sheb is None:
raise OSError("%r is neither a Windows executable, "
"nor a script with a shebang line" % command)
else:
args = list(args)
args.insert(0, command)
cmdline = quoteArguments(args)
origcmd = command
command = sheb
try:
# Let's try again.
doCreate()
except pywintypes.error as pwte2:
# d'oh, failed again!
if _invalidWin32App(pwte2):
raise OSError("%r has an invalid shebang line: "
"%r is not a valid executable" %
(origcmd, sheb))
raise OSError(pwte2)
# close handles which only the child will use
win32file.CloseHandle(hStderrW)
win32file.CloseHandle(hStdoutW)
win32file.CloseHandle(hStdinR)
# set up everything
self.stdout = _pollingfile._PollableReadPipe(
self.hStdoutR,
lambda data: self.proto.childDataReceived(1, data),
self.outConnectionLost,
)
self.stderr = _pollingfile._PollableReadPipe(
self.hStderrR,
lambda data: self.proto.childDataReceived(2, data),
self.errConnectionLost,
)
self.stdin = _pollingfile._PollableWritePipe(self.hStdinW,
self.inConnectionLost)
for pipewatcher in self.stdout, self.stderr, self.stdin:
self._addPollableResource(pipewatcher)
# notify protocol
self.proto.makeConnection(self)
self._addPollableResource(_Reaper(self))
def mClose(self):
if self._oFd:
win32file.CloseHandle(self._oFd)
self._oFd = 0
import win32file as w #use windows API
print("Starting")
# Open Driver as a File Device
hdevice = w.CreateFile("\\\\.\\ReadWrite", 0x80000000 | 0x40000000, 0, None, 3,
0x00000080, None)
w.WriteFile(hdevice, "Hello", None)
tam, string = w.ReadFile(hdevice, 200, None)
print(string)
w.CloseHandle(hdevice)
# Tested on Python 3.4
import win32file
import pywintypes
GENERIC_WRITE = 0x40000000
OPEN_EXISTING = 3
FILE_WRITE_ACCESS = 0x0002
FILE_SHARE_WRITE = 0x00000002
FILE_ATTRIBUTE_NORMAL = 0x00000080
METHOD_BUFFERED = 0
FILE_DEVICE_PROCMON_LOG = 0x00009535
PROCMON_DEBUGGER_HANDLER = r"\\.\Global\ProcmonDebugLogger"
IOCTL_EXTERNAL_LOG_DEBUGOUT = 2503311876 # Why: https://github.com/zippy1981/ProcMon.LINQpad/blob/master/ProcMonDebugOutput.linq
msg = bytes("Hello ProcMon from python with pywin32!", 'UTF-16')
msgLen = len(msg)
handle = win32file.CreateFile(PROCMON_DEBUGGER_HANDLER, GENERIC_WRITE,
FILE_SHARE_WRITE, None, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, 0)
if handle == -1: raise RuntimeWarning("ProcMon doesn't appear to be running")
else:
try:
win32file.DeviceIoControl(handle, IOCTL_EXTERNAL_LOG_DEBUGOUT, msg,
None)
except pywintypes.error as e:
if (e.winerror != 87):
raise # Error 87 means ProcMon simply isn't running
win32file.CloseHandle(handle)
def GetDeviceDescriptions():
"""
gets inforamtions about the available HID as a list of DeviceDescription objects
"""
deviceList = []
#dll references
setupapiDLL = ctypes.windll.setupapi
hidDLL = ctypes.windll.hid
#prepare Interfacedata
interfaceInfo = SP_DEVICE_INTERFACE_DATA()
interfaceInfo.cbSize = sizeof(interfaceInfo)
#prepare InterfaceDetailData Structure
interfaceDetailData = SP_DEVICE_INTERFACE_DETAIL_DATA_A()
interfaceDetailData.cbSize = 5
#prepare HIDD_ATTRIBUTES
hiddAttributes = HIDD_ATTRIBUTES()
hiddAttributes.cbSize = sizeof(hiddAttributes)
#get guid for HID device class
g = GUID()
hidDLL.HidD_GetHidGuid(byref(g))
#get handle to the device information set
hinfo = setupapiDLL.SetupDiGetClassDevsA(
byref(g), None, None, DIGCF_PRESENT + DIGCF_DEVICEINTERFACE)
#enumerate devices
i = 0
while setupapiDLL.SetupDiEnumDeviceInterfaces(hinfo, None, byref(g), i,
byref(interfaceInfo)):
i += 1
#get the required size
requiredSize = c_ulong()
setupapiDLL.SetupDiGetDeviceInterfaceDetailA(hinfo,
byref(interfaceInfo),
None, 0,
byref(requiredSize), None)
if requiredSize.value > 250:
eg.PrintError(Text.errorRetrieval)
continue #prevent a buffer overflow
#get the actual info
setupapiDLL.SetupDiGetDeviceInterfaceDetailA(
hinfo, byref(interfaceInfo), byref(interfaceDetailData),
requiredSize, pointer(requiredSize), None)
devicePath = interfaceDetailData.DevicePath
#get handle to HID device
try:
hidHandle = win32file.CreateFile(
devicePath, win32con.GENERIC_READ | win32con.GENERIC_WRITE,
win32con.FILE_SHARE_READ | win32con.FILE_SHARE_WRITE, None,
win32con.OPEN_EXISTING, 0, 0)
#skipping devices which cannot be opened
#(e.g. mice & keyboards, which are opened exclusively by OS)
if int(hidHandle) <= 0:
continue
except:
continue
#getting additional info
hidDLL.HidD_GetAttributes(int(hidHandle), byref(hiddAttributes))
#prepare string buffer for device info strings
hidpStringType = c_wchar * 128
infoStr = hidpStringType()
#getting manufacturer
result = hidDLL.HidD_GetManufacturerString(int(hidHandle),
byref(infoStr),
ctypes.sizeof(infoStr))
if not result or len(infoStr.value) == 0:
#build a generic ManufacturerString with the vendor ID
vendorString = Text.vendorID + str(hiddAttributes.VendorID)
else:
vendorString = infoStr.value
#getting device name
result = hidDLL.HidD_GetProductString(int(hidHandle), byref(infoStr),
ctypes.sizeof(infoStr))
if not result or len(infoStr.value) == 0:
#getting product name via registry
devicePathSplit = devicePath[4:].split("#")
regHandle = _winreg.OpenKey(
_winreg.HKEY_LOCAL_MACHINE,
"SYSTEM\\CurrentControlSet\\Enum\\" + devicePathSplit[0] +
"\\" + devicePathSplit[1] + "\\" + devicePathSplit[2])
productString, regType = _winreg.QueryValueEx(
regHandle, "DeviceDesc")
_winreg.CloseKey(regHandle)
else:
productString = infoStr.value
#close handle
win32file.CloseHandle(hidHandle)
#create object with all the infos
device = DeviceDescription(devicePath, hiddAttributes.VendorID,
vendorString, hiddAttributes.ProductID,
productString, hiddAttributes.VersionNumber)
#add device to internal list
deviceList.append(device)
#end loop
#destroy deviceinfolist
setupapiDLL.SetupDiDestroyDeviceInfoList(hinfo)
return deviceList
def closePipe(self):
win32file.CloseHandle(self.pipe_handle)
def close_handles(self):
import win32file
for h in itervalues(self.handle_map):
win32file.CloseHandle(h)
self.handle_map = {}
def close(self):
if self.handle is not None:
win32file.CancelIo(self.handle)
win32file.CloseHandle(self.handle)
if self.event is not None:
win32file.CloseHandle(self.event)
