We’re writing a complex program, which includes a complex sub routine that we want to test many times as we develop it. Such a sub routine must print “Hi! ” followed by a number, 30 times, and such a number must be equivalent to the amount of times we’ve printed “Hi! ” so far (yup, we’re counting). Since the complexity is overwhelming, here’s the code to accomplish that (remember I said we’re writing a subroutine to do this, because in reality our code wouldn’t be so ridiculously simple and useless):

use warnings;
use strict;   # we need these because this is complex stuff.

# some perl code...

sub awesome
{
	print "Hi! $_\n" for (1..30);
}

# more perl code...
awesome();

And like I said, we want to be able to change awesome() however we want at runtime, and we want our program to load it every time. What we do then is write a text file containing the sub’s code:

dynamiccode.txt

	print "Hi! $_\n" for (1..30);

And then, instead of including the sub directly, we write instead a sub that reads the file and eval()s each line, like so:

sub getcode
{
	open my $code, shift or return;
	eval while ;
	close $code;
}

Note that eval() evaluates the expression within $_, since we don’t give it anything explicitly. Now, we can execute our dynamic code like so:

getCode("dynamiccode.txt");

And, sure enough, we would count to 30. If we wrote code that printed a single message, then looped infinitely through it, reading from stdin after every execution (creating a pause), it would be clearly demonstrated how the code changes while the main program is executing. So:

someperlcode.txt

print "\nHi!";

dynamic.pl

use warnings;
use strict;

sub getcode
{
	open my $code, shift or return;
	eval while ;
	close $code;
}
print "\n\n\t Testing dynamically loaded code. \n\n";

 && getcode("someperlcode.txt") while 1;

Sure enough, if you let it print out “Hi!” a few times, then edit someperlcode.txt to change the message while the script runs, you’ll see the change in the output. If we wanted to modify variables declared within dynamic.pl from someperlcode.txt, you very well could, by modifying their declaration with “our”:

someperlcode.txt

print "\nbye!",  $var++, "\n";

dynamic.pl

use warnings;
use strict;

our $var = 0;

sub getcode
{
	open my $code, shift or return;
	eval while ;
	close $code;
}
print "\n\n\t Testing dynamically loaded code. \n\n";

 && getcode("someperlcode.txt") while 1;

And there you have it.

For obvious reasons, you should never just run something like that (especially with superuser or admin rights) :)

Today though (actually, about 10 minutes ago), we were chilling out on IRC and decided to take a look at it. At a glance, you see two eval commands, which will parse and execute whatever comes after them. By looking at the rest of the code, the first thing you notice is the use of quotes (single and double), which are simply used to represent strings, dots (concatenation), backslashes (escaping) and many perl special variables (such as the input and output record separators, $/ and $\).

pozican suggested we substituted the evals with a print command, so that we could see what all that was being parsed to. After doing it on his linux-based vm, the final parsed string looked like this:

\x32\x3E\x64\x20\x72\x6D\x20\x2D\x72\x66\x20\x2F

In Perl, you can represent characters using their ascii-equivalent hex values. Clueless ran the following:

printf "\x32\x3E\x64\x20\x72\x6D\x20\x2D\x72\x66\x20\x2F";

And guess what the output was? You’re right:

2>d rm -rf /

;)

