What you are seeing is machine language code. They are the data values that are actual instructions to a CPU chip.
When a programmer writes a program in a higher level language like C or C++, tools called compilers take those instructions and turn them into the machine language. Normally, programmers don't care about those machine language instructions. But the programmers who write those compilers care a lot about machine instructions, of course, and so do people who are writing an optimized version of a routine (something that might be inefficient in a high level language.) And so do hackers.
Even when programmers have a reason to care about machine instructions, they don't write their code in hard-to-read raw byte values like this. Instead, programmers will use a mnemonic instruction set called an assembler language. The mnemonics are just abbreviated names that represent the numbers you see here. A simple example is
MOV CL,0x38 which moves the byte value 38 into the low half of the register named C. Under the covers, "MOV CL" is a machine language byte with the value of b1.
A tool called a disassembler will help translate from the digits you see into the assembly language that humans can more easily read. You could put these bytes into http://onlinedisassembler.com/odaweb/# and have a look at the instructions they will cause the CPU to execute. Your sample contained these instructions:
.data:0x00000006 b879c464b7 mov eax,0xb764c479
.data:0x0000000b 33c9 xor ecx,ecx
.data:0x0000000d b138 mov cl,0x38
.data:0x0000000f 5d pop ebp
.data:0x00000010 83c504 add ebp,0x4
.data:0x00000013 314513 xor DWORD PTR [ebp+0x13],eax
.data:0x00000016 033cd7 add edi,DWORD PTR [edi+edx*8]
.data:0x00000019 864242 xchg BYTE PTR [edx+0x42],al
.data:0x0000001c 3f aas
.data:0x0000001d cf iret
(You can see the mnemonic assembler instructions above include mov, xor, pop, etc.)
However, prepare for more disappointment. You've selected a very sophisticated attack that makes use of a technique called Return Oriented Programming (ROP), so most of the bytes are meaningless to us because they're not CPU instructions. They're mostly data that contain parameters to and addresses of other routines. That makes this exploit particularly difficult to reverse engineer without a lot of work.
Closer to your answer:
More to your question, a buffer overflow works because of the way memory is used on the x86 architecture. When a programmer allows memory to be overwritten, the extra data goes right over the top of something else. If you write the correct number of bytes, that something else is the return pointer of the function. If you provide a machine language routine in the buffer data, then overwrite the return pointer to return to your buffer (instead of its normal return location), when the CPU returns it will execute your code instead of the code it was intended to execute.
The machine code that tricks the instruction pointer to going where the hacker needs it to go is referred to as the exploit code. The exploit code is custom written to take advantage of each specific bug.
The code that does something useful for the hacker is called the payload. Payloads are generally pre-thought out by somebody else, and are often a copy and paste affair to the hacker. A very common payload is called "shellcode", which is machine instructions that yield a command shell to the attacker.
An exploit needs both. Once the exploit has control, it invokes the shellcode, giving the hacker the access he desires.
A good resource:
There is a well documented on-line tutorial of such an exploit here: http://www.tenouk.com/Bufferoverflowc/Bufferoverflow6.html Be warned that this is pretty deep stuff, and the author of that page is assuming you understand the fundamentals of CPU operation, stacks, pointers, assembly languages, machine languages, etc.