coredump - Notes

>> Relocation section '.rela.plt' at offset 0x4b8 contains 1 entry: >> Offset Info Type Sym. Value Sym. Name + Addend >> 000000404018 000200000007 R_X86_64_JUMP_SLO 0000000000000000 puts@GLIBC_2.2.5 + 0 As we can see the offset from relocation at index 0 points to GOT[3].","breadcrumbs":"Development » Dynamic Linking (x86_64)","id":"230","title":"Dynamic Linking (x86_64)"},"231":{"body":"The ELF symbol versioning mechanism allows to attach version information to symbols. This can be used to express symbol version requirements or to provide certain symbols multiple times in the same ELF file with different versions (eg for backwards compatibility). The libpthread.so library is an example which provides the pthread_cond_wait symbol multiple times but in different versions. With readelf the version of the symbol can be seen after the @. > readelf -W --dyn-syms /lib/libpthread.so Symbol table '.dynsym' contains 342 entries: Num: Value Size Type Bind Vis Ndx Name ... 141: 0000f080 696 FUNC GLOBAL DEFAULT 16 pthread_cond_wait@@GLIBC_2.3.2 142: 00010000 111 FUNC GLOBAL DEFAULT 16 pthread_cond_wait@GLIBC_2.2.5 The @@ denotes the default symbol version which will be used during static linking against the library. The following dump shows that the tmp program linked against lpthread will depend on the symbol version GLIBC_2.3.2, which is the default version. > echo \"#include int main() { return pthread_cond_wait(0,0); }\" | gcc -o tmp -xc - -lpthread; readelf -W --dyn-syms tmp | grep pthread_cond_wait; Symbol table '.dynsym' contains 7 entries: Num: Value Size Type Bind Vis Ndx Name ... 2: 00000000 0 FUNC GLOBAL DEFAULT UND pthread_cond_wait@GLIBC_2.3.2 (2) Only one symbol can be annotated as the @@ default version. Using the --version-info flag with readelf, more details on the symbol version info compiled into the tmp ELF file can be obtained. The .gnu.version section contains the version definition for each symbol in the .dynsym section. pthread_cond_wait is at index 2 in the .dynsym section, the corresponding symbol version is at index 2 in the .gnu.version section. The .gnu.version_r section contains symbol version requirements per shared library dependency (DT_NEEDED dynamic entry). > readelf -W --version-info --dyn-syms tmp Symbol table '.dynsym' contains 7 entries: Num: Value Size Type Bind Vis Ndx Name 0: 0000000000000000 0 NOTYPE LOCAL DEFAULT UND 1: 0000000000000000 0 NOTYPE WEAK DEFAULT UND _ITM_deregisterTMCloneTable 2: 0000000000000000 0 FUNC GLOBAL DEFAULT UND pthread_cond_wait@GLIBC_2.3.2 (2) 3: 0000000000000000 0 FUNC GLOBAL DEFAULT UND __libc_start_main@GLIBC_2.2.5 (3) 4: 0000000000000000 0 NOTYPE WEAK DEFAULT UND __gmon_start__ 5: 0000000000000000 0 NOTYPE WEAK DEFAULT UND _ITM_registerTMCloneTable 6: 0000000000000000 0 FUNC WEAK DEFAULT UND __cxa_finalize@GLIBC_2.2.5 (3) Version symbols section '.gnu.version' contains 7 entries: Addr: 0x0000000000000534 Offset: 0x000534 Link: 6 (.dynsym) 000: 0 (*local*) 0 (*local*) 2 (GLIBC_2.3.2) 3 (GLIBC_2.2.5) 004: 0 (*local*) 0 (*local*) 3 (GLIBC_2.2.5) Version needs section '.gnu.version_r' contains 2 entries: Addr: 0x0000000000000548 Offset: 0x000548 Link: 7 (.dynstr) 000000: Version: 1 File: libc.so.6 Cnt: 1 0x0010: Name: GLIBC_2.2.5 Flags: none Version: 3 0x0020: Version: 1 File: libpthread.so.0 Cnt: 1 0x0030: Name: GLIBC_2.3.2 Flags: none Version: 2 The gnu dynamic linker allows to inspect the version processing during runtime by setting the LD_DEBUG environment variable accordingly. # version: Display version dependencies.\n> LD_DEBUG=versions ./tmp 717904: checking for version `GLIBC_2.2.5' in file /usr/lib/libc.so.6 [0] required by file ./tmp [0] 717904: checking for version `GLIBC_2.3.2' in file /usr/lib/libpthread.so.0 [0] required by file ./tmp [0] ... # symbols : Display symbol table processing.\n# bindings: Display information about symbol binding.\n> LD_DEBUG=symbols,bindings ./tmp ... 718123: symbol=pthread_cond_wait; lookup in file=./tmp [0] 718123: symbol=pthread_cond_wait; lookup in file=/usr/lib/libpthread.so.0 [0] 718123: binding file ./tmp [0] to /usr/lib/libpthread.so.0 [0]: normal symbol `pthread_cond_wait' [GLIBC_2.3.2]","breadcrumbs":"Development » ELF Symbol Versioning","id":"231","title":"ELF Symbol Versioning"},"232":{"body":"The following shows an example C++ library libfoo which provides the same symbol multiple times but in different versions. // file: libfoo.cc\n#include // Bind function symbols to version nodes.\n//\n// ..@ -> Is the unversioned symbol.\n// ..@@.. -> Is the default symbol. __asm__(\".symver func_v0,func@\");\n__asm__(\".symver func_v1,func@LIB_V1\");\n__asm__(\".symver func_v2,func@@LIB_V2\"); extern \"C\" { void func_v0() { puts(\"func_v0\"); } void func_v1() { puts(\"func_v1\"); } void func_v2() { puts(\"func_v2\"); }\n} __asm__(\".symver _Z11func_cpp_v1i,_Z8func_cppi@LIB_V1\");\n__asm__(\".symver _Z11func_cpp_v2i,_Z8func_cppi@@LIB_V2\"); void func_cpp_v1(int) { puts(\"func_cpp_v1\"); }\nvoid func_cpp_v2(int) { puts(\"func_cpp_v2\"); } void func_cpp(int) { puts(\"func_cpp_v2\"); } Version script for libfoo which defines which symbols for which versions are exported from the ELF file. # file: libfoo.ver\nLIB_V1 { global: func; extern \"C++\" { \"func_cpp(int)\"; }; local: *;\n}; LIB_V2 { global: func; extern \"C++\" { \"func_cpp(int)\"; };\n} LIB_V1; The local: section in LIB_V1 is a catch all, that matches any symbol not explicitly specified, and defines that the symbol is local and therefore not exported from the ELF file. The library libfoo can be linked with the version definitions in libfoo.ver by passing the version script to the linker with the --version-script flag. > g++ -shared -fPIC -o libfoo.so libfoo.cc -Wl,--version-script=libfoo.ver\n> readelf -W --dyn-syms libfoo.so | c++filt Symbol table '.dynsym' contains 14 entries: Num: Value Size Type Bind Vis Ndx Name ... 6: 0000000000000000 0 OBJECT GLOBAL DEFAULT ABS LIB_V1 7: 000000000000114b 29 FUNC GLOBAL DEFAULT 13 func_cpp(int)@LIB_V1 8: 0000000000001168 29 FUNC GLOBAL DEFAULT 13 func_cpp(int)@@LIB_V2 9: 0000000000001185 29 FUNC GLOBAL DEFAULT 13 func_cpp(int)@@LIB_V1 10: 0000000000000000 0 OBJECT GLOBAL DEFAULT ABS LIB_V2 11: 0000000000001109 22 FUNC GLOBAL DEFAULT 13 func 12: 000000000000111f 22 FUNC GLOBAL DEFAULT 13 func@LIB_V1 13: 0000000000001135 22 FUNC GLOBAL DEFAULT 13 func@@LIB_V2 The following program demonstrates how to make use of the different versions: // file: main.cc\n#include \n#include // Links against default symbol in the lib.so.\nextern \"C\" void func(); int main() { // Call the default version. func(); #ifdef _GNU_SOURCE typedef void (*fnptr)(); // Unversioned lookup. fnptr fn_v0 = (fnptr)dlsym(RTLD_DEFAULT, \"func\"); // Version lookup. fnptr fn_v1 = (fnptr)dlvsym(RTLD_DEFAULT, \"func\", \"LIB_V1\"); fnptr fn_v2 = (fnptr)dlvsym(RTLD_DEFAULT, \"func\", \"LIB_V2\"); assert(fn_v0 != 0); assert(fn_v1 != 0); assert(fn_v2 != 0); fn_v0(); fn_v1(); fn_v2();\n#endif return 0;\n} Compiling and running results in: > g++ -o main main.cc -ldl ./libfoo.so && ./main\nfunc_v2\nfunc_v0\nfunc_v1\nfunc_v2","breadcrumbs":"Development » Example: version script","id":"232","title":"Example: version script"},"233":{"body":"ELF Symbol Versioning Binutils ld: Symbol Versioning LSB: Symbol Versioning How To Write Shared Libraries","breadcrumbs":"Development » References","id":"233","title":"References"},"234":{"body":"","breadcrumbs":"Development » python","id":"234","title":"python"},"235":{"body":"Some decorator examples with type annotation. from typing import Callable def log(f: Callable[[int], None]) -> Callable[[int], None]: def inner(x: int): print(f\"log::inner f={f.__name__} x={x}\") f(x) return inner @log\ndef some_fn(x: int): print(f\"some_fn x={x}\") def log_tag(tag: str) -> Callable[[Callable[[int], None]], Callable[[int], None]]: def decorator(f: Callable[[int], None]) -> Callable[[int], None]: def inner(x: int): print(f\"log_tag::inner f={f.__name__} tag={tag} x={x}\") f(x) return inner return decorator @log_tag(\"some_tag\")\ndef some_fn2(x: int): print(f\"some_fn2 x={x}\")","breadcrumbs":"Development » Decorator [ run ]","id":"235","title":"Decorator [ run ]"},"236":{"body":"Walrus operator := added since python 3.8 . from typing import Optional # Example 1: if let statements def foo(ret: Optional[int]) -> Optional[int]: return ret if r := foo(None): print(f\"foo(None) -> {r}\") if r := foo(1337): print(f\"foo(1337) -> {r}\") # Example 2: while let statements toks = iter(['a', 'b', 'c'])\nwhile tok := next(toks, None): print(f\"{tok}\") # Example 3: list comprehension print([tok for t in [\" a\", \" \", \" b \"] if (tok := t.strip())])","breadcrumbs":"Development » Walrus operator [ run ]","id":"236","title":"Walrus operator [ run ]"},"237":{"body":"Run unittests directly from the command line as python3 -m unittest -v test Optionally pass -k to only run subset of tests. # file: test.py import unittest class MyTest(unittest.TestCase): def setUp(self): pass def tearDown(self): pass # Tests need to start with the prefix 'test'. def test_foo(self): self.assertEqual(1 + 2, 3) def test_bar(self): with self.assertRaises(IndexError): list()[0]","breadcrumbs":"Development » Unittest [ run ]","id":"237","title":"Unittest [ run ]"},"238":{"body":"Run doctests directly from the command line as python -m doctest -v test.py # file: test.py def sum(a: int, b: int) -> int: \"\"\"Sum a and b. >>> sum(1, 2) 3 >>> sum(10, 20) 30 \"\"\" return a + b","breadcrumbs":"Development » Doctest [ run ]","id":"238","title":"Doctest [ run ]"},"239":{"body":"Micro benchmarking. python -m timeit '[x.strip() for x in [\"a \", \" b\"]]'","breadcrumbs":"Development » timeit","id":"239","title":"timeit"},"24":{"body":"Bash supports regular expression matching with the binary operator =~. The match results can be accessed via the $BASH_REMATCH variable: ${BASH_REMATCH[0]} contains the full match ${BASH_REMATCH[1]} contains match of the first capture group INPUT='title foo : 1234'\nREGEX='^title (.+) : ([0-9]+)$'\nif [[ $INPUT =~ $REGEX ]]; then echo \"${BASH_REMATCH[0]}\" # title foo : 1234 echo \"${BASH_REMATCH[1]}\" # foo echo \"${BASH_REMATCH[2]}\" # 1234\nfi Caution : When specifying a regex in the [[ ]] block directly, quotes will be treated as part of the pattern. [[ $INPUT =~ \"foo\" ]] will match against \"foo\" not foo!","breadcrumbs":"Tools » Regular Expressions","id":"24","title":"Regular Expressions"},"240":{"body":"x86_64 arm64 armv7","breadcrumbs":"Arch","id":"240","title":"Arch"},"241":{"body":"keywords: x86_64, x86, abi 64bit synonyms: x86_64, x64, amd64, intel 64 32bit synonyms: x86, ia32, i386 ISA type: CISC Endianness: little","breadcrumbs":"Arch » x86_64","id":"241","title":"x86_64"},"242":{"body":"","breadcrumbs":"Arch » Registers","id":"242","title":"Registers"},"243":{"body":"bytes\n[7:0] [3:0] [1:0] [1] [0] desc\n----------------------------------------------------------\nrax eax ax ah al accumulator\nrbx ebx bx bh bl base register\nrcx ecx cx ch cl counter\nrdx edx dx dh dl data register\nrsi esi si - sil source index\nrdi edi di - dil destination index\nrbp ebp bp - bpl base pointer\nrsp esp sp - spl stack pointer\nr8-15 rNd rNw - rNb","breadcrumbs":"Arch » General purpose register","id":"243","title":"General purpose register"},"244":{"body":"bytes\n[7:0] [3:0] [1:0] desc\n---------------------------------------------------\nrflags eflags flags flags register\nrip eip ip instruction pointer","breadcrumbs":"Arch » Special register","id":"244","title":"Special register"},"245":{"body":"rflags\nbits desc instr comment\n-------------------------------------------------------------------------------------------------------------- [21] ID identification ability to set/clear -> indicates support for CPUID instr [18] AC alignment check alignment exception for PL 3 (user), requires CR0.AM\n[13:12] IOPL io privilege level [11] OF overflow flag [10] DF direction flag cld/std [9] IF interrupt enable cli/sti [7] SF sign flag [6] ZF zero flag [4] AF auxiliary carry flag [2] PF parity flag [0] CF carry flag Change flag bits with pushf / popf instructions: pushfd // push flags (4bytes) onto stack\nor dword ptr [esp], (1 << 18) // enable AC flag\npopfd // pop flags (4byte) from stack There is also pushfq / popfq to push and pop all 8 bytes of rflags.","breadcrumbs":"Arch » FLAGS register","id":"245","title":"FLAGS register"},"246":{"body":"rdmsr // Read MSR register, effectively does EDX:EAX <- MSR[ECX]\nwrmsr // Write MSR register, effectively does MSR[ECX] <- EDX:EAX","breadcrumbs":"Arch » Model Specific Register (MSR)","id":"246","title":"Model Specific Register (MSR)"},"247":{"body":"Explicitly specify size of the operation. mov byte ptr [rax], 0xff // save 1 byte(s) at [rax]\nmov word ptr [rax], 0xff // save 2 byte(s) at [rax]\nmov dword ptr [rax], 0xff // save 4 byte(s) at [rax]\nmov qword ptr [rax], 0xff // save 8 byte(s) at [rax]","breadcrumbs":"Arch » Size directives","id":"247","title":"Size directives"},"248":{"body":"mov qword ptr [rax], rbx // save val in rbx at [rax]\nmov qword ptr [imm], rbx // save val in rbx at [imm]\nmov rax, qword ptr [rbx+4*rcx] // load val at [rbx+4*rcx] into rax rip relative addressing: lea rax, [rip+.my_str] // load addr of .my_str into rax\n...\n.my_str:\n.asciz \"Foo\"","breadcrumbs":"Arch » Addressing","id":"248","title":"Addressing"},"249":{"body":"The operand size of a string instruction is defined by the instruction suffix b | w | d | q. Source and destination registers are modified according to the direction flag (DF) in the flags register DF=0 increment src/dest registers DF=1 decrement src/dest registers Following explanation assumes byte operands with DF=0: movsb // move data from string to string // ES:[DI] <- DS:[SI] // DI <- DI + 1 // SI <- SI + 1 lodsb // load string // AL <- DS:[SI] // SI <- SI + 1 stosb // store string // ES:[DI] <- AL // DI <- DI + 1 cmpsb // compare string operands // DS:[SI] - ES:[DI] ; set status flag (eg ZF) // SI <- SI + 1 // DI <- DI + 1 scasb // scan string // AL - ES:[DI] ; set status flag (eg ZF) // DI <- DI + 1 String operations can be repeated: rep // repeat until rcx = 0\nrepz // repeat until rcx = 0 or while ZF = 0\nrepnz // repeat until rcx = 0 or while ZF = 1","breadcrumbs":"Arch » String instructions","id":"249","title":"String instructions"},"25":{"body":"The complete builtin is used to interact with the completion system. complete # print currently installed completion handler\ncomplete -F # install as completion handler for \ncomplete -r # uninstall completion handler for Variables available in completion functions: # in\n$1 # \n$2 # current word\n$3 # privous word COMP_WORDS # array with current command line words\nCOMP_CWORD # index into COMP_WORDS with current cursor position # out\nCOMPREPLY # array with possible completions The compgen builtin is used to generate possible matches by comparing word against words generated by option. compgen

Export & Import Keys

Search & Send keys