User:Rorschach

I am a self-taught programmer, I've been coding for several years now and am decently good at it. I code mainly in C/C++ and Python but know several other languages as well. My current project is a C++ fuzzer, if you're interested in the code or want to contribute ping me on IRC under rorschach. I hate talking about myself, so if you want to know more hit me up on IRC.

rorschach

Python class logs:

02:00 < rorschach> ok 02:00 < rorschach> here goes nothing 02:01 < rorschach> so if you want to run python there's two ways to do it 02:01 < rorschach> you can run straight into an interpreter 02:01 < rorschach> like so 02:01 < rorschach> rorschach@bastille:~$ python 02:01 < rorschach> Python 2.6.6 (r266:84292, Dec 26 2010, 22:31:48) 02:01 < rorschach> [GCC 4.4.5] on linux2 02:01 < rorschach> Type "help", "copyright", "credits" or "license" for more information. 02:01 < rorschach> >>> print "test" 02:01 < rorschach> test 02:01 < rorschach> >>> 02:01 < rorschach> or you can input a python file 02:02 < rorschach> rorschach@bastille:~$ cat test.py 02:02 < rorschach> print "test" 02:02 < rorschach> rorschach@bastille:~$ python test.py 02:02 < rorschach> test 02:02 < rorschach> rorschach@bastille:~$ 02:02 < rorschach> I find directly into the interpreter handy for testing code or a quick calculator 02:03 -!- ctOph13 [[email protected]] has left #CSIII [] 02:03 -!- ctOph13 [[email protected]] has joined #CSIII 02:03 < rorschach> to print in python < 3.0 you use 'print "string"' 02:03 < rorschach> in 3.0 < you use print("string") 02:03 < rorschach> to declare variables you 02:03 < rorschach> variable_name = "" 02:04 < rorschach> you don't state the variable type, and you can dynamically change them 02:04 < rorschach> >>> test = "test" 02:04 < rorschach> >>> test = 1 02:04 < rorschach> >>> print test 02:04 < rorschach> 1 02:04 < rorschach> >>> 02:04 < rorschach> python is reliant on whitespace 02:05 < rorschach> so instead of braces like in C, you use indentation (or spacing, it doesn't matter as long as it stays the same) 02:05 < rorschach> so an example of a conditional: 02:05 < rorschach> >>> if "test" == "test": 02:05 < rorschach> ... print "test" 02:05 < rorschach> ... else: 02:05 < rorschach> ... print "no" 02:05 < rorschach> ... 02:05 < rorschach> test 02:05 < rorschach> >>> 02:06 < rorschach> (the "..." are added by the interpreter) 02:06 < ktbonefish> 4 spaces = 1 tab, 1 tab = 1 whitespace generally? 02:06 < rorschach> no 02:06 < rorschach> whitespace could be 1 space 02:06 < rorschach> or it could be 3 tabs 02:07 < rorschach> it doesn't matter as long as in that block it remains the same 02:07 < ktbonefish> gotcha 02:07 < rorschach> example for good measure 02:07 < rorschach> >>> if "test" == "test": 02:07 < rorschach> ... print "test" 02:07 < rorschach> ... else: 02:07 < rorschach> ... print "no" 02:07 < rorschach> ... 02:07 < rorschach> test 02:07 < rorschach> >>> 02:07 < rorschach> a while loop would look like: 02:07 < rorschach> while a < 10: 02:08 < rorschach> so basically just like in C 02:08 < rorschach> you can even put () around the statements if that floats your boat 02:08 < rorschach> while (a < 10): 02:08 <@p00pi3> which do you primarily use, 2.7? or 3.0? i know they're different, and not many devs seem to like 3.0 02:08 < rorschach> is valid 02:08 < rorschach> I use < 3 02:08 < rorschach> just depends on what the distro comes with 02:09 < rorschach> I actually usually 02:09 < rorschach> mv /usr/bin/python /usr/bin/python3; ln -s /usr/bin/python27 /usr/bin/python 02:09 < rorschach> on a new install if it comes with python3 by default 02:09 < rorschach> a for loop is where it gets interesting 02:10 < rorschach> you would 02:10 < rorschach> (here's an example) 02:11 < rorschach> >>> # to iterate over a list with a for loop: 02:11 < rorschach> ... 02:11 < rorschach> >>> list_a = ("123", "abc", "456", "def") 02:11 < rorschach> >>> for a in list_a: 02:11 < rorschach> ... print a 02:11 < rorschach> ... 02:11 < rorschach> 123 02:11 < rorschach> abc 02:11 < rorschach> 456 02:11 < rorschach> def 02:11 < rorschach> >>> 02:11 < rorschach> actually that's a tuple, but the point remains 02:12 < rorschach> if you want to declare a tuple or list you would: 02:12 < rorschach> >>> tuple_a = () 02:12 < rorschach> >>> list_b = [] 02:12 < rorschach> >>> 02:12 < rorschach> an empty one that is 02:12 -!- dem [[email protected]] has joined #CSIII 02:12 < ktbonefish> what is a tuple compared to a list? 02:12 < rorschach> you can declare them like I did above if you want (probably preferred) 02:12 < rorschach> umm 02:13 < rorschach> I think a tuple is an unordered list? but don't take my word for it 02:13 < rorschach> I'm not totally sure 02:13 < rorschach> (if someone does know, please jump in) 02:13 < ctOph13> http://tinyurl.com/tuplevslist 02:14 < rorschach> http://news.e-scribe.com/397 02:14 < ctOph13> pretty good description there 02:14 < rorschach> python also has dictionaries 02:14 < rorschach> which is a key:value set 02:15 < rorschach> example: 02:15 < rorschach> >>> dictionary_a = {"123":1, "abc":2, 3:"567"} 02:15 < rorschach> >>> print dictionary_a['123'] 02:15 < rorschach> 1 02:15 < rorschach> >>> print dictionary_a[1] 02:15 < rorschach> Traceback (most recent call last): File "<stdin>", line 1, in <module> 02:15 < rorschach> KeyError: 1 02:15 < rorschach> >>> print dictionary_a['abc'] 02:15 < rorschach> 2 02:15 < rorschach> >>> 02:16 < rorschach> note that trying to access the value like that triggers an error 02:16 < rorschach> do dictionaries make sense? 02:16 < ctOph13> do you need to use double quotes when declaring, and single quotes when accessing? 02:17 < rorschach> umm 02:17 < rorschach> pretty sure it doesn't matter 02:17 < ktbonefish> ^ 02:17 < ctOph13> k 02:17 < rorschach> double quotes is probably better form though 02:17 < rorschach> >>> print dictionary_a['abc'] 02:17 < rorschach> 2 02:17 < rorschach> >>> print dictionary_a["abc"] 02:17 < rorschach> 2 02:17 < rorschach> >>> 02:17 < rorschach> python don't give a shit 02:17 < rorschach> :3 02:17 < ctOph13> haha, cool 02:17 < rorschach> ok 02:17 < ktbonefish> what about quotes within quotes 02:17 < ktbonefish> isn't it single has to be outside? 02:17 < rorschach> for that 02:17 < rorschach> you could do single quotes (which is easier) 02:18 -!- Sparkles [[email protected]] has quit [client exited: :3] 02:18 < rorschach> or you can \" 02:18 < rorschach> escape the quote 02:18 < rorschach> single quotes makes it easier to read though 02:18 < ktbonefish> k 02:18 < rorschach> in the for loop example, you may have noticed the "in" operator 02:19 < rorschach> in a for loop 02:19 < rorschach> that will iterate through a list / tuple 02:19 < rorschach> and assign each value to that variable specified 02:19 < rorschach> so in: 02:19 < rorschach> for a in tuple_a: 02:20 < rorschach> each time it iterates a will contain the value of the element 02:20 < rorschach> that probably doesn't make sense 02:20 < rorschach> but look at the example of a for loop from above 02:20 < rorschach> in an if statement 02:20 < ctOph13> makes sense, kinda like for each statements 02:20 < rorschach> you can find a substring or an element 02:20 < rorschach> yeah basically ctOph13 02:21 < rorschach> so 02:21 < rorschach> >>> tuple_a = ("123", "abc", "456", "def") 02:21 < rorschach> >>> if "123" in tuple_a: 02:21 < rorschach> ... print "\o/" 02:21 < rorschach> ... 02:21 < rorschach> \o/ 02:21 < rorschach> >>> string_a = "blahblahtestblah" 02:21 < rorschach> >>> if "test" in string_a: 02:21 < rorschach> ... print "\o/" 02:21 < rorschach> ... 02:21 < rorschach> \o/ 02:21 < rorschach> >>> 02:21 < rorschach> get it? 02:22 < rorschach> it's a very handy operator once you get used to it 02:22 < rorschach> ok 02:22 < rorschach> string contatenation can be done with the + operator 02:23 < rorschach> you can also use += to append to the end 02:23 < rorschach> >>> string_a = "blahblahtestblah" 02:23 < rorschach> >>> string_a = "123" + string_a + "test" 02:23 < rorschach> >>> print string_a 02:23 < rorschach> 123blahblahtestblahtest 02:23 < rorschach> >>> string_a += "567" 02:23 < rorschach> >>> print string_a 02:23 < rorschach> 123blahblahtestblahtest567 02:23 < rorschach> >>> 02:24 < rorschach> if you want to add an int to a string 02:24 < rorschach> wrap it with str() before you do so 02:24 -!- bacq [[email protected]] has quit [Ping timeout] 02:24 < rorschach> >>> string_b = "abc" 02:24 < rorschach> >>> int_a = 1 02:24 < rorschach> >>> string_b += str(int_a) 02:24 < rorschach> >>> print string_b 02:24 < rorschach> abc1 02:24 < rorschach> >>> 02:25 < rorschach> to define a function in python 02:25 < rorschach> you use 02:25 < rorschach> def function_name(arg1, arg2): 02:25 < ktbonefish> question about int to string, can you pull a int out of a string and convert it to such easily? 02:25 < rorschach> (you don't have to specify a return type, either) 02:25 < rorschach> yes 02:26 < rorschach> >>> string_c = "1" 02:26 < rorschach> >>> int_a = int(string_c) 02:26 < rorschach> >>> print int_a 02:26 < rorschach> 1 02:26 < rorschach> >>> 02:26 < ktbonefish> gotcha 02:26 <@mutiny> How does python handle regular expressions? 02:26 < rorschach> import re 02:26 < rorschach> re.compile("regular_expression") 02:26 < mike> you have to important them? @_@ 02:26 < rorschach> http://docs.python.org/library/re.html 02:26 < rorschach> yeah 02:27 < rorschach> import is the equivalent of an #include in c 02:27 < rorschach> for those who don't know 02:27 < mike> i don't use c 02:27 < mike> :) 02:27 < rorschach> :3 02:27 < rorschach> what do you use? 02:27 < mike> perl. 02:28 < rorschach> erm 02:28 < rorschach> one sec 02:28 <@mutiny> Perl's engine has regex built in. 02:28 < mike> yes. 02:28 < mike> exactly. 02:28 <@mutiny> mike: A lot of languages didn't have support for regex at first, and were later added into the engine 02:28 <@mutiny> Anyways, that's off track :3 02:28 < rorschach> it's like using 02:28 < rorschach> mike 02:29 < rorschach> I believe 02:29 < rorschach> I can't remember what the actually terminology would be 02:29 < rorschach> :3 02:29 < rorschach> err "use" 02:29 < rorschach> ok 02:29 < rorschach> classes 02:30 < mike> I would call that use. 02:30 < rorschach> let me write a quick class 02:30 <@mutiny> pastebin that code, for ease of use :3 02:30 <@mutiny> or put it on a wiki page or smth 02:30 < rorschach> yeah I will 02:30 < mike> like using a package/module? 02:30 < rorschach> yeah or a header file 02:33 < rorschach> http://pastie.org/private/sv4fspthmqu2mggelmw 02:33 < rorschach> every function in a class has to have the self variable pased to it 02:34 < rorschach> self contains all of the variables that you want to be accessed by any function in the class 02:34 < rorschach> but you have to set that variable in self like I did in the class 02:34 < mike> what's a class? 02:35 < rorschach> god dammit 02:35 < rorschach> :3 02:35 < rorschach> hold on 02:35 < mike> D: did I miss something 02:35 < rorschach> no 02:35 < rorschach> I can't think of a good explanation 02:35 <@mutiny> He's probably looking up the perl equivalent 02:35 < rorschach> hold on 02:35 < mike> It looks like a really complicated array the way you have it set up 02:36 < rorschach> http://en.wikipedia.org/wiki/Class_%28computer_programming%29 02:36 < rorschach> basically 02:36 < rorschach> fuck 02:36 < rorschach> I can't explain it 02:36 < rorschach> :3 02:36 < rorschach> just read the wikipedia article 02:37 <@mutiny> a class is an object 02:37 <@mutiny> that's the tl'dr 02:37 < rorschach> yeah 02:37 < rorschach> :3 02:37 < ctOph13> ^ 02:37 < rorschach> is everyone following so far? 02:37 < ctOph13> yup 02:37 < corvus> yes 02:37 < mike> it's an object that does what 02:37 < mike> like hashes blew my mind at first 02:38 < mike> What circumstance would you use a class? 02:38 <@mutiny> If you don't know what an object is or why they are useful, we may arrange a class specifically to discuss OOP 02:38 < rorschach> do you need anymore explanation on syntax? 02:38 < rorschach> anyone? 02:38 < ctOph13> no looks good 02:38 < rorschach> mike 02:38 < rorschach> a class basically contains functions that are only accessible by an instance of that class 02:38 < rorschach> in this case 02:38 < rorschach> inst 02:39 < rorschach> it helps keep the code simple and organized 02:39 < mike> sort of like a subroutine? 02:39 < rorschach> you don't have to pass around shit tons of variables 02:39 < ctOph13> Lets see if I can kind of explain it 02:39 < ctOph13> Lets say you have a kitchen program 02:39 < rorschach> since they are all contained in a variable called self that is passed to each function in the class automatically 02:39 < ctOph13> in the kitchen you have stuff, like a microwave, a fridge, a stove, etc 02:39 < rorschach> mike: a subroutine is a function 02:40 < rorschach> :3 02:40 < ctOph13> each object would be a class, so like a microwave class, a fridge class, etc 02:40 < mike> so cascading it would be outside a subroutine 02:40 < ctOph13> because those things have their own properties (size, color, etc) you write them as their own seperate class or object. they can also perform routines/functions/methods 02:41 < mike> so if you had like a button that you wanted to do things independently 02:41 < mike> you'd give it a class 02:41 < ctOph13> right 02:41 < mike> understood. 02:41 < ctOph13> a button has a size, color, text 02:41 < rorschach> but a class can be for anything 02:41 < ctOph13> ^ 02:42 < rorschach> I am writing a fuzzer 02:42 < rorschach> and I wrote a class for it 02:42 < rorschach> that holds all of the functions the fuzzer would need 02:42 < rorschach> all of the variables, etc 02:42 < rorschach> which simplifies passing around a shit load of variables to every function that it might not need 02:43 -!- raxen [[email protected]] has joined #CSIII 02:43 < rorschach> so within the fuzz class 02:43 < rorschach> there are functions for socket fuzzing 02:43 < rorschach> or debugging 02:43 < rorschach> whatever 02:43 < rorschach> that I can call when I need to 02:43 < rorschach> make sense, kinda? 02:43 < mike> but it won't touch the functions unless the class is called 02:43 < mike> saves effort 02:43 < rorschach> (OOP took me a while though) 02:43 < rorschach> yeah basically 02:44 < rorschach> ok so now the fun stuff 02:44 < mike> what are big languages that aren't object oriented? 02:44 < rorschach> umm 02:44 < rorschach> C 02:44 < mike> I thought 02:44 < mike> okay nevermind 02:44 < rorschach> C++ is object oriented, but C isn't 02:44 < mike> thanks lol 02:44 < mike> oooo kay 02:44 < mike> got it 02:44 < rorschach> np 02:44 < rorschach> other than that, I can't think of any 02:44 < rorschach> is PHP OOP? 02:44 < raxen> assembly. 02:45 < mike> lol assembly 02:45 < raxen> that is assembly isn't oop as well. 02:45 < rorschach> assembly 02:45 <@mutiny> I think most modern languages support OOP, though you always can choose not to use it :3 02:45 < rorschach> there you go 02:45 < mike> mutiny: that's what I was thinking. 02:45 < rorschach> I just barely started using classes 02:45 < rorschach> and most people call me a masochist because of it 02:45 < rorschach> :3 02:46 < ctOph13> haha 02:46 < rorschach> I also usually code in pure c 02:46 < rorschach> which also contributes to that title. 02:46 < rorschach> anywho 02:46 < rorschach> so there are some good packet capture libraries in python 02:46 < rorschach> they have libpcap for python 02:46 < rorschach> but you can also use scapy 02:47 < rorschach> which can basically do anything 02:47 < rorschach> here's a script that uses scapy for packet capture that I wrote a while back 02:48 < rorschach> http://pastebin.com/G0VydTHG 02:48 < rorschach> you'll see on line 157 02:48 < rorschach> the sniff() function 02:48 < rorschach> basically 02:49 < rorschach> sniff(prn=lambda pkt:takedownParse(pkt, ips), store=0) 02:49 < rorschach> it tells sniff not to store any packets 02:49 < rorschach> but everytime it receives one 02:49 < rorschach> to call takedownParse() 02:49 < rorschach> and prn= lambda pkt: 02:49 < rorschach> tells it that the packet is called pkt, so you can call you function and pass the argument 02:49 < rorschach> which is pretty simple 02:50 < rorschach> I wrote an icmp chat client with scapy as well 02:50 < rorschach> https://github.com/v0rbis-dev/ICMP-Chat 02:51 < rorschach> (this uses a class, too) 02:51 < rorschach> receive_message() on line 130 is sniffing 02:52 < rorschach> send_command() on line 140 constructs and sends an icmp packet 02:52 < rorschach> scapy is confusing at first but it's actually really simple 02:52 < rorschach> here's the scapy docs http://www.secdev.org/projects/scapy/doc/ 02:52 < rorschach> and there's all sorts of things you can do with it 02:53 < rorschach> they have tons of examples here http://www.secdev.org/projects/scapy/doc/usage.html#recipes 02:53 < rorschach> another handy library is ip_addr by google 02:54 < rorschach> http://code.google.com/p/ipaddr-py/ 02:54 < rorschach> the documentation is here: http://code.google.com/p/ipaddr-py/wiki/Using3144 02:54 < rorschach> and it's really straight forward 02:55 < rorschach> but say you want to make a list of every IP address in a given range 02:55 < rorschach> you can do 02:55 < rorschach> ipaddr.IPv4Network('192.168.0.1/24') 02:55 < rorschach> ip_list = ipaddr.IPv4Network('192.168.0.1/24') 02:55 < rorschach> then you could 02:55 < rorschach> for ip in ip_list: 02:55 < rorschach> print ip 02:55 < rorschach> or do some kind of scan for every IP whatever 02:56 < rorschach> and it's a lot simpler than trying to calculate what a /32 might be 02:57 < rorschach> there's also pydbg 02:57 < rorschach> which I don't use because it's only for windows 02:57 < rorschach> unfortunately 02:57 < rorschach> but if you want to write a debugger in python on windows 02:57 < rorschach> http://wikisecure.net/security/pydbg-an-installation-guide 02:57 < rorschach> that's a great library 02:58 < rorschach> they do have ptrace for python though 02:58 < rorschach> http://pypi.python.org/pypi/ptrace/ 02:58 < rorschach> but basically there are tons of great libraries for python 02:58 < rorschach> for everything you can imagine 02:59 < rorschach> those are the useful ones I can think of off teh top of my head 02:59 < rorschach> but yeah 02:59 < rorschach> any questions? 02:59 < rorschach> or did I lose you all? :p 03:00 < corvus> pretty interesting libraries, encouragement to play around with python more than I have 03:01 -!- hackerhousemom [[email protected]] has quit [client exited: hackerhousemom] 03:01 < rorschach> yeah they are interesting 03:01 < rorschach> and they have tons of them too 03:01 < rorschach> pretty much just google 03:01 < rorschach> python is annoying as fuck for writing any kind of interfaces though 03:01 < corvus> Thanks rorschach, glad I made it home intime for this! :3 03:02 < rorschach> :) 03:02 < rorschach> np 03:03 < rorschach> so if there's no more questions I'm gonna go have a smoke 03:06 < rorschach> by the way 03:06 < rorschach> scapy is in most repos 03:07 < rorschach> under scapy or python-scapy 03:12 < corvus> Thanks again, hope you enjoyed your smoke!! :) 03:14 <@p00pi3> scapy rules. 03:15 < rorschach> that i did ^.^ 03:16 <@p00pi3> you wrote scapy? 03:17 <@p00pi3> i'll have to shake your hand one day. =) 03:20 < rorschach> o.o 03:20 < rorschach> no i didn't lol