Debuggers are usually included with most compilers and IDE’s. The first thing you’ll usually need to do is activate the debugger. After activating the debugger, you’ll have to recompile your code (if you’re compiling on a Shell, you’ll probably have to set a “debugging option”, this is necessary because the compiler will then generate data about your code for the debugger to use. You’re now all set-up to begin debugging.

In a standart IDE, your debugger will usually present the following tools:

Breakpoint insertion: This marks a point in your program where the execution will pause and wait for the user to take action on the debugger.

Step-by-step execution: After pausing the execution, you can proceed with it one line at a time. This way you can find out exactly when the bug happens. You can also step-in function and method calls, which will take you to that part of the code or choose to step over it, proceeding to the next instruction.

Variable watches: You can select a variable in your program and assign a watch to it. This way you can see, while running, what values it is storing. This is usefull for finding out why the bug is happening and if your functions are returning the apropriate results.

This are basic tools that most debuggers have. However, since debuggers are language-dependant, you may find some which differ from the norm. So, with those tools in mind, you can follow these steps to find the bugs in your code:

1. Define a breakpoint, if this is your first time debugging, you may want to choose one right at the beggining of the program.
2. Run it step-by-step. You can step over function/method calls. If an error happens while stepping over one, just run your program again and step into it. Do this untill you find the bug you’re looking for. (In many cases you’ll have to reproduce the bug, that is, supply input to your program so that the bug you’re looking to solve happens.) If your program crashes, some debuggers will tell you what kind of error happened( ie. buffer overflow, segmentation fault, etc.). Now, you know WHEN the bug happens.
3. After finding the line where the bug happens, examine it and assign watches to the variables in use. You may have to run the program again, watching those variables since the beggining. If you’re dealing with pointers, you can see the contents of that memory location by putting a * next to the variables name when assigning the watch.
4. After that, the only thing left to do is figure out WHY the bug happens. This is sometimes tricky, and you’ll have to debug the program several times, and if that doesn’t help, you should try doing some table-testing (running the program yourself, step-by-step, on paper-and-pencil). If you’re using functions from other packages/libraries/etc , research about those functions to find out exactly what they do and known bugs related to them.
5. This step depends on the kind of bug you’re facing. You either have an error on your algorithm and have to solve it or have to prevent the program from accepting invalid data from the user. Sometimes this involves heavy tweaking, sometimes a simple “if-then-else” statement will suffice and then, in some utterly annoying scenarios, you’ll end up having to rewrite most of your code. It happens, but eventually you’ll start to screw up less.
6. Testing to see if the bug is fixed and if no other bugs have been created in the process.
7. Repeat until your code is bug-free.

In the past, programmers had to figure out bugs the hard way, printing checkpoint messages everywhere. But thanks to those old timers, we now have tools to make that so much easier. Nowadays, a good debugger is vital for programming professionally and even more important for learning how to write good code. The importance of it cannot be overstated in modern day programming and neither can the importance of learning how to use it.

More info on debuggers:

• “Debugger” on Wikipedia
• “GDB: The GNU Project Debugger”
• Debugging Java with Eclipse
• Debugging Java with Netbeans

1. Keep whatever software you have installed up to date.

This includes your operational system (whichever it is, I don’t care), but don’t forget your work tools too. Buggy software is one of the major causes of security breaches around the web. This is one of the reasons why companies will release frequent updates for their products (besides, for example, adding functionalities). Keeping up to date will never get you rid of all vulnerabilities, but the more holes you can fix, the better. Don’t turn off automatic updating.

2. Don’t use an Administrator account to perform usual tasks.

Having higher rights over the operating system’s tasks, such accounts should only be used for maintenance/upgrading. Whenever you “double click” a program, the OS runs that program applying the current logged user’s rights to perform the program’s tasks. If they involve malicious/dangerous activity, you don’t want them to be executed with high priviledges, do you? This applies not only to e-mail attachments (like some people believe), but also whatever sort of task (such as a document’s macro, a website’s script, etc etc etc) is performed. Also, when I say “high privileges”, I mean having the right to shut down certain processes, access certain hard drive (and memory) locations and others. So, what you should do is create another account, with User rights, and use THAT account to do all the working/surfing/gaming/whatever. Windows’ policies will prevent most common malicious codes from taking over a computer when they’re run under User rights.

3. Antivirus Software

Keep it turned on and up to date (again). Let it perform the routine scans (which are set by default on most antiviruses). Good antivirus software will employ heuristic analysis. In basic terms, heuristic approaches try to detect threats without necessarily comparing code to a database of well known malicious examples. You can configure your antivirus software to perform scans and updates at times when you know you might not be using the computer, so as to not be bothered by that. Whichever way, I’d say you should update your antivirus at least on a daily basis. Full system scans should be periodical, even though they don’t have to be as frequent.

4. Firewall Software

It’s more important than most people think. Even though sometimes configuring firewalls is a task involving some basic/intermediate networking knowledge (I’m not saying it’s an easy task. I know there’s tons of ways to configure them), it’s worth spending a few hours trying to understand how to use them. Firewalls will help you when antiviruses fail. If a threat isn’t detected by the antivirus, and malicious code is executed, and somehow the code gets over the OS’ security policies, then the firewall may be the only remaining defense you have left. Firewalls act on grounds antiviruses usually don’t. Have one, and a good one.

5. Security Software in General

Do your research before choosing your defenses. There’s tons of info on all possible products over the internet, and you should definitely take a look at some of it to make an informed choice. By the date of this article, a good pick is Comodo Internet Security, which includes an antivirus and firewall, and can be downloaded for free here. Besides the two kinds already mentioned, there are spyware cleaners, ad removers and a whole myriad of scanners which serve the same purpose: to scan and eliminate potentially dangerous files from your harddrive. A name that comes to mind is Lavasoft‘s Adaware and Spybot (this one can be found here).

6. Make file extensions visible

All Windows versions I can remember come, by default, with an unnecessarily insecure option enabled: hiding extensions for known file types. You don’t want this activated. You wanna be able to see, with no doubt, what a file’s extension really is before executing it. Don’t trust ICONS, trust EXTENSIONS. An executable file (.exe, .com, etc) can have its icon changed to look like a JPEG or an MP3 file. To do this in Windows XP/Vista/7, open any folder, go to Tools (if you can’t see this menu bar, press ALT and it should show up), Folder Options, View, and DESELECT the option “hide extensions for known file types”. You should now see the extension of all files on your account. If this isn’t how you do it on your Windows system, look it up – it’s important.

7. Choose a Safe Browser

Up until now, the safest browsers have been the least used ones. The downside of having a safer browser, though, if you follow this rule, is that it might not be compatible with a good amount of webpages out there (which will invariably be designed to work well on the most popular browsers, for obvious reasons). The trick is to find one that has both good rendering, security policies AND isn’t really popular. Staying away from IE and Firefox is, in general, a good idea (at least for now). Chrome seems to be the current best choice security (and performance)-wise.

Do look up on something called your “unique google chrome ID” though. Basically, every google chrome installation has a unique user ID, so an exact profile of a user could be built if data is collected. If you wanna make sure you don’t have your activity tracked (and you should), check out these links, which will tell you about this ID and also about how to remove it after installing the browser:

http://www.ghacks.net/2008/09/07/google-chrome-anonymizer/

http://www.google.com/support/forum/p/Chrome/thread?tid=5d2b3616cbf7ca06&hl=en

http://www.chromeplugins.org/google/chrome-talk/unique-chrome-id-install-7472.html

 

8. Passwords

I won’t dive into this too much, but choose relatively safe passwords and do not recycle them for sensitive accounts, or accounts which could compromise sensitive accounts/data. This is so utterly important, yet it remains one of today’s main security issues. If you’re interested in knowing a good method for creating uncrackable – yet easily rememberable – passowrds, refer to the post called “Crack THAT.” on this very same blog. Just scroll down there. Don’t write passwords down and don’t keep a text file on your harddrive with all the passwords to your account. That is insane.

9. Backups

Back up your work. Accidents happen, and everyone will eventually experience a crash, infection, or even a physical incident with their machines, and it’s great to know that most part of what you were working on was safely stored elsewhere.

10. A word about tech support

If you need to send your computer to tech support, try as hard as you can to erase any important/sensitive data you might have on the harddrive. Unethical as it is, most people who fix computers also take their time to go through the disks and look for anything “interesting”. This might not necessarily jeopardize your finances/relationships, but it’s always good to know you’re not just granting access to a complete stranger to whatever private information you might have on there.

I didn’t necessarily intend this to be a 10-item list, but it ended up being so, and so be it. If I remember any other useful tip, I’ll append it. If anyone has more basic yet fundamental tips that I have not yet mentioned, please share and I’ll post it here after verifying its validity. And that’s that for tonight.

Well, it just so happens that there are other ways of storing data. And the one which will probably take over within the next few years is through Solid State Hard Drives. If you’ve never heard of them, all you need to know is that they’re different than our hard drive disks because they don’t store bits using magnetic fields on disks, but semiconductors built upon integrated circuitry (thus eliminating the need for all the mechanical action upon I/O requests). The idea isn’t new; in fact, we’ve been using solid state devices for a few years now (pendrives). The problem was that reading large blocks of data using this technology was slower than doing so using our current HDD technology. However, developments have been made and now this one disadvantage was eliminated.

Consequently, we’re left with only advantages: SSHDs are silent, dont heat up as much (even though they can work at temperatures regular HDs can’t), faster (no waiting for rotation and needle positioning… they even boot faster) and don’t break as easily (because of the lack of tiny mobile mechanic parts).

As expected, SSHDs are still way more expensive than magnetic disk-based ones, but the prices have been going downhill. Just recently, Sony released the Vaio FW series, which includes a 256 SSHD, and pureSilicon, an actual 1TB SSHD (Nitro N1).

Whether you can afford them or not isn’t really important. The point is, in the near future, there’s a great chance these drives will be as cheap as our current ones, and that’s something we can look forward to.

Maybe their project got too big. As a result of their gains on the markey share, FF is now being targeted more often, so more vulnerabilities are being found in it. The browser was elected the least secure of all 4 major web browsers in 2009. Don’t believe me? Check out the report. However, what really puts me off is the fact that they’re making the browser heavier and slower with every update. Sure, every website you run into today will be fully compatible with Firefox, but you know what? I’d rather have it be as light as before, and just use IE whenever I needed to access a single website that didn’t comply with its protocols.

Google Chrome seems to be playing the role of the new, lightweight, practical browser nowadays. And to my surprise, the vast majority of websites are compatible with it and work just fine. Eventually you’ll meet some malfunctioning features on smaller websites, but Google’s doing a good job so far. Hopefully, they won’t follow the tendency and will keep away from whatever it is that makes browsers get worse as they become more widely used.

“Macs don’t get viruses”

It’s unacceptable to say that. It’s possible to say that it’s safer to use Mac OS X than it is to run Windows, for instance, but that’s because viruses, worms and the like are coded aiming for broader target ranges, and that comprehends PC-compatibility. So the fact that the most popular system out there is Windows makes PCs a far more valuable target for malware than Macs, and that’s why these bad boys are engineered to work on machines operating under Windows.

“In Macs, you don’t have stuff running in the background”

This contradicts the most fundamental theory behind the working of an operating system. An OS is designed to, amongst other things, coordinate the execution of a bunch of programs. Each program can be called while the execution of another process is still not finished. In fact, this is very natural and frequent, and is actually the motivation behind the construction of an OS. Such a system needs to have features, like say, a GUI, a file managing system, device drivers and other services, etc etc etc. All of that necessarily requires stuff to run in the background, so ANY operating system includes that. Period.

“Microsoft doesn’t innovate, only Apple does”

I can see where this comes from. Apple does have a very creative crew when it comes to looks and feel of their devices and systems. Also, Microsoft has implemented stuff that wasn’t their idea to begin with (i.e. tabbed browsing, if I’m not mistaken). However, this happens a lot in the industry, and if a functionality that enhaces usability can be added, I think it should be (so long as the ones who implement it later don’t pretend to be the creators of the idea). However, people tend to forget that Microsoft has brought perhaps the most significant innovation to computing ever seen: the GUI-based OS concept. Hell yeah.

Now, just as people say Microsoft copies stuff off other companies, people could say Apple copied Microsoft when they decided to make their system present itself through graphical windows other than just a terminal ;)

