././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1656405348.447302 rzpipe-0.4.0/0000755000175100001710000000000000000000000013624 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/LICENSE0000644000175100001710000000206300000000000014632 0ustar00runnerdocker00000000000000The MIT License (MIT) Copyright (c) 2015 pancake Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/MANIFEST.in0000644000175100001710000000014100000000000015356 0ustar00runnerdocker00000000000000include setup.py include rzpipe/__init__.py include LICENSE include README.md include MANIFEST.in././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1656405348.447302 rzpipe-0.4.0/PKG-INFO0000644000175100001710000000245600000000000014730 0ustar00runnerdocker00000000000000Metadata-Version: 2.1 Name: rzpipe Version: 0.4.0 Summary: Pipe interface for rizin Home-page: https://rizin.re Author: rizinorg Author-email: info@rizin.re License: MIT Description: # rzpipe for Python Interact with rizin using the `#!pipe` command or in standalone scripts that communicate with local or remote rizin via pipe, tcp or http. ## Installation ```sh $ pip install rzpipe ``` or ```sh $ pip3 install rzpipe ``` ## Usage example: ```python import rzpipe pipe = rzpipe.open("/bin/ls") pipe.cmd('aa') print(pipe.cmd("afl")) print(pipe.cmdj("aflj")) # evaluates JSON and returns an object print(pipe.cmdj("ij").core.format) # shows file format pipe.quit() ``` Platform: UNKNOWN Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python :: 3 Classifier: Operating System :: OS Independent Classifier: Topic :: Security Classifier: Topic :: Software Development :: Assemblers Classifier: Topic :: Software Development :: Debuggers Classifier: Topic :: Software Development :: Disassemblers Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/README.md0000644000175100001710000000077200000000000015111 0ustar00runnerdocker00000000000000# rzpipe for Python Interact with rizin using the `#!pipe` command or in standalone scripts that communicate with local or remote rizin via pipe, tcp or http. ## Installation ```sh $ pip install rzpipe ``` or ```sh $ pip3 install rzpipe ``` ## Usage example: ```python import rzpipe pipe = rzpipe.open("/bin/ls") pipe.cmd('aa') print(pipe.cmd("afl")) print(pipe.cmdj("aflj")) # evaluates JSON and returns an object print(pipe.cmdj("ij").core.format) # shows file format pipe.quit() ``` ././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1656405348.447302 rzpipe-0.4.0/rzpipe/0000755000175100001710000000000000000000000015135 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/rzpipe/__init__.py0000644000175100001710000001100500000000000017243 0ustar00runnerdocker00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- """rzpipe This module provides an API to interact with the rizin commandline interface from Python using a pipe. The pipe can be connected to the parent process to run Python scripts from the rizin shell itself, or it can spawn a new process, connect via HTTP to a remote rizin http server, etc. Some rizin commands display the information in JSON, that's why rzpipe provides `-j` methods to directly parse it and return a native Python object. Example: $ python > import rzpipe > with rzpipe.open("/bin/ls") as rz: > print(rz.cmd("pd 10")) > print(rz.cmdj("aoj")[0]['size']) """ import os import sys import time try: import rzlang except ImportError: rzlang = None VERSION = "0.4.0" from .open_sync import open from shutil import which def version(): """Return string with the version of the rzpipe library""" return VERSION if __name__ == "__main__": print("[+] Spawning rizin tcp and http servers") os.system("pkill rizin") os.system("rizin -qc.:9080 /bin/ls &") os.system("rizin -qc=h /bin/ls &") time.sleep(1) if sys.version_info <= (3, 0): # Test rzpipe with local process print("[+] Testing python rzpipe local") rlocal = open(which("ls")) print(rlocal.cmd("pi 5")) # print rlocal.cmd("pn") info = rlocal.cmdj("ij") print("Architecture: " + info["bin"]["machine"]) # Test rzpipe with remote tcp process (launch it with "rizin -qc.:9080 myfile") print("[+] Testing python rzpipe tcp://") rremote = open("tcp://127.0.0.1:9080") disas = rremote.cmd("pi 5") if not disas: print("Error with remote tcp conection") else: print(disas) # Test rzpipe with remote http process (launch it with "rizin -qc=H myfile") print("[+] Testing python rzpipe http://") rremote = open("http://127.0.0.1:9090") disas = rremote.cmd("pi 5") if not disas: print("Error with remote http conection") else: print(disas) else: # -------------------------------------------------------------------------- # Python 3 examples, with non-blocking API and callbacks # -------------------------------------------------------------------------- def callback(result): print(result) # # Test rzpipe with local process # # Start 1 task print("[+] Testing python rzpipe local") rlocal = open(which("ls")) t = rlocal.cmd("pi 5", callback=callback) rlocal.wait(t) # Wait for task end info = rlocal.cmdj("ij") rlocal.wait(info) print("Architecture: " + info["bin"]["machine"]) rlocal.close() # Start 3 tasks with Context manager print("[+] Testing python rzpipe local with 3 queries") with open("/bin/ls") as rlocall: t1 = rlocall.cmd("pi 5", callback=callback) t2 = rlocall.cmd("pi 5", callback=callback) t3 = rlocall.cmd("pi 5", callback=callback) rlocall.wait([t1, t2, t3]) # # Test rzpipe with remote tcp process (launch it with "rizin -qc.:9080 myfile") # # Start 1 task print("[+] Testing python rzpipe tcp://") rremote = open("tcp://127.0.0.1:9080") t = rremote.cmd("pi 5", callback=callback) rremote.wait(t) rremote.close() # Start 3 tasks with Context manager print("[+] Testing python rzpipe tcp:// with 3 queries") with open("tcp://127.0.0.1:9080") as rremote: t1 = rremote.cmd("pi 5", callback=callback) t2 = rremote.cmd("pi 5", callback=callback) t3 = rremote.cmd("pi 5", callback=callback) rremote.wait([t1, t2, t3]) # # Test rzpipe with remote http process (launch it with "rizin -qc=H myfile") # print("[+] Testing python rzpipe http://") rremote = open("tcp://127.0.0.1:9080") t = rremote.cmd("pi 5", callback=callback) rremote.wait(t) rremote.close() # Start 3 tasks with Context manager print("[+] Testing python rzpipe http:// with 3 queries") with open("http://127.0.0.1:9090") as rremote: t1 = rremote.cmd("pi 10", callback=callback) t2 = rremote.cmd("pi 5", callback=callback) t3 = rremote.cmd("pi 5", callback=callback) rremote.wait([t1, t2, t3]) os.system("pkill -INT rizin") ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/rzpipe/native.py0000644000175100001710000000662100000000000017002 0ustar00runnerdocker00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- import contextlib import ctypes from ctypes import Structure, addressof, c_char_p, c_void_p from ctypes.util import find_library lib_name = find_library("rz_core") if not lib_name: raise ImportError("No native rz_core library") try: from ctypes import CDLL lib = CDLL(lib_name) except ImportError: pass try: from ctypes import WinDLL lib = WinDLL(lib_name) except ImportError: pass class AddressHolder(object): def __get__(self, obj, type_): if getattr(obj, "_address", None) is None: obj._address = addressof(obj) return obj._address def __set__(self, obj, value): obj._address = value class WrappedRMethod(object): def __init__(self, cname, args, ret, lib=lib, ): self.cname = cname self.args = args self.ret = ret self.args_set = False self.method = getattr(lib, cname) def __call__(self, *args): if not self.args_set: if self.args: self.method.argtypes = [ getattr(ctypes, x.strip()) for x in self.args.split(",") ] self.method.restype = getattr(ctypes, self.ret) if self.ret else None self.args_set = True args = list(args) for i, arg_type in enumerate(self.method.argtypes): if arg_type is c_char_p: args[i] = args[i].encode() if self.method.restype is c_char_p: return self.method(*args).decode() return self.method(*args) class WrappedApiMethod(object): def __init__(self, method, ret2, last): self.method = method self._o = None self.ret2 = ret2 self.last = last def __call__(self, *a): result = self.method(self._o, *a) if self.ret2: if self.ret2 == "c_char_p": return result else: result = getattr(ctypes, self.ret2)(result) if self.last: return getattr(result, self.last) return result def __get__(self, obj, type_): if type_ is RzCore: self._o = obj._o return self def register(cname, args, ret, lib=lib): ret2 = last = None if ret: if "A" <= ret[0] <= "Z": x = ret.find("<") if x != -1: ret = ret[0:x] last = "contents" ret = "POINTER(" + ret + ")" else: last = "value" ret2 = ret method = WrappedRMethod(cname, args, ret, lib=lib,) wrapped_method = WrappedApiMethod(method, ret2, last) return wrapped_method, method class RzCore(Structure): # 1 def __init__(self, lib=lib): Structure.__init__(self) rz_core_new = lib.rz_core_new rz_core_new.restype = c_void_p self._o = rz_core_new() _o = AddressHolder() cmd_str, rz_core_cmd_str = register( "rz_core_cmd_str", "c_void_p, c_char_p", "c_char_p", ) free, rz_core_free = register( "rz_core_free", "c_void_p", "c_void_p", ) @contextlib.contextmanager def core(): c = RzCore() yield c c.free() __all__ = [ core.__name__, register.__name__, RzCore.__name__, WrappedRMethod.__name__, WrappedApiMethod.__name__, ] # c = RzCore() # c.cmd_str("o /bin/ls") # print(c) # print(c.cmd_str("s entry0;pd 20")) # c.free(); ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/rzpipe/open_async.py0000644000175100001710000001564400000000000017657 0ustar00runnerdocker00000000000000# -*- coding: utf-8 -*- """open_async.py This script use code from rzpipe-async/open_p3.py script. """ import asyncio import os import re import typing from collections.abc import Iterable from contextlib import ContextDecorator from urllib.parse import quote, urlparse from .open_base import OpenBase, get_rizin_path class open(OpenBase, ContextDecorator): # -------------------------------------------------------------------------- # Context manager functions # -------------------------------------------------------------------------- def __enter__(self): return self def __exit__(self, *exc): self.close() return False def close(self): if self._loop.is_running(): self._loop.stop() if not self._loop.is_closed(): self._loop.close() def __init__(self, filename="", flags=None, rz_home=None): super(open, self).__init__(filename, flags) if flags is None: flags = [] self.rz_home = rz_home if os.name == "nt": self._loop = asyncio.ProactorEventLoop() asyncio.set_event_loop(self._loop) else: watcher = asyncio.get_child_watcher() self._loop = asyncio.new_event_loop() watcher.attach_loop(self._loop) self._async = True if filename.startswith("http://"): self._cmd_coro = self._cmd_http self.uri = "/cmd" _tmp = urlparse(filename) self._host = _tmp.hostname self._port = _tmp.port elif filename.startswith("ccall://"): self._cmd_coro = self._cmd_native self.uri = filename[7:] elif filename.startswith("tcp://"): r = re.match(r"tcp://(\d+\.\d+.\d+.\d+):(\d+)/?", filename) if not r: raise ValueError("You must provide the tcp address in this format:\n" "tcp://xxx.xxx.xxx.xxx:yyyy") self._cmd_coro = self._cmd_tcp self._host = r.group(1) self._port = r.group(2) elif filename.startswith("https://"): raise ValueError("https protocol is not supported yet") elif filename: self._cmd_coro = self._cmd_process cmd = ["-q0", filename] cmd = cmd[:1] + flags + cmd[1:] self._process_start_cmd = cmd else: self._async = False def _on_cmd_finished(self, future): """ After a command is invoked this helper invokes the callback that is returned by the _cmd_* coroutine methods. :param future: :return: """ result, callback = future.result() if callback: callback(result) def _cmd(self, cmd, **kwargs): # Get callback, if available callback = kwargs.get("callback") future = asyncio.Future(loop=self._loop) future.add_done_callback(self._on_cmd_finished) task = self._loop.create_task(self._cmd_coro(cmd, future, callback)) # Create and start a new task (coroutine) self._loop.run_until_complete(task) return task.result() if task else None async def _cmd_process(self, cmd, future, callback): if not hasattr(self, "process"): rz_path = get_rizin_path() if self.rz_home is not None: if not os.path.isdir(self.rz_home): raise Exception( "`rizinhome` passed to `open` is invalid, leave it None or put a valid path to rizin folder" ) rz_path = os.path.join(self.rz_home, "rizin") if os.name == "nt": rz_path += ".exe" # Init the process self.process = await asyncio.create_subprocess_exec( rz_path, *self._process_start_cmd, shell=False, stdin=asyncio.subprocess.PIPE, stdout=asyncio.subprocess.PIPE, loop=self._loop ) await self.process.stdout.read(1) # Reads initial \x00 normalized_cmd = cmd.strip().replace("\n", ";") self.process.stdin.write(bytes(normalized_cmd + "\n", "utf-8")) buffer = [] while True: # foo = self.process.stdout.read(1) char = await self.process.stdout.read(1) if char == b"\x00": break if len(char) < 1: return None buffer.append(char) decoded_buffer = b"".join(buffer).decode("utf-8") future.set_result((decoded_buffer, callback)) return decoded_buffer async def _cmd_http(self, cmd, future, callback): try: quoted_cmd = quote(cmd) reader, writer = await asyncio.open_connection( self._host, self._port, loop=self._loop ) message = "\n\r".join( [ "GET /cmd/%s HTTP/1.1" % quoted_cmd, "Host: %s:%s" % (self._host, self._port), "User-Agent: rzpipe/Python Client", "Accept: */*", "", "", ] ).encode() writer.write(message) data = await reader.read(512) res = [data] while data: data = await reader.read(512) res.append(data) writer.close() res = b"".join(res) # Remove http headers start = 0 for x in res.splitlines(): if not x: start += 1 break start += len(x) + 1 # +1 because we must be count '\n' res = res[start:].decode("utf-8", errors="ignore") future.set_result((res, callback)) return res except Exception as e: future.set_result((str(e), callback)) async def _cmd_tcp(self, cmd, future, callback): try: reader, writer = await asyncio.open_connection( self._host, self._port, loop=self._loop ) writer.write(cmd.encode("utf-8")) data = await reader.read(512) res = [data] while data: res.append(data) data = await reader.read(512) res = b"".join(res).decode("utf-8", errors="ignore") future.set_result((res, callback)) writer.close() return res except Exception as e: future.set_result((str(e), callback)) def wait(self, task: typing.Union[asyncio.Task, asyncio.Future]): """ Wait until the task or future is finished. :param task: :return: """ tasks = task if not isinstance(task, Iterable): tasks = [task] if self._loop.is_running(): asyncio.wait(tasks, loop=self._loop) ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/rzpipe/open_base.py0000644000175100001710000002233700000000000017451 0ustar00runnerdocker00000000000000# /usr/bin/env python3 # -*- coding: utf-8 -*- """open_base.py base class for new open objects from open_sync and open_async. Code derived from __init__.py """ import json import os import platform import sys from shutil import which from subprocess import Popen, PIPE try: import rzlang except ImportError: rzlang = None try: from .native import RzCore except ImportError: RzCore = None if os.name == "nt": from ctypes import byref, c_ulong, create_string_buffer, windll GENERIC_READ = 0x80000000 GENERIC_WRITE = 0x40000000 OPEN_EXISTING = 0x3 INVALID_HANDLE_VALUE = -1 PIPE_READMODE_MESSAGE = 0x2 ERROR_PIPE_BUSY = 231 ERROR_MORE_DATA = 234 BUFSIZE = 4096 chBuf = create_string_buffer(BUFSIZE) cbRead = c_ulong(0) cbWritten = c_ulong(0) def has_rzlang(): return rzlang is not None and rzlang.cmd is not None def jo2po(jo): from collections import namedtuple def _json_object_hook(d): keys = [x.replace('.', '_') if x != 'class' else 'klass' for x in d.keys()] return namedtuple("X", keys)(*d.values()) def json2obj(data): return json.loads(data, object_hook=_json_object_hook) return json2obj(jo) def get_rizin_path(): """ Helper to get the path to the rizin binary. :return: """ bin_file = which("rizin") if bin_file and os.path.isfile(bin_file): return bin_file else: _platform = platform.system().lower() if _platform.startswith("darwin"): bin_file = "/usr/local/bin/rizin" else: bin_file = "/usr/bin/rizin" if os.path.isfile(bin_file): return bin_file else: raise IOError("rizin can't be found in your system") class OpenBase(object): """ Class representing an rzpipe connection with a running rizin instance Class body derived from __init__.py "open" class. """ def __init__(self, filename="", flags=None): """ Open a new rizin pipe The 'filename' can be one of the following: * absolute or relative path to file * http://: to connect to an rizin webserver * tcp://: to connect to an rizin tcp server * #!pipe when launching it from rizin via RzLang.pipe Args: filename (str): path to filename or uri flags (list of str): arguments, either in compact form ("-wdn") or separated by commas ("-w","-d","-n") Returns: Returns an object with methods to interact with rizin via commands """ if not flags: flags = [] self._async = False # Set cmd native as default self.uri = filename self._cmd = self._cmd_native if not filename and has_rzlang(): self._cmd = self._cmd_rzlang return try: if os.name == "nt": pipe_name = os.environ["RZ_PIPE_PATH"] while 1: pipe_handle = windll.kernel32.CreateFileW( pipe_name, GENERIC_READ | GENERIC_WRITE, 0, None, OPEN_EXISTING, 0, None, ) if pipe_handle != INVALID_HANDLE_VALUE: break err = windll.kernel32.GetLastError() if err != ERROR_PIPE_BUSY: raise OSError("Invalid Handle Value: Could not open pipe: {0}".format(hex(err))) elif (windll.kernel32.WaitNamedPipeW(pipe_name, 20000)) == 0: raise OSError("Invalid Handle Value: Pipe busy") self.pipe = [pipe_handle, pipe_handle] else: self.pipe = [ int(os.environ["RZ_PIPE_IN"]), int(os.environ["RZ_PIPE_OUT"]), ] self._cmd = self._cmd_pipe self.url = "#!pipe" return except Exception: # provided _cmd_native as a default, in case we land here pass if filename.startswith("#!pipe"): raise ValueError("ERROR: Cannot use #!pipe without RZPIPE_{IN|OUT} env") def __enter__(self): return self def __exit__(self, *args): self.quit() def _cmd_pipe(self, cmd): out = b"" cmd = cmd.strip().replace("\n", ";") if os.name == "nt": cmd = cmd.encode("utf-8") windll.kernel32.WriteFile( self.pipe[1], cmd, len(cmd), byref(cbWritten), None ) while True: windll.kernel32.ReadFile( self.pipe[1], chBuf, BUFSIZE, byref(cbRead), None ) out += chBuf.value if ord(chBuf[cbRead.value - 1]) == 0: if len(out) > 0 and out[-1] == 0: out = out[0:-1] break else: os.write(self.pipe[1], cmd.encode()) while True: res = os.read(self.pipe[0], 4096) if len(res) < 1: break if res[-1] == b"\x00"[0]: out += res[0:-1] else: out += res if len(res) < 4096: break return out.decode("utf-8") def _cmd_native(self, cmd): cmd = cmd.strip().replace("\n", ";") if not RzCore: raise Exception("RzCore is None because there is no native rz_core library") if not hasattr(self, "native"): self.native = RzCore() self.native.cmd_str("o " + self.uri) return self.native.cmd_str(cmd) def _cmd_rzlang(self, cmd): return rzlang.cmd(cmd) def quit(self): """Quit current rzpipe session and kill""" self.cmd("q") if hasattr(self, "process"): import subprocess is_async = not isinstance(self.process, subprocess.Popen) if not is_async: for f in [self.process.stdin, self.process.stdout]: if f is not None: f.close() self.process.terminate() self.process.wait() delattr(self, "process") if is_async: import asyncio asyncio.get_event_loop().run_until_complete(asyncio.sleep(0.1)) # rizin commands def cmd(self, cmd, **kwargs): """Run an rizin command return string with result Args: cmd (str): rizin command kwargs: Only for open_async: callback (typing.Callable): callback which is to be invoked after cmd has finished Returns: Returns an string with the results of the command res = self._cmd(cmd) if res is not None: return res.strip() return None """ res = self._cmd(cmd, **kwargs) if res is not None: if os.name == "nt": res = res.replace("\r\n", "\n") return res return None def cmdj(self, cmd, **kwargs): """Same as cmd() but evaluates JSONs and returns an object Args: cmdj (str): rizin command Returns: Returns a JSON object respresenting the parsed JSON """ result = self.cmd(cmd, **kwargs) if result is None: return None result = result.strip() if result == "": return None try: data = json.loads(result) except (ValueError, KeyError, TypeError) as e: print("rzpipe.cmdj.Error: %s\n" % e, file=sys.stderr) data = None return data def cmdJ(self, cmd, **kwargs): """Same as cmdj() but evaluates into a native Python Object Args: cmdJ (str): rizin command Returns: Returns a Python object respresenting the parsed JSON """ result = self.cmd(cmd, **kwargs) if result is None: return None result = result.strip() if result == "": return None try: return jo2po(result) except (ValueError, KeyError, TypeError) as e: print("rzpipe.cmdj.Error: %s\n" % e, file=sys.stderr) return None def syscmd(self, cmd): """Executes a program and returns the output (stdout only) Args: cmd (str): commandline shell command Returns: Returns a string with the output """ p = Popen(cmd, shell=True, stdin=PIPE, stdout=PIPE) out, err = p.communicate() return out def syscmdj(self, cmd): """Executes a program and returns an object representing the parsed JSON of the output Args: cmd (str): commandline shell command Returns: Returns an object constructed by parsing the JSON returned by the command """ try: data = json.loads(self.syscmd(cmd)) except (ValueError, KeyError, TypeError) as e: print("rzpipe.syscmdj.Error %s\n" % e, file=sys.stderr) data = None return data ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/rzpipe/open_sync.py0000644000175100001710000001141000000000000017501 0ustar00runnerdocker00000000000000#!/usr/bin/env python3 # -*- coding: utf-8 -*- """open_sync.py This script use code from old __init__.py open object """ import re import socket import time import os from subprocess import Popen, PIPE from urllib.request import urlopen from urllib.error import URLError from urllib.parse import quote from .open_base import OpenBase try: import fcntl except ImportError: fcntl = None class open(OpenBase): def __init__(self, filename="", flags=None, rizin_home=None): super(open, self).__init__(filename, flags) if flags is None: flags = [] if filename.startswith("http://"): self._cmd = self._cmd_http self.uri = filename + "/cmd" elif filename.startswith("ccall://"): self._cmd = self._cmd_native self.uri = filename[7:] elif filename.startswith("tcp://"): r = re.match(r"tcp://(\d+\.\d+.\d+.\d+):(\d+)/?", filename) if not r: raise ValueError("You must provide the tcp address in this format:\n" "tcp://xxx.xxx.xxx.xxx:yyyy") self._cmd = self._cmd_tcp self.conn = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.conn.connect((r.group(1), int(r.group(2)))) elif filename: self._cmd = self._cmd_process if rizin_home is not None: if not os.path.isdir(rizin_home): raise Exception( "`rizinhome` passed is invalid, leave it None or put a valid path to rizin folder" ) rze = os.path.join(rizin_home, "rizin") else: rze = "rizin" if os.name == "nt": # avoid errors on Windows when subprocess messes with name rze += ".exe" cmd = [rze, "-q0", filename] cmd = cmd[:1] + flags + cmd[1:] try: self.process = Popen( cmd, shell=False, stdin=PIPE, stdout=PIPE, bufsize=0 ) except Exception: raise Exception("ERROR: Cannot find rizin in PATH") self.process.stdout.read(1) # Reads initial \x00 # make it non-blocking to speedup reading self.nonblocking = True fd = self.process.stdout.fileno() if not self.__make_non_blocking(fd): raise Exception("ERROR: Cannot make stdout pipe non-blocking") @staticmethod def __make_non_blocking(fd): if fcntl is not None: fl = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, fl | os.O_NONBLOCK) return True if os.name != "nt": raise NotImplementedError() import msvcrt from ctypes import windll, byref from ctypes.wintypes import HANDLE, DWORD, BOOL try: from ctypes import POINTER except: from ctypes.wintypes import POINTER LPDWORD = POINTER(DWORD) SetNamedPipeHandleState = windll.kernel32.SetNamedPipeHandleState SetNamedPipeHandleState.argtypes = [HANDLE, LPDWORD, LPDWORD, LPDWORD] SetNamedPipeHandleState.restype = BOOL h = msvcrt.get_osfhandle(fd) PIPE_NOWAIT = DWORD(0x00000001) res = SetNamedPipeHandleState(h, byref(PIPE_NOWAIT), None, None) return res != 0 def _cmd_process(self, cmd): cmd = cmd.strip().replace("\n", ";") self.process.stdin.write((cmd + "\n").encode("utf8")) r = self.process.stdout self.process.stdin.flush() out = b"" while True: if self.nonblocking: try: foo = r.read(4096) except Exception: continue else: foo = r.read(1) if foo: if foo.endswith(b"\0"): out += foo[:-1] break out += foo else: # if there is no any output from pipe this loop will eat CPU, probably we have to do micro-sleep here if self.nonblocking: time.sleep(0.001) return out.decode("utf-8", errors="ignore") def _cmd_http(self, cmd): try: quoted_cmd = quote(cmd) response = urlopen("{uri}/{cmd}".format(uri=self.uri, cmd=quoted_cmd)) return response.read().decode("utf-8", errors="ignore") except URLError: pass return None def _cmd_tcp(self, cmd): res = b"" self.conn.sendall(str.encode(cmd, "utf-8")) data = self.conn.recv(512) while data: res += data data = self.conn.recv(512) return res.decode("utf-8", errors="ignore") ././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1656405348.447302 rzpipe-0.4.0/rzpipe.egg-info/0000755000175100001710000000000000000000000016627 5ustar00runnerdocker00000000000000././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405348.0 rzpipe-0.4.0/rzpipe.egg-info/PKG-INFO0000644000175100001710000000245600000000000017733 0ustar00runnerdocker00000000000000Metadata-Version: 2.1 Name: rzpipe Version: 0.4.0 Summary: Pipe interface for rizin Home-page: https://rizin.re Author: rizinorg Author-email: info@rizin.re License: MIT Description: # rzpipe for Python Interact with rizin using the `#!pipe` command or in standalone scripts that communicate with local or remote rizin via pipe, tcp or http. ## Installation ```sh $ pip install rzpipe ``` or ```sh $ pip3 install rzpipe ``` ## Usage example: ```python import rzpipe pipe = rzpipe.open("/bin/ls") pipe.cmd('aa') print(pipe.cmd("afl")) print(pipe.cmdj("aflj")) # evaluates JSON and returns an object print(pipe.cmdj("ij").core.format) # shows file format pipe.quit() ``` Platform: UNKNOWN Classifier: License :: OSI Approved :: MIT License Classifier: Programming Language :: Python :: 3 Classifier: Operating System :: OS Independent Classifier: Topic :: Security Classifier: Topic :: Software Development :: Assemblers Classifier: Topic :: Software Development :: Debuggers Classifier: Topic :: Software Development :: Disassemblers Description-Content-Type: text/markdown ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405348.0 rzpipe-0.4.0/rzpipe.egg-info/SOURCES.txt0000644000175100001710000000037700000000000020522 0ustar00runnerdocker00000000000000LICENSE MANIFEST.in README.md setup.py rzpipe/__init__.py rzpipe/native.py rzpipe/open_async.py rzpipe/open_base.py rzpipe/open_sync.py rzpipe.egg-info/PKG-INFO rzpipe.egg-info/SOURCES.txt rzpipe.egg-info/dependency_links.txt rzpipe.egg-info/top_level.txt././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405348.0 rzpipe-0.4.0/rzpipe.egg-info/dependency_links.txt0000644000175100001710000000000100000000000022675 0ustar00runnerdocker00000000000000 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405348.0 rzpipe-0.4.0/rzpipe.egg-info/top_level.txt0000644000175100001710000000000700000000000021356 0ustar00runnerdocker00000000000000rzpipe ././@PaxHeader0000000000000000000000000000003300000000000011451 xustar000000000000000027 mtime=1656405348.447302 rzpipe-0.4.0/setup.cfg0000644000175100001710000000004600000000000015445 0ustar00runnerdocker00000000000000[egg_info] tag_build = tag_date = 0 ././@PaxHeader0000000000000000000000000000002600000000000011453 xustar000000000000000022 mtime=1656405042.0 rzpipe-0.4.0/setup.py0000755000175100001710000000155400000000000015346 0ustar00runnerdocker00000000000000#!/usr/bin/env python3 from setuptools import setup import rzpipe def readme(): with open("README.md") as readme_file: return readme_file.read() setup( name="rzpipe", version=rzpipe.version(), description="Pipe interface for rizin", long_description=readme(), long_description_content_type="text/markdown", author="rizinorg", author_email="info@rizin.re", url="https://rizin.re", license="MIT", package_dir={"rzpipe": "rzpipe"}, packages=["rzpipe"], classifiers=[ "License :: OSI Approved :: MIT License", "Programming Language :: Python :: 3", "Operating System :: OS Independent", "Topic :: Security", "Topic :: Software Development :: Assemblers", "Topic :: Software Development :: Debuggers", "Topic :: Software Development :: Disassemblers", ], )