void *load_elf_binary(char* buf, int fd) { /* * ELFheader is at a fixed location and has paramters * required to understand the other components in the * ELF file * * */ Elf64_Ehdr *elfHeader; Elf64_Phdr *phHeader; unsigned char *e_ident; long pg_size; elfHeader = (Elf64_Ehdr *)buf; e_ident = elfHeader->e_ident; // validate elf validate_elf(e_ident); // get program header that has information about parts that // needs to be loaded in memory. phHeader = (Elf64_Phdr *)(buf + elfHeader->e_phoff); // get the page size ASSERT_I( (pg_size = sysconf(_SC_PAGE_SIZE)), "page size" ); DEBUG("Page size: %ld\n", pg_size); int i, prot; unsigned long offsetInPg; // we need to add this number to tatal size unsigned long alignedPgAddr; // pg_size - 1 == 000000 => will give rounded up bits unsigned long mapSize; // total map size. includes bits wasted due to allignment unsigned long offsetInFile; // offset in file Elf64_Addr p_vaddr; int flags = MAP_PRIVATE | MAP_DENYWRITE; unsigned long k_bss; int base_address_set = 0; for (i = 0; i < elfHeader->e_phnum; ++i) { // skip if it's not a load if (phHeader[i].p_type != PT_LOAD) continue; p_vaddr = phHeader[i].p_vaddr; offsetInPg = p_vaddr & (pg_size - 1); alignedPgAddr = p_vaddr & ~(pg_size - 1); mapSize = phHeader[i].p_filesz + offsetInPg; offsetInFile = phHeader[i].p_offset - offsetInPg; prot = getProt(phHeader[i].p_flags); if (elfHeader->e_type == ET_EXEC) flags |= MAP_FIXED; char *m_map; ASSERT_I( (m_map = mmap((caddr_t)alignedPgAddr, mapSize, prot, flags, fd, offsetInFile)), "mmap"); totalMemoryMapped += mapSize; fprintf(stderr, "Mapping aligned virtual address at %li and TMP: %li\n", alignedPgAddr, totalMemoryMapped); CMP_AND_FAIL(m_map, (char *)alignedPgAddr, "Couldn't assign asked virtual address"); // we shift the base address using statuc link. if (base_address_set == 0) { base_virtual_address = (unsigned long)m_map; base_address_set = 1; } // adjust the bss segment. // bss doesn't occupy any space in file where as it does in memory // Note that it is actually present as zero bytes in elf too. if (phHeader[i].p_memsz > phHeader[i].p_filesz) { alignedPgAddr = phHeader[i].p_vaddr + phHeader[i].p_filesz; // move to next page and find the boundary alignedPgAddr = (alignedPgAddr + pg_size - 1) & ~(pg_size - 1); mapSize = phHeader[i].p_memsz - phHeader[i].p_filesz; flags |= MAP_ANONYMOUS; // map this region to Anonymous which is "zeroed" out ASSERT_I( (m_map = mmap((caddr_t)alignedPgAddr, mapSize, prot, flags, -1, 0)), "mmap"); totalMemoryMapped += mapSize; fprintf(stderr, "[BSS]Mapping aligned virtual address at %li and TMP: %li\n", alignedPgAddr, totalMemoryMapped); } } // the entry point for program to execute DEBUG("Entry Point: %p\n", (void *)elfHeader->e_entry); DEBUG("Base aaddress: %li\n", base_virtual_address); return (void *)elfHeader->e_entry; }
int main(int argc, char** argv) { string* addr = new string("127.0.0.1"); uint16_t port = 7766; //Determines whether the program is executed in the sender or receiver role m_nPID = atoi(argv[1]); //the number of OTs that are performed. Has to be initialized to a certain minimum size due to uint64_t numOTs = 1000000; //bitlength of the values that are transferred - NOTE that when bitlength is not 1 or a multiple of 8, the endianness has to be observed uint32_t bitlength = 8; uint32_t runs = 1; //Use elliptic curve cryptography in the base-OTs m_eFType = ECC_FIELD; //The symmetric security parameter (80, 112, 128) uint32_t m_nSecParam = 128; //Number of threads that will be used in OT extension m_nNumOTThreads = 1; //Specifies which OT flavor should be used snd_ot_flavor stype = Snd_OT; rec_ot_flavor rtype = Rec_OT; m_nBaseOTs = 190; m_nChecks = 380; m_bUseMinEntCorAssumption = false; m_eProt = IKNP; read_test_options(&argc, &argv, &m_nPID, &numOTs, &bitlength, &m_nSecParam, addr, &port, &m_eProt, &stype, &rtype, &m_nNumOTThreads, &m_nBaseOTs, &m_nChecks, &m_bUseMinEntCorAssumption, &runs); /*int32_t read_test_options(int32_t* argcp, char*** argvp, uint32_t* role, uint64_t* numots, uint32_t* bitlen, uint32_t* secparam, string* address, uint16_t* port, ot_ext_prot* protocol, snd_ot_flavor* sndflav, rec_ot_flavor* rcvflav, uint32_t* nthreads, uint32_t* nbaseots, uint32_t* nchecks, bool* usemecr, uint32_t* runs) {*/ crypto *crypt = new crypto(m_nSecParam, (uint8_t*) m_cConstSeed[m_nPID]); if(m_nPID == SERVER_ID) //Play as OT sender { InitOTSender(addr->c_str(), port, crypt); CBitVector delta, X1, X2; //The masking function with which the values that are sent in the last communication step are processed m_fMaskFct = new XORMasking(bitlength, delta); //creates delta as an array with "numOTs" entries of "bitlength" bit-values and fills delta with random values delta.Create(numOTs, bitlength, crypt); //Create X1 and X2 as two arrays with "numOTs" entries of "bitlength" bit-values and resets them to 0 X1.Create(numOTs, bitlength, crypt); X2.Create(numOTs, bitlength, crypt); #ifndef BATCH cout << getProt(m_eProt) << " Sender performing " << numOTs << " " << getSndFlavor(stype) << " / " << getRecFlavor(rtype) << " extensions on " << bitlength << " bit elements with " << m_nNumOTThreads << " threads, " << getFieldType(m_eFType) << " and" << (m_bUseMinEntCorAssumption ? "": " no" ) << " min-ent-corr-robustness " << runs << " times" << endl; #endif for(uint32_t i = 0; i < runs; i++) { ObliviouslySend(X1, X2, numOTs, bitlength, stype, rtype, crypt); } } else //Play as OT receiver { InitOTReceiver(addr->c_str(), port, crypt); CBitVector choices, response; //The masking function with which the values that are sent in the last communication step are processed m_fMaskFct = new XORMasking(bitlength); //Create the bitvector choices as a bitvector with numOTs entries choices.Create(numOTs, crypt); //Pre-generate the respose vector for the results response.Create(numOTs, bitlength); response.Reset(); /* * The inputs of the receiver in G_OT, C_OT and R_OT are the same. The only difference is the version * variable that has to match the version of the sender. */ #ifndef BATCH cout << getProt(m_eProt) << " Receiver performing " << numOTs << " " << getSndFlavor(stype) << " / " << getRecFlavor(rtype) << " extensions on " << bitlength << " bit elements with " << m_nNumOTThreads << " threads, " << getFieldType(m_eFType) << " and" << (m_bUseMinEntCorAssumption ? "": " no" ) << " min-ent-corr-robustness " << runs << " times" << endl; #endif for(uint32_t i = 0; i < runs; i++) { ObliviouslyReceive(choices, response, numOTs, bitlength, stype, rtype, crypt); } } //Cleanup(); delete crypt; return 1; }
int main(int argc, char **argv) { const char *addr = "127.0.0.1"; int port = 7766; if (argc != 2) { cout << "Please call with 0 if acting as server or 1 if acting as client" << endl; return 0; } // Determines whether the program is executed in the sender or receiver role m_nPID = atoi(argv[1]); cout << "Playing as role: " << m_nPID << endl; assert(m_nPID >= 0 && m_nPID <= 1); // The symmetric security parameter (80, 112, 128) uint32_t m_nSecParam = 128; crypto *crypt = new crypto(m_nSecParam, (uint8_t *)m_cConstSeed[m_nPID]); uint32_t m_nBaseOTs = 190; uint32_t m_nChecks = 380; ot_ext_prot lastprot = PROT_LAST; field_type lastfield = FIELD_LAST; if (m_nPID == SERVER_ID) // Play as OT sender { InitSender(addr, port); OTExtSnd *sender = NULL; for (uint32_t i = 0; i < m_nTests; i++) { if (lastprot != tests[i].prot || lastfield != tests[i].ftype) { // if(sender) delete sender; sender = InitOTExtSnd(tests[i].prot, m_nBaseOTs, m_nChecks, tests[i].usemecr, tests[i].ftype, crypt); lastprot = tests[i].prot; lastfield = tests[i].ftype; } cout << "Test " << i << ": " << getProt(tests[i].prot) << " Sender " << tests[i].numots << " " << getSndFlavor(tests[i].sflavor) << " / " << getRecFlavor(tests[i].rflavor) << " on " << tests[i].bitlen << " bits with " << tests[i].nthreads << " threads, " << getFieldType(tests[i].ftype) << " and" << (tests[i].usemecr ? "" : " no") << " MECR" << endl; run_test_sender(tests[i].numots, tests[i].bitlen, tests[i].sflavor, tests[i].rflavor, tests[i].nthreads, crypt, sender); } delete sender; } else // Play as OT receiver { InitReceiver(addr, port); OTExtRec *receiver = NULL; for (uint32_t i = 0; i < m_nTests; i++) { if (lastprot != tests[i].prot || lastfield != tests[i].ftype) { // if(receiver) delete receiver; receiver = InitOTExtRec(tests[i].prot, m_nBaseOTs, m_nChecks, tests[i].usemecr, tests[i].ftype, crypt); lastprot = tests[i].prot; lastfield = tests[i].ftype; } cout << "Test " << i << ": " << getProt(tests[i].prot) << " Receiver " << tests[i].numots << " " << getSndFlavor(tests[i].sflavor) << " / " << getRecFlavor(tests[i].rflavor) << " on " << tests[i].bitlen << " bits with " << tests[i].nthreads << " threads, " << getFieldType(tests[i].ftype) << " and" << (tests[i].usemecr ? "" : " no") << " MECR" << endl; run_test_receiver(tests[i].numots, tests[i].bitlen, tests[i].sflavor, tests[i].rflavor, tests[i].nthreads, crypt, receiver); } delete receiver; } Cleanup(); delete crypt; return 1; }