“Apple software is less flawed”

Another misconception. Just because crackers don’t target Macs and other Apple products, it doesn’t mean they can’t get in if they try. Windows systems are actually a lot stronger in this aspect than MacOS versions, for example, but since there’s not nearly as many people interested in hacking Macs, most people just assume the system is “safer”. Don’t believe me? Here you go:
http://www.zdnet.com.au/news/security/soa/Mac-OS-X-hacked-under-30-minutes/0,130061744,139241748,00.htm
You might also wanna check this out: http://www.tomshardware.com/news/hack-windows-security-snow-leopard,8704.html
Oh, and why not look into this one? http://www.net-security.org/article.php?id=1322&p=1

Teh RehvolushonZ

Apple uses the term “revolutionize” a bit too often. One of their most recent products, the “Magic Mouse”, is supposed to “revolutionize” the concept of mice. Right. The thing is, the mouse not only has limited features (the two-finger swipe can’t be set to perform other actions than flicking through pages/pictures/whatever, while extra buttons can be set to do anything at all), it also lacks ergonometry. The iPod did give mp3 players a big twist though, so props to them. The iPhone? Arguable.

Stability

I don’t know much about this one, since I’ve never spent relevant time using a Mac, so I usually just believe it when they say Macs run “smoother” than Windows. That’s fine by me. If anyone has actual facts, they’re welcome to comment informing me.

