void readcfg(char *filename) {
FILE *input;
struct contents *p;
//p = malloc(sizeof(struct contents));
if((input = fopen(filename, "r")) == NULL){
fprintf(stderr, "ERROR: fopen()\n");
exit(-1);
}
if ( (err = load_address(input, vip, vhw, vpt, &vad, &vha,1)) < 0 ){
load_error(err,"Original Victim");
}
if ( (err = load_address(input, aip, ahw, apt, &aad, &aha,1)) < 0 ){
load_error(err,"Original Attacker");
}
if ( (err = load_address(input, rvip, rvmc, vpt, &revi_ip, &revi_mac,0)) < 0 ){
load_error(err,"Replay Victim");
}
if ( (err = load_address(input, ratip, ratmac, apt, &reat_ip, &reat_mac,0)) < 0 ){
load_error(err,"Replay Attacker");
}
if ( fgets(iface, sizeof(iface), input) == NULL ) {
fprintf(stderr, "Interface too large\n");
exit(-1);
}
rmnl(iface);
if ( fgets(timing, sizeof(timing), input) == NULL ) {
fprintf(stderr, "Timing in correct\n");
exit(-1);
}
fclose(input);
return;
}
ContentPtr ContentFactory::createContent(const QString& uri)
{
auto content = _makeContent(uri);
if (!content->readMetadata())
throw load_error("Could not read content metadata.");
return content;
}
void
main (int argc, char *argv[])
{
FILE *fp;
struct stat statbuf;
if (argc != 2) load_error (0);
fp = fopen (argv[1], "rb");
if (fp == NULL) load_error (1, argv[1]);
if (stat (argv[1], &statbuf)) load_error (2, argv[1]);
if (statbuf.st_size < 24) load_error (5);
load_elf_exe (fp);
/* THE ROAD OF NO RETURN!!! */
run_executable();
}
FaceDetector::FaceDetector()
{
if (FLAGS_detector_file.length() > 0) {
if (!m_classifier.load(FLAGS_detector_file)) {
throw load_error()
<< boost::errinfo_file_name(FLAGS_detector_file);
}
}
}
ElfDynVal load_getDyn(sElfDyn *dyn,ElfDynTag tag) {
if(dyn == NULL)
load_error("No dynamic entries");
while(dyn->d_tag != DT_NULL) {
if(dyn->d_tag == tag)
return dyn->d_un.d_val;
dyn++;
}
return 0;
}
bool load_hasDyn(sElfDyn *dyn,ElfDynTag tag) {
if(dyn == NULL)
load_error("No dynamic entries");
while(dyn->d_tag != DT_NULL) {
if(dyn->d_tag == tag)
return true;
dyn++;
}
return false;
}
void readcfg1(char *filename) {
FILE *input;
if((input = fopen(filename, "r")) == NULL){
fprintf(stderr, "ERROR: fopen()\n");
exit(-1);
}
// Get victim ip, mac, port
if ( (err = load_address(input, vip, vhw, vpt, &vad, &vha,1)) < 0 )
load_error(err,"Original Victim");
// Get attacker ip, mac, port
if ( (err = load_address(input, aip, ahw, apt, &aad, &aha,1)) < 0 )
load_error(err,"Original Attacker");
// Get replay victim, ip, mac and then add original victim port
if ( (err = load_address(input, rvip, rvmc, vpt, &revi_ip, &revi_mac,0)) < 0 )
load_error(err,"Replay Victim");
// Get replay attacker, ip, mac and then add original attacker port
if ( (err = load_address(input, ratip, ratmac, apt, &reat_ip, &reat_mac,0)) < 0 )
load_error(err,"Replay Attacker");
// Get the interface
if ( fgets(iface, sizeof(iface), input) == NULL ) {
fprintf(stderr, "Interface too large\n");
exit(-1);
}
rmnl(iface);
// Get the timing
if ( fgets(timing, sizeof(timing), input) == NULL ) {
fprintf(stderr, "Timing in correct\n");
exit(-1);
}
rmnl(timing);
fclose(input);
}
/*!
* \brief Check for a unloaded data on the stream.
*
* If there is still data left on the stream (excluding any initial comments),
* throws an exception with details on the stream position where this occurred.
* All data left from this position onwards is also returned.
*/
void check_incompleteload(std::istream &is)
{
libbase::eatcomments(is);
if (!is.eof())
{
std::ostringstream sout;
sout << "Incomplete loading, stopped at position " << is.tellg()
<< ", next line:" << std::endl;
std::string s;
getline(is, s);
sout << s;
throw load_error(sout.str());
}
}
/*!
* \brief Check for a failure during the last stream input.
*
* If the last stream input did not succeed, throws an exception with
* details on the stream position where this occurred.
*/
void check_failedload(std::istream &is)
{
if (is.fail())
{
std::ios::iostate state = is.rdstate();
is.clear();
std::ostringstream sout;
sout << "Failure loading object at position " << is.tellg()
<< ", next line:" << std::endl;
std::string s;
getline(is, s);
sout << s;
is.clear(state);
throw load_error(sout.str());
}
}
uintptr_t load_setupProg(int binFd,A_UNUSED uintptr_t a,A_UNUSED uintptr_t b,A_UNUSED size_t c,
int argc,char **argv) {
#else
uintptr_t load_setupProg(int binFd,int argc,char **argv) {
#endif
sSharedLib *prog;
uintptr_t entryPoint;
/* create entry for program */
prog = (sSharedLib*)malloc(sizeof(sSharedLib));
if(!prog)
load_error("Not enough mem!");
prog->isDSO = false;
prog->relocated = false;
prog->initialized = false;
prog->dynstrtbl = NULL;
prog->dyn = NULL;
prog->name = "-Main-";
prog->deps = NULL;
appendto(&libs,prog);
/* load program including shared libraries into linked list */
load_doLoad(binFd,prog);
/* load segments into memory */
entryPoint = load_addSegments();
#if PRINT_LOADADDR
for(sSharedLib *l = libs; l != NULL; l = l->next) {
uintptr_t addr;
lookup_byName(NULL,"_start",&addr);
debugf("[%d] Loaded %s @ %p .. %p (text @ %p) with deps: ",
getpid(),l->name,l->loadAddr,l->loadAddr + l->textSize,addr);
for(sDep *dl = l->deps; dl != NULL; dl = dl->next)
debugf("%s ",dl->lib->name);
debugf("\n");
}
#endif
/* relocate everything we need so that the program can start */
load_reloc();
/* call global constructors */
load_init(argc,argv);
return entryPoint;
}
static void load_relocLib(sSharedLib *l) {
ElfAddr *got;
sElfRel *rel;
/* already relocated? */
if(l->relocated)
return;
/* first go through the dependencies; this may be required for the R_386_COPY-relocation */
for(sDep *dl = l->deps; dl != NULL; dl = dl->next)
load_relocLib(dl->lib);
if(load_hasDyn(l->dyn,DT_TEXTREL))
load_error("Unable to reloc library %s: requires a writable text segment\n",l->name);
DBGDL("Relocating %s (loaded @ %p)\n",l->name,l->loadAddr ? l->loadAddr : l->textAddr);
rel = (sElfRel*)load_getDyn(l->dyn,DT_REL);
if(rel)
load_relocDyn(l,rel,load_getDyn(l->dyn,DT_RELSZ),DT_REL);
rel = (sElfRel*)load_getDyn(l->dyn,DT_RELA);
if(rel)
load_relocDyn(l,rel,load_getDyn(l->dyn,DT_RELASZ),DT_RELA);
/* adjust addresses in PLT-jumps */
if(l->jmprel) {
load_relocDyn(l,(void*)((uintptr_t)l->jmprel - l->loadAddr),
load_getDyn(l->dyn,DT_PLTRELSZ),l->jmprelType);
}
/* store pointer to library and lookup-function into GOT */
got = (ElfAddr*)load_getDyn(l->dyn,DT_PLTGOT);
DBGDL("GOT-Address of %s: %p\n",l->name,got);
if(got) {
got = (ElfAddr*)((uintptr_t)got + l->loadAddr);
got[1] = (ElfAddr)l;
got[2] = (ElfAddr)&lookup_resolveStart;
}
l->relocated = true;
/* no longer needed */
close(l->fd);
}
static void load_relocDyn(sSharedLib *l,void *entries,size_t size,uint type) {
sElfRel *rel = (sElfRel*)((uintptr_t)entries + l->loadAddr);
sElfRela *rela = (sElfRela*)((uintptr_t)entries + l->loadAddr);
size_t count = type == DT_REL ? size / sizeof(sElfRel) : size / sizeof(sElfRela);
for(size_t x = 0; x < count; x++) {
ulong info,offset,addend;
if(type == DT_REL) {
info = rel[x].r_info;
offset = rel[x].r_offset;
addend = 0;
}
else {
info = rela[x].r_info;
offset = rela[x].r_offset;
addend = rela[x].r_addend;
}
int rtype = ELF_R_TYPE(info);
if(rtype == R_NONE)
continue;
size_t symIndex = ELF_R_SYM(info);
sElfSym *sym = l->dynsyms + symIndex;
const char *symname = l->dynstrtbl + sym->st_name;
uintptr_t value = sym->st_value;
uintptr_t *ptr = (uintptr_t*)(offset + l->loadAddr);
if(rtype == R_JUMP_SLOT) {
value = *ptr;
if(*ptr == 0 || LD_BIND_NOW) {
if(!lookup_byName(l,symname,&value)) {
if(!lookup_byName(NULL,symname,&value))
load_error("Unable to find symbol '%s'\n",symname);
}
value -= l->loadAddr;
}
}
/* if the symbol-value is 0, it seems that we have to lookup the symbol now and
* store that value instead. TODO I'm not sure if thats correct */
else if(rtype != R_RELATIVE && (rtype == R_COPY || value == 0)) {
if(!lookup_byName(l,symname,&value))
load_error("Unable to find symbol '%s'\n",symname);
// we'll add that again
value -= l->loadAddr;
}
switch(rtype) {
case R_COPY:
memcpy((void*)offset,(void*)(value + l->loadAddr),sym->st_size);
/* set the GOT-Entry in the library of the symbol to the address we've copied
* the value to. TODO I'm not sure if that's the intended way... */
load_adjustCopyGotEntry(symname,offset);
break;
default:
if(!perform_reloc(l,rtype,offset,ptr,value,addend)) {
load_error("In library %s: Unknown relocation: off=%p info=%p type=%d addend=%x\n",
l->name,offset,info,ELF_R_TYPE(info),addend);
}
break;
}
DBGDL("Rel (%s) off=%p reloc=%p value=%p symbol=%s\n",
load_getRelName(rtype),offset,*ptr,value,symname);
}
}