int main(int argc, char *argv[])
{
// Initialize pin & symbol manager
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return Usage();
}
// Write to a file since cout and cerr maybe closed by the application
TraceFile.open(KnobOutputFile.Value().c_str());
TraceFile << hex;
TraceFile.setf(ios::showbase);
// Register Image to be called to instrument functions.
IMG_AddInstrumentFunction(Image, 0);
// RTN_AddInstrumentFunction(Routine, 0);
// Register ImageUnload to be called when an image is unloaded
// IMG_AddUnloadFunction(ImageUnload, 0);
// Register Fini to be called when the application exits
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
// Initialize the pin lock
InitLock(&lock);
// Initialize pin
if (PIN_Init(argc, argv)) return Usage();
PIN_InitSymbols();
out = fopen(KnobOutputFile.Value().c_str(), "w");
// Register ImageLoad to be called when each image is loaded.
IMG_AddInstrumentFunction(ImageLoad, 0);
// Register Analysis routines to be called when a thread begins/ends
PIN_AddThreadStartFunction(ThreadStart, 0);
PIN_AddThreadFiniFunction(ThreadFini, 0);
// Register Fini to be called when the application exits
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
if (PIN_Init(argc, argv))
return 1;
Stat.open(STAT_FILE);
TraceFile.open(TRACE_FILE);
RetFile.open(RET_FILE);
PIN_InitLock(&lock);
tls_key = PIN_CreateThreadDataKey(0);
// Register ThreadStart to be called when a thread starts.
PIN_AddThreadStartFunction(ThreadStart, 0);
TRACE_AddInstrumentFunction(Trace, 0);
IMG_AddInstrumentFunction(ImageLoad, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
return 0;
}
int main( int argc, char *argv[] ) {
if ( PIN_Init( argc, argv ) ) {
return Usage();
}
PIN_InitSymbols();
initRcdcSim();
IMG_AddInstrumentFunction( instrumentImage, NULL );
TRACE_AddInstrumentFunction( instrumentTrace, NULL );
cerr << " Before this function\n";
//INS_AddInstrumentFunction(Instruction, 0);
cerr << " After this function\n";
PIN_AddThreadStartFunction( threadBegin, NULL );
PIN_AddThreadFiniFunction( threadEnd, NULL );
PIN_AddContextChangeFunction( beforeSignal, NULL );
PIN_AddSyscallEntryFunction( beforeSyscall, NULL );
PIN_AddSyscallExitFunction( afterSyscall, NULL );
PIN_AddFiniUnlockedFunction( pinFini, NULL );
if ( !CODECACHE_ChangeMaxInsPerTrace( 4096 * 1024 ) ) {
fprintf( stderr, "TLSProf::CODECACHE_ChangeMaxInsPerTrace failed.\n" );
}
THREADID tid = PIN_SpawnInternalThread( ioThread, NULL, 0, &s_IOThreadId );
assert( tid != INVALID_THREADID );
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
PIN_InitSymbols();
if( PIN_Init(argc,argv) )
{
return Usage();
}
TraceFile.open(KnobOutputFile.Value().c_str());
TraceFile << hex;
TraceFile.setf(ios::showbase);
cout << hex;
cout.setf(ios::showbase);
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
int log_taint = 0;
for (int i = 3; i < argc; i++) {
if(!strcmp(argv[i], "--main-module")) {
set_main_module();
log_info("Whitelisted the main module\n");
}
else if(!strcmp(argv[i], "--range")) {
ADDRINT start = strtoul(argv[++i], NULL, 16);
ADDRINT end = strtoul(argv[++i], NULL, 16);
add_instrument_range(start, end);
log_info("Whitelisted range 0x%08x..0x%08x\n", start, end);
}
else if(!strcmp(argv[i], "--ins")) {
log_info("Whitelisted mnemonic(s): %s\n", argv[++i]);
add_instrument_instruction(argv[i]);
}
else if(!strcmp(argv[i], "--inside")) {
ADDRINT start = strtoul(argv[++i], NULL, 16);
ADDRINT end = strtoul(argv[++i], NULL, 16);
add_instrument_inside(start, end);
log_info("Whitelisted inside sequence 0x%08x..0x%08x\n",
start, end);
}
else if(!strcmp(argv[i], "--module")) {
add_instrument_module(argv[++i]);
log_info("Whitelisted modules containing: %s\n", argv[i]);
}
}
PIN_Init(argc, argv);
PIN_InitSymbols();
registers_init();
taint_init(log_taint);
taint_source_enable("getc");
taint_source_enable("scanf");
IMG_AddInstrumentFunction(&module_range_handler, NULL);
IMG_AddInstrumentFunction(&taint_sources_handler, NULL);
INS_AddInstrumentFunction(&insns, NULL);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
// Initialize symbol processing
PIN_InitSymbols();
// Initialize pin
if (PIN_Init(argc, argv)) return Usage();
logging = ! KnobReplay.Value();
if (logging)
{
trace = fopen("record_imageload_rec.out", "w");
imgLog = fopen("imageload.log", "w");
IMG_AddInstrumentFunction(LogImageLoad, 0);
IMG_AddUnloadFunction (LogImageUnload, 0);
}
else
{ // Replaying
trace = fopen("record_imageload_play.out", "w");
imgLog = fopen("imageload.log", "r");
// We will handle image load operations.
PIN_SetReplayMode (REPLAY_MODE_IMAGEOPS);
// And then we replay the first two image load ops before we start the program.
// We do this even before adding the image instrumentation callback, that should still work,
// Pin should defer these and replay them inside PIN_StartProgram.
ReplayImageEntry();
ReplayImageEntry();
INS_AddInstrumentFunction (InstrumentInstruction, 0);
}
// These Trace functions demonstrate that the events are happening, they are the client...
IMG_AddInstrumentFunction(TraceImageLoad, 0);
IMG_AddUnloadFunction (TraceImageUnload, 0);
// Register Fini to be called when the application exits
PIN_AddFiniFunction(Fini, 0);
// Start the program, never returns
PIN_StartProgram();
return 0;
}
int main( int argc, char **argv ){
PIN_InitSymbols();
if( PIN_Init(argc,argv) ) {
return Usage();
}
//out_file.open(KnobOutputFile.Value().c_str(), fstream::out);
stringstream ss(KnobThreadCount.Value());
ss >> total_threads;
char *out_file_name = new char[BUF_SIZE];
out_file = new fstream*[total_threads];
for (INT32 i = 0; i < total_threads; i++) {
sprintf(out_file_name, "%s.%d", KnobOutputFile.Value().c_str(), i);
//cout<< out_file_name << endl;
out_file[i] = new fstream(out_file_name, fstream::out);
}
stringstream ss_count(KnobSampleRate.Value());
ss_count >> sample_counter;
cout << "::PINTOOL:: sample per " << sample_counter << " inst" << endl;
string stdinFile = KnobStdinFile.Value();
if(stdinFile.size() > 0) {
assert(freopen(stdinFile.c_str(), "rt", stdin));
}
string isSeqProgram = KnobSeqProgram.Value();
if(isSeqProgram.size() > 0) {
SeqProgram = true;
}
CacheUtil::getInstance().initialize();
CacheCore::getInstance().initialize(total_threads);
if(!SeqProgram) {
PIN_AddThreadStartFunction(ThreadBegin,0);
PIN_AddThreadFiniFunction(ThreadEnd,0);
}
/* initialize random seed: */
srand (time(NULL));
IMG_AddInstrumentFunction(Image, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
}
int main(int argc, char **argv)
{
PIN_InitSymbols();
if ( PIN_Init(argc, argv) )
return -1;
IMG_AddInstrumentFunction(process_loaded_image, 0);
PIN_StartProbedProgram();
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
IMG_AddInstrumentFunction(InstrumentImage, 0);
PIN_AddFiniFunction(AtApplicationEnd, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
IMG_AddInstrumentFunction(OnImage, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char** argv)
{
PIN_InitSymbols();
if(PIN_Init(argc,argv))
{
return Usage();
}
// Set up the events
initialize_events();
if(!KnobDisableLibraryTracing.Value())
{
printf("Enabling library tracing.\n");
/* Enable library tracing. */
IMG_AddInstrumentFunction(library_loaded_function, 0);
IMG_AddUnloadFunction(library_unloaded_function, 0);
}
if(KnobEnableInitialMonitoring.Value())
{
printf("Enabling tracing on initialization.\n");
event_monitoring_set(true);
}
if(KnobEnableMonitoring.Value())
{
long start = KnobRegionStart.Value();
long end = KnobRegionEnd.Value();
const char* library_name = KnobRegionName.Value().c_str();
printf("Library name: %s\n", library_name);
printf("0x%lx 0x%lx\n", start, end);
region_t *r = (region_t*)malloc(sizeof(region_t));
r->start = (void*)start;
r->end = (void*)end;
strncpy(r->library_name, library_name, 260);
printf("Added %s\n", r->library_name);
add_region_to_monitoring(r);
event_snapshot_set(true);
region_monitoring_enabled = true;
}
// Add instrumentation. It handles both regions and instruction monitoring so must be enabled
INS_AddInstrumentFunction(instruction_trace, 0);
// Start up the program to investigate.
PIN_StartProgram();
return 0;
}
//! The pintool's entry point
int main(int argc, char *argv[]) {
PIN_InitSymbols();
PIN_SetSyntaxIntel();
if(PIN_Init(argc, argv))
return Usage();
/* Init the Triton module */
triton::bindings::python::inittriton();
/* Define Triton architecure */
if (sizeof(void*) == QWORD_SIZE)
tracer::pintool::api.setArchitecture(triton::arch::ARCH_X86_64);
else
tracer::pintool::api.setArchitecture(triton::arch::ARCH_X86);
/* During the execution provide concrete values only if Triton needs them - cf #376, #632 and #645 */
tracer::pintool::api.addCallback(tracer::pintool::context::needConcreteRegisterValue);
tracer::pintool::api.addCallback(tracer::pintool::context::needConcreteMemoryValue);
/* Image callback */
IMG_AddInstrumentFunction(IMG_Instrumentation, nullptr);
/* Instruction callback */
TRACE_AddInstrumentFunction(TRACE_Instrumentation, nullptr);
/* End instrumentation callback */
PIN_AddFiniFunction(callbackFini, nullptr);
/* Syscall entry callback */
PIN_AddSyscallEntryFunction(callbackSyscallEntry, nullptr);
/* Syscall exit callback */
PIN_AddSyscallExitFunction(callbackSyscallExit, nullptr);
/* Signals callback */
PIN_InterceptSignal(SIGHUP, callbackSignals, nullptr);
PIN_InterceptSignal(SIGINT, callbackSignals, nullptr);
PIN_InterceptSignal(SIGQUIT, callbackSignals, nullptr);
PIN_InterceptSignal(SIGILL, callbackSignals, nullptr);
PIN_InterceptSignal(SIGABRT, callbackSignals, nullptr);
PIN_InterceptSignal(SIGFPE, callbackSignals, nullptr);
PIN_InterceptSignal(SIGKILL, callbackSignals, nullptr);
PIN_InterceptSignal(SIGSEGV, callbackSignals, nullptr);
PIN_InterceptSignal(SIGPIPE, callbackSignals, nullptr);
PIN_InterceptSignal(SIGALRM, callbackSignals, nullptr);
PIN_InterceptSignal(SIGTERM, callbackSignals, nullptr);
PIN_InterceptSignal(SIGBUS, callbackSignals, nullptr);
/* Exec the Pin's python bindings */
tracer::pintool::initBindings(argc, argv);
tracer::pintool::execScript(KnobPythonModule.Value().c_str());
return 0;
}
int main(INT32 argc, CHAR **argv)
{
PIN_Init(argc, argv);
PIN_InitSymbols();
INS_AddInstrumentFunction(Instruction, 0);
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char *argv[])
{
if( PIN_Init(argc,argv) )
return Usage();
// Next call is needed, otherwise we can't find routines by name
PIN_InitSymbols();
outFile = KnobOutputFile.Value().empty() ? &cout : new std::ofstream(KnobOutputFile.Value().c_str());
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_StartProgram(); // Never returns
return 0;
}
int main(int argc, char **argv)
{
PIN_Init(argc, argv);
PIN_InitSymbols();
//PIN_AddThreadStartFunction(OnThread, 0);
IMG_AddInstrumentFunction(Image, 0);
PIN_AddContextChangeFunction(OnException, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbolsAlt( SYMBOL_INFO_MODE(UINT32(IFUNC_SYMBOLS) | UINT32(DEBUG_OR_EXPORT_SYMBOLS)));
IMG_AddInstrumentFunction(Image,0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
IMG_AddInstrumentFunction(OnImage, 0);
PIN_AddContextChangeFunction(OnSignal, 0);
PIN_AddFiniFunction(OnExit, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char **argv)
{
PIN_Init(argc, argv);
PIN_InitSymbols();
OutFile.open("iarg_tsc_probed1.out");
IMG_AddInstrumentFunction(Image, 0);
PIN_StartProgramProbed();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitSymbols();
PIN_Init(argc, argv);
IMG_AddInstrumentFunction(ImgFirst, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, char **argv)
{
PIN_Init(argc, argv);
PIN_InitSymbols();
IMG_AddInstrumentFunction(Image, 0);
RTN_AddInstrumentFunction(Rtn, 0);
PIN_AddFiniFunction(Fini, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
PIN_InitLock(&ToolLock);
IMG_AddInstrumentFunction(OnImage, 0);
PIN_AddSyscallEntryFunction(OnSyscall, 0);
PIN_StartProgram();
return 0;
}
int main(INT32 argc, CHAR **argv)
{
PIN_InitSymbols();
PIN_Init(argc, argv);
PIN_AddFollowChildProcessFunction(FollowChild, 0);
// Never returns
if (PIN_IsProbeMode())
{
IMG_AddInstrumentFunction(ImageLoad, (VOID *)1);
PIN_StartProgramProbed();
}
else
{
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_StartProgram();
}
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
PIN_AddSignalInterceptFunction(SIGUSR2, SignalHandler, 0);
IMG_AddInstrumentFunction(Image, 0);
TRACE_AddInstrumentFunction(Trace, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char** argv)
{
PIN_InitSymbols();
if (!PIN_Init(argc, argv))
{
IMG_AddInstrumentFunction(on_module_loading, 0);
PIN_StartProbedProgram();
}
exit(1);
}
int mainRoutine()
{
TraceAntiDebug.open("logs\\antidebug_routines.out");
TraceAntiVirtual.open("logs\\antivirtual_routines.out");
TraceAntiSandbox.open("logs\\antisandbox_routines.out");
TraceRegistry.open("logs\\registry.out");
RTN_AddInstrumentFunction(Routine, 0);
PIN_AddFiniFunction(RoutinesFini, 0);
IMG_AddInstrumentFunction(Image, (VOID *) 1);
PIN_AddFiniFunction(Fini, 0);
return 0;
}
int main(int argc, char * argv[])
{
PIN_InitSymbols();
PIN_Init(argc, argv);
TRACE_AddInstrumentFunction(Trace, 0);
IMG_AddInstrumentFunction(Image, 0);
// Never returns
PIN_StartProgram();
return 0;
}
int main(int argc, CHAR *argv[])
{
PIN_InitSymbols();
if (PIN_Init(argc,argv))
return 1;
TraceFile.open(KnobOutputFile.Value().c_str());
IMG_AddInstrumentFunction(ImageLoad, 0);
PIN_StartProgramProbed();
return 0;
}
int main(int argc, char *argv[])
{
PIN_InitSymbols();
if(PIN_Init(argc, argv)){
return Usage();
}
PIN_SetSyntaxIntel();
IMG_AddInstrumentFunction(Image, 0);
INS_AddInstrumentFunction(Instruction, 0);
PIN_StartProgram();
return 0;
}
int main(int argc, char * argv[])
{
PIN_Init(argc, argv);
PIN_InitSymbols();
InitLock(&Lock);
IMG_AddInstrumentFunction(OnImage, 0);
RTN_AddInstrumentFunction(InstrumentRtn, 0);
PIN_InterceptDebuggingEvent(DEBUGGING_EVENT_BREAKPOINT, Intercept, 0);
PIN_InterceptDebuggingEvent(DEBUGGING_EVENT_ASYNC_BREAK, Intercept, 0);
PIN_AddFiniFunction(OnExit, 0);
PIN_StartProgram();
return 0;
}