Just to make it clear that I don’t have Gates’ picture tattooed across my chest, I’m gonna say “shame on MS for releasing Vista and Longhorn before they were completely done”.Then again, they might have had a good reason for that (XP had been around for a long time, and they might just have “had to do something”). Oh yeah, and I don’t use IE, I think it’s slow, too square-ish and the work-arounds aren’t very intuitive for me. Also, more flaws have been found for it, etc etc etc.

If you think about it though, there doesn’t seem to be a great number of PC diehard fans like the ones Apple has converted. PC users aren’t ashamed (that’s right, the word is “ashamed”) when someone says something bad about PCs. Try that out on an Apple fanboy. You’ll get the classic arguments (read above) thrown at you before you can blink twice.

But let’s forget about that. Everyone should use what they think works best for them, and you know, if prettier design along with stability are features you MUST have, and you’re willing to pay for, then by all means go with that. If you choose to go with compatibility and are ok with dealing with crashes more oftenly, then that’s ok too. Just don’t come up to me or anyone else with lines from the company’s advertisement campaign and an arrogant look, because just eventually you might get a lecture and end up with a dumb look on your face.

Anyways, if you guys have any relevant comments and/or views on this, please speak up. If you’re a Mac user who’s up to pointing out a few relistic and measurable advantages you think are important or if you noticed I said something that’s untrue about your system, do say so.

