def _compile(self, md, ars):
mcp = md.Compile()
smsg = mcp.get_name()
try:
cflgs = self._cpp_compiler_flags
if cflgs is not None:
if utils.is_windows():
mcp.set_cpp_compiler_flags("windows", cflgs)
elif utils.is_linux():
mcp.set_cpp_compiler_flags("linux", cflgs)
elif utils.is_mac():
mcp.set_cpp_compiler_flags("mac", cflgs)
lflgs = self._linker_flags
if lflgs is not None:
if utils.is_windows():
mcp.set_linker_flags("windows", lflgs)
elif utils.is_linux():
mcp.set_linker_flags("linux", lflgs)
elif utils.is_mac():
mcp.set_linker_flags("mac", lflgs)
mcp.run()
smsg += " - OK!"
ars.append(smsg)
except Exception as e:
smsg += " - ERROR: " + utils.exception_to_string(e)
ars.append(smsg)
raise e
def __init__(self, reference_folder=None, screenshot_folder=None,
keyword_on_failure='ImageHorizonLibrary.Take A Screenshot'):
'''ImageHorizonLibrary can be imported with several options.
``reference_folder`` is path to the folder where all reference images
are stored. It must be a _valid absolute path_. As the library
is suite-specific (ie. new instance is created for every suite),
different suites can have different folders for it's reference images.
``screenshot_folder`` is path to the folder where screenshots are
saved. If not given, screenshots are saved to the current working
directory.
``keyword_on_failure`` is the keyword to be run, when location-related
keywords fail. If you wish to not take screenshots, use for example
`BuiltIn.No Operation`. Keyword must however be a valid keyword.
'''
self.reference_folder = reference_folder
self.screenshot_folder = screenshot_folder
self.keyword_on_failure = keyword_on_failure
self.open_applications = OrderedDict()
self.screenshot_counter = 1
self.is_windows = utils.is_windows()
self.is_mac = utils.is_mac()
self.is_linux = utils.is_linux()
class TestRemoveSection(TestCase):
def setUp(self):
self.logger = logging.getLogger(__name__)
self.tmp_dir = tempfile.mkdtemp(suffix='_lief_test_section')
self.logger.debug("temp dir: {}".format(self.tmp_dir))
@unittest.skipUnless(is_linux() and is_x86_64(), "requires Linux x86-64")
@unittest.skipUnless(has_recent_glibc(), "Need a recent GLIBC version")
def test_simple(self):
sample_path = get_sample('ELF/ELF64_x86-64_binary_ls.bin')
output = os.path.join(self.tmp_dir, "ls.section")
ls = lief.parse(sample_path)
ls.remove_section(".text", clear=False)
ls.write(output)
st = os.stat(output)
os.chmod(output, st.st_mode | stat.S_IEXEC)
p = Popen([output, "--help"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
stdout, _ = p.communicate()
self.logger.debug(stdout.decode("utf8"))
self.assertIsNotNone(re.search(r'GNU coreutils',
stdout.decode("utf8")))
def tearDown(self):
# Delete it
if os.path.isdir(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
def __init__(self, agent_main):
self._agent_main=agent_main
if utils.is_windows():
self._osnative = Windows(self._agent_main)
elif utils.is_linux():
self._osnative = Linux()
elif utils.is_mac():
self._osnative = Mac()
def log_environment_info():
if utils.is_linux():
logger.info("Xorg running: %s" % test_utils.is_xorg_running())
logger.info("Platform identifier: %s" % utils.platform_identifier)
logger.info("Bare metal: %s" % utils.is_bare_metal_system())
logger.info("Running as user: %s" % getpass.getuser())
rawVersionInfo = dcgm_agent.dcgmVersionInfo()
logger.info("Build info: %s" % rawVersionInfo.rawBuildInfoString)
logger.info("Mig: %s" % test_utils.is_mig_mode_enabled())
logger.debug("ENV : %s" %
string.join(map(str, sorted(os.environ.items())), "\n"))
def initialize_sdk(fileName):
sdk_executable = sdk_path + fileName
if utils.is_linux():
if os.path.exists(sdk_executable):
# On linux, for binaries inside the package (not just commands in the path) test that they have +x
# e.g. if package is extracted on windows and copied to Linux, the +x privileges will be lost
assert os.access(sdk_executable, os.X_OK), \
"SDK binary %s is not executable! Make sure that the testing archive has been correctly extracted." \
% sdk_executable
return subprocess.Popen( sdk_executable, stdout=PIPE, stdin=PIPE)
def start(self, timeout=default_timeout):
"""
Begin executing the application.
The application may block if stdout/stderr buffers become full.
This should be followed by self.terminate() or self.wait() to finish execution.
Execution will be forcefully terminated if the timeout expires.
If timeout is None, then this app will never timeout.
"""
assert self._subprocess is None
logger.debug("Starting " + str(self))
env = self._create_subprocess_env()
if utils.is_linux():
if os.path.exists(self.executable):
# On linux, for binaries inside the package (not just commands in the path) test that they have +x
# e.g. if package is extracted on windows and copied to Linux, the +x privileges will be lost
assert os.access(self.executable, os.X_OK), "Application binary %s is not executable! Make sure that the testing archive has been correctly extracted." % (self.executable)
self.startTime = datetime.datetime.now()
self._subprocess = subprocess.Popen(
[self.executable] + self.args,
stdin=None,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
cwd=self.cwd,
env=env)
AppRunner._processes.append(self) # keep track of running processe
# Start timeout if we want one
self._timer = None
if timeout is not None:
self._timer = threading.Timer(timeout, self._trigger_timeout)
self._timer.start()
if not test_utils.noLogging:
def args_to_fname(args):
# crop each argument to 16 characters and make sure the output string is no longer than 50 chars
# Long file names are hard to read (hard to find the extension of the file)
# Also python sometimes complains about file names being too long.
# IOError: [Errno 36] File name too long
return "_".join([utils.string_to_valid_file_name(x)[:16] for x in self.args])[:50]
shortname = os.path.basename(self.executable) + "_" + args_to_fname(self.args)
stdout_fname = os.path.relpath(os.path.join(
logger.log_dir, "app_%03d_%s_stdout.txt" % (self.process_nb, shortname)))
stderr_fname = os.path.relpath(os.path.join(
logger.log_dir, "app_%03d_%s_stderr.txt" % (self.process_nb, shortname)))
# If the app fails, this message will get printed. If it succeeds it'll get popped in _process_finish
self._info_message = logger.info("Starting %s...\nstdout in %s\nstderr in %s" % (
str(self)[:64], # cut the string to make it more readable
stdout_fname, stderr_fname), defer=True)
self._logfile_stdout = open(stdout_fname, "w", encoding='utf-8')
self._logfile_stderr = open(stderr_fname, "w", encoding='utf-8')
class TestGOTPatch(TestCase):
def setUp(self):
self.logger = logging.getLogger(__name__)
self.tmp_dir = tempfile.mkdtemp(suffix='_lief_test_466')
self.logger.debug("temp dir: {}".format(self.tmp_dir))
@unittest.skipUnless(is_linux() and is_x86_64(), "requires Linux x86-64")
@unittest.skipUnless(has_recent_glibc(), "Need a recent GLIBC version")
def test_freebl(self):
libfreebl3_path = get_sample('ELF/ELF64_x86-64_library_libfreebl3.so')
output_ls = os.path.join(self.tmp_dir, "ls.new")
output_libfreebl3 = os.path.join(self.tmp_dir, "libfreebl3.so")
libfreebl3 = lief.parse(libfreebl3_path)
ls = lief.parse("/usr/bin/ls")
if lief.ELF.DYNAMIC_TAGS.FLAGS_1 in ls and ls[
lief.ELF.DYNAMIC_TAGS.FLAGS_1].has(
lief.ELF.DYNAMIC_FLAGS_1.PIE):
ls[lief.ELF.DYNAMIC_TAGS.FLAGS_1].remove(
lief.ELF.DYNAMIC_FLAGS_1.PIE)
ls.add_library("libfreebl3.so")
ls += lief.ELF.DynamicEntryRunPath("$ORIGIN")
libfreebl3 += lief.ELF.DynamicEntryRunPath("$ORIGIN")
ls.write(output_ls)
libfreebl3.write(output_libfreebl3)
st = os.stat(output_ls)
os.chmod(output_ls, st.st_mode | stat.S_IEXEC)
st = os.stat(output_libfreebl3)
os.chmod(output_libfreebl3, st.st_mode | stat.S_IEXEC)
p = Popen([output_ls, "--version"],
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
stdout, _ = p.communicate()
self.logger.debug(stdout.decode("utf8"))
self.assertIsNotNone(
re.search(r'ls \(GNU coreutils\) ', stdout.decode("utf8")))
self.assertEqual(p.returncode, 0)
def tearDown(self):
# Delete it
if os.path.isdir(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
class TestEmptyGNUHash(TestCase):
SYMBOLS = {
"myinstance": 0x1159,
"myinit": 0x1175,
"mycalc": 0x1199,
"mydelete": 0x1214,
}
def setUp(self):
self.logger = logging.getLogger(__name__)
self.tmp_dir = tempfile.mkdtemp(suffix='_lief_test_empty_gnu_hash')
self.logger.debug("temp dir: {}".format(self.tmp_dir))
@unittest.skipUnless(is_linux() and is_x86_64(), "requires Linux x86-64")
@unittest.skipUnless(has_recent_glibc(), "Need a recent GLIBC version")
def test_export(self):
target_path = get_sample('ELF/ELF64_x86-64_binary_empty-gnu-hash.bin')
output = os.path.join(self.tmp_dir, "libnoempty.so")
binary = lief.parse(target_path)
binary[lief.ELF.DYNAMIC_TAGS.FLAGS_1].remove(
lief.ELF.DYNAMIC_FLAGS_1.PIE)
for name, addr in TestEmptyGNUHash.SYMBOLS.items():
binary.add_exported_function(addr, name)
binary.write(output)
st = os.stat(output)
os.chmod(output, st.st_mode | stat.S_IEXEC)
lib = ctypes.cdll.LoadLibrary(output)
# Raise 'AttributeError' if not exported
print(lib.myinstance)
self.assertIsNotNone(lib.myinstance)
def tearDown(self):
# Delete it
if os.path.isdir(self.tmp_dir):
shutil.rmtree(self.tmp_dir)
OUTPUT_MOVIE_FORMAT = '.mp4'
POINT2_TAG = 'point2'
POINT3_TAG = 'point3'
LINE2_TAG = 'line2'
LINE3_TAG = 'line3'
GRID2_TAG = 'grid2'
GRID3_TAG = 'grid3'
ISO_TAG = 'iso'
X_TAG = 'x'
Y_TAG = 'y'
Z_TAG = 'z'
video_writer = 'ffmpeg'
video_extra_args = ['-vcodec', 'libx264', '-pix_fmt', 'yuv420p']
if utils.is_linux():
video_writer = 'mencoder'
video_extra_args = []
def remove_ext(filename):
return filename[:-len(INPUT_ARRAY_FORMAT)]
def parse_tags(filename):
tokens = remove_ext(filename).split('#')
if len(tokens) > 1:
return tokens[1].split(',')
else:
return []
def is_animation(tags):
for tag in tags:
