As human beings, we generally perceive numbers and mathematics on a 10-base number system. Why? The simplest answer is probably that we have 10 fingers and toes. Thus, 10 is a number which is easy for us to make sense of. This is not the case with computers. Most people are aware that computers perceive data in binary form, or 2-base numbering. There’s always only 2 possibilities. A circuit is either on or off.

How does this relate to the hard drive?

When a manufacturer places memory on the magnetic disks of your hard drive, it does so using SI or metric unit values which increment by the 1000s (1GB = 1000MB = 1000000KB…). As such, with the earlier 1TB, you’re really purchasing 1(1000^4) bytes of data.

Now, when a computer goes to measure this disk space it does so differently. You still have 1(1000^4) bytes. However, the conversion between units is different. Unit values are instead converted as powers of 1024 instead of 1000. The reason? 1024 is the power of 2 that was chosen at some point. Perhaps because it’s 2^10 and someone thought that would be easier for humans to make sense of (I can only speculate). This means that 1TB to a computer, is really 1024GB

To make up for this confusion, the IEC standardized a unit system for computer memory which uses units such as the Kibibyte in place of the kilobyte. Hopefully this system will take over and alleviate the confusion from earlier.

But why did I decided to write an article on 10-base and 2-base number systems? The simplest answer would be that I was bored out of my mind but I also wanted to provide a good preface of information for using a little java applet I wrote for fun (I’m odd and code for fun) that converts these units for a user. You’ll find it on the Memory Unit Converter page of this website. I have a statistics application which I’ll be posting soon too.

• The name of a MySQL user account with sufficient privileges to perform a backup. ‘root’, will likely suffice.
• The password of the previously mentioned user.
• The directory and file where you’d like the backup saved to. By default, backups are made to a /root/backup directory and files are named by *date*_db_backup.sql. If this directory does not exist, you’ll have to create it.
• The specific database you’d like to backup.

#!/bin/bash
#######ARGUMENTS#############
#	MySQL user to execute dump
	db_backup_user="root";
#	Password of MySQL user
	db_backup_password="***";
#	Directory to place the updates
	db_backup_dir="/root/backup/$(date +%m_%d_%y)_db_backup.sql";
#	Specific database to backup. Removing this line and its usage in the mysqldump string will backup ALL databases with the added: --all-databases parameter.
	db_backup_db="test";
##############################
echo 'BEGINNING MySQL DUMP. PLACING DATABASES IN "/root/backup" DIR';
mysqldump -u$db_backup_user -p$db_backup_password $db_backup_db > $db_backup_dir ;
echo 'END OF "dbbackup.sh" NOW CLOSING';
exit;

Next, name the file with a .sh file extension and place it in a secure directory on your server. I recommend the root user directory (/root). This is a precaution since the file must be configured with the MySQL a user’s password in order to run properly.

Your next question may not be how to run it. You can manually run backups by executing the shell file within the shell (make sure it has execute permissions). An alternative is to automate database backups using crontab. Crontab is the better option for preventing catastrophic data loss since individuals may get lazy or genuinely forget to perform timely updates.

Please note, that there are many additional steps which may be taken to ensure the best integrity of backups. This tutorial merely shows a method for accessing the database files.

Before I gave up, I wrote a simple method for calculating the area under normal distribution curves based on Z statistics (the result of a statistical Z-Test). It uses the Error Function to approximate left-tail probability (-infinity  -> Z-statistic).

        /*
	 * Normal probability method
         * @author Nicholas Pier
	 */
	static public double getCDF(double x){
		double p = .5 * (1 + getERF( x / Math.sqrt(2)));
		return p;
	}
        static private double getERF(double x){
		double a = (8 * (Math.PI - 3)) / (3 * Math.PI * (4- Math.PI));
		double erf = (x / Math.abs(x)) * Math.sqrt(1 - Math.exp(-Math.pow(x, 2) *(((4/Math.PI) + (a * Math.pow(x, 2))) / (1 + (a * Math.pow(x, 2))))));
		return erf;
	}

Much to my delight, not only is my work being paid for and used on another website, but the owner of NetTrain has allowed me to keep all the source-code open and free. As such, you may now download the new plugin via the following link: download

Also, if you’d like a working example of the code, please visit the Subnet Calculator Page on my website or the implementation of NetTrain.com

I currently run a Linux home server for the purpose of website development and testing prior to making content available online. However, it occurred to me following installation that the ‘www.hostname.tld/phpMyAdmin’ directory, while requiring authentication, is open to the internet and likewise, subject to brute force attacks. This tutorial will attempt to offer a number of solutions to securing such an installation.

Installation and Securing Mysql

The tutorial assumes a default Ubuntu 10.04 Installation with both apache and mysql installed (phpMyAdmin is a front-end for mysql).
The very first task in securing both phpMyAdmin and mysql should be to change the mysql root password. By default, Ubuntu uses no password for the root user. This is absolutely insecure. So, how does one set the mysql password? It’s actually fairly simple. Reach a shell and enter the following commands. The string of x’s following password can be supplemented with a password of your choice. Obviously, the complexity of one’s password will dictate how affective this procedure has been.

mysql -u root
set password for root@localhost = password('xxxxxxx');
flush privileges;
quit;

Now that mysql is secure, install the phpMyAdmin front-end. The installation is fairly simple. Once again, shell access will be required. Assuming your server installation has internet access, issue the following command. The ‘sudo’ at the beginning of the command provides the user with temporary root privileges and will ask for the current user’s password (assuming this user is included in sudoers, beyond the scope of my tutorial).

sudo apt-get install phpmyadmin

To complete the installation, one must have access to their mysql root password and the ip address or hostname of the mysql server (local loopbacks like localhost or 127.0.0.1 will generally suffice). Once the installation is complete, the phpMyAdmin interface should be accessible through a web browser. A screenshot of how this may appear is provided.

Securing phpMyAdmin

Now that phpMyAdmin is installed, it should be apparent that the www.hostname.tld/phpMyAdmin website directory is not something which should be visible to the general public. This tutorial will show two methods for securing the directory and making it inaccessible to unwanted hosts. The first denies or allows hosts based on IP address or hostname. The second, employs apache’s built-in user authentication.

To begin, all configuration changes should be made to the file: /etc/phpmyadmin/apache.conf

Simply open this file with root privileges using a text-editor of your choice and find the <Directory>  …  </Directory> tags. All edits will go within this area.

Host-based Security

To enable host-based security, or rather the denial or allowing of hosts based on IP / hostname, one line must be added between the aforementioned tags.

Order Allow, Deny

This command establishes the default behavior of the security. If allow comes before deny, apache will deny all traffic by default while making exceptions for Allow commands. The converse of this, ‘Deny, Allow’, will allow all traffic by default and only deny hosts for which a Deny command exists. Now, an explanation of both Allow and Deny commands.
A specific host may be allowed using the following command:

Allow from 192.168.1.4

Or, an entire subnet may be allowed using either of the following:

Allow from 192.168.1.0/24
Allow from 192.168.1.0/255.255.255.0

To make these statements Deny hosts, simply replace the Allow with Deny. Also, hostnames may be used instead of ip addresses, however this is not recommended as the system must perform a lookup every time the page is accessed. Below, is an example of my section in the apache.conf file.

# phpMyAdmin default Apache configuration
Alias /phpmyadmin /usr/share/phpmyadmin

Options FollowSymLinks
DirectoryIndex index.php

# Deny all hosts unless an implicit Allow command is included.
# In this case, Allow from 192.168.1.0/24.

Order Allow,Deny
Allow from 192.168.1.0/24

AddType application/x-httpd-php .php
php_flag magic_quotes_gpc Off
php_flag track_vars On
php_flag register_globals Off
php_value include_path .

Finally, once any changes are made to the apache.conf file, apache must be restarted to enable the changes. From a command shell, enter the following to verify and enable your changes.

sudo apache2ctl configtest
sudo apache2ctl restart

User-based Security

The second option for securing the phpMyAdmin directory is to password-protect the directory with a username and password. This may seem silly since phpMyAdmin already requires a password, but it’s an additional level of defense to keep users away from your databases.

The configuration begins as follows and should be placed between the aforementioned <Directory> tags in /etc/phpmyadmin/apache.conf :

AuthType Basic
AuthName "phpMyAdmin Authentication"
AuthUserFile /etc/phpmyadmin/passwords
Require user admin

This command is fairly simple. AuthType enables password protection and AuthName provides a name for the particular instance. AuthUserFile specifies the file which holds usernames and passwords. The final line, Require user … specifies which user has access to this directory. Next, we must make this passwords file and create a user with a password. Open a shell and issue the following:

sudo htpasswd –c /etc/phpmyadmin/passwords admin

Following the entering of this command, the system will prompt you for a password for the specified user. The –c parameter creates the /etc/phpmyadmin/passwords file, it is not necessary if the file already exists. Further, the admin username can be supplemented with a username of your choice. For example, I might enter: htpasswd –c /etc/phpmyadmin/passwords npier

Finally, once any changes are made to the apache.conf file, apache must be restarted to enable the changes. From a command shell, enter the following to verify and enable your changes.

sudo apache2ctl configtest
sudo apache2ctl restart

Further Thoughts
SSL encryption would also provide additional security as all passwords submitted in this tutorial are sent in clear text and are capable of being ‘sniffed’ with a network analyzer. This is sometimes referred to as “the man in the middle.” I’m including a link to an excellent documentation for enabling this on Ubuntu server: https://help.ubuntu.com/8.04/serverguide/C/httpd.html#https-configuration

Please feel free to provide any feedback regarding this post. It is my wish that these instructions will pose little issue for many users.

I’ve spent most of today working on it and hopefully it works well in all cases. However, the form handler may still allow some improper values. As long as proper input is provided, the calculator should produce accurate results. To view the calculator, visit the ‘Subnet Calculator‘ via the link provided above.

As always, I’m providing the source to my program. It’s currently set up to be used as a page template. Paste the code into a .php file and place it in the directory of a WordPress template to use it. Click here to download the source or ‘Continue Reading’ to view the source.

<?php
/*
Template Name: Subnet Page
*/
?>
 
<?php get_header(); ?>
 
    <div id="content">
 
        <div id="main">
 
            <div class="box1 clearfix">
                    <div class="post clearfix">
<?php
//Shows Input form until the subnet button is clicked.
	if (!isset($_POST['submit'])) {
?>
		<h2 class="hd-page">Subnet Calculator</h2>
				<form name="subnet-calculator" action="<?php get_permalink()?>" method="post">
					<table width="100%">
						<tr>
							<td width="40%" align="left"><p>IP Address</p><p><input type="text" size="3" name="subOctet1">.<input type="text" size="3" name="subOctet2">.<input type="text" size="3" name="subOctet3">.<input type="text" size="3" name="subOctet4"></p></td>
							<td width="30%" align="left"><p>/ Mask</p> <p>/ <input type="text" size="2" name="bits"></p></td>
							<td width="30" valign="middle"><br /><p><button type="submit" name="submit">Results</button></p></td>
						</tr>
					</table>
				</form>
		<?php
	}
	else {
				//Variables
				$subArray = array($_POST['subOctet1'], $_POST['subOctet2'], $_POST['subOctet3'], $_POST['subOctet4']);
				$bits = $_POST['bits'];
 
					function formCheck($subArray, $bits){
						//FORM CHECK Subnet
						foreach ($subArray as $i => $value) {
							if (($subArray[$i] != null) && ($subArray[$i] > 255 || $subArray[$i] < 0)) {
								echo '<h3>You have entered an incorrect value. Subnet octet values must be between 0 and 255.</h3>';
								return false;
							}
						}
						//FORM CHECK bits
						if (($bits != null) && ($bits > 30 || $bits < 0)) {
							echo '<h3>You have entered an incorrect value. Subnet bits must be less than 30 and greater than 0 </h3>';
							return false;
						}
						else { return true;}
					}
 
 
				//Functions for calculation of subnet information.
					//Returns Subnet Mask as String
					function getSubnetMask($bits){
						$subnetMask = array();
						for($i = 0; $i < 4; $i++){
							if($bits >= 8){
								$subnetMask[$i] = 255;
								$bits -= 8;
							}
							else{
								$subnetMask[$i] = (string)(256 - (pow(2,(8 - $bits))));
								$bits = 0;
							}
						}
						return implode('.', $subnetMask);
					}
					//Returns Wildcard Mask as String
					function getWildCardMask($bits){
						$wildcardMask = '';
						for($i = 0; $i < 4; $i++){
							if($bits >= 8){
								$wildcardMask[$i] = 0;
								$bits -= 8;
							}
							else{
								$wildcardMask[$i] = (string)(pow(2,(8 - $bits)) - 1);
								$bits = 0;
							}
						}
						return implode('.', $wildcardMask);
					}
					//Returns Class of IP Address/Subnet as String based on first octet.
					function getSubnetClass($subArray){
					$subclass = '';
						if($subArray[0] > 0 && $subArray[1] < 128){
							$subClass = 'A';
						}
						if($subArray[0] > 127 && $subArray[1] < 192){
							$subClass = 'B';
						}
						if($subArray[0] > 191 && $subArray[1] < 224){
							$subClass = 'C';
						}
						if($subArray[0] > 223){
							$subClass = 'D (multicast)';
						}
						if($subArray[0] > 239){
							$subClass = 'E (reserved)';
						}
						return $subClass;
					}
					//Gets number of subnets ignoring class rules (Subnet/Hosts). Returns Integer as String.
					function getClasslessSubnets($bits){
						return pow(2,$bits);
					}
					//Gets number of subnets using class rules (Class/Subnet/Hosts). Returns Integer as String.
					function getClassfulSubnets($bits, $subArray){
						if(getSubnetClass($subArray) == "A" && $bits > 7){
							$bits -= 8;
							return pow(2,$bits);
						}
						if(getSubnetClass($subArray) == "B" && $bits > 15){
							$bits -= 16;
							return pow(2,$bits);
						}
						if(getSubnetClass($subArray) == "C" && $bits > 23){
							$bits -= 24;
							return pow(2,$bits);
						}
						else{
							return 'Classful rules may not be applied to this subnet.';
						}
					}
					//Gets number of hosts using bits after prefix length. Returns Integer as String.
					function getHosts($bits){
						return pow(2,(32 - $bits)) - 2;
					}
					//Returns the subnet which contains the input IP as String.
					function getSubnet($mask, $subArray){
						$subnetMask = explode('.', $mask);
						$subnet = array();
						for($i = 0; $i < 4; $i++){
							if($subnetMask[$i] == 255){
								$subnet[$i] = $subArray[$i];
							}
							elseif($subnetMask[$i] == 0){
								$subnet[$i] = 0;
							}
							else{
								while($subArray[$i] >= $subnet[$i]){
									$subnet[$i] += (255 - $subnetMask[$i]);
								}
								$subnet[$i] -= (255- $subnetMask[$i]);
							}
						}
						return implode('.', $subnet);
					}
					//Returns the broadcast address of subnet which contains the input IP as String.
					function getBroadcast($mask, $subArray){
						$subnetMask = explode('.', $mask);
						$broadcast = array();
						for($i = 0; $i < 4; $i++){
							if($subnetMask[$i] == 255){
								$broadcast[$i] = $subArray[$i];
							}
							elseif($subnetMask[$i] == 0){
								$broadcast[$i] = 255;
							}
							else{
								while($subArray[$i] >= $broadcast[$i]){
									$broadcast[$i] += (255 - $subnetMask[$i]);
								}
							}
						}
						return implode('.', $broadcast);
					}
					//Returns the first usable host in subnet as String.
					function getLowRange($subnet){
						$lowRange = explode('.', $subnet);
						$lowRange[3]++;
						return implode('.', $lowRange);
					}
					//Returns the last usable host in subnet as String.
					function getHighRange($broadcast){
						$highRange = explode('.', $broadcast);
						$highRange[3]--;
						return implode('.', $highRange);
					}
//If the formc check returns true. Display results.
				if (formCheck($subArray, $bits) == true){
				?>
						<table width="100%">
							<tr>
								<td width="50%" valign="top">
									<h3>Subnet Information</h3>
									<p>
										Class: <strong class="value"><?php echo getSubnetClass($subArray); ?></strong><br />
										Subnet: <strong class="value"><?php echo getSubnet(getSubnetMask($bits), $subArray); ?></strong><br />
										Host-range: <strong class="value"><?php echo getLowRange(getSubnet(getSubnetMask($bits), $subArray)) . ' - ' . getHighRange(getBroadcast(getSubnetMask($bits), $subArray)); ?></strong><br />
										Broadcast-address: <strong class="value"><?php echo getBroadcast(getSubnetMask($bits), $subArray); ?></strong><br />
										Classful-subnets: <strong class="value"><?php echo getClassfulSubnets($bits, $subArray); ?></strong>
									</p>
								</td>
 
								<td width="50%" valign="top">
									<h3>Prefix Information</h3>
									<p>
										Prefix-length: <strong class="value"><?php echo "/" . $bits; ?></strong><br />
										Subnet-mask: <strong class="value"><?php echo getSubnetMask($bits); ?></strong><br />
										Wildcard-mask: <strong class="value"><?php echo getWildCardMask($bits); ?></strong><br />
										Hosts-per-subnet: <strong class="value"><?php echo getHosts($bits); ?></strong><br />
										Classless-subnets: <strong class="value"><?php echo getClasslessSubnets($bits, $subArray); ?></strong>
									</p>
								</td>
							</tr>
						</table>
 
 
            <?php
			}
		}
					edit_post_link(__('Edit this entry.',woothemes), '<p>', '</p>');
			?>
                </div>
            </div>
 
        </div><!-- / #main -->
 
<?php get_sidebar(); ?>
 
	</div><!-- / #content -->
<?php get_footer(); ?>

I’ll likely be posting the widget for free distribution on WordPress’s site soon. I’m in the process of making the widget more accessible to normal users as it currently requires the manual input of a user’s steam account URL into a text file.

Update: I’ve release version 1.01 of my Steam Community Gamestats Widget. I’ve been sick recently and had a lot of time to revise the code and better adapt it to WordPress’  Widget Class implemented in WordPress 2.8.