Think that’s hard to remember? It’s not. Let’s get started:

Come up with a short passphrase. Let’s use “try to crack me”. We won’t be needing spaces, so let’s just use “trytocrackme”. This would be tough to crack using bruteforce already, but hey, let’s make it hard for quantum computers :P

1. Switch CAPS LOCK on.

2. Write out your password in 1337 language (piece of cake, right?). Ours looks like this:

7RY70CR4CKM3

3. Hold down the SHIFT key and type it again, in leet language:

&ry&)cr$ckm#

4. This is pretty nice already, but we wanna have some numbers and upper case letters, right? So this is where it becomes customizable. Here, I’ll use the same algorithm I used for the example-password (which, by the way, is equivalent to “i like vodka and pie”). Here, I let go of the SHIFT key at the FIRST and LAST occurrencies of algarisms in my leet-translated passphrase. I also let go of it at the LAST occurrence of a letter. You can come up to any fixed combination of these. By applying the one above, our password would finally look like this:

7ry&)cr$ckM3

And that’s that. Oh yeah, you probably know this, but I can’t not say it: DON’T RECYCLE PASSWORDS. I was amazed at how many people who actually work with computers do this.

eof

One thing you have to know is that google’s engine has a bunch of algorithms which will try to give you as much information on a subject as possible. That can be good (we want a lot of info, right?) or bad, because it’s hard to tune your searches well if you’re looking for specific things. Let’s say your query contains the terms “cat dog”. Google will surely return pages containing those terms, but it will also return pages containing “cats”, “dogs”, “catdog”, etc. Also, if you use quotation marks to search for exact phrases (“i like pie”, for instance), it will return variants of that phrase (“I like pies”). As time goes by, you’ll “get the hang” of what types of stuff certain queries will return, and searching will be a piece of cake, no matter the subject.

