def get_device_path(h_info, interface_data, ptr_info_data = None): """"Returns Hardware device path Parameters: h_info, interface set info handler interface_data, device interface enumeration data ptr_info_data, pointer to SP_DEVINFO_DATA() instance to receive details """ required_size = c_ulong(0) dev_inter_detail_data = SP_DEVICE_INTERFACE_DETAIL_DATA() dev_inter_detail_data.cb_size = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) # get actual storage requirement SetupDiGetDeviceInterfaceDetail(h_info, byref(interface_data), None, 0, byref(required_size), None) ctypes.resize(dev_inter_detail_data, required_size.value) # read value SetupDiGetDeviceInterfaceDetail(h_info, byref(interface_data), byref(dev_inter_detail_data), required_size, None, ptr_info_data) # extract string only return dev_inter_detail_data.get_string()
def byteslike(*pos, **kw): """Create a bytes-like object having no string or sequence methods""" data = bytes(*pos, **kw) obj = EmptyStruct() ctypes.resize(obj, len(data)) memoryview(obj).cast("B")[:] = data return obj
def recv(self): """ Receive a request message from the client """ msgdata = (c_ubyte * NORM_MSG_SIZE)() msg = mempair(p9msg, msgdata) (baddr, blen) = msg.databuf() l = libc.recv(self.__clsock, baddr, blen, 0) hdr = msg.car() if l > sizeof(hdr): if hdr.size > l: if hdr.size > MAX_MSG_SIZE: raise IOError("The message is too large: %d bytes" % hdr.size) resize(msgdata, hdr.size) (baddr, blen) = msg.databuf() l2 = libc.recv(self.__clsock, baddr + hdr.size - l, blen - l, 0) if l2 > 0: l += l2 else: raise IOError("Unable to read the %d remaining bytes" % blen - l) else: raise IOError("Unable to read the message") return (l, msg)
def _set_unicode_buffer(self, value): cls = type(self) wchar_size = ctypes.sizeof(WCHAR) bufsize = (len(value) + 1) * wchar_size ctypes.resize(self, ctypes.sizeof(cls) + bufsize) addr = ctypes.addressof(self) + ctypes.sizeof(cls) ctypes.memmove(addr, value, bufsize)
def get_token_obj(self): token_addr = 0 handle_info = SYSTEM_HANDLE_INFORMATION_EX() length = ctypes.c_ulong() while True: status = NtQuerySystemInformation(SystemHandleInformationEx, ctypes.byref(handle_info), ctypes.sizeof(handle_info), ctypes.byref(length)) if status != STATUS_INFO_LENGTH_MISMATCH: break ctypes.resize(handle_info, length.value) if status < 0: raise WinErrorFromNtStatus(status) if status == 0: pid = GetCurrentProcessId() token = wintypes.HANDLE(0) curproc = wintypes.HANDLE(GetCurrentProcess()) success = OpenProcessToken(curproc, TOKEN_ALL_ACCESS, ctypes.byref(token)) if success: for i in range(handle_info.NumberOfHandles): if pid == handle_info.Handles[i].UniqueProcessId: h = handle_info.Handles[i] if (token.value == h.Handle or CompareObjectHandles(token, h.Handle)): token_addr = h.Object break CloseHandle(token) return token_addr
def __init__(self, connectKey , platforms): super(AS2PSConnectCommand,self).__init__(eCommand_Main_Connect,eCommand_Sub_Connect_Req) self.nConnectKey = connectKey self.nPlatformCount = sizeof(platforms) / sizeof(TPlatformContext) if self.nPlatformCount > 0: resize(self,sizeof(self) + sizeof(TPlatformContext) * self.nPlatformCount) memmove(addressof(self) + sizeof(self.__class__),platforms,sizeof(platforms))
def list_usb_devices(self, **kwargs): self.device_paths = [] value = 0x00000000 try: if kwargs["default"] == True: value |= DIGCF_DEFAULT if kwargs["present"] == True: value |= DIGCF_PRESENT if kwargs["allclasses"] == True: value |= DIGCF_ALLCLASSES if kwargs["profile"] == True: value |= DIGCF_PROFILE if kwargs["deviceinterface"] == True: value |= DIGCF_DEVICE_INTERFACE except KeyError: if value == 0x00000000: value = 0x00000010 pass flags = DWORD(value) self.handle = self.api.exec_function_setupapi(SetupDiGetClassDevs, byref(self.guid), None, None, flags) sp_device_interface_data = SpDeviceInterfaceData() sp_device_interface_data.cb_size = sizeof(sp_device_interface_data) sp_device_interface_detail_data = SpDeviceInterfaceDetailData() sp_device_info_data = SpDevinfoData() sp_device_info_data.cb_size = sizeof(sp_device_info_data) i = 0 required_size = c_ulong(0) member_index = DWORD(i) while self.api.exec_function_setupapi(SetupDiEnumDeviceInterfaces, self.handle, None, byref(self.guid), member_index, byref(sp_device_interface_data)): self.api.exec_function_setupapi(SetupDiGetDeviceInterfaceDetail, self.handle, byref(sp_device_interface_data), None, 0, byref(required_size), None) resize(sp_device_interface_detail_data, required_size.value) sp_device_interface_detail_data.cb_size = sizeof( SpDeviceInterfaceDetailData) - sizeof(WCHAR * 1) if self.api.exec_function_setupapi( SetupDiGetDeviceInterfaceDetail, self.handle, byref(sp_device_interface_data), byref(sp_device_interface_detail_data), required_size, byref(required_size), byref(sp_device_info_data)): path = wstring_at( byref(sp_device_interface_detail_data, sizeof(DWORD))) self.device_paths.append(path) i += 1 member_index = DWORD(i) required_size = c_ulong(0) resize(sp_device_interface_detail_data, sizeof(SpDeviceInterfaceDetailData)) return len(self.device_paths) > 0
def resizeArray(array, new_size): resize(array, sizeof(array._type_)*new_size) newarray = (array._type_*new_size).from_address(addressof(array)) if hasattr(array,"original"): newarray.original = array.original else: newarray.original = array return newarray
def copyImage(byte_array, imageSize): if imageSize > 8: ctypes.resize(byte_array, imageSize) image = [] for i in range(imageSize): image.append(byte_array[i]) return array.array('B', image).tostring() return byte_array
def len(self, value): rsize = self._extra_end + value if ctypes.sizeof(self) < rsize: try: ctypes.resize(self, rsize) except ValueError: raise ValueError("Need %s more space" % (rsize - ctypes.sizeof(self))) self._len = self._extra_size + value
def resize_array(array, size): """ extends array with given size :param array: ctypes array :param int size: new size (should be more than current size) :return: pointer on new array """ resize(array, sizeof(array._type_) * size) return (array._type_ * size).from_address(addressof(array))
def _set_unicode_buffer(self, values): cls = type(self) wchar_size = ctypes.sizeof(WCHAR) bufsize = (len('\x00'.join(values)) + 1) * wchar_size ctypes.resize(self, ctypes.sizeof(cls) + bufsize) addr = ctypes.addressof(self) + ctypes.sizeof(cls) for value in values: bufsize = (len(value) + 1) * wchar_size ctypes.memmove(addr, value, bufsize) addr += bufsize
def _get_info(self, information_type_guid, info): self._check_closed() guid = GUID(information_type_guid) size = ctypes.c_ulong() status = call(self.file_protocol.GetInfo, ctypes.addressof(self.file_protocol), ctypes.addressof(guid), ctypes.addressof(size), 0) if status != EFI_BUFFER_TOO_SMALL: check_status(status) ctypes.resize(info, size.value) check_status(call(self.file_protocol.GetInfo, ctypes.addressof(self.file_protocol), ctypes.addressof(guid), ctypes.addressof(size), ctypes.addressof(info))) return info
def __init__(self, trace, data, dataquality): """ The init function requires a ObsPy Trace object which will be used to fill self.mstg. """ # Initialize MSTraceGroup mstg = clibmseed.mst_initgroup(None) self.mstg = mstg # Set numtraces. mstg.contents.numtraces = 1 # Initialize MSTrace object and connect with group mstg.contents.traces = clibmseed.mst_init(None) chain = mstg.contents.traces # Figure out the datatypes. sampletype = SAMPLETYPE[data.dtype.type] c_dtype = DATATYPES[sampletype] # Set the header values. chain.contents.network = trace.stats.network chain.contents.station = trace.stats.station chain.contents.location = trace.stats.location chain.contents.channel = trace.stats.channel chain.contents.dataquality = dataquality chain.contents.type = '\x00' chain.contents.starttime = \ util._convertDatetimeToMSTime(trace.stats.starttime) chain.contents.endtime = \ util._convertDatetimeToMSTime(trace.stats.endtime) chain.contents.samprate = trace.stats.sampling_rate chain.contents.samplecnt = trace.stats.npts chain.contents.numsamples = trace.stats.npts chain.contents.sampletype = sampletype # Create a single datapoint and resize its memory to be able to # hold all datapoints. tempdatpoint = c_dtype() datasize = SAMPLESIZES[sampletype] * trace.stats.npts # XXX: Ugly workaround for traces with less than 17 data points if datasize < 17: datasize = 17 C.resize(tempdatpoint, datasize) # The datapoints in the MSTG structure are a pointer to the memory # area reserved for tempdatpoint. chain.contents.datasamples = C.cast(C.pointer(tempdatpoint), C.c_void_p) # Swap if wrong byte order because libmseed expects native byteorder. if data.dtype.byteorder != "=": data = data.byteswap() # Pointer to the NumPy data buffer. datptr = data.ctypes.get_data() # Manually move the contents of the NumPy data buffer to the # address of the previously created memory area. C.memmove(chain.contents.datasamples, datptr, datasize)
def save(self, fn): """ Serializes the dictionary to file [fn]. Args: fn: The filename of the file. """ resize(self._data, self._header.n_nodes * sizeof(Node)) fp = open(fn, "wb") fp.write(self._header) fp.write(self._data) fp.close()
def from_address_copy(cls, address, size=None): x = ctypes.Structure.__new__(cls) if size is not None: ctypes.resize(x, size) ctypes.memmove(ctypes.byref(x), address, ctypes.sizeof(x)) delta = ctypes.addressof(x) - address for n in cls._string_names_: ustr = getattr(x, '_{}'.format(n)) addr = ctypes.c_void_p.from_buffer(ustr.Buffer) if addr: addr.value += delta return x
def get_handles(): info = SYSTEM_HANDLE_INFORMATION_EX() length = wintypes.ULONG() while True: status = ntdll.NtQuerySystemInformation( SystemExtendedHandleInformation, ctypes.byref(info), ctypes.sizeof(info), ctypes.byref(length)) if status != STATUS_INFO_LENGTH_MISMATCH: break ctypes.resize(info, length.value) if status < 0: raise ctypes.WinError(ntdll.RtlNtStatusToDosError(status)) return info.Handles
def create_notification_struct(self, payload): # type: (bytes) -> structs.SAdsNotificationHeader buf = b"\x00" * 12 # hNotification, nTimeStamp buf += struct.pack("<i", len(payload)) buf += payload notification = structs.SAdsNotificationHeader() resize(notification, len(buf)) memmove( pointer(notification), (ctypes.c_ubyte * len(buf)).from_buffer_copy(buf), sizeof(notification), ) return notification
def get_variable(name, guid): attribute = ctypes.c_uint32(0) data = ctypes.create_string_buffer(1) size = ctypes.c_ulong(ctypes.sizeof(data)) while True: status = call(system_table.RuntimeServices.contents.GetVariable, ctypes.addressof(name), ctypes.addressof(guid), ctypes.addressof(attribute), ctypes.addressof(size), ctypes.addressof(data)) if status == EFI_NOT_FOUND: break if status == EFI_BUFFER_TOO_SMALL: ctypes.resize(data, size.value) continue check_status(status) return data, attribute.value, size.value
def read(self, size=-1): self._check_closed() if size < 0: try: size = self.file_info.FileSize - self.tell() except EFIException as e: size = self.file_info.FileSize size = ctypes.c_ulong(size) buf = ctypes.create_string_buffer(0) ctypes.resize(buf, size.value) check_status(call(self.file_protocol.Read, ctypes.addressof(self.file_protocol), ctypes.addressof(size), ctypes.addressof(buf))) if size.value != ctypes.sizeof(buf): ctypes.resize(buf, size.value) return buf.raw
def get_all_dev_interface(ClassGuid, Enumerator, Flags, search_interface=GUID_INTERFACE_USB_DEVICE): if not Flags & DIGCF_DEVICEINTERFACE: raise ValueError, "The DIGCF_DEVICEINTERFACE flag is required here." devinfo = GetClassDevs(ClassGuid, Enumerator, 0, Flags) if devinfo == INVALID_HANDLE_VALUE: raise RuntimeError, format_err() m = 0 dinter = SP_DEVICE_INTERFACE_DATA() dinter.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA) bufsize = DWORD() res = [] while True: if not EnumDeviceInterfaces(devinfo, None, search_interface, m, dinter): err = get_last_error() if err != ERROR_NO_MORE_ITEMS: DestroyDeviceInfoList(devinfo) raise RuntimeError, 'EnumDeviceInterface ' + format_err( err) break # Find required bufsize GetDeviceInterfaceDetail(devinfo, dinter, None, 0, bufsize, None) if USE_RESIZE: detail = SP_DEVICE_INTERFACE_DETAIL_DATA() resize(detail, bufsize.value) detailp = byref(detail) else: detail = detail_gen(bufsize.value) # cast is needed because GetDeviceInterfaceDetail is defined to require # POINTER(SP_DEVICE_INTERFACE_DETAIL_DATA) # Instead of a cast the object could also be a subclass detailp = cast(pointer(detail), POINTER(SP_DEVICE_INTERFACE_DETAIL_DATA)) detail.cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) # Note that the last argument could be used to have the SP_DEVINFO_DATA # reference of this entry that can be used with GetDeviceInstanceId if not GetDeviceInterfaceDetail(devinfo, dinter, detailp, sizeof(detail), None, None): DestroyDeviceInfoList(devinfo) raise RuntimeError, 'GetDeviceInterfaceDetail ' + format_err() if USE_RESIZE: res.append(detail.get_string()) else: res.append(detail.DevicePath) m += 1 DestroyDeviceInfoList(devinfo) return res
def create_notification_struct(payload: bytes) -> \ structs.SAdsNotificationHeader: """Create notification callback structure""" buf = b"\x00" * 12 # hNotification, nTimeStamp buf += struct.pack("<i", len(payload)) buf += payload notification = structs.SAdsNotificationHeader() resize(notification, len(buf)) memmove( pointer(notification), (ctypes.c_ubyte * len(buf)).from_buffer_copy(buf), sizeof(notification), ) return notification
def load(fp, mutable: bool = True, value_encoding=None, value_errors=None): """Deserialize a BSER-encoded blob. @param fp: The file-object to deserialize. @type file: @param mutable: Whether to return mutable results. @type mutable: bool @param value_encoding: Optional codec to use to decode values. If unspecified or None, return values as bytestrings. @type value_encoding: str @param value_errors: Optional error handler for codec. 'strict' by default. The other most common argument is 'surrogateescape' on Python 3. If value_encoding is None, this is ignored. @type value_errors: str """ buf = ctypes.create_string_buffer(8192) SNIFF_BUFFER_SIZE = len(EMPTY_HEADER) # pyre-fixme[16]: `int` has no attribute `from_buffer`. # pyre-fixme[58]: `*` is not supported for operand types `Type[ctypes.c_char]` # and `int`. header = (ctypes.c_char * SNIFF_BUFFER_SIZE).from_buffer(buf) read_len = _read_bytes(fp, header) if read_len < len(header): return None # pyre-fixme[16]: Module `pywatchman` has no attribute `bser`. total_len = bser.pdu_len(buf) if total_len > len(buf): ctypes.resize(buf, total_len) # pyre-fixme[58]: `*` is not supported for operand types `Type[ctypes.c_char]` # and `Any`. body = (ctypes.c_char * (total_len - len(header))).from_buffer(buf, len(header)) read_len = _read_bytes(fp, body) if read_len < len(body): raise RuntimeError("bser data ended early") # pyre-fixme[16]: Module `pywatchman` has no attribute `bser`. return bser.loads( # pyre-fixme[58]: `*` is not supported for operand types # `Type[ctypes.c_char]` and `Any`. (ctypes.c_char * total_len).from_buffer(buf, 0), mutable, value_encoding, value_errors, )
def print_variables(): name = ctypes.create_unicode_buffer("") size = ctypes.c_ulong(ctypes.sizeof(name)) guid = GUID() while True: status = call(system_table.RuntimeServices.contents.GetNextVariableName, ctypes.addressof(size), ctypes.addressof(name), ctypes.addressof(guid)) if status == EFI_NOT_FOUND: break if status == EFI_BUFFER_TOO_SMALL: ctypes.resize(name, size.value) continue check_status(status) print name.value, guid data, attributes, data_size = get_variable(name, guid) print "attributes={:#x} size={} data:".format(attributes, data_size) print bits.dumpmem(data.raw)
def GetDevicePaths(uuid, db, field, cid): guid = parse_uuid(uuid) hdi = SAPI.SetupDiGetClassDevsW(byref(guid), None, None, DIGCF_DEVINTERFACE | DIGCF_PRESENT) dd = SP_DEVINFO_DATA(sizeof(SP_DEVINFO_DATA)) did = SP_DEVICE_INTERFACE_DATA(sizeof(SP_DEVICE_INTERFACE_DATA)) i = 0 while SAPI.SetupDiEnumDeviceInterfaces(hdi, None, byref(guid), i, byref(did)): i += 1 size = DWORD(0) SAPI.SetupDiGetDeviceInterfaceDetailW(hdi, byref(did), None, 0, byref(size), 0) didd = PSP_DEVICE_INTERFACE_DETAIL_DATA() resize(didd, size.value) didd.cbSize = sizeof(PSP_DEVICE_INTERFACE_DETAIL_DATA) - sizeof(WCHAR * 1) SAPI.SetupDiGetDeviceInterfaceDetailW(hdi, byref(did), byref(didd), size, byref(size), byref(dd)) path = wstring_at(byref(didd, sizeof(DWORD))) db = DeviceConnect(path, db, field, cid) return db
def _increase_mem(self): """ Doubles the size of the node array. The size must be increased on the _data member, since this ctype object owns the memory. """ s_bytes = self._buf_nodes * sizeof(Node) if s_bytes != sizeof(self._data): raise ValueError("Internal Error!") resize(self._data, s_bytes*2) memset(byref(self._data, s_bytes), 0, s_bytes) self._buf_nodes *= 2 # Renew the pointer since the arrays' memory # might have been moved. self._p = TrieDict._P(self._data)
def get_all_dev_interface(ClassGuid, Enumerator, Flags, search_interface=GUID_INTERFACE_USB_DEVICE): if not Flags & DIGCF_DEVICEINTERFACE: raise ValueError, "The DIGCF_DEVICEINTERFACE flag is required here." devinfo = GetClassDevs(ClassGuid, Enumerator, 0, Flags) if devinfo == INVALID_HANDLE_VALUE: raise RuntimeError, format_err() m=0 dinter = SP_DEVICE_INTERFACE_DATA() dinter.cbSize = sizeof(SP_DEVICE_INTERFACE_DATA) bufsize = DWORD() res = [] while True: if not EnumDeviceInterfaces(devinfo, None, search_interface, m, dinter): err = get_last_error() if err != ERROR_NO_MORE_ITEMS: DestroyDeviceInfoList(devinfo) raise RuntimeError, 'EnumDeviceInterface '+format_err(err) break # Find required bufsize GetDeviceInterfaceDetail(devinfo, dinter, None, 0, bufsize, None) if USE_RESIZE: detail = SP_DEVICE_INTERFACE_DETAIL_DATA() resize(detail, bufsize.value) detailp = byref(detail) else: detail = detail_gen(bufsize.value) # cast is needed because GetDeviceInterfaceDetail is defined to require # POINTER(SP_DEVICE_INTERFACE_DETAIL_DATA) # Instead of a cast the object could also be a subclass detailp = cast(pointer(detail), POINTER(SP_DEVICE_INTERFACE_DETAIL_DATA)) detail.cbSize = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) # Note that the last argument could be used to have the SP_DEVINFO_DATA # reference of this entry that can be used with GetDeviceInstanceId if not GetDeviceInterfaceDetail(devinfo, dinter, detailp, sizeof(detail), None, None): DestroyDeviceInfoList(devinfo) raise RuntimeError, 'GetDeviceInterfaceDetail '+format_err() if USE_RESIZE: res.append(detail.get_string()) else: res.append(detail.DevicePath) m += 1 DestroyDeviceInfoList(devinfo) return res
def list_usb_devices(self, **kwargs): self.device_paths = [] value = 0x00000000 try: if kwargs["default"] == True: value |= DIGCF_DEFAULT if kwargs["present"] == True: value |= DIGCF_PRESENT if kwargs["allclasses"] == True: value |= DIGCF_ALLCLASSES if kwargs["profile"] == True: value |= DIGCF_PROFILE if kwargs["deviceinterface"] == True: value |= DIGCF_DEVICE_INTERFACE except KeyError: if value == 0x00000000: value = 0x00000010 pass flags = DWORD(value) self.handle = self.api.exec_function_setupapi(SetupDiGetClassDevs, byref(self.guid), None, None, flags) sp_device_interface_data = SpDeviceInterfaceData() sp_device_interface_data.cb_size = sizeof(sp_device_interface_data) sp_device_interface_detail_data = SpDeviceInterfaceDetailData() sp_device_info_data = SpDevinfoData() sp_device_info_data.cb_size = sizeof(sp_device_info_data) i = 0 required_size = c_ulong(0) member_index = DWORD(i) while self.api.exec_function_setupapi(SetupDiEnumDeviceInterfaces , self.handle, None, byref(self.guid), member_index, byref(sp_device_interface_data)): self.api.exec_function_setupapi(SetupDiGetDeviceInterfaceDetail, self.handle, byref(sp_device_interface_data), None, 0, byref(required_size), None) resize(sp_device_interface_detail_data, required_size.value) sp_device_interface_detail_data.cb_size = sizeof(SpDeviceInterfaceDetailData) - sizeof(WCHAR * 1) if self.api.exec_function_setupapi(SetupDiGetDeviceInterfaceDetail, self.handle, byref(sp_device_interface_data), byref(sp_device_interface_detail_data), required_size, byref(required_size), byref(sp_device_info_data)): path = wstring_at(byref(sp_device_interface_detail_data, sizeof(DWORD))) self.device_paths.append(path) i += 1 member_index = DWORD(i) required_size = c_ulong(0) resize(sp_device_interface_detail_data, sizeof(SpDeviceInterfaceDetailData)) return len(self.device_paths) > 0
def _ensure_free(self, bytes_in_buf, min_bytes_free): buf_size = self._buf_size bytes_free = buf_size - bytes_in_buf if bytes_free < min_bytes_free: bytes_needed = min_bytes_free - bytes_free new_buf_size = max(buf_size * 2, buf_size + bytes_needed) if new_buf_size > self.MAX_BUFFER_SIZE: raise Exception("%r exceeds max buffer size %r" % (new_buf_size, self.MAX_BUFFER_SIZE)) orig_buf = self._orig_buf ctypes.resize(orig_buf, new_buf_size) new_buf_type = ctypes.c_char * new_buf_size buf_address = ctypes.addressof(orig_buf) self._buf = buf = new_buf_type.from_address(buf_address) self._view = view = memoryview(buf) self._buf_size = new_buf_size else: view = self._view # Return view as a convenience. return view
def handlepacket(p): global N, img_list, imgvalue_list, img_map if p.haslayer(Raw): # 找出有上网数据的 load = p.load ack = p.ack try: ## 如果为图片相应,且带有HTTP头(即第一个图片TCP包) if 'Content-Type: image' in str(load): # 如果为图片响应 postfix = re.findall('image/(.*?)\\\\r', str(load))[0] # 图片后缀 length = int( re.findall('Content-Length: (.*?)\\\\r', str(load))[0]) # 图片数据长度 ip_src = p['IP'].src # 源头IP ip_dst = p['IP'].dst # 目的IP img_list[ack] = [(postfix, length, ip_src, ip_dst) ] # 0为图片信息(以下为图片二进制数据) img_load = load[load.find(b'\x0d\x0a\x0d\x0a') + 4:] # 去除请求头部分,只要图片数据 img_list[ack].append(img_load) ## 如果为某图片的后续数据包 elif ack in list(img_list.keys()): img_load = load # 所有load均为图片数据 img_list[ack].append(img_load) img = bytes() postfix = img_list[ack][0][0] # 图片后缀 length = img_list[ack][0][1] # 图片长度 ip_src = img_list[ack][0][2] # 源头IP ip_dst = img_list[ack][0][3] # 目的IP for i in img_list[ack][1:]: img += i if len(img) == length: # 如果图片数据已经完整 imgname = '%d.%s' % (N, img_map[postfix]) with open('./images/%s/%s' % (target, imgname), 'wb') as f: f.write(img) img = Image.open(BytesIO(img)) img = resize(200, 200, img) img_tk = ImageTk.PhotoImage(img) imgvalue_list.append(img_tk) Label(frame, image=imgvalue_list[-1], bg='black').grid(row=(N - 1) // 4, column=(N - 1) % 4, padx=23, pady=3) canvas.create_window((ww / 2, math.ceil(N / 4) * 105), window=frame) #create_window canvas['scrollregion'] = (0, 0, ww, math.ceil(N / 4) * 210) canvas.yview_moveto(1) print('%s【driftnet】: saving image data as "%s"' % (time.strftime("%Y-%m-%d %H:%M:%S", time.localtime()), imgname)) N += 1 except: pass
def load(fp, mutable=True, value_encoding=None, value_errors=None): """Deserialize a BSER-encoded blob. @param fp: The file-object to deserialize. @type file: @param mutable: Whether to return mutable results. @type mutable: bool @param value_encoding: Optional codec to use to decode values. If unspecified or None, return values as bytestrings. @type value_encoding: str @param value_errors: Optional error handler for codec. 'strict' by default. The other most common argument is 'surrogateescape' on Python 3. If value_encoding is None, this is ignored. @type value_errors: str """ buf = ctypes.create_string_buffer(8192) SNIFF_BUFFER_SIZE = len(EMPTY_HEADER) header = (ctypes.c_char * SNIFF_BUFFER_SIZE).from_buffer(buf) read_len = _read_bytes(fp, header) if read_len < len(header): return None total_len = bser.pdu_len(buf) if total_len > len(buf): ctypes.resize(buf, total_len) body = (ctypes.c_char * (total_len - len(header))).from_buffer( buf, len(header)) read_len = _read_bytes(fp, body) if read_len < len(body): raise RuntimeError("bser data ended early") return bser.loads( (ctypes.c_char * total_len).from_buffer(buf, 0), mutable, value_encoding, value_errors, )
def load(fp, mutable=True): """Deserialize bser from a file-like object""" buf = ctypes.create_string_buffer(8192) # 2 bytes marker, 1 byte int size, up to 8 bytes int64 value SNIFF_BUFFER_SIZE = 13 header = (ctypes.c_char * SNIFF_BUFFER_SIZE).from_buffer(buf) num_bytes = _read_bytes(fp, header) if num_bytes < SNIFF_BUFFER_SIZE: return None expected_len, pos = _pdu_info_helper(header) total_len = expected_len + pos if len(buf) < total_len: ctypes.resize(buf, total_len) body = (ctypes.c_char * (total_len - len(header))).from_buffer(buf, len(header)) num_bytes = _read_bytes(fp, body) if num_bytes < (total_len - len(header)): raise RuntimeError('bser data ended early') return _bser_loads_recursive(buf, pos, mutable)[0]
def load(fp, mutable=True, value_encoding=None, value_errors=None): """Deserialize a BSER-encoded blob. @param fp: The file-object to deserialize. @type file: @param mutable: Whether to return mutable results. @type mutable: bool @param value_encoding: Optional codec to use to decode values. If unspecified or None, return values as bytestrings. @type value_encoding: str @param value_errors: Optional error handler for codec. 'strict' by default. The other most common argument is 'surrogateescape' on Python 3. If value_encoding is None, this is ignored. @type value_errors: str """ buf = ctypes.create_string_buffer(8192) SNIFF_BUFFER_SIZE = len(EMPTY_HEADER) header = (ctypes.c_char * SNIFF_BUFFER_SIZE).from_buffer(buf) read_len = _read_bytes(fp, header) if read_len < len(header): return None total_len = bser.pdu_len(buf) if total_len > len(buf): ctypes.resize(buf, total_len) body = (ctypes.c_char * (total_len - len(header))).from_buffer(buf, len(header)) read_len = _read_bytes(fp, body) if read_len < len(body): raise RuntimeError("bser data ended early") return bser.loads( (ctypes.c_char * total_len).from_buffer(buf, 0), mutable, value_encoding, value_errors, )
def load(fp, mutable=True): """Deserialize bser from a file-like object""" buf = ctypes.create_string_buffer(8192) # 2 bytes marker, 1 byte int size, up to 8 bytes int64 value SNIFF_BUFFER_SIZE = 13 header = (ctypes.c_char * SNIFF_BUFFER_SIZE).from_buffer(buf) num_bytes = _read_bytes(fp, header) if num_bytes < SNIFF_BUFFER_SIZE: return None expected_len, pos = _pdu_info_helper(header) total_len = expected_len + pos if len(buf) < total_len: ctypes.resize(buf, total_len) body = (ctypes.c_char * (total_len - len(header))).from_buffer( buf, len(header)) num_bytes = _read_bytes(fp, body) if num_bytes < (total_len - len(header)): raise RuntimeError('bser data ended early') return _bser_loads_recursive(buf, pos, mutable)[0]
def device_interface_guid_to_paths(guid): """Find the connected devices that match the provided GUID. :param guid: The deviceInterfaceGUID to match. :return: The list of path strings. """ paths = [] flags = DWORD(DIGCF_PRESENT | DIGCF_DEVICE_INTERFACE) guid = GUID(guid) handle = SetupDiGetClassDevs(byref(guid), None, None, flags) if handle is None: raise RuntimeError('SetupDiGetClassDevs invalid') sp_device_interface_data = SpDeviceInterfaceData() sp_device_info_data = SpDevinfoData() member_index = 0 while SetupDiEnumDeviceInterfaces(handle, None, byref(guid), DWORD(member_index), byref(sp_device_interface_data)): required_size = c_ulong(0) bResult = SetupDiGetDeviceInterfaceDetail( handle, byref(sp_device_interface_data), None, 0, byref(required_size), None) sp_device_interface_detail_data = SpDeviceInterfaceDetailData() resize(sp_device_interface_detail_data, required_size.value) sp_device_interface_detail_data.cb_size = sizeof( SpDeviceInterfaceDetailData) bResult = SetupDiGetDeviceInterfaceDetail( handle, byref(sp_device_interface_data), byref(sp_device_interface_detail_data), required_size, byref(required_size), byref(sp_device_info_data)) if bResult: path = wstring_at( byref(sp_device_interface_detail_data, sizeof(DWORD))) paths.append(path) member_index += 1 SetupDiDestroyDeviceInfoList(handle) return paths
def GetAllFeature(self, hCamera): """ Retrieve a camera setting using the feature id definitions. """ BufferSize = C.c_int(0) rc = self.__lib.PxLGetCameraFeatures( hCamera, PxLapi.FEATURE_ALL, None, C.byref(BufferSize)) if rc < 0: return (rc, 0) else: FeatureInfo = CAMERA_FEATURES() C.resize(FeatureInfo, BufferSize.value) rc = self.__lib.PxLGetCameraFeatures( hCamera, PxLapi.FEATURE_ALL, C.byref(FeatureInfo), C.byref(BufferSize)) if rc < 0: return (rc, 0) else: return rc, FeatureInfo
def _get_enhkey(self, flag): pCertCtx = pointer(self) enhkey = CERT_ENHKEY_USAGE() size = DWORD() res = CertGetEnhancedKeyUsage(pCertCtx, flag, None, pointer(size)) if res == 0: return self._enhkey_error() resize(enhkey, size.value) res = CertGetEnhancedKeyUsage(pCertCtx, flag, pointer(enhkey), pointer(size)) if res == 0: return self._enhkey_error() oids = set() for i in range(enhkey.cUsageIdentifier): oid = enhkey.rgpszUsageIdentifier[i] if oid: if PY3: oid = oid.decode("ascii") oids.add(oid) return oids
def recv(self): """ Receive a request message from the client """ msgdata = (c_ubyte * NORM_MSG_SIZE)() msg = mempair(p9msg, msgdata) (baddr, blen) = msg.databuf() l = libc.recv(self.__clsock, baddr, blen, 0) hdr = msg.car() if l > sizeof(hdr): if hdr.size > l: if hdr.size > MAX_MSG_SIZE: raise IOError ("The message is too large: %d bytes" % hdr.size) resize(msgdata, hdr.size) (baddr, blen) = msg.databuf() l2 = libc.recv(self.__clsock, baddr + hdr.size - l, blen - l, 0) if l2 > 0: l += l2 else: raise IOError ("Unable to read the %d remaining bytes" % blen - l) else: raise IOError ("Unable to read the message") return (l, msg)
def get_device_path(h_info, interface_data, ptr_info_data=None): """"Returns Hardware device path Parameters: h_info, interface set info handler interface_data, device interface enumeration data ptr_info_data, pointer to SP_DEVINFO_DATA() instance to receive details """ required_size = c_ulong(0) dev_inter_detail_data = SP_DEVICE_INTERFACE_DETAIL_DATA() dev_inter_detail_data.cb_size = sizeof(SP_DEVICE_INTERFACE_DETAIL_DATA) # get actual storage requirement SetupDiGetDeviceInterfaceDetail(h_info, byref(interface_data), None, 0, byref(required_size), None) ctypes.resize(dev_inter_detail_data, required_size.value) # read value SetupDiGetDeviceInterfaceDetail(h_info, byref(interface_data), byref(dev_inter_detail_data), required_size, None, ptr_info_data) # extract string only return dev_inter_detail_data.get_string()
def _set_name(self, name): b = ctypes.create_unicode_buffer(name) ctypes.resize(self, ctypes.sizeof(self.__class__) + ctypes.sizeof(b)) ctypes.memmove(ctypes.addressof(self) + ctypes.sizeof(self.__class__), ctypes.addressof(b), ctypes.sizeof(b)) self.Size = ctypes.sizeof(b)
def growTrie(): # Originally I wrote to disk then pulled it back because most methods to # extend C structured array requires having both the old and new array in # memory at once for some period of time, but since our columns are individual # arrays, we only require 28% of the RAM that doing it as a single array takes. # This is also why we extend SEQ first. global A global C global G global T global COUNT global SEQ if arrayKind == 'numpy': SEQ = numpy.concatenate((SEQ,numpy.zeros(10000000, dtype='int64'))) A = numpy.concatenate((A,numpy.zeros(10000000, dtype='uint32'))) C = numpy.concatenate((C,numpy.zeros(10000000, dtype='uint32'))) G = numpy.concatenate((G,numpy.zeros(10000000, dtype='uint32'))) T = numpy.concatenate((T,numpy.zeros(10000000, dtype='uint32'))) COUNT = numpy.concatenate((COUNT,numpy.zeros(10000000, dtype='uint32'))) elif arrayKind == 'ctypes': newSize = A._length_+10000000 ctypes.resize(SEQ, ctypes.sizeof(SEQ._type_)*newSize) SEQ = (SEQ._type_*newSize).from_address(ctypes.addressof(SEQ)) ctypes.resize(A, ctypes.sizeof(A._type_)*newSize) A = (A._type_*newSize).from_address(ctypes.addressof(A)) ctypes.resize(C, ctypes.sizeof(C._type_)*newSize) C = (C._type_*newSize).from_address(ctypes.addressof(C)) ctypes.resize(G, ctypes.sizeof(G._type_)*newSize) G = (A._type_*newSize).from_address(ctypes.addressof(G)) ctypes.resize(T, ctypes.sizeof(T._type_)*newSize) T = (A._type_*newSize).from_address(ctypes.addressof(T)) ctypes.resize(COUNT, ctypes.sizeof(COUNT._type_)*newSize) COUNT = (A._type_*newSize).from_address(ctypes.addressof(COUNT)) elif arrayKind == 'cffi': try: tempA = A; A = ffi.new("uint32_t[]", len(A)+10000000); ffi.memmove(A,tempA,len(tempA)*(ffi.sizeof(A)/len(A))) tempC = C; C = ffi.new("uint32_t[]", len(C)+10000000); ffi.memmove(C,tempC,len(tempC)*(ffi.sizeof(C)/len(C))) tempG = G; G = ffi.new("uint32_t[]", len(G)+10000000); ffi.memmove(G,tempG,len(tempG)*(ffi.sizeof(G)/len(G))) tempT = T; T = ffi.new("uint32_t[]", len(T)+10000000); ffi.memmove(T,tempT,len(tempT)*(ffi.sizeof(T)/len(T))) tempCOUNT = COUNT; COUNT = ffi.new("uint32_t[]", len(COUNT)+10000000); ffi.memmove(COUNT,tempCOUNT,len(tempCOUNT)*(ffi.sizeof(COUNT)/len(COUNT))) tempSEQ = SEQ; SEQ = ffi.new("int64_t[]", len(SEQ)+10000000); ffi.memmove(SEQ,tempSEQ,len(tempSEQ)*(ffi.sizeof(SEQ)/len(SEQ))) except AttributeError: print 'ERROR! Your version of python does not fully support cffi! Please upgrade, or set the intial amount of RAM to something larger.' exit() getRAM()
def list_usb_devices(self, **kwargs): self.device_paths = {} value = 0x00000000 try: if kwargs.get("default"): value |= DIGCF_DEFAULT if kwargs.get("present"): value |= DIGCF_PRESENT if kwargs.get("allclasses"): value |= DIGCF_ALLCLASSES if kwargs.get("profile"): value |= DIGCF_PROFILE if kwargs.get("deviceinterface"): value |= DIGCF_DEVICE_INTERFACE except KeyError: if value == 0x00000000: value = 0x00000010 pass flags = DWORD(value) self.handle = self.api.exec_function_setupapi(SetupDiGetClassDevs, byref(self.usb_winusb_guid), None, None, flags) sp_device_interface_data = SpDeviceInterfaceData() sp_device_interface_data.cb_size = sizeof(sp_device_interface_data) sp_device_interface_detail_data = SpDeviceInterfaceDetailData() sp_device_info_data = SpDevinfoData() sp_device_info_data.cb_size = sizeof(sp_device_info_data) i = 0 required_size = DWORD(0) member_index = DWORD(i) cb_sizes = (8, 6, 5) # different on 64 bit / 32 bit etc while self.api.exec_function_setupapi(SetupDiEnumDeviceInterfaces, self.handle, None, byref(self.usb_winusb_guid), member_index, byref(sp_device_interface_data)): self.api.exec_function_setupapi(SetupDiGetDeviceInterfaceDetail, self.handle, byref(sp_device_interface_data), None, 0, byref(required_size), None) resize(sp_device_interface_detail_data, required_size.value) path = None for cb_size in cb_sizes: sp_device_interface_detail_data.cb_size = cb_size ret = self.api.exec_function_setupapi(SetupDiGetDeviceInterfaceDetail, self.handle, byref(sp_device_interface_data), byref(sp_device_interface_detail_data), required_size, byref(required_size), byref(sp_device_info_data)) if ret: cb_sizes = (cb_size, ) path = wstring_at(byref(sp_device_interface_detail_data, sizeof(DWORD))) break if path is None: raise ctypes.WinError() # friendly name name = path buff_friendly_name = ctypes.create_unicode_buffer(250) if self.api.exec_function_setupapi(SetupDiGetDeviceRegistryProperty, self.handle, byref(sp_device_info_data), SPDRP_FRIENDLYNAME, None, ctypes.byref(buff_friendly_name), ctypes.sizeof(buff_friendly_name) - 1, None): name = buff_friendly_name.value else: print(ctypes.WinError()) self.device_paths[name] = path i += 1 member_index = DWORD(i) required_size = c_ulong(0) resize(sp_device_interface_detail_data, sizeof(SpDeviceInterfaceDetailData)) return self.device_paths
def get_integrity_level(): '''from http://www.programcreek.com/python/example/3211/ctypes.c_long''' if sys.platform != 'win32': if os.geteuid() != 0: return "Medium" else: return "High" mapping = { 0x0000: u'Untrusted', 0x1000: u'Low', 0x2000: u'Medium', 0x2100: u'Medium high', 0x3000: u'High', 0x4000: u'System', 0x5000: u'Protected process', } BOOL = ctypes.c_long DWORD = ctypes.c_ulong HANDLE = ctypes.c_void_p class SID_AND_ATTRIBUTES(ctypes.Structure): _fields_ = [ ('Sid', ctypes.c_void_p), ('Attributes', DWORD), ] class TOKEN_MANDATORY_LABEL(ctypes.Structure): _fields_ = [ ('Label', SID_AND_ATTRIBUTES), ] TOKEN_READ = DWORD(0x20008) TokenIntegrityLevel = ctypes.c_int(25) ERROR_INSUFFICIENT_BUFFER = 122 ctypes.windll.kernel32.GetLastError.argtypes = () ctypes.windll.kernel32.GetLastError.restype = DWORD ctypes.windll.kernel32.GetCurrentProcess.argtypes = () ctypes.windll.kernel32.GetCurrentProcess.restype = ctypes.c_void_p ctypes.windll.advapi32.OpenProcessToken.argtypes = (HANDLE, DWORD, ctypes.POINTER(HANDLE)) ctypes.windll.advapi32.OpenProcessToken.restype = BOOL ctypes.windll.advapi32.GetTokenInformation.argtypes = ( HANDLE, ctypes.c_long, ctypes.c_void_p, DWORD, ctypes.POINTER(DWORD)) ctypes.windll.advapi32.GetTokenInformation.restype = BOOL ctypes.windll.advapi32.GetSidSubAuthorityCount.argtypes = [ctypes.c_void_p] ctypes.windll.advapi32.GetSidSubAuthorityCount.restype = ctypes.POINTER( ctypes.c_ubyte) ctypes.windll.advapi32.GetSidSubAuthority.argtypes = (ctypes.c_void_p, DWORD) ctypes.windll.advapi32.GetSidSubAuthority.restype = ctypes.POINTER(DWORD) token = ctypes.c_void_p() proc_handle = ctypes.windll.kernel32.GetCurrentProcess() if not ctypes.windll.advapi32.OpenProcessToken(proc_handle, TOKEN_READ, ctypes.byref(token)): logging.error('Failed to get process token') return None if token.value == 0: logging.error('Got a NULL token') return None try: info_size = DWORD() if ctypes.windll.advapi32.GetTokenInformation(token, TokenIntegrityLevel, ctypes.c_void_p(), info_size, ctypes.byref(info_size)): logging.error('GetTokenInformation() failed expectation') return None if info_size.value == 0: logging.error('GetTokenInformation() returned size 0') return None if ctypes.windll.kernel32.GetLastError() != ERROR_INSUFFICIENT_BUFFER: logging.error('GetTokenInformation(): Unknown error: %d', ctypes.windll.kernel32.GetLastError()) return None token_info = TOKEN_MANDATORY_LABEL() ctypes.resize(token_info, info_size.value) if not ctypes.windll.advapi32.GetTokenInformation( token, TokenIntegrityLevel, ctypes.byref(token_info), info_size, ctypes.byref(info_size)): logging.error( 'GetTokenInformation(): Unknown error with buffer size %d: %d', info_size.value, ctypes.windll.kernel32.GetLastError()) return None p_sid_size = ctypes.windll.advapi32.GetSidSubAuthorityCount( token_info.Label.Sid) res = ctypes.windll.advapi32.GetSidSubAuthority( token_info.Label.Sid, p_sid_size.contents.value - 1) value = res.contents.value return mapping.get(value) or u'0x%04x' % value finally: ctypes.windll.kernel32.CloseHandle(token)
def ensure_size(self, size): while ctypes.sizeof(self.buf) - self.wpos < size: ctypes.resize(self.buf, ctypes.sizeof(self.buf) * 2)
def get_integrity_level(): """Returns the integrity level of the current process as a string. TODO(maruel): It'd be nice to make it work on cygwin. The problem is that ctypes.windll is unaccessible and it is not known to the author how to use stdcall convention through ctypes.cdll. """ if get_os_version_number() == u'5.1': # Integrity level is Vista+. return None mapping = { 0x0000: u'untrusted', 0x1000: u'low', 0x2000: u'medium', 0x2100: u'medium high', 0x3000: u'high', 0x4000: u'system', 0x5000: u'protected process', } # This was specifically written this way to work on cygwin except for the # windll part. If someone can come up with a way to do stdcall on cygwin, that # would be appreciated. BOOL = ctypes.c_long DWORD = ctypes.c_ulong HANDLE = ctypes.c_void_p class SID_AND_ATTRIBUTES(ctypes.Structure): _fields_ = [ ('Sid', ctypes.c_void_p), ('Attributes', DWORD), ] class TOKEN_MANDATORY_LABEL(ctypes.Structure): _fields_ = [ ('Label', SID_AND_ATTRIBUTES), ] TOKEN_READ = DWORD(0x20008) # Use the same casing as in the C declaration: # https://msdn.microsoft.com/library/windows/desktop/aa379626.aspx TokenIntegrityLevel = ctypes.c_int(25) ERROR_INSUFFICIENT_BUFFER = 122 # All the functions used locally. First open the process' token, then query # the SID to know its integrity level. ctypes.windll.kernel32.GetLastError.argtypes = () ctypes.windll.kernel32.GetLastError.restype = DWORD ctypes.windll.kernel32.GetCurrentProcess.argtypes = () ctypes.windll.kernel32.GetCurrentProcess.restype = ctypes.c_void_p ctypes.windll.advapi32.OpenProcessToken.argtypes = (HANDLE, DWORD, ctypes.POINTER(HANDLE)) ctypes.windll.advapi32.OpenProcessToken.restype = BOOL ctypes.windll.advapi32.GetTokenInformation.argtypes = ( HANDLE, ctypes.c_long, ctypes.c_void_p, DWORD, ctypes.POINTER(DWORD)) ctypes.windll.advapi32.GetTokenInformation.restype = BOOL ctypes.windll.advapi32.GetSidSubAuthorityCount.argtypes = [ctypes.c_void_p] ctypes.windll.advapi32.GetSidSubAuthorityCount.restype = ctypes.POINTER( ctypes.c_ubyte) ctypes.windll.advapi32.GetSidSubAuthority.argtypes = (ctypes.c_void_p, DWORD) ctypes.windll.advapi32.GetSidSubAuthority.restype = ctypes.POINTER(DWORD) # First open the current process token, query it, then close everything. token = ctypes.c_void_p() proc_handle = ctypes.windll.kernel32.GetCurrentProcess() if not ctypes.windll.advapi32.OpenProcessToken(proc_handle, TOKEN_READ, ctypes.byref(token)): logging.error('Failed to get process\' token') return None if token.value == 0: logging.error('Got a NULL token') return None try: # The size of the structure is dynamic because the TOKEN_MANDATORY_LABEL # used will have the SID appened right after the TOKEN_MANDATORY_LABEL in # the heap allocated memory block, with .Label.Sid pointing to it. info_size = DWORD() if ctypes.windll.advapi32.GetTokenInformation(token, TokenIntegrityLevel, ctypes.c_void_p(), info_size, ctypes.byref(info_size)): logging.error('GetTokenInformation() failed expectation') return None if info_size.value == 0: logging.error('GetTokenInformation() returned size 0') return None if ctypes.windll.kernel32.GetLastError() != ERROR_INSUFFICIENT_BUFFER: logging.error('GetTokenInformation(): Unknown error: %d', ctypes.windll.kernel32.GetLastError()) return None token_info = TOKEN_MANDATORY_LABEL() ctypes.resize(token_info, info_size.value) if not ctypes.windll.advapi32.GetTokenInformation( token, TokenIntegrityLevel, ctypes.byref(token_info), info_size, ctypes.byref(info_size)): logging.error( 'GetTokenInformation(): Unknown error with buffer size %d: %d', info_size.value, ctypes.windll.kernel32.GetLastError()) return None p_sid_size = ctypes.windll.advapi32.GetSidSubAuthorityCount( token_info.Label.Sid) res = ctypes.windll.advapi32.GetSidSubAuthority( token_info.Label.Sid, p_sid_size.contents.value - 1) value = res.contents.value return mapping.get(value) or u'0x%04x' % value finally: ctypes.windll.kernel32.CloseHandle(token)
def DeviceConnect(path, db, field, cid): if debug: print('Connecting to:', path) cached = 1 device_found = -1 for j in range(len(db)): address = db[j]['hwid'].split('_')[1] if address in path: device_found = j cached = db[j]['status'] != 'connected' if device_found < 0: return db hDevice = windll.kernel32.CreateFileW(path, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE, None, OPEN_EXISTING, 0, None) ServicesBufferCount = USHORT() BT.BluetoothGATTGetServices(hDevice, 0, None, byref(ServicesBufferCount), BLUETOOTH_GATT_FLAG_NONE) ServicesBuffer = new(BTH_LE_GATT_SERVICE * ServicesBufferCount.value) BT.BluetoothGATTGetServices(hDevice, ServicesBufferCount, byref(ServicesBuffer), byref(ServicesBufferCount), BLUETOOTH_GATT_FLAG_NONE) for Service in ServicesBuffer: CharacteristicsBufferCount = USHORT(0) hr = BT.BluetoothGATTGetCharacteristics( hDevice, byref(Service), 0, None, byref(CharacteristicsBufferCount), BLUETOOTH_GATT_FLAG_NONE) CharacteristicsBuffer = new(BTH_LE_GATT_CHARACTERISTIC * CharacteristicsBufferCount.value) CharacteristicsBufferActual = USHORT(0) BT.BluetoothGATTGetCharacteristics(hDevice, byref(Service), CharacteristicsBufferCount, byref(CharacteristicsBuffer), byref(CharacteristicsBufferActual), BLUETOOTH_GATT_FLAG_NONE) for Characteristic in CharacteristicsBuffer: uuid = Characteristic.CharacteristicUuid.ShortUuid charValueDataSize = USHORT() hr = BT.BluetoothGATTGetCharacteristicValue( hDevice, byref(Characteristic), 0, None, byref(charValueDataSize), BLUETOOTH_GATT_FLAG_NONE if cached else BLUETOOTH_GATT_FLAG_FORCE_READ_FROM_DEVICE) pCharValueBuffer = BTH_LE_GATT_CHARACTERISTIC_VALUE() resize(pCharValueBuffer, charValueDataSize.value) hr = BT.BluetoothGATTGetCharacteristicValue( hDevice, byref(Characteristic), charValueDataSize, byref(pCharValueBuffer), None, BLUETOOTH_GATT_FLAG_NONE if cached else BLUETOOTH_GATT_FLAG_FORCE_READ_FROM_DEVICE) StringValue = string_at(byref(pCharValueBuffer, sizeof(ULONG))) arr = bytearray(StringValue) if uuid == 0x2A19: # battery level value = 0 if len(arr) < 1 else arr[0] elif uuid == 0x2A01: # appearance value = int(codecs.encode(arr, 'hex'), 16) value = Appearance(value) else: # string value = str(StringValue.decode(errors='ignore')) if debug: print('\t%X' % uuid, value) if device_found != -1 and uuid == cid: db[device_found][field] = value return db
def get_integrity_level_win(): """Returns the integrity level of the current process as a string. TODO(maruel): It'd be nice to make it work on cygwin. The problem is that ctypes.windll is unaccessible and it is not known to the author how to use stdcall convention through ctypes.cdll. """ if sys.platform != 'win32': return None if get_os_version_number() == u'5.1': # Integrity level is Vista+. return None mapping = { 0x0000: u'untrusted', 0x1000: u'low', 0x2000: u'medium', 0x2100: u'medium high', 0x3000: u'high', 0x4000: u'system', 0x5000: u'protected process', } # This was specifically written this way to work on cygwin except for the # windll part. If someone can come up with a way to do stdcall on cygwin, that # would be appreciated. BOOL = ctypes.c_long DWORD = ctypes.c_ulong HANDLE = ctypes.c_void_p class SID_AND_ATTRIBUTES(ctypes.Structure): _fields_ = [ ('Sid', ctypes.c_void_p), ('Attributes', DWORD), ] class TOKEN_MANDATORY_LABEL(ctypes.Structure): _fields_ = [ ('Label', SID_AND_ATTRIBUTES), ] TOKEN_READ = DWORD(0x20008) # Use the same casing as in the C declaration: # https://msdn.microsoft.com/library/windows/desktop/aa379626.aspx TokenIntegrityLevel = ctypes.c_int(25) ERROR_INSUFFICIENT_BUFFER = 122 # All the functions used locally. First open the process' token, then query # the SID to know its integrity level. ctypes.windll.kernel32.GetLastError.argtypes = () ctypes.windll.kernel32.GetLastError.restype = DWORD ctypes.windll.kernel32.GetCurrentProcess.argtypes = () ctypes.windll.kernel32.GetCurrentProcess.restype = ctypes.c_void_p ctypes.windll.advapi32.OpenProcessToken.argtypes = ( HANDLE, DWORD, ctypes.POINTER(HANDLE)) ctypes.windll.advapi32.OpenProcessToken.restype = BOOL ctypes.windll.advapi32.GetTokenInformation.argtypes = ( HANDLE, ctypes.c_long, ctypes.c_void_p, DWORD, ctypes.POINTER(DWORD)) ctypes.windll.advapi32.GetTokenInformation.restype = BOOL ctypes.windll.advapi32.GetSidSubAuthorityCount.argtypes = [ctypes.c_void_p] ctypes.windll.advapi32.GetSidSubAuthorityCount.restype = ctypes.POINTER( ctypes.c_ubyte) ctypes.windll.advapi32.GetSidSubAuthority.argtypes = (ctypes.c_void_p, DWORD) ctypes.windll.advapi32.GetSidSubAuthority.restype = ctypes.POINTER(DWORD) # First open the current process token, query it, then close everything. token = ctypes.c_void_p() proc_handle = ctypes.windll.kernel32.GetCurrentProcess() if not ctypes.windll.advapi32.OpenProcessToken( proc_handle, TOKEN_READ, ctypes.byref(token)): logging.error('Failed to get process\' token') return None if token.value == 0: logging.error('Got a NULL token') return None try: # The size of the structure is dynamic because the TOKEN_MANDATORY_LABEL # used will have the SID appened right after the TOKEN_MANDATORY_LABEL in # the heap allocated memory block, with .Label.Sid pointing to it. info_size = DWORD() if ctypes.windll.advapi32.GetTokenInformation( token, TokenIntegrityLevel, ctypes.c_void_p(), info_size, ctypes.byref(info_size)): logging.error('GetTokenInformation() failed expectation') return None if info_size.value == 0: logging.error('GetTokenInformation() returned size 0') return None if ctypes.windll.kernel32.GetLastError() != ERROR_INSUFFICIENT_BUFFER: logging.error( 'GetTokenInformation(): Unknown error: %d', ctypes.windll.kernel32.GetLastError()) return None token_info = TOKEN_MANDATORY_LABEL() ctypes.resize(token_info, info_size.value) if not ctypes.windll.advapi32.GetTokenInformation( token, TokenIntegrityLevel, ctypes.byref(token_info), info_size, ctypes.byref(info_size)): logging.error( 'GetTokenInformation(): Unknown error with buffer size %d: %d', info_size.value, ctypes.windll.kernel32.GetLastError()) return None p_sid_size = ctypes.windll.advapi32.GetSidSubAuthorityCount( token_info.Label.Sid) res = ctypes.windll.advapi32.GetSidSubAuthority( token_info.Label.Sid, p_sid_size.contents.value - 1) value = res.contents.value return mapping.get(value) or u'0x%04x' % value finally: ctypes.windll.kernel32.CloseHandle(token)
def get_integrity_level(): '''from http://www.programcreek.com/python/example/3211/ctypes.c_long''' if sys.platform != 'win32': if os.geteuid() != 0: return "Medium" else: return "High" mapping = { 0x0000: u'Untrusted', 0x1000: u'Low', 0x2000: u'Medium', 0x2100: u'Medium high', 0x3000: u'High', 0x4000: u'System', 0x5000: u'Protected process', } BOOL = ctypes.c_long DWORD = ctypes.c_ulong HANDLE = ctypes.c_void_p class SID_AND_ATTRIBUTES(ctypes.Structure): _fields_ = [ ('Sid', ctypes.c_void_p), ('Attributes', DWORD), ] class TOKEN_MANDATORY_LABEL(ctypes.Structure): _fields_ = [ ('Label', SID_AND_ATTRIBUTES), ] TOKEN_READ = DWORD(0x20008) TokenIntegrityLevel = ctypes.c_int(25) ERROR_INSUFFICIENT_BUFFER = 122 ctypes.windll.kernel32.GetLastError.argtypes = () ctypes.windll.kernel32.GetLastError.restype = DWORD ctypes.windll.kernel32.GetCurrentProcess.argtypes = () ctypes.windll.kernel32.GetCurrentProcess.restype = ctypes.c_void_p ctypes.windll.advapi32.OpenProcessToken.argtypes = ( HANDLE, DWORD, ctypes.POINTER(HANDLE)) ctypes.windll.advapi32.OpenProcessToken.restype = BOOL ctypes.windll.advapi32.GetTokenInformation.argtypes = ( HANDLE, ctypes.c_long, ctypes.c_void_p, DWORD, ctypes.POINTER(DWORD)) ctypes.windll.advapi32.GetTokenInformation.restype = BOOL ctypes.windll.advapi32.GetSidSubAuthorityCount.argtypes = [ctypes.c_void_p] ctypes.windll.advapi32.GetSidSubAuthorityCount.restype = ctypes.POINTER( ctypes.c_ubyte) ctypes.windll.advapi32.GetSidSubAuthority.argtypes = (ctypes.c_void_p, DWORD) ctypes.windll.advapi32.GetSidSubAuthority.restype = ctypes.POINTER(DWORD) token = ctypes.c_void_p() proc_handle = ctypes.windll.kernel32.GetCurrentProcess() if not ctypes.windll.advapi32.OpenProcessToken( proc_handle, TOKEN_READ, ctypes.byref(token)): logging.error('Failed to get process token') return None if token.value == 0: logging.error('Got a NULL token') return None try: info_size = DWORD() if ctypes.windll.advapi32.GetTokenInformation( token, TokenIntegrityLevel, ctypes.c_void_p(), info_size, ctypes.byref(info_size)): logging.error('GetTokenInformation() failed expectation') return None if info_size.value == 0: logging.error('GetTokenInformation() returned size 0') return None if ctypes.windll.kernel32.GetLastError() != ERROR_INSUFFICIENT_BUFFER: logging.error( 'GetTokenInformation(): Unknown error: %d', ctypes.windll.kernel32.GetLastError()) return None token_info = TOKEN_MANDATORY_LABEL() ctypes.resize(token_info, info_size.value) if not ctypes.windll.advapi32.GetTokenInformation( token, TokenIntegrityLevel, ctypes.byref(token_info), info_size, ctypes.byref(info_size)): logging.error( 'GetTokenInformation(): Unknown error with buffer size %d: %d', info_size.value, ctypes.windll.kernel32.GetLastError()) return None p_sid_size = ctypes.windll.advapi32.GetSidSubAuthorityCount( token_info.Label.Sid) res = ctypes.windll.advapi32.GetSidSubAuthority( token_info.Label.Sid, p_sid_size.contents.value - 1) value = res.contents.value return mapping.get(value) or u'0x%04x' % value finally: ctypes.windll.kernel32.CloseHandle(token)