Patrick’s development blog

centering a <div> using CSS

Posted in Articles, Webdesign by Patrick on February 14, 2008

Centering something in HTML/XHTML isn’t a matter of course anymore. That doesn’t mean it’s anywhere hard, but designers get to know more and more about web standards nowadays and constantly struggles with web browsers that are a little deviant *cough* (Internet Explorer).

In the good old days, most people would probably attempt to center something using the <center> tag (I know this is the stone age). I’m not sure if it’s just that nobody cared back then, but nowadays it’s not a part of the standard. In my option, designing websites consists mostly of creating ugly hacks so the website works fairly well with most browsers, this is quite sad.

Anyways, this is what i’ve come across about how to center div’s using CSS.


#contents {
width: 400px;
margin-left: auto;
margin-right: auto;
}

<div id=”contents”>
Insert text/image/whatever here..
</div>

This would naturally be everything we would need in order to center the
<div> tag. Some browsers just behave differently (like Internet Explorer) though. That’s why we have to add text-align: center; into the body section of the CSS code. This will also center the text in the div so we will have to counter that by adding text-align: left; into the #contents id.

Centering a div using CSS


body {
text-align: center;
}

#contents {
text-align: left;
width: 400px;
margin-left: auto;
margin-right: auto;
}

<div id=”contents”>
Lorem ipsum dolor sit amet, consectetuer adipiscing elit.
</div>

The width attribute was put there in order to get a constant size of the box. It would look ridicilious other way. Now the contents box will be centered horizontally.

Advertisements

checking prime numbers

Posted in Articles, C++ by Patrick on February 12, 2008

It’s amazing how many functions i’ve found on the internet during the time I was writing a prime checker function and none of these functions worked, which was very surprising. I learned a few things at least. When checking if a number is a prime, you only have to check if the number is divisible by any value until its square root. An exception is number 2 which is a prime number.

The first twenty primes are 2,3,5,7,11,13,17,19,23,29,31,37,41,43,47,53,59,61,67,71

And as you probably know, a prime number is always positive (>1) and only divisible by 1 and itself. The following c++ program types the first 50 prime numbers.

IsPrime.cpp

#include <iostream>
#include <cmath>

bool isPrime(int n) {
if (n<=1) return false;
if (n==2) return true;

for (int i=2;i<sqrt(static_cast<double>(n))+1;i++) {
if (n%i==0) return false;
}
return true;
}

int main() {
for (int i=0;i<50;i++) {
if (isPrime(i)) std::cout << i << " ";
}

std::cin.get();
return 0;

}

This function was made rather quickly, but i’m pretty sure it works since the 50 first prime numbers were correct.

secure hashes in PHP using salt

Posted in Articles, Security by Patrick on February 12, 2008

This tutorial shows the principle of using a salt in order to secure your password hashes. It’s written with my scripting-language of choice which is PHP, but the principle is the same with whatever server-language you might be using. Before going on, i’ll explain some facts that might be good to know before reading the article.

Brute force
Brute force is a comparison technique which goes trough all possible characters and in this case runs trough an algorithm to compare with the hashed password. To put it simply, it compares all different characters until it finds the right password.

One way encryption
The process of encrypting a string so it cannot be decrypted. These are also called hashing algorithms. The most used ones are md5 and sha1. The general difference between these two is that sha1 is generally stronger since it returns a 160-bit fingerprint while md5 is 128-bit. You might ask how we can make use of something that cannot be decrypted. It’s quite easy, we compare different hashes and do not decrypt them.

Whenever you store information about a user in your database. You most likely store the passwords using a one way encryption like md5 or sha1. If not, you really have to think over your security, big time. Still, even if you encrypt the passwords, they can still be cracked using brute force, rainbow tables or dictionary attacks. If we assume the passwords are very sloppy and insecure while the hashes have leaked to the cracker. Unfortunately it’s very uncommon that the users use a smart password, so it’s no use relying on the users.

This is where salt comes in. It simply adds a certain string into the password before hashing it. It’s not any harder to do than regular hashing.