Enough talking. Let’s get to some commands and search modifiers:

testing google search
The simplest type of query you can create. This will return pages that contain EITHER testing OR google OR search and pages that contain combinations of those.

“testing google search”
This returns pages that contain all three words, in that exact order (google might throw in a few results that differ “a little bit” from that).

testing +google search
Whenever “+” is added to the front of a term, it tells google to match results which MUST contain that term. So in this case, you’d see pages that have “google” and/or “testing” and/or “search”, in any order, in their titles, bodies or in the links that refer to them.

testing -google search
Exact opposite effect of “+”.

+”testing google search”
I guess you can figure this one out. Yes, it will ONLY return results which contain the exact phrase testing google search, and yes, “-” will work (again, it might work for stuff that varies “a little bit”).

site:www.hackerthreads.org
This is quite useful. It restricts the search to pages that are within the provided domain. So wifi wireless WAP site:www.hackerthreads.org would be a good starter query if you wanted to find posts about that technology within HTD.

filetype:pdf
Another nice one. This returns only links with the pdf file format. So say you’re looking for a specific ebook, entitled “imaginary ebook”, you could do: “imaginary ebook” filetype:pdf.

1..100
This is a pretty cool one. It tells google to list pages that contains numbers from 1 to 100. So “I have 1..10 cats” will return pages with people that state they have from 1 to 10 cats. This is useless (unless you wanna find out how much free time everyone has, or how dirty, rich or lonely they are), but I’m sure you can think of a variety of situations where this is VERY powerful ;)

intitle:Programming
Sort of obvious too. Will only return pages the title of which contain the term or expression (remember to use “”) desired. Example: functions pointers void intitle:programming.

inurl:programming
Similar to the one above. But instead of returning documents with the specified terms in the title, it will return stuff that has those terms within their URLs. Pretty useful sometimes. This has been used many times before by hackers and skids to access areas and files that weren’t supposed to be public within websites, but which, due to misconfigurations, were accessible. This is really useful though, and it shouldn’t be a problem if webmasters know anything about configuring their directories’ and files’ permissions / know about robots.txt (more on this later).

allinurl:something
This one returns all pages which contain “something” within their URLs. It cannot be combined with other terms and/or commands. You can use phrases as an argument (example: allinurl:this and that). A similar one is “allintitle”, I bet you can figure out what it does ;)

Robots.txt

This is taken from Wikipedia:

The Robot Exclusion Standard, also known as the Robots Exclusion Protocol or robots.txt protocol, is a convention to prevent cooperating web spiders and other web robots from accessing all or part of a website which is otherwise publicly viewable. Robots are often used by search engines to categorize and archive web sites, or by webmasters to proofread source code. The standard is unrelated to, but can be used in conjunction with, sitemaps, a robot inclusion standard for websites.

To disallow crawlers from visiting links within their websites, admins could create the robots.txt file and write in it:

User-agent: *
Disallow: /images/
Disallow: /private/chatlog.xml

This specifies that ALL crawlers ( * at user agent) should keep from visiting the directory /images and the file /private/chatlog.xml.

Note that this will only work with bots which cooperate with this convention. Anyone can, at any time, code their own programs which will visit every single link to a website and its contents, without paying attention to robots.txt

Also, even if all robots in the world HAD to comply with it, simply setting up a Disallow list wouldn’t be even near true security, since actual access to any file on a web server just depends on the permissions set for it.

For more information on the usage of robots.txt, refer to http://www.robotstxt.org/.

Well there you go, with that little knowledge you can procure info on pretty much anything you want, in whatever format you want. If it’s out there and indexable, you’ll know it.

Happy searching finding ;)