If you're British, they got porn laws and shit, but if you're in the US of A then not really.
ISPs are concerned with torrenting of CP and torrenting of intellectual property.
They can keep logs but its really expensive so they only do it for subpoenas.
Back orifice was an old ass virus used in the 90's and change of the millennium.
Smurf was making your packets big as fuck and sending it to people using windows. Apparently it made them BSOD.
Meterpreter is meh imo. I used to be a sperg over trying to write my own shellcode but its just easier to use meterpreter since I can declare bad chars and generally throw it into any type of encoder.
So haxxorz, lets try to make exploit dev simple.
So, you got a shed in your back yard.
There are tables in the shed.
Each table can do one project or can hold one thing. There is only you inside the room. So one thing at a time.
This is the basic explanation for memory and operations in memory.
Memory is your ram. Shit goes in, shit is analyzed, shit is done. Little guy in the shed is your cpu. Welp, little guy in the shed follows the instructions like every normal person follows ikea instructions. (Generally the correct way until timmy shits himself and then the fun happens)
What if you could over-write the instructions he takes? Say, write A 2,000 times. Welp the sheet of paper is STACK (esp). Alright, so CPU rights 2000 A's, but where does he get this instruction and where does he go back to once he's done?
Well, CPU needs to know what he's working on. This is EIP, 4 bytes out of the millions of spots in memory… 4 bytes control the flow of direction. Where does CPU go back to once he's done with the operation? He's got a sticky note next his current operation, and that tells him where to go back to. Thats EBP.
So, what if we got control of what happened next? That means we control the program at the same privileges it was started at… on top of that, we can do anything we want inside of it… within reason.
We send 2000 A's and the program executes fine. CPU interpters those A's and then passes it off. Nothing happens. Well, what if we don't send enough data? This is when we need a reciprocal pattern. Of unique digits. !mona or metasploit can do this for us and will tell us in the dump how many chars we need.
Since I'm a lazy ass, lets just say we find the offset for EIP is 3054 bytes. This means the EBP is around 3050 bytes in the stack and there is 3049 bytes of space and one terminating signal of space in there. Since we know where EIP is, we can put the breaks on the program by sending 3054 bytes of A's and 4 B's and then 500 C's.
The C's tell us where the rest of the data will go. So we're looking at the debugger, the debugger shows "43434343" in the ESP table. This means the program offloads part of the workload to a different table. So we have to find a way to make the program jump from calling quits to the table where the C's are.
We will need a JMP ESP command. We can do this by looking for this in memory in DLLs or in the program itself. DLLs are generally DEP and ASLR finicky so its best to search there. Look for dedicated system DLLs or DLLs for the program.
We've found a JMP ESP command at \x78\x56\x34\x12. It has ASLR disabled and DEP disabled.
The exploit data we should send now should look like
A*3054 \x78\x56\x34\x12 C*500
A's get us to the control point (EIP, what happens next)
\x78\x56\x34\x12 tells us to jump to ESP (So EIP says hey, we're jumping to ESP)
So the cpu walks over to the workbench of ESP.
ESP has C's in there…… this won't do we need something like start a command prompt, open goatse, or soemthing
This is where we break out C, metasploit, or google for some dank shell code.
Congrats you now know how to send a basic exploit remotely.