The principle of using salt

// this is what it normally looks like when hashing a string using md5
$password = md5($password);

// using a salt, you instead concentate a string to the password before hashing it
$password = md5($salt.$password);

If we assume $password contains a very weak password, for example “abcdef”. Which would be very easy to brute force. The salt can make this password practically as strong as you want it. There are many methods out there and people constantly invent new ways to generate a salt. In my option, the salt doesn’t need to be that complicated though. The only way someone can brute force the password in this state, is by knowing which salt you use. If they’ve come that far, it wouldn’t matter in any case.

A salt can be as complicated or simple as you want it. Here is an example.

Creating a simple salt

$password = "banana";
$salt = "aB1cD2eF3G";
$password = md5($salt.$password);

This might not be the best and most used salt method out there, but it works. Suppose you use the password “banana” from the example. Then the generated hash would actually become “aB1cD2eF3Gbanana” which is a considerably stronger password than “banana”. This takes care of the user’s bad habit of using easy passwords with only lowercase characters. Just remember that you don’t have to use the salt in the beginning of the string, the principle is the same if you type md5($password.$salt). You can do however you want.

I have seen it’s very common to combine different encryption methods as well. This is in my option very effective. If we create a salt based on the password that uses sha1 and md5 together and then use md5 to concentate these strings like a normal salt. We would get a salt that contains a double encryption of two different encryption methods. The hash we get from this is then added to the password before hashing it once again.

$password = "banana"
$salt = sha1(md5($password));
$password = md5($password.$salt);

This would be equal to a password that is a hash itself + it’s regular password.

md5("f8bbff024e7d04d98a349ccb0984ad85d8ba86fabanana");

Brute forcing the password hash in this case would mean to brute force the sha1 generated string with the password”f8bbff024e7d04d98a349ccb0984ad85d8ba86fabanana”. In other words close to impossible unless you have over million years and a supercomputer at hand. Well, even if you had, you would only get another hash out of the current one, if you want it to be that way.

How to crack salted hashes
The only known way to crack salted hashes is to know the salt algorithm. If the cracker knows this, it’s possible to brute force it by adding the necessary data before starting the brute force process. It’s hard to explain in words so i’ll give another example.

// the regular salt process, this is the “algorithm”
$salt = md5($password);
$password = md5($salt.$password);

// we suppose $test_string is the string it tests
// since this is brute force it’ll be various different strings
// “a”, “b”, “c”, “d” .. “aa”, “ab” … etc

// if md5(md5(“abc”). “abc”) is equal to
// md5(md5($password). $password) then
// “abc” is the password we are searching for

if (md5(md5($test_string). $test_string) == md5($salt.$password))
echo $test_string; // this is the password

To put it simply, if the cracker knows what salt algorithm is used. We will be back to step one and the salted hash is just as vulnerable as the regular md5 hash that isn’t salted. It’s very unlikely that the cracker do know though, i’m just pointing out the flaws.

This is how webmasters can protect their users from evil crackers or annoying skiddies that have come across a cracking program. Not many webmasters secure their website and use salted passwords though, some even leave them in clear text in the database. So i’ll let my next article be about how to create strong passwords so the users themselves can protect their password/account better. Strong passwords should be an obvious thing, but it sadly isn’t.

generic stringstream function in c++

Posted in C++ by Patrick on February 9, 2008

Something i’ve found useful while programming in C++, is the use of std::stringstream to convert different datatypes to std::string. Fortunately, the process is the same for all types. That’s why a generic helper-function is preferable and will simplify the process considerably.

In order to use stringstreams, the library <sstream> has to be included. The following will create a reusable stringstream helper-function using templates.

template <typename T> std::string to_string(const T& value) {
std::stringstream os;
os << value;
return os.str();
}

The parameter contains the value that will be converted into a string, so you only have to assign a string to the function.

// assign a new string to the return value of to_string and show the contents
std::string str = to_string(5.12);
std::cout << str;