Kota Jembal Ubuntu / Linux

E: Unable to fetch some archives, m

2016-06-12T20:28:00.000-07:00

from http://stackoverflow.com

This is linked to using a non LTS version of ubuntu called an End of life version. As those have discontinued support. You can check if your ubuntu lies in the end of life version on this link -> https://wiki.ubuntu.com/Releases
The simplest solution is to do the following two steps:
1- Backup your sources list -> sudo cp /etc/apt/sources.list /etc/apt/sources.list.backup
2- Open the sources file "/etc/apt/sources.list" Rename all the instances of us.archive or archive in http://us.archive.ubuntu.com/ubuntu/ to
http://old-releases.ubuntu.com/ubuntu/
Also do the same for the http://security.ubuntu.com/ubuntu/dists/saucy-security/universe/binary-i386/Packages
3- Run sudo apt-get update after doing the above.
That should fix the issue.
Warning: Please update your ubuntu to an LTS version as soon as possible otherwise you won't be getting the latest security patches. This is definitely not a solution that you would deploy on production machines.

Install package using tasksel (Ubuntu 16.04)

2016-05-25T19:44:00.002-07:00

tasksel is a gui for install a bundle og installation

1. install the tasksel tool

# apt install tasksel

2. run the tasksel util

# tasksel

Network Security tools script

2015-05-22T00:13:00.002-07:00

Chkrootkit:
chkrootkit is a tool to locally check for signs of a rootkit. It contains a chkrootkit: shell script that checks system binaries for rootkit modification.

Installation:
Open up the terminal and type the following command to install chkrootkit:

$ sudo apt-get install chkrootkit

Using chkrootkit:
Open up the terminal and type the command: $ sudo chkrootkit
This will perform all tests

Other Configurations:
If you want an automatic daily run of chkrootkit:
Open /etc/chkrootkit.conf and Replace RUN_DAILY="false" by RUN_DAILY="true"

If you also want a daily mailed report :
Open /etc/cron.daily/chkrootkit and replace '$CHKROOTKIT $RUN_DAILY_OPTS' by

'$CHKROOTKIT $RUN_DAILY_OPTS | mail -s '"\"Daily chkrootkit run from $HOSTNAME \"$YOUR_EMAIL_ADDRESS"'

Rkhunter:
Rootkit Hunter scans files and systems for known and unknown rootkits, backdoors, sniffers, and malware. The application consists of the main shell script, a few text-based databases, and optional Perl scripts. It can recognise and run external applications like 'skdet' and 'unhide'. It should run on almost every Unix clone.

Installation:
Open up the terminal and type the following command to install Rkhunter:

$ sudo apt-get install Rkhunter

Using Rkhunter:
Open up the terminal and type the command: $ sudo rkhunter --check
This will perform all tests

By default, the log file '/var/log/rkhunter.log' will be created. It will contain the results of the checks made by Rkhunter

The following command option causes rkhunter to check and download the later version of any of its text data files: $ sudo rkhunter --update

others :

1. DenyHosts

What is DenyHosts?

DenyHosts is a script intended to be run by Linux system administrators to help thwart SSH server attacks (also known as dictionary based attacks and brute force attacks). If you've ever looked at your ssh log (/var/log/secure on Redhat, /var/log/auth.log on Mandrake, etc...) you may be alarmed to see how many hackers attempted to gain access to your server. Hopefully, none of them were successful (but then again, how would you know?). Wouldn't it be better to automatically prevent that attacker from continuing to gain entry into your system?

Features

- Parses /var/log/secure to find all login attempts and filters failed and successful attempts. - Synchronization mode (new in 2.0) allows DenyHosts daemons the ability to share data via a centralized server to proactively thwart attacks.
- Can be run from the command line, cron or as a daemon (new in 0.9)
- Records all failed login attempts for the user and offending host
- For each host that exceeds a threshold count, records the evil host
- Keeps track of each non-existent user (eg. sdadasd) when a login attempt failed.
- Keeps track of each existing user (eg. root) when a login attempt failed.
- Keeps track of each offending host (with 0.8+ these hosts can be purged if the associated entry in /etc/hosts.deny is expired)
- Keeps track of suspicious logins (that is, logins that were successful for a host that had many login failures)
- Keeps track of the file offset, so that you can reparse the same file (/var/log/secure) continuously (until it is rotated).
- When the log file is rotated, the script will detect it and parse from the beginning.
- Appends /etc/hosts.deny and adds the newly banned hosts
- Optionally sends an email of newly banned hosts and suspicious logins.
- Keeps a history of all user, host, user/host combo and suspicious logins encountered which includes the data and number of corresponding failed login attempts.
- Maintains failed valid and invalid user login attempts in separate files, such that it is easy to see which valid user is under attack (which would give you the opportunity to remove the account, change the password or change it's default shell to something like /sbin/nologin
- Upon each run, the script will load the previously saved data and re-use it to append new failures.
- Resolves IP addresses to hostnames, if available (new in v0.6.0).
- /etc/hosts.deny entries can be expired (purge) at a user specified time (new in 0.8)

These are some of the people and sites that have blogged about DenyHosts:

2. Fail2ban

Fail2ban scans log files (e.g. /var/log/apache/error_log) and bans IPs that show the malicious signs -- too many password failures, seeking for exploits, etc. Generally Fail2Ban is then used to update firewall rules to reject the IP addresses for a specified amount of time, although any arbitrary other action (e.g. sending an email) could also be configured. Out of the box Fail2Ban comes with filters for various services (apache, courier, ssh, etc).

3. Ubuntu security tools

The Ubuntu repositories contain several useful tools for maintaining a secure network and network administration. This page attempts to list the most popular and useful of these utilities, a brief description of them, and how to install them.

Wireshark (Previously called Ethereal) - a popular network traffic analyzing tool, that can capture both off the wire and from existing capture files. It features a helpful GUI to ease analysis. Note: The Universe package adds a menu entry that expects the user to have a root account. To use ethereal in Ubuntu, use gksudo in a terminal. You should only run it using sudo if need to capture packets live; root privileges are not required to read saved capture files. For Ubuntu 6.06 and earlier install the ethereal and ethereal-common packages from the Universe Repository.
- For Ubuntu 6.10 onwards install install the wireshark and wireshark-common packages from the Universe Repository.
''Nessus'' - a powerful remote network security auditor, with a nice GUI. Nessus supports plugins and offers a usually current attack database. It also features useful scripting abilities, allowing you to automate many tasks. Nessus is no longer open source, but is available free for personal use.
''OpenVAS'' (The Open Vulnerability Assessment System) is a framework of several services and tools offering a comprehensive and powerful vulnerability scanning and vulnerability management solution. The actual security scanner is accompanied with a daily updated feed of Network Vulnerability Tests (NVTs), over 20,000 in total (as of January 2011). All OpenVAS products are Free Software. Most components are licensed under the GNU General Public License (GNU GPL). (forum thread on how to install and use.)
Nmap - the standard network mapper. Has a thousand and one uses. To install Nmap install the nmap package.
Etherape - an etherman clone. It displays network activity with an intuitive UI. Install the etherape package from the Universe Repository.
Kismet - a wireless sniffing tool. Includes support for GPS map scanning with in use of the gpsdrive package. Install the kismet package from the Universe Repository.
Chkrootkit - chkrootkit can be used to help determine if a machine has been compromised. While not what you should use for the 'final word' on if you have been compromised, it runs a lot of useful checks and can direct suspicions towards finding a solution. To install chkrootkit install the chkrootkit package.
Rkhunter (Ubuntu 6.06 and above only) - another rootkit detection software. Install the rkhunter package from the Universe Repository.
tiger - Tiger is a package consisting of Bourne Shell scripts, C code and data files which is used for checking for security problems on a UNIX system. It scans system configuration files, file systems, and user configuration files for possible security problems and reports them. Install tiger chkrootkit john.
GnuPG - also known as GPG, is an open source PGP replacement implementing the OpenPGP standard. Lacks support for IDEA, but is incredibly useful. Included by default. GnuPG will allow you to encrypt emails, digitally sign, and integrates well into the Evolution mail client as well as Thunderbird.
Seahorse - a light-weight Gnome frontend for GPG, makes managing keys much easier. Install the seahorse package from the Universe Repository.
Nemesis - a command-line based packet injection utility. Requires a bit of reading the documentation to get full use from. To install nemesis install the nemesis package from the Universe Repository.
Tcpdump - while its name suggests that it works for only TCP, tcpdump also supports UDP, BGP, NFS, and a lot of other packet types. It is a powerful network utility that should be in every admins toolbox, allowing you to pull in everything off the wire. In combination with ethereal it doesn't miss much. To install tcpdump install the tcpdump package.
OpenSSH - OpenSSH almost singlehandedly stopped admins from using telnet, an insecure protocol. The OpenSSH client is installed by default. Generally you want to use SSH instead of telnet or rsh. In some situations, such as large number of clients, you might want to pursue other options, such as telnet with ssl. To install the ssh server install the openssh-server package.
denyhosts (Ubuntu 6.10 and above only) - scans your SSH logs to find brute-force attacks, and then blocks the IPs they came from. To install denyhosts install the denyhosts package.

ssh compromised

2015-05-21T04:03:00.000-07:00

Chkrootkit:
chkrootkit is a tool to locally check for signs of a rootkit. It contains a chkrootkit: shell script that checks system binaries for rootkit modification.

Installation:
Open up the terminal and type the following command to install chkrootkit:

$ sudo apt-get install chkrootkit

'$CHKROOTKIT $RUN_DAILY_OPTS | mail -s '"\"Daily chkrootkit run from $HOSTNAME \"$YOUR_EMAIL_ADDRESS"'

$ sudo apt-get install Rkhunter

ssh compromised

1. stop ssh service

sudo /etc/init.d/ssh stop

2. stop ssh service

# sudo /etc/init.d/ssh start

3. Do not start at boot time :

chkconfig sshd off

1. Check auth log :
/var/log/auth.log
/var/log/auth.log.0

2. Do a portscan with nmap

3. security tools utils :

- logcheck, portsentry, and tripwire

"it's very common for random dictionary SSH attempts, so i wouldn't be too worried by that. you may want to change the port for random obfuscation, but you'll still see random attempts from time to time, it's life having a machine on the internet." - Owen

"Will happen all the time with ssh enabled. Move it to a high port." - Bill K

if there was an attack, the best advice is to reinstall it from scratch ( make sure you plugin any holes on the new install ). It is very easy to not notice a backdoor or a stealth process, you are better off reinstalling.
"* ... prevent this from happening in the future?"

security updates
tight firewall
strong passwords
turn off uneccessary services

Suggestion :

There is some poor advice on this thread, such as:

using a non-standard port for ssh (wrong!)
using some third party security tool (adding an unnecessary dependency/complexity)
configuring your firewall to block or whitelisting (maintenance head-ache)

Simply tweak your /etc/ssh/sshd_config instead to improve security:

PermitRootLogin no
Configure AllowUsers for only the users on the system who have ssh accounts
Consider using only physical keys with 'PasswordAuthentication no'

If you are box has been infiltrated. Rebuild the box.

-----------------------------------------------------------------------------------------------------------------

See:

How can I prevent this from happening in the future?

See:

-----------------------------------------------------------------------------------------------------------------

You can watch the box to see what's going in and out and look for anything suspicious. See this post: http://stackoverflow.com/questions/124745/sniffing-network-traffic-for-signs-of-virusesspyware

-----------------------------------------------------------------------------------------------------------------

Psad coupled with Shorewall is a good way to compliment your iptables rules.
I also use Fail2ban to track my ssh logins

-----------------------------------------------------------------------------------------------------------------

http://www.ossec.net/
taken from the website :
"OSSEC is an Open Source Host-based Intrusion Detection System. It performs log analysis, file integrity checking, policy monitoring, rootkit detection, real-time alerting and active response."

log analysis It can check logs file on your servers and alerts you via rules (there are a lot pre-defined and you can add your own)
file integrity tripwire/aide like functionnality so you will see if any file has been modified on your server
policy monitoring : check some "Best practices" security rules
rootkit detection : rkhunter, chkrootkit like functionnality
real-time alerting and active response : You can configure ossec to react automatically to alerts (i don't use this but you can use it to block ssh access to hosts making too many failed connections attempts)

Really good product and it is very active
To harden your box you can also use lynis or bastille

-----------------------------------------------------------------------------------------------------------------

take a look at tools like logcheck, portsentry, and tripwire. it's very common for random dictionary SSH attempts, so i wouldn't be too worried by that. you may want to change the port for random obfuscation, but you'll still see random attempts from time to time, it's life having a machine on the internet.
-----------------------------------------------------------------------------------------------------------------

Prevention :

- Use iptables

$ iptables        -A INPUT      -p tcp --dport 22 -m state --state ESTABLISHED,RELATED -j ACCEPT
$ iptables        -A INPUT      -p tcp --dport 22 -m state --state NEW -m limit --limit 3/min --limit-burst 3 -j ACCEPT
$ iptables        -A INPUT      -p tcp --dport 22 -j DROP

Use DenyHosts to monitor my logs for suspicious SSH traffic, it can configured to automatically firewall off hosts at a certain point.

others :

1. DenyHosts

What is DenyHosts?

Features

2. Fail2ban

3. Ubuntu security tools

Wireshark (Previously called Ethereal) - a popular network traffic analyzing tool, that can capture both off the wire and from existing capture files. It features a helpful GUI to ease analysis. Note: The Universe package adds a menu entry that expects the user to have a root account. To use ethereal in Ubuntu, use gksudo in a terminal. You should only run it using sudo if need to capture packets live; root privileges are not required to read saved capture files. For Ubuntu 6.06 and earlier install the ethereal and ethereal-common packages from the Universe Repository.
- For Ubuntu 6.10 onwards install install the wireshark and wireshark-common packages from the Universe Repository.
''Nessus'' - a powerful remote network security auditor, with a nice GUI. Nessus supports plugins and offers a usually current attack database. It also features useful scripting abilities, allowing you to automate many tasks. Nessus is no longer open source, but is available free for personal use.
''OpenVAS'' (The Open Vulnerability Assessment System) is a framework of several services and tools offering a comprehensive and powerful vulnerability scanning and vulnerability management solution. The actual security scanner is accompanied with a daily updated feed of Network Vulnerability Tests (NVTs), over 20,000 in total (as of January 2011). All OpenVAS products are Free Software. Most components are licensed under the GNU General Public License (GNU GPL). (forum thread on how to install and use.)
Nmap - the standard network mapper. Has a thousand and one uses. To install Nmap install the nmap package.
Etherape - an etherman clone. It displays network activity with an intuitive UI. Install the etherape package from the Universe Repository.
Kismet - a wireless sniffing tool. Includes support for GPS map scanning with in use of the gpsdrive package. Install the kismet package from the Universe Repository.
Chkrootkit - chkrootkit can be used to help determine if a machine has been compromised. While not what you should use for the 'final word' on if you have been compromised, it runs a lot of useful checks and can direct suspicions towards finding a solution. To install chkrootkit install the chkrootkit package.
Rkhunter (Ubuntu 6.06 and above only) - another rootkit detection software. Install the rkhunter package from the Universe Repository.
tiger - Tiger is a package consisting of Bourne Shell scripts, C code and data files which is used for checking for security problems on a UNIX system. It scans system configuration files, file systems, and user configuration files for possible security problems and reports them. Install tiger chkrootkit john.
GnuPG - also known as GPG, is an open source PGP replacement implementing the OpenPGP standard. Lacks support for IDEA, but is incredibly useful. Included by default. GnuPG will allow you to encrypt emails, digitally sign, and integrates well into the Evolution mail client as well as Thunderbird.
Seahorse - a light-weight Gnome frontend for GPG, makes managing keys much easier. Install the seahorse package from the Universe Repository.
Nemesis - a command-line based packet injection utility. Requires a bit of reading the documentation to get full use from. To install nemesis install the nemesis package from the Universe Repository.
Tcpdump - while its name suggests that it works for only TCP, tcpdump also supports UDP, BGP, NFS, and a lot of other packet types. It is a powerful network utility that should be in every admins toolbox, allowing you to pull in everything off the wire. In combination with ethereal it doesn't miss much. To install tcpdump install the tcpdump package.
OpenSSH - OpenSSH almost singlehandedly stopped admins from using telnet, an insecure protocol. The OpenSSH client is installed by default. Generally you want to use SSH instead of telnet or rsh. In some situations, such as large number of clients, you might want to pursue other options, such as telnet with ssl. To install the ssh server install the openssh-server package.
denyhosts (Ubuntu 6.10 and above only) - scans your SSH logs to find brute-force attacks, and then blocks the IPs they came from. To install denyhosts install the denyhosts package.

SCP command

2014-11-25T00:59:00.000-08:00

Basic syntax of SCP

# scp source_file_name username@destination_host:destination_folder

Provide the detail information of SCP process using -v parameter

# scp -v Label.pdf mrarianto@202.x.x.x:.

Provide modification times, access times, and modes from original files

# scp -p Label.pdf mrarianto@202.x.x.x:.

Make file transfer faster using -C parameter

# scp -pv messages.log mrarianto@202.x.x.x:.

# scp -Cpv messages.log mrarianto@202.x.x.x:.

Select another cipher to encrypt files

# scp -c 3des Label.pdf mrarianto@202.x.x.x:.

Limiting bandwidth usage

# scp -l 400 Label.pdf mrarianto@202.x.x.x:.

Specify specific port to use with SCP

scp -P 2249 Label.pdf mrarianto@202.x.x.x:.

Copy files inside directory recursively

 scp -r documents mrarianto@202.x.x.x:.

Disable progress meter and warning / diagnostic message

scp -q Label.pdf mrarianto@202.x.x.x:.

Copy files using SCP through Proxy

ProxyCommand /usr/bin/corkscrew 10.0.96.6 8080 %h %p ~/.ssh/proxyauth

“~/.ssh/proxyauth

myusername:mypassword

Select different ssh_config file

scp -F /home/pungki/proxy_ssh_config Label.pdf

Laravel 4 – simple website with backend tutorial – Part 1

2014-10-30T16:54:00.000-07:00

Laravel 4 – simple website with backend tutorial – Part 1

85 Comments

Laravel 4 app will be developed at the same time as writing this article, and everything will be up on Github. I’ll try to separate the tutorial parts in branches so it will be easier to follow. Github URL: https://github.com/bstrahija/l4-site-tutorial
EDIT: The second part of Laravel 4 tutorial is available!!!
This is by no means a tutorial for beginners, there are plenty of those I assume you already know the basics on how to install Composer, pull down the Laravel 4 base application. You will need some mid-level knowledge on tools like Composer, Git, working in the terminal…
I’m going to put up some links to resources on getting started with Laravel and Composer at the end of this article. Also keep in mind that at this point Laravel 4 is still in BETA, but it’s really stable and scheduled for release during May.

Installing Laravel 4 and all the dependencies

Since Laravel 4 already leverages a lot of third party packages, we’ll expand on that, and add some that could be useful for our application. Here are some of composer packages that we’re going to need:

Sentry – user authentication (cartalyst/sentry)
Imagine – image manipulation and resizing (imagine/Imagine)
Markdown – for converting markdown text to HTML (dflydev/markdown)

So, first let’s start by creating a new L4 app. We’re going to call our app simply “L4 Site”. You can call yours anything you like

1 2	`git clone -b develop git://github.com/laravel/laravel.git l4_site` `cd l4_site`

The next step is to setup our composer file. After adding our dependencies, it should look like this:

{

    &quot;require&quot;: {

        &quot;laravel/framework&quot;: &quot;4.0.*&quot;,

        &quot;cartalyst/sentry&quot;: &quot;2.0.*&quot;,

        &quot;dflydev/markdown&quot;: &quot;v1.0.2&quot;,

        &quot;imagine/Imagine&quot;: &quot;v0.4.1&quot;

    },

    &quot;autoload&quot;: {

        &quot;classmap&quot;: [

            &quot;app/commands&quot;,

            &quot;app/controllers&quot;,

            &quot;app/models&quot;,

            &quot;app/database/migrations&quot;,

            &quot;app/database/seeds&quot;,

            &quot;app/tests/TestCase.php&quot;

        ]

    },

    &quot;scripts&quot;: {

        &quot;post-update-cmd&quot;: &quot;php artisan optimize&quot;

    },

    &quot;config&quot;: {

        &quot;preferred-install&quot;: &quot;dist&quot;

    },

    &quot;minimum-stability&quot;: &quot;dev&quot;

}

Then just run “php composer install” and wait for all the dependencies to download. This could take a couple of minutes.
When everything is finished downloading we need to check if the app actually works. For this I would recommend to setup a virtual host entry, or if you working on a machine with PHP 5.4 you can utilize the PHP built in server by running “php artisan serve” from the console.
For simplicity sake I’ll take the approach with the build in PHP server which will start the server on the URL http://localhost:8000/.
If you get the Hello World! page then everything is fine, but if you see any errors you should consult the Laravel 4 documentation.

Setup the database and migrations

The next step is to setup the database connection and create our migrations. I’ll be working with a MySQL database, but you can choose whatever database type you want as long as Laravel 4 supports it. If don’t know what migrations and seeding are, you can read more on that here: http://four.laravel.com/docs/migrations
My database is named “l4_site”, and now I am going to enter the database credentials into the database configuration file (app/config/database.php). This is pretty straightforward, but if you run into problems consult the Laravel 4 documentation.
Since we’re leveraging the Sentry package for our user authentication stuff, and Sentry already has some migration setup, we just need to run those migrations by running the following command in our console:

php artisan migrate --package=cartalyst/sentry

Sentry should create 4 DB tables: users, groups, users_groups and throttle. To complete installation for the Sentry package consult the Sentry docs: http://docs.cartalyst.com/sentry-2/installation/laravel-4
EDIT: Some people complained there’s not enough info on installing Sentry, so basicaly you need to add the service provider and the alias to your app/config/app.php file:

'Cartalyst\Sentry\SentryServiceProvider'

and

'Sentry' =&gt; 'Cartalyst\Sentry\Facades\Laravel\Sentry',

I hope this clears it up.
Now that we have our authentication tables setup, we need to create tables that will contain the actual content. We will have 2 types of content entries, articles and pages. So the migrations that we need are these:

php artisan migrate:make create_articles_table --table=articles --create

php artisan migrate:make create_pages_table --table=pages --create

The migrations are created inside the directory “app/database/migrations“. To keep things simple, these are my migrations.
Articles:

&lt;?php

use Illuminate\Database\Schema\Blueprint;

use Illuminate\Database\Migrations\Migration;

class CreateArticlesTable extends Migration {

    public function up()

    {

        Schema::create('articles', function(Blueprint $table)

        {

            $table-&gt;increments('id');

            $table-&gt;string('title');

            $table-&gt;string('slug');

            $table-&gt;text('body')-&gt;nullable();

            $table-&gt;string('image')-&gt;nullable();

            $table-&gt;integer('user_id');

            $table-&gt;timestamps();

        });

    }

    public function down()

    {

        Schema::drop('articles');

    }

}

and Pages:

&lt;?php

use Illuminate\Database\Schema\Blueprint;

use Illuminate\Database\Migrations\Migration;

class CreatePagesTable extends Migration {

    public function up()

    {

        Schema::create('pages', function(Blueprint $table)

        {

            $table-&gt;increments('id');

            $table-&gt;string('title');

            $table-&gt;string('slug');

            $table-&gt;text('body')-&gt;nullable();

            $table-&gt;integer('user_id');

            $table-&gt;timestamps();

        });

    }

    public function down()

    {

        Schema::drop('pages');

    }

}

Now just run “php artisan migrate” and the tables are created. It’s magic

Our models

To actually work with the database we need to create our models. The models that we need are:
app/models/Article.php

&lt;?php namespace App\Models;

class Article extends \Eloquent {

    protected $table = 'articles';

    public function author()

    {

        return $this-&gt;belongsTo('User');

    }

}

app/models/Page.php

&lt;?php namespace App\Models;

class Page extends \Eloquent {

    protected $table = 'pages';

    public function author()

    {

        return $this-&gt;belongsTo('User');

    }

}

There’s already a default User model in the “app/models” folder, I just like to namespace it like the others under App\Models. Go ahead and check it out at: https://github.com/bstrahija/l4-site-tutorial/blob/master/app/models/User.php

Seeding the database

For the app to actually contain some data, I like to add some dummy content. This can be achieved easily by using the Laravel 4 seeds. The files should be located in the “app/database/seeds” directory, and here my setup for the app:
app/database/seeds/DatabaseSeeder.php

&lt;?php

class DatabaseSeeder extends Seeder {

    public function run()

    {

        $this-&gt;call('SentrySeeder');

        $this-&gt;command-&gt;info('Sentry tables seeded!');

        $this-&gt;call('ContentSeeder');

        $this-&gt;command-&gt;info('Content tables seeded!');

    }

}

EDIT: Since we use the Sentry package I changed the way the user is created. We now use

Sentry::getUserProvider()-&gt;create();

for creation.
Also note that the User model is namespaced under App\Models, so you should also update you default model. Just take a look at everything here: https://github.com/bstrahija/l4-site-tutorial/blob/master/app/models/User.php
app/database/seeds/SentrySeeder.php

&lt;?php

use App\Models\User;

class SentrySeeder extends Seeder {

    public function run()

    {

        DB::table('users')-&gt;delete();

        DB::table('groups')-&gt;delete();

        DB::table('users_groups')-&gt;delete();

        Sentry::getUserProvider()-&gt;create(array(

            'email'       =&gt; 'admin@admin.com',

            'password'    =&gt; &quot;admin&quot;,

            'first_name'  =&gt; 'John',

            'last_name'   =&gt; 'McClane',

            'activated'   =&gt; 1,

        ));

        Sentry::getGroupProvider()-&gt;create(array(

            'name'        =&gt; 'Admin',

            'permissions' =&gt; array('admin' =&gt; 1),

        ));

        // Assign user permissions

        $adminUser  = Sentry::getUserProvider()-&gt;findByLogin('admin@admin.com');

        $adminGroup = Sentry::getGroupProvider()-&gt;findByName('Admin');

        $adminUser-&gt;addGroup($adminGroup);

    }

}

app/database/seeds/ContentSeeder.php

&lt;?php

use App\Models\Article;

use App\Models\Page;

class ContentSeeder extends Seeder {

    public function run()

    {

        DB::table('articles')-&gt;delete();

        DB::table('pages')-&gt;delete();

        Article::create(array(

            'title'   =&gt; 'First post',

            'slug'    =&gt; 'first-post',

            'body'    =&gt; 'Lorem
 ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod 
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim 
veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea 
commodo consequat. Duis aute irure dolor in reprehenderit in voluptate 
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint 
occaecat cupidatat non proident, sunt in culpa qui officia deserunt 
mollit anim id est laborum.',

            'user_id' =&gt; 1,

        ));

        Page::create(array(

            'title'   =&gt; 'About us',

            'slug'    =&gt; 'about-us',

            'body'    =&gt; 'Lorem
 ipsum dolor sit amet, consectetur adipisicing elit, sed do eiusmod 
tempor incididunt ut labore et dolore magna aliqua. Ut enim ad minim 
veniam, quis nostrud exercitation ullamco laboris nisi ut aliquip ex ea 
commodo consequat. Duis aute irure dolor in reprehenderit in voluptate 
velit esse cillum dolore eu fugiat nulla pariatur. Excepteur sint 
occaecat cupidatat non proident, sunt in culpa qui officia deserunt 
mollit anim id est laborum.',

            'user_id' =&gt; 1,

        ));

    }

}

Now run “php artisan db:seed” in the console, and your database will be populated with the dummy data from the seeds. Nice.

Extra tip on database seeding

I created a couple of custom artisan commands to refresh the app. You can check them out: https://github.com/bstrahija/l4-site-tutorial/tree/master/app/commands
This is useful for me when working on the app, and sometimes the data is modified, or some entries are deleted. Then I can easily reset the database to a fresh state by running:

php artisan app:refresh

Also, since the migrate command doesn’t migrate 3rd party packages, I added the Sentry migration to the command.
You can add your own commands, call other package migrations etc.

Tinker with our models

Laravel 4 comes with a nice tool for tinkering with out app.
What we can do now is test if the database was properly seeded. Just run “php artisan tinker” and we get into a simple REPL for our app.
Now to check if our pages and articles were seeded we just run the following inside the REPL:

echo App\Models\Page::all();

echo App\Models\Article::all();

And for each command we should get our database content entries in JSON format.

What is next?

For now we just created our database and models, added some dummy data to the database, and there isn’t really much to see in the browser yet.
In the next part we will start to create our backend panel so prepare yourself for some working with routes, controllers, views and assets.
The backend will be built with the Twitter Bootstrap package, since I find it’s the easiest to integrate.

25 Laravel Tips and Tricks

2014-10-27T08:44:00.003-07:00

25 Laravel Tips and Tricks

by Jeffrey Way31 Oct 20131 Comment

There was a period of time, not too long ago, when PHP and its community were, for lack of better words, hated. Seemingly, the headline joke of every day was one that related to how terrible PHP was. Let's see, what new PHP-slamming blog article will be posted today?

Yes, sadly enough, the community and ecosystem simply weren't on the same level as other modern languages.

Yes, sadly enough, the community and ecosystem simply weren't on the same level as other modern languages. It seemed that PHP was destined to live out its dominating lifespan in the form of messy WordPress themes.
But, then, quite amazingly, things began to change - and quickly, too. Like a witch stirring the pot, innovative new projects began popping out of nowhere. Perhaps most notable of these projects was Composer: PHP's definitive dependency manager (not unlike Ruby's Bundler or Node's NPM). While, in the past, PHP developers were forced to wrangle PEAR into shape (a nightmare, indeed), now, thanks to Composer, they can simply update a JSON file, and immediately pull in their desired dependency. A profiler here, a testing framework there... all in seconds!
In the crowded PHP framework world, just as CodeIgniter began to fizzle out, Taylor Otwell's Laravel framework arose out of the ashes to become the darling of the community. With such a simple and elegant syntax, building applications with Laravel and PHP was - gasp - downright fun! Further, with version 4 of the framework leveraging Composer heavily, things finally seemed to be falling into place for the community.

Want migrations (version control for your database)? Done. How about a powerful Active-Record implementation? Sure, Eloquent will do the trick quite nicely. What about testing facilities? Of course. And routing? Most certainly. What about a highly tested HTTP layer? Thanks to Composer, Laravel can leverage many of the excellent Symfony components. When it comes right down to it, chances are, if you need it, Laravel offers it.

While PHP used to be not dissimilar from a game of Jenga - just one block and away from falling to pieces - suddenly, thanks to Laravel and Composer, the future couldn't look any brighter. So pull out some shades, and dig into all that the framework has to offer.

1. Eloquent Queries

Laravel offers one of the most powerful Active-Record implementations in the PHP world. Let's say that you have an orders table, along with an Order Eloquent model:

class Order extends Eloquent {}

We can easily perform any number of database queries, using simple, elegant PHP. No need to throw messy SQL around the room. Let's grab all orders.

$orders = Order::all();

Done. Or maybe, those orders should be returned in order, according to the release date. That's easy:

$orders = Order::orderBy('release_date', 'desc')->get();

What if, rather than fetching a record, we instead need to save a new order to the database. Sure, we can do that.

$order = new Order;

$order->title = 'Xbox One';

$order->save();

Finished! With Laravel, tasks that used to be cumbersome to perform are laughably simple.

2. Flexible Routing

Laravel is unique in that it can be used in a number of ways. Prefer a simpler, more Sinatra-like routing system? Sure, Laravel can offer that quite easily, using closures.

Route::get('orders', function()

{

    return View::make('orders.index')

        ->with('orders', Order::all());

});

This can prove helpful for small projects and APIs, but, chances are high that you'll require controllers for most of your projects. That's okay; Laravel can do that, too!

Route::get('orders', 'OrdersController@index');

Done. Notice how Laravel grows with your needs? This level of accomodation is what makes the framework as popular as it is today.

3. Easy Relationships

What do we do in the instances when we must define relationships? For example, a task will surely belong to a user. How might we represent that in Laravel? Well, assuming that the necessary database tables are setup, we only need to tweak the related Eloquent models.

class Task extends Eloquent {

    public function user()

    {

        return $this->belongsTo('User');

    }

}

class User extends Eloquent {

    public function tasks()

    {

        return $this->hasMany('Task');

    }

}

And, with that, we're done! Let's grab all tasks for the user with an id of 1. We can do that in two lines of code.

$user = User::find(1);

$tasks = $user->tasks;

However, because we've defined the relationship from both ends, if we instead want to fetch the user associated with a task, we can do that, too.

$task = Task::find(1);

$user = $task->user;

4. Form Model Binding

Often, it can be helpful to link a form to a model. The obvious example of this is when you wish to edit some record in your database. With form model binding, we can instantly populate the form fields with the values from the associated table row.

{{ Form::model($order) }}

    <div>

        {{ Form::label('title', 'Title:') }}

        {{ Form::text('title') }}

    </div>

    <div>

        {{ Form::label('description', 'Description:') }}

        {{ Form::textarea('description') }}

    </div>

{{ Form::close() }}

Because the form is now linked to a specific Order instance, the inputs will display the correct values from the table. Simple!

5. Cache Database Queries

Too many database queries, and, very quickly, your application can become like molasses. Luckily, Laravel offers a simple mechanism for caching these queries, using nothing more than a single method call.
Let's grab all questions from the database, but cache the query, since it's not likely that this table will be updated frequently.

$questions = Question::remember(60)->get();

That's it! Now, for the next hour of pages requests, that query will remain cached, and the database will not be touched.

6. View Composers

You'll encounter situations when multiple views require a certain variable or piece of data. A good example of this is a navigation bar that displays a list of tags.
Too keep controllers as minimal as possible, Laravel offers view composers to manage things like this.

View::composer('layouts.nav', function($view)

{

    $view->with('tags', ['tag1', 'tag2']);

});

With this piece of code, any time that the layouts/nav.blade.php view is loaded, it will have access to a variable, $tags, equal to the provided array.

7. Simple Authentication

Laravel takes a dead-simple approach to authentication. Simply pass an array of credentials, likely fetched from a login form, to Auth::attempt(). If the provided values match what is stored in the users table, the user will instantly be logged in.

$user = [

    'email' => 'email',

    'password' => 'password'

];

if (Auth::attempt($user))

{

    // user is now logged in!

    // Access user object with Auth::user()

}

What if we need to log the user out - perhaps, when a /logout URI is hit? That's easy, too.

Route::get('logout', function()

{

    Auth::logout();

    return Redirect::home();

});

8. Resources

Working RESTfully in Laravel has never been easier. To register a resourceful controller, simple call Route::resource(), like so:

Route::resource('orders', 'OrdersController');

With this code, Laravel will register eight routes.

GET /orders
GET /orders/:order
GET /orders/create
GET /orders/:order/edit
POST /orders
PUT /orders/:order
PATCH /orders/:order
DELETE /orders/:order

Further, the companion controller may be generated from the command line:

php artisan controller:make OrdersController

Within this generated controller, each method will correspond to one of the routes above. For examples, /orders will map to the index method, /orders/create will map to create, etc.
We now have the necessary power to build RESTful applications and APIs with ease.

9. Blade Templating

While, yes, PHP is by nature a templating language, it hasn't evolved to become an overly good one. That's okay, though; Laravel offers its Blade engine to fill the gap. Simply name your views with a .blade.php extension, and they will automatically be parsed, accordingly. Now, we can do such things as:

@if ($orders->count())

    <ul>

        @foreach($orders as $order)

            <li>{{ $order->title }}</li>

        @endforeach

    </ul>

@endif

10. Testing Facilities

Because Laravel makes use of Composer, we instantly have PHPUnit support in the framework out of the box. Install the framework and run phpunit from the command line to test it out.
Even better, though, Laravel offers a number of test helpers for the most common types of functional tests.
Let's verify that the home page returns a status code of 200.

public function test_home_page()

{

    $this->call('GET', '/');

    $this->assertResponseOk();

}

Or maybe we want to confirm that, when a contact form is posted, the user is redirected back to the home page with a flash message.

public function test_contact_page_redirects_user_to_home_page()

{

    $postData = [

        'name' => 'Joe Example',

        'email' => 'email-address',

        'message' => 'I love your website'

    ];

    $this->call('POST', '/contact', $postData);

    $this->assertRedirectedToRoute('home', null, ['flash_message']);

}

11. Remote Component

As part of Laravel 4.1 - scheduled to be released in November, 2013 - you can easily write an Artisan command to SSH into your server, and perform any number of actions. It's as simple as using the SSH facade:

SSH::into('production')->run([

    'cd /var/www',

    'git pull origin master'

]);

Pass an array of commands to the run() method, and Laravel will handle the rest! Now, because it makes sense to execute code like this as an Artisan command, you only need to run php artisan command:make DeployCommand, and insert the applicable code into the command's fire method to rapidly create a dedicated deployment command!

12. Events

Laravel offers an elegant implementation of the observer pattern that you may use throughout your applications. Listen to native events, like illuminate.query, or even fire and catch your own.
A mature use of events in an application can have an incredible effect on its maintainability and structure.

Event::listen('user.signUp', function()

{

    // do whatever needs to happen

    // when a new user signs up

});

Like most things in Laravel, if you'd instead prefer to reference a class name, rather than a closure, you can freely do so. Laravel will then resolve it out of the IoC container.

Event::listen('user.signUp', 'UserEventHandler');

13. View All Routes

As an application grows, it can be difficult to view which routes have been registered. This is especially true if proper care has not been given to your routes.php file (i.e. abusive implicit routing).
Laravel offers a helpful routes command, which will display all registered routes, as well as the controller methods that they trigger.

php artisan routes

14. Queues

Think about when a user signs up for your application. Likely, a number of events must take place. A database table should be updated, a newsletter list should be appended to, an invoice must be raised, a welcome email might be sent, etc. Unfortunately, these sorts of actions have a tendency to take a long time.
Why force the user to wait for these actions, when we can instead throw them into the background?

Queue::push('SignUpService', compact('user'));

Perhaps the most exciting part, though, is that Laravel brilliantly offers support for Iron.io push queues. This means that, even without an ounce of "worker" or "daemon" experience, we can still leverage the power of queues. Simply register a URL end-point using Laravel's helpful php artisan queue:subscribe command, and Iron.io will ping your chosen URL each time a job is added to the queue.

Simple steps to faster performance!

15. Easy Validation

When validation is required (and when isn't it), Laravel again comes to the rescue! Using the Validator class is as intuitive as can be. Simply pass the object under validation, as well as a list of rules to the make method, and Laravel will take care of the rest.

$order = [

    'title' => 'Wii U',

    'description' => 'Game console from Nintendo'

];

$rules = [

    'title' => 'required',

    'description' => 'required'

];

$validator = Validator::make($order, $rules);

if ($validator->fails())

{

    var_dump($validator->messages()); // validation errors array

}

Typically, this type of code will be stored within your model, meaning that validation of, say, an order could be reduced to a single method call:

$order->isValid();

16. Tinker Tinker

Especially when first learning Laravel, it an be helpful to tinker around with the core. Laravel's tinker Artisan command can help with this.

As part of version 4.1, the tinker command is even more powerful, now that it leverages the popular Boris component.

$ php artisan tinker

> $order = Order::find(1);

> var_dump($order->toArray());

> array(...)

17. Migrations

Think of migrations as version control for your database. At any given point, you may "rollback" all migrations, rerun them, and much more. Perhaps the true power rests in the power to push an app to production, and run a single php artisan migrate command to instantly construct your database.
To prepare the schema for a new users table, we may run:

php artisan migrate:make create_users_table

This will generate a migration file, which you may then populate according to your needs. Once complete, php artisan migrate will create the table. That's it! Need to roll back that creation? Easy! php artisan migrate:rollback.
Here's an example of the schema for a frequently asked questions table.

public function up()

{

    Schema::create('faqs', function(Blueprint $table) {

        $table->integer('id', true);

        $table->text('question');

        $table->text('answer');

        $table->timestamps();

    });

}

public function down()

{

    Schema::drop('faqs');

}

Notice how the drop() method performs the inverse of up(). This is what allows us to rollback the migration. Isn't that a lot easier that wrangling a bunch of SQL into place?

18. Generators

While Laravel offers a number of helpful generators, an incredibly helpful third-party package, called "Laravel 4 Generators," takes this even further. Generate resources, seed files, pivot tables, and migrations with schema!
In this previous tip, we were forced to manually write the schema. However, with the generators package enabled, we can instead do:

php artisan generate:migration create_users_table --fields="username:string, password:string"

The generator will take care of the rest. This means that, with two commands, you can prepare and build a new database table.

Laravel 4 Generators may be installed through Composer.

19. Commands

As noted earlier, there are number of instances when it can be helpful to write custom commands. They can be used to scaffold applications, generate files, deploy applications, and everything in between.
Because this is such a common task, Laravel makes the process of creating a command as easy as it can be.

php artisan command:make MyCustomCommand

This command will generate the necessary boilerplate for your new custom command. Next, from the newly created, app/commands/MyCustomCommand.php, fill the appropriate name and description:

protected $name = 'command:name';

protected $description = 'Command description.';

And, finally, within the command class' fire() method, perform any action that you need to. Once finished, the only remaining step is to register the command with Artisan, from app/start/Artisan.php.

Artisan::add(new MyCustomCommand);

Believe it or not; that's it! You may now call your custom command from the terminal.

20. Mock Facades

Laravel leverages the facade pattern heavily. This allows for the clean static-like syntax that you'll undoubtedly come to love (Route::get(), Config::get(), etc.), while still allowing for complete testability behind the scenes.
Because these "underlying classes" are resolved out of the IoC container, we can easily swap those underlying instances out with mocks, for the purposes of testing. This allows for such control as:

Validator::shouldReceive('make')->once();

Yep, we're calling shouldReceive directly off of the facade. Behind the scenes, Laravel makes use of the excellent Mockery framework to allow for this. This means that you may freely use these facades in your code, while still allowing for 100% testability.

21. Form Helpers

Because building forms can frequently be a cumbersome task, Laravel's form builder steps in to ease the process, as well as leverage many of the idiosyncrasies related to form construction. Here are a few examples:

{{ Form::open() }}

    {{ Form::text('name') }}

    {{ Form::textarea('bio') }}

    {{ Form::selectYear('dob', date('Y') - 80, date('Y')) }}

{{ Form::close() }}

What about tasks, such as remembering input from the previous form submission? Laravel can do all of that automatically!

22. The IoC Container

At the core of Laravel is its powerful IoC container, which is a tool that assists in managing class dependencies. Notably, the container has the power to automatically resolve classes without configuration!
Simply typehint your dependencies within the constructor, and, upon instantiation, Laravel will use PHP's Reflection API to intelligently read the typehints, and attempt to inject them for you.

public function __construct(MyDependency $thing)

{

    $this->thing = $thing;

}

As long as you request the class out of the IoC container, this resolution will take place automatically.

$myClass = App::make('MyClass');

An important note is that controllers are always resolved out of the IoC container. As such, you may free typhint your controller's dependencies, and Laravel will subsequently do its best to inject them for you.

23. Environments

While a single environment might work for small projects, for any applications of size, multiple environments will prove essentials. Development, testing, production...all of these are essential and require their own configuration.
Maybe your test environment uses a database in memory for testing. Maybe your development environment uses different API keys. Likely, your production environment will use a custom database connection string.
Luckily, Laravel makes our job simple once again. Have a look at bootstrap/start.php in your app.
Here's a basic demonstration of setting both a local and production environment, based upon the browser's address bar.

$env = $app->detectEnvironment(array(

    'local' => array('localhost'),

    'production' => array('*.com')

));

While this will work, generally speaking, it's preferred to use environment variables for this sort of thing. No worries; this is still doable in Laravel! Instead, simply return a function from the detectEnvironment method on the container object.

$env = $app->detectEnvironment(function()

{

    return getenv('ENV_NAME') ?: 'local';

});

Now, unless an environment variable has been set (which you will do for production), the environment will default to local.

24. Simple Configuration

Laravel, yet again, takes a dead-simple approach to configuration. Create a folder within app/config that matches your desired environment, and any configuration files within it will take precedence, if the environment name matches. As such, to, say, set a different billing API key for development, you could do:

<?php app/config/development/billing.php

return [

    'api_key' => 'your-development-mode-api-key'

];

The configuration switcharoo is automatic. Simply type Config::get('billing.api_key'), and Laravel will correctly determine which file to read from.

25. Top-Shelf Further Learning

When it comes to education, the Laravel community, despite its relatively young age, is a never-ending well. In little over a year, a half-dozen different books - related to all matters of Laravel development - have been released.

12 Type Of Servers And What They Do

2014-05-05T03:58:00.003-07:00

1. Real-Time Communication Servers
Also known as chat servers or IRC, and sometimes known as instant messaging (IM) servers, these servers are meant to allow huge number users to exchange information instantly.

2. FTP Servers
This is one of the oldest of the Internet services available. The FTP or File Transfer Protocol allows the users to securely transfer one or more files of any size between two computers.

3. Collaboration Servers
In many ways, collaboration software, once called 'groupware,' demonstrates the original power of the Web. Collaboration software designed to enable users to collaborate, regardless of location, via the Internet or a corporate intranet and to work together in a virtual atmosphere.

4. List Servers
List servers lets users better manage their mass mailing lists like open interactive discussions or one-way lists to deliver newsletters, announcements or advertising.

5. Telnet Servers
The Telnet server lets the users on to a host computer control and work on remote computers.

6. Web Servers
At its core, a Web server serves static content to a Web browser by loading a file from a disk and serving it across the network to a user's Web browser. This entire exchange is mediated by the browser and server talking to each other using HTTP.

7. Virtual Servers
A virtual server is a web server which shares its resources with multiple users. It's another way of saying that multiple web sites share the resources of one server.

8. Proxy Servers
Proxy server is a server which acts as an intermediary for requests between the users and the servers. Client connects to the proxy server and the proxy server evaluates the requests sent by the users simplifies them and control their complexities.

9. Mail Servers
Mail servers help in moving and storing the e-mail over a network via LANs and WANs or across the Internet.

10. Server Platforms
Normally used in same context with that of operating systems, server platforms are the platforms that are under the hardware or software of a system and the hence in the engine that drives the server.

11. Open Source Servers
Similar to server platforms, Open source server are referred to the underlying open source operating system used in the IT infrastructures of the companies.

12. Application Servers
Application servers are a type of middleware which connects the database servers and the app users.

15 IT Courses That Will Make You An Industry Hero

2014-05-03T20:55:00.001-07:00

1. PMP: Project Management Professional

This is a course whose credentials are recognised as one of the most important
certification for project managers. The course has an acknowledgement from the fraternity globally. It is in heavy demand globally. The course is meant for experienced project management professionals. The testing is rigorous.

2. CISSP: Certified Information Systems Security Professional

The CIISP credential is meant primarily for security managers and professionals who work towards he development of policies and procedures in information security. This course has become the global standard in information security certifications. The course was the
first in information security, accredited by the ANSI (American
National Standards Institute) to ISO (International Organization for
Standardization) Standard 17024:2003.

3. MCSD: Microsoft Certified Solutions Developer

THE MCSD is a new new Microsoft developer certification programme. This has replaced the Microsoft Certified Solutions Developer certification. The new course validated the ability of the candidate to design and build application solutions, which may well span multiple versions of a single technology or integrate multiple technologies.

4. MCDBA: Microsoft Certified Database Administrator

The course is meant for employees of MNCs that are looking for quick and reliable systems that would help process and retrieve information, throught operations of their own database servers and business intelligence software. The course is an MCDBA and an individual that is MCDBA certified can design, implement, and manage SQL Server 2000 databases. The certification was retired on 30 September, 2012, though if you achieved it before that date it will still appear on your transcript as a legacy certification.

5. CCDA®: Cisco Certified Design Associate

This course indicates that the taker of the course posses a strong foundation and apprentice knowledge of network design for Cisco converged networks. The course is meant for network design engineers, technicians, and support engineers, who enable efficient network
environments.

6. MCAD: Microsoft Certified Application Developer

This course gives its taker an industry recognition for professional developers that are involved in building powerful applications using Microsoft Visual Studio.

7. VCP-DV: VMware Certified Professional Datacenter Virtualisation

Virtualisation is one of the most important trends in modern technology. This course, provided by VMware, one of the world’s leading vendors of virtualisation products is the first step that an individual could take in gaining industry-recognized expertise in
virtual infrastructure.

8. CNE: Certified Novell Engineer

The CNE course is meant for those individuals who have the expertise and knowledge to solve advanced company-wide support problems and high-level network problems.

9. ITIL v3 Foundation

This course is more of a foundation building course meant that provides quality IT Service Management. The good thing about the course is that it uses documented and proven processes that covering the entire Service Lifecycle.

10. CCA: Citrix Certified Administrator - Citrix XenServer 6

Another entry level certification course, this validates the skills a candidate might have with one of 11 specific Citrix products, the most popular being XenApp, XenDesktop, and XenServer.

11. MCITP: Database Administrator

This is a validation course that aims at building the IT professional’s capability in the deployment, designing, optimizing, and operating technologies for a particular job role. MCITP certifications builds on the technical proficiency measured in the Microsoft Certified Technology Specialist (MCTS) certifications.

12. MCTS: SQL Server 2005

Those that have taken this course are usually IT professionals who might want to pursue careers as database administrators, database developers, or business intelligence developers. The course gives its taker a validation that the IT professional can implement and maintain databases by using specific instructions and specifications.

13. MCT: Microsoft Certified Trainer

Those that have taken this course are considered to be premier technical and instructional experts on Microsoft technologies. The benefits of the course include substantial discounts on exams, books, and Microsoft products; members-only newsgroups and online community resources; and invitations to exclusive events and programs.

14. CCNP®: Cisco Certified Network Professional

The course offers two tracks at the Associate and Professional levels - Designing and Networking. It is demonstrative of the fact that the taker has the ability to plan, implement, verify, and troubleshoot local and wide-area enterprise networks.

15. CCA: Citrix Certified Administrator - Citrix XenDesktop 5

The Citrix CCA is an entry-level certification. Earning this certification validates the candidate's skills with one of 11 specific Citrix products, the most popular being XenApp, XenDesktop, and XenServer.

Donwload entire web using ubuntu / linux

2014-05-01T19:46:00.002-07:00

Basic wget Commands:
To download a file from the Internet type:

wget http://www.example.com/downloads.zip

If you are downloading a large file, for example an ISO image, this could take some time. If your Internet connection goes down, then what do you do? You will have to start the download again. If you are downloading a 700Mb ISO image on a slow connection, this could be very annoying! To get around this problem, you can use the -c parameter. This will continue the download after any disruptions. eg:

wget -c http://www.example.com/linux.iso

I have came across some websites that do not allow you to download any files using a download manager. To get around this,

wget -U mozilla http://www.example.com/image.jpg

This will pass wget off as being a Mozilla web browser

Downloading Entire Sites:
Wget is also able to download an entire website. But because this can put a heavy load upon the server, wget will obey the robots.txt file.

wget -r -p http://www.example.com

The -p parameter tells wget to include all files, including images. This will mean that all of the HTML files will look how they should do.

So what if you don't want wget to obey by the robots.txt file? You can simply add -e robots=off to the command like this:

wget -r -p -e robots=off http://www.example.com

As many sites will not let you download the entire site, they will check your browsers identity. To get around this, use -U mozilla as I explained above.

wget -r -p -e robots=off -U mozilla http://www.example.com

A lot of the website owners will not like the fact that you are downloading their entire site. If the server sees that you are downloading a large amount of files, it may automatically add you to it's black list. The way around this is to wait a few seconds after every download. The way to do this using wget is by including --wait=X (where X is the amount of seconds.)

you can also use the parameter: --random-wait to let wget chose a random number of seconds to wait. To include this into the command:

wget --random-wait -r -p -e robots=off -U mozilla http://www.example.com

Other Useful wget Parameters:
--limit-rate=20k : Limits the rate at which it downloads files. (20Kb/s)
-b : Continues wget after logging out. Very useful if you are connecting to your home PC via SSH.
-o $HOME/wget_log.txt : Logs the output of the wget command to a text file within your home directory. Useful for if you are using wget in the background, as you can check for any errors that may appear.

Hack Into Gmail And Facebook Using Kali Linux!

2014-05-01T16:05:00.003-07:00

1. Open the backtrack terminal use the ifconfig command to find your IP address.

2. On the terminal type cd /pentest/exploits/set

3. You will need to have the Social Engineering Toolkit (SET) for this one.

4. Start this us and then choose the second option, which says ‘Website Attack Vectors’.

5. In the next part, you have to select the fourth option, which says ‘Tabnabbing Attack Method’.

6. Choose the second option, which is ‘Site Cloner’.

7. Now you have to enter the URL of the website that you want to clone or hack into. In this case the URL will be www.gmail.com. The SET will automatically create the clone. Press enter in order to continue.

8. The URL now needs to be converted into the Google URL. For this use goo.gl and send the link address to you’re the person you want to attack. This you can do in a myriad number of ways like email, chat etc.

9. When your victim will open their internet browser for Gmail, they should get a message saying that the page is still loading. As soon as they open a new tab, the fake clone that we made will start functioning.

How To Install Wordpress on Ubuntu 14.04

2014-05-01T04:35:00.000-07:00

How To Install Wordpress on Ubuntu 14.04

Tagged In: Ubuntu, My Sql, Apache, Php, Word Press

Introduction

At this time, WordPress is the most popular CMS (content management system) on the internet. It allows you to easily set up flexible blogs and websites on top of a MySQL backend with PHP processing. WordPress has seen incredible adoption and is a great choice for getting a website up and running quickly.
In this guide, we'll focus on getting a WordPress instance set up with an Apache web server on Ubuntu 14.04.

Prerequisites

Before you begin this guide, there are some important steps that you need to complete on your server.
We will be proceeding through these steps as a non-root user with sudo privileges, so you will need to have one available. You can find out how to create a user with sudo privileges by following steps 1-4 in our Ubuntu 14.04 initial server setup guide.
Additionally, you'll need to have a LAMP (Linux, Apache, MySQL, and PHP) stack installed on your VPS instance. If you don't have these components already installed and configured, you can use this guide to learn how to install LAMP on Ubuntu 14.04.
When you are finished with these steps, you can continue with this guide.

Step One — Create a MySQL Database and User for WordPress

The first step that we will take is a preparatory one. WordPress uses a relational database to manage and store site and user information.
We have MySQL installed, which can provide this functionality, but we need to make a database and a user for WordPress to work with.
To get started, log into the MySQL root (administrative) account by issuing this command:

mysql -u root -p

You will be prompted for the password you set for the MySQL root account when you installed the software. You will then be given a MySQL command prompt.
First, we can create a separate database that WordPress can control. You can call this whatever you would like, but I will be calling it wordpress because it is descriptive and simple. Enter this command to create the database:

CREATE DATABASE wordpress;

Every MySQL statement must end in a semi-colon (;), so check to make sure this is present if you are running into any issues.
Next, we are going to create a separate MySQL user account that we will use exclusively to operate on our new database. Creating one-function databases and accounts is a good idea from a management and security standpoint.
I am going to call the new account that I'm making wordpressuser and will assign it a password of password. You should definitely change the password for your installation and can name the user whatever you'd like. This is the command you need to create the user:

CREATE USER wordpressuser@localhost IDENTIFIED BY 'password';

At this point, you have a database and a user account, each made specifically for WordPress. However, these two components have no relationship yet. The user has no access to the database.
Let's fix that by granting our user account access to our database with this command:

GRANT ALL PRIVILEGES ON wordpress.* TO wordpressuser@localhost;

Now the user has access to the database. We need to flush the privileges so that the current instance of MySQL knows about the recent privilege changes we've made:

FLUSH PRIVILEGES;

We're all set now. We can exit out of the MySQL prompt by typing:

exit

You should now be back to your regular command prompt.

Step Two — Download WordPress

Next, we will download the actual WordPress files from the project's website.
Luckily, the WordPress team always links the most recent stable version of their software to the same URL, so we can get the most up-to-date version of WordPress by typing this:

cd ~
wget http://wordpress.org/latest.tar.gz

This will download a compressed file that contains the archived directory contents of the WordPress files to our home directory.
We can extract the files to rebuild the WordPress directory we need by typing:

tar xzvf latest.tar.gz

This will create a directory called wordpress in your home directory.
While we are downloading things, we should also get a few more packages that we need. We can get these directly from Ubuntu's default repositories after we update our local package index:

sudo apt-get update
sudo apt-get install php5-gd libssh2-php

This will allow you to work with images and will also allow you to install plugins and update portions of your site using your SSH login credentials.

Step Three — Configure WordPress

Most of the configuration that we will be doing will be through a web interface later on. However, we do need to do some work from the command line before we can get this up and running.
Begin by moving into the WordPress directory that you just unpacked:

cd ~/wordpress

A sample configuration file that mostly matches the configuration we need is included by default. However, we need to copy it to the default configuration file location to get WordPress to recognize the file. Do that now by typing:

cp wp-config-sample.php wp-config.php

Now that we have a configuration file to work with, let's open it in a text editor:

nano wp-config.php

As I said before, this file is almost entirely suitable for our needs already. The only modifications we need to make is to the parameters that hold our database information.
We will need to find the settings for DB_NAME, DB_USER, and DB_PASSWORD in order for WordPress to correctly connect and authenticate to the database we created.
Fill in the values of these parameters with the information for the database you created. It should look like this:

// ** MySQL settings - You can get this info from your web host ** //
/** The name of the database for WordPress */
define('DB_NAME', 'wordpress');

/** MySQL database username */
define('DB_USER', 'wordpressuser');

/** MySQL database password */
define('DB_PASSWORD', 'password');

These are the only values that you need to change.
When you are finished, save and close the file.

Step Four — Copy Files to the Document Root

Now that we have our application configured, we need to copy it into Apache's document root, where it can be served to visitors of our website.
One of the easiest and most reliable way of transferring files from directory to directory is with the rsync command. This preserves permissions and has good data integrity features.
The location of the document root in the Ubuntu 14.04 LAMP guide is /var/www/html/. We can transfer our WordPress files there by typing:

sudo rsync -avP ~/wordpress/ /var/www/html/

This will safely copy all of the contents from the directory you unpacked to the document root.
We should now move into the document root to make some final permissions changes

cd /var/www/html

You will need to change the ownership of our files for increased security.
We want to give user ownership to the regular, non-root user (with sudo privileges) that you plan on using to interact with your site. This can be your regular user if you wish, but some may suggest that you create an additional user for this process. It is up to you which you choose.
For this guide, we will use the same account that we set up during the initial server setup guide, which we called demo. This is the account I am performing all of the actions of this guide as.
The group ownership we will give to our web server process, which is www-data. This will allow Apache to interact with the content as necessary.
We can quickly assign these ownership values by typing:

sudo chown -R demo:www-data *

This will set up the ownership properties that we are looking for.
While we are dealing with ownership and permissions, we should also look into assigning correct ownership on our uploads directory. This will allow us to upload images and other content to our site. Currently, the permissions are too restrictive.
First, let's manually create the uploads directory beneath the wp-content directory at our document root. This will be the parent directory of our content:

mkdir /var/www/html/wp-content/uploads

We have a directory now to house uploaded files, however the permissions are still too restrictive. We need to allow the web server itself to write to this directory. We can do this by assigning group ownership of this directory to our web server, like this:

sudo chown -R :www-data /var/www/html/wp-content/uploads

This will allow the web server to create files and directories under this directory, which will permit us to upload content to the server.

Step Five — Complete Installation through the Web Interface

Now that you have your files in place and your software is configured, you can complete the installation through the web interface.
In your web browser, navigate to your server's domain name or public IP address:

http://server_domain_name_or_IP

You will see the WordPress initial configuration page, where you will create an initial administrator account:

Fill out the information for the site and the administrative account you wish to make. When you are finished, click on the install button at the bottom.
WordPress will confirm the installation, and then ask you to log in with the account you just created:

Hit the button at the bottom and then fill out your account information:

You will be presented with the WordPress interface:

Step Six (Optional) — Configure Pretty Permalinks for WordPress

By default, WordPress creates URLs dynamically that look something like this:

http://server_domain_name_or_IP/?p=1

This isn't exactly the most useful interface for visitors or search engines, so most users want to modify this. WordPress has the ability to create "pretty" permalinks which will clean up the URL into a more human-friendly format.
There are a few things we need to do to get this to work with Apache on Ubuntu 14.04.

Modifying Apache to Allow URL Rewrites

First, we need to modify the Apache virtual host file for WordPress to allow for .htaccess overrides. You can do this by editing the virtual host file.
By default, this is 000-default.conf, but your file might be different if you created another configuration file:

sudo nano /etc/apache2/sites-available/000-default.conf

Inside of this file, we want to set up a few things. We should set the ServerName and create a directory section where we allow overrides. This should look something like this:

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html
    ServerName server_domain_name_or_IP
    <Directory /var/www/html/>
        AllowOverride All
    </Directory>
    . . .

When you are finished, save and close the file.
Next, we need to enable the rewrite module, which allows you to modify URLs. You can do this by typing:

sudo a2enmod rewrite

After you have made these changes, restart Apache:

sudo service apache2 restart

Create an .htaccess File

Now that Apache is configured to allow rewrites through .htaccess files, we need to create an actual file.
You need to place this file in your document root. Type this to create an empty file:

touch /var/www/html/.htaccess

This will be created with your username and user group. We need the web server to be the group owner though, so we should adjust the ownership by typing:

sudo chown :www-data /var/www/html/.htaccess

We now have the correct ownership of this file.
We may need to adjust the permissions however. This depends on how you prefer to work. WordPress will generate the necessary rewrite rules for you. If it has write permissions to this file, it can implement the rules automatically. If it does not, you will have to manually edit this file to add the correct rules.
Which configuration you choose depends on how much you value convenience over security. Allowing the web server write access to this file will definitely be more convenient, but some say that it is an unnecessary security risk.
If you want WordPress to automatically update this file with rewrite rules, you can ensure that it has the correct permissions to do so by typing:

chmod 664 /var/www/html/.htaccess

If you want to update this file manually for the sake of a small security gain, you can allow the web server only read privileges by typing:

chmod 644 /var/www/html/.htaccess

Change the Permalink Settings in WordPress

When you are finished doing the server-side changes, you can easily adjust the permalink settings through the WordPress administration interface.
On the left-hand side, under the Settings menu, you can select Permalinks:

You can choose any of the preconfigured settings to organize URLs, or you can create your own.

When you have made your selection, click "Save Changes" to generate the rewrite rules.
If you allowed the web server write access to your .htaccess file, you should see a message like this:

If you did not allow the web server write access to your .htaccess file, you will be provided with the rewrite rules you need to add to the file manually.
Copy the lines that WordPress gives you and then edit file on your server:

nano /var/www/html/.htaccess

This should give you the same functionality.

Conclusion

You should now have a WordPress instance up and running on your Ubuntu 14.04 VPS. There are many avenues you can take from here. Below we've listed some options:

By Justin Ellingwood

How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 14.04

2014-05-01T04:29:00.000-07:00

How To Install Linux, Apache, MySQL, PHP (LAMP) stack on Ubuntu 14.04

Tagged In: Linux Basics, Ubuntu, My Sql, Apache, Php, Getting Started, Lamp Stack

Introduction

A "LAMP" stack is a group of open source software that is typically installed together to enable a server to host dynamic websites and web apps. This term is actually an acronym which represents the Linux operating system, with the Apache web server. The site data is stored in a MySQL database, and dynamic content is processed by PHP.
In this guide, we'll get a LAMP stack installed on an Ubuntu 14.04 Droplet. Ubuntu will fulfill our first requirement: a Linux operating system.

Prerequisites

Before you begin with this guide, you should have a separate, non-root user account set up on your server. You can learn how to do this by completing steps 1-4 in the initial server setup for Ubuntu 14.04.

Step One — Install Apache

The Apache web server is currently the most popular web server in the world, which makes it a great default choice for hosting a website.
We can install Apache easily using Ubuntu's package manager, apt. A package manager allows us to install most software pain-free from a repository maintained by Ubuntu. You can learn more about how to use apt here.
For our purposes, we can get started by typing these commands:

sudo apt-get update
sudo apt-get install apache2

Since we are using a sudo command, these operations get executed with root privileges. It will ask you for your regular user's password to verify your intentions.
Afterwards, your web server is installed.
You can do a spot check right away to verify that everything went as planned by visiting your server's public IP address in your web browser (see the note under the next heading to find out what your public IP address is if you do not have this information already):

http://your_server_IP_address

You will see the default Ubuntu 14.04 Apache web page, which is there for informational and testing purposes. It should look something like this:

If you see this page, then your web server is now correctly installed.

How To Find your Server's Public IP Address

If you do not know what your server's public IP address is, there are a number of ways you can find it. Usually, this is the address you use to connect to your server through SSH.
From the command line, you can find this a few ways. First, you can use the iproute2 tools to get your address by typing this:

ip addr show eth0 | grep inet | awk '{ print $2; }' | sed 's/\/.*$//'

This will give you one or two lines back. They are both correct addresses, but your computer may only be able to use one of them, so feel free to try each one.
An alternative method is to use an outside party to tell you how it sees your server. You can do this by asking a specific server what your IP address is:

curl http://icanhazip.com

Regardless of the method you use to get your IP address, you can type it into your web browser's address bar to get to your server.

Step Two — Install MySQL

Now that we have our web server up and running, it is time to install MySQL. MySQL is a database management system. Basically, it will organize and provide access to databases where our site can store information.
Again, we can use apt to acquire and install our software. This time, we'll also install some other "helper" packages that will assist us in getting our components to communicate with each other:

sudo apt-get install mysql-server libapache2-mod-auth-mysql php5-mysql

Note: In this case, you do not have to run sudo apt-get update prior to the command. This is because we recently ran it in the commands above to install Apache. The package index on our computer should already be up-to-date.
During the installation, your server will ask you to select and confirm a password for the MySQL "root" user. This is an administrative account in MySQL that has increased privileges. Think of it as being similar to the root account for the server itself (the one you are configuring now is a MySQL-specific account however).
When the installation is complete, we need to run some additional commands to get our MySQL environment set up securely.
First, we need to tell MySQL to create its database directory structure where it will store its information. You can do this by typing:

sudo mysql_install_db

Afterwards, we want to run a simple security script that will remove some dangerous defaults and lock down access to our database system a little bit. Start the interactive script by running:

sudo mysql_secure_installation

You will be asked to enter the password you set for the MySQL root account. Next, it will ask you if you want to change that password. If you are happy with your current password, type "n" for "no" at the prompt.
For the rest of the questions, you should simply hit the "ENTER" key through each prompt to accept the default values. This will remove some sample users and databases, disable remote root logins, and load these new rules so that MySQL immediately respects the changes we have made.
At this point, your database system is now set up and we can move on.

Step Three — Install PHP

PHP is the component of our setup that will process code to display dynamic content. It can run scripts, connect to our MySQL databases to get information, and hand the processed content over to our web server to display.
We can once again leverage the apt system to install our components. We're going to include some helper packages as well:

sudo apt-get install php5 libapache2-mod-php5 php5-mcrypt

This should install PHP without any problems. We'll test this in a moment.
In most cases, we'll want to modify the way that Apache serves files when a directory is requested. Currently, if a user requests a directory from the server, Apache will first look for a file called index.html. We want to tell our web server to prefer PHP files, so we'll make Apache look for an index.php file first.
To do this, type this command to open the dir.conf file in a text editor with root privileges:

sudo nano /etc/apache2/mods-enabled/dir.conf

It will look like this:

<IfModule mod_dir.c>
    DirectoryIndex index.html index.cgi index.pl index.php index.xhtml index.htm
</IfModule>

We want to move the PHP index file highlighted above to the first position after the DirectoryIndex specification, like this:

<IfModule mod_dir.c>
    DirectoryIndex index.php index.html index.cgi index.pl index.xhtml index.htm
</IfModule>

When you are finished, save and close the file by pressing "CTRL-X". You'll have to confirm the save by typing "Y" and then hit "ENTER" to confirm the file save location.
After this, we need to restart the Apache web server in order for our changes to be recognized. You can do this by typing this:

sudo service apache2 restart

Install PHP Modules

To enhance the functionality of PHP, we can optionally install some additional modules.
To see the available options for PHP modules and libraries, you can type this into your system:

apt-cache search php5-

The results are all optional components that you can install. It will give you a short description for each:

php5-cgi - server-side, HTML-embedded scripting language (CGI binary)
php5-cli - command-line interpreter for the php5 scripting language
php5-common - Common files for packages built from the php5 source
php5-curl - CURL module for php5
php5-dbg - Debug symbols for PHP5
php5-dev - Files for PHP5 module development
php5-gd - GD module for php5
. . .

To get more information about what each module does, you can either search the internet, or you can look at the long description in the package by typing:

apt-cache show package_name

There will be a lot of output, with one field called Description-en which will have a longer explanation of the functionality that the module provides.
For example, to find out what the php5-cli module does, we could type this:

apt-cache show php5-cli

Along with a large amount of other information, you'll find something that looks like this:

. . .
SHA256: 91cfdbda65df65c9a4a5bd3478d6e7d3e92c53efcddf3436bbe9bbe27eca409d
Description-en: command-line interpreter for the php5 scripting language
 This package provides the /usr/bin/php5 command interpreter, useful for
 testing PHP scripts from a shell or performing general shell scripting tasks.
 .
 The following extensions are built in: bcmath bz2 calendar Core ctype date
 dba dom ereg exif fileinfo filter ftp gettext hash iconv libxml mbstring
 mhash openssl pcntl pcre Phar posix Reflection session shmop SimpleXML soap
 sockets SPL standard sysvmsg sysvsem sysvshm tokenizer wddx xml xmlreader
 xmlwriter zip zlib.
 .
 PHP (recursive acronym for PHP: Hypertext Preprocessor) is a widely-used
 open source general-purpose scripting language that is especially suited
 for web development and can be embedded into HTML.
Description-md5: f8450d3b28653dcf1a4615f3b1d4e347
Homepage: http://www.php.net/
. . .

If, after researching, you decide you would like to install a package, you can do so by using the apt-get install command like we have been doing for our other software.
If we decided that php5-cli is something that we need, we could type:

sudo apt-get install php5-cli

If you want to install more than one module, you can do that by listing each one, separated by a space, following the apt-get install command, like this:

sudo apt-get install package1 package2 ...

At this point, your LAMP stack is installed and configured. We should still test out our PHP though.

Step Four — Test PHP Processing on your Web Server

In order to test that our system is configured properly for PHP, we can create a very basic PHP script.
We will call this script info.php. In order for Apache to find the file and serve it correctly, it must be saved to a very specific directory, which is called the "web root".
In Ubuntu 14.04, this directory is located at /var/www/html/. We can create the file at that location by typing:

sudo nano /var/www/html/info.php

This will open a blank file. We want to put the following text, which is valid PHP code, inside the file:

<?php
phpinfo();
?>

When you are finished, save and close the file.
Now we can test whether our web server can correctly display content generated by a PHP script. To try this out, we just have to visit this page in our web browser. You'll need your server's public IP address again.
The address you want to visit will be:

http://your_server_IP_address/info.php

The page that you come to should look something like this:

This page basically gives you information about your server from the perspective of PHP. It is useful for debugging and to ensure that your settings are being applied correctly.
If this was successful, then your PHP is working as expected.
You probably want to remove this file after this test because it could actually give information about your server to unauthorized users. To do this, you can type this:

sudo rm /var/www/html/info.php

You can always recreate this page if you need to access the information again later.

Conclusion

Now that you have a LAMP stack installed, you have many choices for what to do next. Basically, you've installed a platform that will allow you to install most kinds of websites and web software on your server.
Some popular options are:

Install Wordpress the most popular content management system on the internet
Set Up PHPMyAdmin to help manage your MySQL databases from web browser.
Learn more about MySQL to manage your databases.
Learn how to create an SSL Certificate to secure traffic to your web server.
Learn how to use SFTP to transfer files to and from your server.

Note: We will be updating the links above to our 14.04 documentation as it is written.

By Justin Ellingwood

How To Set Up Apache Virtual Hosts on Ubuntu 14.04 LTS

2014-05-01T02:21:00.000-07:00

How To Set Up Apache Virtual Hosts on Ubuntu 14.04 LTS

Tagged In: Linux Basics, Ubuntu, Apache, Faq, Getting Started

Introduction

The Apache web server is the most popular way of serving web content on the internet. It accounts for more than half of all active websites on the internet and is extremely powerful and flexible.
Apache breaks its functionality and components into individual units that can be customized and configured independently. The basic unit that describes an individual site or domain is called a virtual host.
These designations allow the administrator to use one server to host multiple domains or sites off of a single interface or IP by using a matching mechanism. This is relevant to anyone looking to host more than one site off of a single VPS.
Each domain that is configured will direct the visitor to a specific directory holding that site's information, never indicating that the same server is also responsible for other sites. This scheme is expandable without any software limit as long as your server can handle the load.
In this guide, we will walk you through how to set up Apache virtual hosts on an Ubuntu 14.04 VPS. During this process, you'll learn how to serve different content to different visitors depending on which domains they are requesting.

Prerequisites

Before you begin this tutorial, you should create a non-root user as described in steps 1-4 here.
You will also need to have Apache installed in order to work through these steps. If you haven't already done so, you can get Apache installed on your server through apt-get:

sudo apt-get update
sudo apt-get install apache2

After these steps are complete, we can get started.
For the purposes of this guide, my configuration will make a virtual host for example.com and another for test.com. These will be referenced throughout the guide, but you should substitute your own domains or values while following along.
To learn how to set up your domain names with DigitalOcean, follow this link. If you do not have domains available to play with, you can use dummy values.
We will show how to edit your local hosts file later on to test the configuration if you are using dummy values. This will allow you to test your configuration from your home computer, even though your content won't be available through the domain name to other visitors.

Step One — Create the Directory Structure

The first step that we are going to take is to make a directory structure that will hold the site data that we will be serving to visitors.
Our document root (the top-level directory that Apache looks at to find content to serve) will be set to individual directories under the /var/www directory. We will create a directory here for both of the virtual hosts we plan on making.
Within each of these directories, we will create a public_html file that will hold our actual files. This gives us some flexibility in our hosting.
For instance, for our sites, we're going to make our directories like this:

sudo mkdir -p /var/www/example.com/public_html
sudo mkdir -p /var/www/test.com/public_html

The portions in red represent the domain names that we are wanting to serve from our VPS.

Step Two — Grant Permissions

Now we have the directory structure for our files, but they are owned by our root user. If we want our regular user to be able to modify files in our web directories, we can change the ownership by doing this:

sudo chown -R $USER:$USER /var/www/example.com/public_html
sudo chown -R $USER:$USER /var/www/test.com/public_html

The $USER variable will take the value of the user you are currently logged in as when you press "ENTER". By doing this, our regular user now owns the public_html subdirectories where we will be storing our content.
We should also modify our permissions a little bit to ensure that read access is permitted to the general web directory and all of the files and folders it contains so that pages can be served correctly:

sudo chmod -R 755 /var/www

Your web server should now have the permissions it needs to serve content, and your user should be able to create content within the necessary folders.

Step Three — Create Demo Pages for Each Virtual Host

We have our directory structure in place. Let's create some content to serve.
We're just going for a demonstration, so our pages will be very simple. We're just going to make an index.html page for each site.
Let's start with example.com. We can open up an index.html file in our editor by typing:

nano /var/www/example.com/public_html/index.html

In this file, create a simple HTML document that indicates the site it is connected to. My file looks like this:

<html>
  <head>
    <title>Welcome to Example.com!</title>
  </head>
  <body>
    <h1>Success!  The example.com virtual host is working!</h1>
  </body>
</html>

Save and close the file when you are finished.
We can copy this file to use as the basis for our second site by typing:

cp /var/www/example.com/public_html/index.html /var/www/test.com/public_html/index.html

We can then open the file and modify the relevant pieces of information:

nano /var/www/test.com/public_html/index.html

<html>
  <head>
    <title>Welcome to Test.com!</title>
  </head>
  <body>
    <h1>Success!  The test.com virtual host is working!</h1>
  </body>
</html>

Save and close this file as well. You now have the pages necessary to test the virtual host configuration.

Step Four — Create New Virtual Host Files

Virtual host files are the files that specify the actual configuration of our virtual hosts and dictate how the Apache web server will respond to various domain requests.
Apache comes with a default virtual host file called 000-default.conf that we can use as a jumping off point. We are going to copy it over to create a virtual host file for each of our domains.
We will start with one domain, configure it, copy it for our second domain, and then make the few further adjustments needed. The default Ubuntu configuration requires that each virtual host file end in .conf.

Create the First Virtual Host File

Start by copying the file for the first domain:

sudo cp /etc/apache2/sites-available/000-default.conf /etc/apache2/sites-available/example.com.conf

Open the new file in your editor with root privileges:

sudo nano /etc/apache2/sites-available/example.com.conf

The file will look something like this (I've removed the comments here to make the file more approachable):

<VirtualHost *:80>
    ServerAdmin webmaster@localhost
    DocumentRoot /var/www/html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

As you can see, there's not much here. We will customize the items here for our first domain and add some additional directives. This virtual host section matches any requests that are made on port 80, the default HTTP port.
First, we need to change the ServerAdmin directive to an email that the site administrator can receive emails through.

ServerAdmin admin@example.com

After this, we need to add two directives. The first, called ServerName, establishes the base domain that should match for this virtual host definition. This will most likely be your domain. The second, called ServerAlias, defines further names that should match as if they were the base name. This is useful for matching hosts you defined, like www:

ServerName example.com
ServerAlias www.example.com

The only other thing we need to change for a basic virtual host file is the location of the document root for this domain. We already created the directory we need, so we just need to alter the DocumentRoot directive to reflect the directory we created:

DocumentRoot /var/www/example.com/public_html

In total, our virtualhost file should look like this:

<VirtualHost *:80>
    ServerAdmin admin@example.com
    ServerName example.com
    ServerAlias www.example.com
    DocumentRoot /var/www/example.com/public_html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Save and close the file.

Copy First Virtual Host and Customize for Second Domain

Now that we have our first virtual host file established, we can create our second one by copying that file and adjusting it as needed.
Start by copying it:

sudo cp /etc/apache2/sites-available/example.com.conf /etc/apache2/sites-available/test.com.conf

Open the new file with root privileges in your editor:

sudo nano /etc/apache2/sites-available/test.com.conf

You now need to modify all of the pieces of information to reference your second domain. When you are finished, it may look something like this:

<VirtualHost *:80>
    ServerAdmin admin@test.com
    ServerName test.com
    ServerAlias www.test.com
    DocumentRoot /var/www/test.com/public_html
    ErrorLog ${APACHE_LOG_DIR}/error.log
    CustomLog ${APACHE_LOG_DIR}/access.log combined
</VirtualHost>

Save and close the file when you are finished.

Step Five — Enable the New Virtual Host Files

Now that we have created our virtual host files, we must enable them. Apache includes some tools that allow us to do this.
We can use the a2ensite tool to enable each of our sites like this:

sudo a2ensite example.com.conf
sudo a2ensite test.com.conf

When you are finished, you need to restart Apache to make these changes take affect:

sudo service apache2 restart

You will most likely receive a message saying something similar to:

 * Restarting web server apache2
 AH00558: apache2: Could not reliably determine the server's fully qualified domain name, using 127.0.0.1. Set the 'ServerName' directive globally to suppress this message

This is a harmless message that does not affect our site.

Step Six — Set Up Local Hosts File (Optional)

If you haven't been using actual domain names that you own to test this procedure and have been using some example domains instead, you can at least test the functionality of this process by temporarily modifying the hosts file on your local computer.
This will intercept any requests for the domains that you configured and point them to your VPS server, just as the DNS system would do if you were using registered domains. This will only work from your computer though, and is simply useful for testing purposes.
Make sure you are operating on your local computer for these steps and not your VPS server. You will need to know the computer's administrative password or otherwise be a member of the administrative group.
If you are on a Mac or Linux computer, edit your local file with administrative privileges by typing:

sudo nano /etc/hosts

If you are on a Windows machine, you can find instructions on altering your hosts file here.
The details that you need to add are the public IP address of your VPS server followed by the domain you want to use to reach that VPS.
For the domains that I used in this guide, assuming that my VPS IP address is 111.111.111.111, I could add the following lines to the bottom of my hosts file:

127.0.0.1   localhost
127.0.1.1   guest-desktop
111.111.111.111 example.com
111.111.111.111 test.com

This will direct any requests for example.com and test.com on our computer and send them to our server at 111.111.111.111. This is what we want if we are not actually the owners of these domains in order to test our virtual hosts.
Save and close the file.

Step Seven — Test your Results

Now that you have your virtual hosts configured, you can test your setup easily by going to the domains that you configured in your web browser:

http://example.com

You should see a page that looks like this:

Likewise, if you can visit your second page:

http://test.com

You will see the file you created for your second site:

If both of these sites work well, you've successfully configured two virtual hosts on the same server.
If you adjusted your home computer's hosts file, you may want to delete the lines you added now that you verified that your configuration works. This will prevent your hosts file from being filled with entries that are not actually necessary.
If you need to access this long term, consider purchasing a domain name for each site you need and setting it up to point to your VPS server.

Conclusion

If you followed along, you should now have a single server handling two separate domain names. You can expand this process by following the steps we outlined above to make additional virtual hosts.
There is no software limit on the number of domain names Apache can handle, so feel free to make as many as your server is capable of handling.

By Justin Ellingwood

Hacker Alert: Here Are 8 Major Types Of DDoS Attacks

2014-05-01T00:59:00.002-07:00

1.UDP Flood

A UDP flood attack is a denial-of-service (DoS) attack using the User Datagram Protocol (UDP), a sessionless/connectionless computer networking protocol. Using UDP for denial-of-service attacks is not as straightforward as with the Transmission Control Protocol (TCP). However, a UDP flood attack can be initiated by sending a large number of UDP packets to random ports on a remote host. As a result, the distant host will: check for the application listening at that port, see that no application listens at that port and reply with an ICMP Destination Unreachable packet.

2.Ping of Death

A ping of death is a type of attack on a computer that involves sending a malformed or otherwise malicious ping to a computer. A correctly formed ping message is typically 56 bytes in size, or 84 bytes when the Internet Protocol (IP) header is considered. Historically, many computer systems could not properly handle a ping packet larger than the maximum IPv4 packet size of 65535bytes. Larger packets could crash the target computer. In early implementations of TCP/IP, this bug was easy to exploit. This exploit affected a wide variety of systems, including Unix, Linux, Mac, Windows, printers, and routers.

3.Reflected / Spoofed attack

A distributed denial of service attack may involve sending forged requests of some type to a very large number of computers that will reply to the requests. Using Internet Protocol address spoofing, the source address is set to that of the targeted victim, which means all the replies will go to (and flood) the target.

4.Nuke

A Nuke is an old denial-of-service attack against computer networks consisting of fragmented or otherwise invalid ICMP packets sent to the target, achieved by using a modified ping utility to repeatedly send this corrupt data, thus slowing down the affected computer until it comes to a complete stop.

5.Slowloris

Slowloris is a piece of software written by Robert "RSnake" Hansen which allows a single machine to take down another machine's web server with minimal bandwidth and side effects on unrelated services and ports. Slowloris tries to keep many connections to the target web server open and hold them open as long as possible. It accomplishes this by opening connections to the target web server and sending a partial request.

6.Unintentional DDoS

This describes a situation where a website ends up denied, not due to a deliberate attack by a single individual or group of individuals, but simply due to a sudden enormous spike in popularity. This can happen when an extremely popular website posts a prominent link to a second, less well-prepared site, for example, as part of a news story.

7.Zero Day DDoS

General term used to describe vulnerabilities and exploits that are still new and haven't been patched yet.

8.SYN Flood

A SYN flood is a form of denial-of-service attack in which an attacker sends a succession of SYN requests to a target's system in an attempt to consume enough server resources to make the system unresponsive to legitimate traffic.

58 Cool Linux Hacks!

2014-04-30T10:02:00.000-07:00

Efytimes brings to you 58 super cool hacks for all levels of Linux users!

Are you ready to try your hands on these cool Linux hacks! Set your machine on and get started!

Fix a wonky terminal

Difficulty: Easy
Application: bash

We've all done it - accidentally used less or cat to list a file, and ended up viewing binary instead. This usually involves all sorts of control codes that can easily screw up your terminal display. There will be beeping. There will be funny characters. There will be odd colour combinations. At the end of it, your font will be replaced with hieroglyphics and you don't know what to do. Well, bash is obviously still working, but you just can't read what's actually going on! Send the terminal an initialisation command:

reset

and all will be well again.

Creating Mozilla keywords

Difficulty: Easy
Application: Firefox/Mozilla

A useful feature in Konqueror is the ability to type gg onion to do a Google search based on the word onion. The same kind of functionality can be achieved in Mozilla by first clicking on Bookmarks>Manage Bookmarks and then Add a New Bookmark. Add the URL as:

http://www.google.com/search?q=%s

Now select the entry in the bookmark editor and click the Properties button. Now enter the keyword as gg (or this can be anything you choose) and the process is complete. The %s in the URL will be replaced with the text after the keyword. You can apply this hack to other kinds of sites that rely on you passing information on the URL.

Alternatively, right-click on a search field and select the menu option "Add a Keyword for this Search...". The subsequent dialog will allow you to specify the keyword to use.

Running multiple X sessions

Difficulty: Easy
Application: X

If you share your Linux box with someone and you are sick of continually logging in and out, you may be relieved to know that this is not really needed. Assuming that your computer starts in graphical mode (runlevel 5), by simultaneously pressing the keys Control+Alt+F1 - you will get a login prompt. Insert your login and password and then execute:

startx -- :1

to get into your graphical environment. To go back to the previous user session, press Ctrl+Alt+F7, while to get yours back press Ctrl+Alt+F8.

You can repeat this trick: the keys F1 to F6 identify six console sessions, while F7 to F12 identify six X sessions. Caveat: although this is true in most cases, different distributions can implement this feature in a different way.

Faster browsing

Difficulty: Easy
Application: KDE

In KDE 3.2, a little-known but useful option has been added to speed up your web browsing experience. Start the KDE Control Center and choose System > KDE performance from the sidebar. You can now select to preload Konqueror instances. Effectively, this means that Konqueror is run on startup, but kept hidden until you try to use it. When you do, it pops up almost instantaneously. Bonus!

Backup your website easily

Difficulty: Easy
Application: Backups

If you want to back up a directory on a computer and only copy changed files to the backup computer instead of everything with each backup, you can use the rsync tool to do this. You will need an account on the remote computer that you are backing up from. Here is the command:

rsync -vare ssh jono@192.168.0.2:/home/jono/importantfiles/* /home/jono/backup/

Here we are backing up all of the files in /home/jono/importantfiles/ on 192.168.0.2 to /home/jono/backup on the current machine.

Keeping your clock in time

Difficulty: Easy
Application: NTP

If you find that the clock on your computer seems to wander off the time, you can make use of a special NTP tool to ensure that you are always synchronised with the kind of accuracy that only people that wear white coats get excited about. You will need to install the ntpdate tool that is often included in the NTP package, and then you can synchronise with an NTP server:

ntpdate ntp.blueyonder.co.uk

A list of suitable NTP servers is available at www.eecis.udel.edu/~mills/ntp/clock1b.html. If you modify your boot process and scripts to include this command you can ensure that you are perfectly in time whenever you boot your computer. You could also run a cron job to update the time.

Finding the biggest files

Difficulty: Easy
Application: Shell

A common problem with computers is when you have a number of large files (such as audio/video clips) that you may want to get rid of. You can find the biggest files in the current directory with: ( only in current directory )

ls -lSrh (the r causes the large files to be listed at the end, the h gives human readable output (MB and such))

You could also search for the biggest MP3/MPEGs:

ls -lSrh *.mp*

You can also look for the largest directories with:

du -kx | egrep -v "\./.+/" | sort -n

You can find the biggest files in your home directory, ( in the whole directory structure ).

find ~ -type f -exec ls -s {} \; | sort -n

List only the top 10 biggest file.

find . -type f -exec ls -s {} \; | sort -nr | head -10

Nautilus shortcuts

Difficulty: Easy
Application: Nautilus

Although most file managers these days are designed to be used with the mouse, it's also useful to be able to use the keyboard sometimes. Nautilus has a few keyboard shortcuts that can have you flying through files:

Open a location - Ctrl+L
Open Parent folder - Ctrl+Up
Arrow keys navigate around current folder.

You can also customise the file icons with 'emblems'. These are little graphical overlays that can be applied to individual files or groups. Open the Edit > Backgrounds and Emblems menu item, and drag-and-drop the images you want.

Defrag your databases

Difficulty: Easy
Application: MySQL

Whenever you change the structure of a MySQL database, or remove a lot of data from it, the files can become fragmented resulting in a loss of performance, particularly when running queries. Just remember any time you change the database to run the optimiser:

mysqlcheck -o

You may also find it worth your while to defragment your database tables regularly if you are using VARCHAR fields: these variable-length columns are particularly prone to fragmentation.

Quicker emails

Difficulty: Easy
Application: KMail

Can't afford to waste three seconds locating your email client? Can't be bothered finding the mouse under all those gently rotting mountains of clutter on your desk? Whatever you are doing in KDE, you are only a few keypresses away from sending a mail. Press Alt+F2 to bring up the 'Run command' dialog.

Press return and KMail will automatically fire up, ready for your words of wisdom. You don't even need to fill in the entire email address. This also works for Internet addresses: try typing www.slashdot.org to launch Konqueror.

Parallelise your build

Difficulty: Easy
Application: GCC

If you're running a multiprocessor system (SMP) with a moderate amount of RAM, you can usually see significant benefits by performing a parallel make when building code. Compared to doing serial builds when running make (as is the default), a parallel build is a vast improvement. To tell make to allow more than one child at a time while building, use the -j switch:

make -j4; make -j4 modules

Save battery power

Difficulty: Intermediate
Application: hdparm

You are probably familiar with using hdparm for tuning a hard drive, but it can also save battery life on your laptop, or make life quieter for you by spinning down drives.

hdparm -y /dev/hdb
hdparm -Y /dev/hdb
hdparm -S 36 /dev/hdb

In order, these commands will: cause the drive to switch to Standby mode, switch to Sleep mode, and finally set the Automatic spindown timeout. This last includes a numeric variable, whose units are blocks of 5 seconds (for example, a value of 12 would equal one minute).

Incidentally, this habit of specifying spindown time in blocks of 5 seconds should really be a contender for a special user-friendliness award - there's probably some historical reason for it, but we're stumped. Write in and tell us if you happen to know where it came from!

Wireless speed management

Difficulty: Intermediate
Application: iwconfig

The speed at which a piece of radio transmission/receiver equipment can communicate with another depends on how much signal is available. In order to maintain communications as the available signal fades, the radios need to transmit data at a slower rate. Normally, the radios attempt to work out the available signal on their own and automatically select the fastest possible speed. In fringe areas with a barely adequate signal, packets may be needlessly lost while the radios continually renegotiate the link speed. If you can't add more antenna gain, or reposition your equipment to achieve a better enough signal, consider forcing your card to sync at a lower rate. This will mean fewer retries, and can be substantially faster than using a continually flip-flopping link. Each driver has its own method for setting the link speed. In Linux, set the link speed with iwconfig:

iwconfig eth0 rate 2M

This forces the radio to always sync at 2Mbps, even if other speeds are available. You can also set a particular speed as a ceiling, and allow the card to automatically scale to any slower speed, but go no faster. For example, you might use this on the example link above:

iwconfig eth0 rate 5.5M auto

Using the auto directive this way tells the driver to allow speeds up to 5.5Mbps, and to run slower if necessary, but will never try to sync at anything faster. To restore the card to full auto scaling, just specify auto by itself:

iwconfig eth0 rate auto

Cards can generally reach much further at 1Mbps than they can at 11Mbps. There is a difference of 12dB between the 1Mbps and 11Mbps ratings of the Orinoco card - that's four times the potential distance just by dropping the data rate!

Unclog open ports

Difficulty: Intermediate
Application: netstat

Generating a list of network ports that are in the Listen state on a Linux server is simple with netstat:

root@catlin:~# netstat -lnp
Active Internet connections (only servers)
Proto Recv-Q Send-Q Local Address Foreign Address State PID/Program name 
tcp 0 0 0.0.0.0:5280 0.0.0.0:* LISTEN 698/perl 
tcp 0 0 0.0.0.0:80 0.0.0.0:* LISTEN 217/httpd 
tcp 0 0 10.42.3.2:53 0.0.0.0:* LISTEN 220/named 
tcp 0 0 10.42.4.6:53 0.0.0.0:* LISTEN 220/named 
tcp 0 0 127.0.0.1:53 0.0.0.0:* LISTEN 220/named 
tcp 0 0 0.0.0.0:22 0.0.0.0:* LISTEN 200/sshd 
udp 0 0 0.0.0.0:32768 0.0.0.0:* 220/named 
udp 0 0 10.42.3.2:53 0.0.0.0:* 220/named 
udp 0 0 10.42.4.6:53 0.0.0.0:* 220/named 
udp 0 0 127.0.0.1:53 0.0.0.0:* 220/named 
udp 0 0 0.0.0.0:67 0.0.0.0:* 222/dhcpd 
raw 0 0 0.0.0.0:1 0.0.0.0:* 7 222/dhcpd

That shows you that PID 698 is a Perl process that is bound to port 5280. If you're not root, the system won't disclose which programs are running on which ports.

Faster Hard drives

Difficulty: Expert
Application: hdparm

You may know that the hdparm tool can be used to speed test your disk and change a few settings. It can also be used to optimise drive performance, and turn on some features that may not be enabled by default. Before we start though, be warned that changing drive options can cause data corruption, so back up all your important data first. Testing speed is done with:

hdparm -Tt /dev/hda

You'll see something like:

/dev/hda:
Timing buffer-cache reads:   128 MB in  1.64 seconds =78.05 MB/sec
Timing buffered disk reads:  64 MB in 18.56 seconds = 3.45MB/sec

Now we can try speeding it up. To find out which options your drive is currently set to use, just pass hdparm the device name:

hdparm /dev/hda
 /dev/hda:
 multcount    =  16 (on)
 I/O support  =  0 (default 16-bit)
 unmaskirq    =  0 (off)
 using_dma    =  0 (off)
 keepsettings =  0 (off)
 readonly     =  0 (off)
 readahead    =  8 (on)
 geometry     = 40395/16/63, sectors = 40718160, start = 0

This is a fairly default setting. Most distros will opt for safe options that will work with most hardware. To get more speed, you may want to enable dma mode, and certainly adjust I/O support. Most modern computers support mode 3, which is a 32-bit transfer mode that can nearly double throughput. You might want to try

hdparm -c3 -d1/dev/hda

Then rerun the speed check to see the difference. Check out the modes your hardware will support, and the hdparm man pages for how to set them.

Uptime on your hands

Difficulty: Expert
Application: Perl

In computing, wasted resources are resources that could be better spent helping you. Why not run a process that updates the titlebar of your terminal with the current load average in real-time, regardless of what else you're running?

Save this as a script called tl, and save it to your ~/bin directory:

#!/usr/bin/perl -w

use strict;
$|++;

my $host=`/bin/hostname`;
chomp $host;

while(1) {

open(LOAD,"/proc/loadavg") || die "Couldn't open /proc/loadavg: $!\n";

my @load=split(/ /,);
close(LOAD);
print "\033]0;";
print "$host: $load[0] $load[1] $load[2] at ", scalar(localtime);
print "\007";

sleep 2;
}

When you'd like to have your titlebar replaced with the name, load average, and current time of the machine you're logged into, just run tl&. It will happily go on running in the background, even if you're running an interactive program like Vim.

Grabbing a screenshot without X

Difficulty: Easy
Application: Shell

There are plenty of screen-capture tools, but a lot of them are based on X. This leads to a problem when running an X application would interfere with the application you wanted to grab - perhaps a game or even a Linux installer. If you use the venerable ImageMagick import command though, you can grab from an X session via the console. Simply go to a virtual terminal (Ctrl+Alt+F1 for example) and enter the following:

chvt 7; sleep 2; import -display :0.0 -window root sshot1.png; chvt 1;

The chvt command changes the virtual terminal, and the sleep command gives it a while to redraw the screen. The import command then captures the whole display and saves it to a file before the final chvt command sticks you back in the virtual terminal again. Make sure you type the whole command on one line.

This can even work on Linux installers, many of which leave a console running in the background - just load up a floppy/CD with import and the few libraries it requires for a first-rate run-anywhere screen grabber.

Access your programs remotely

Difficulty: Easy
Application: X

If you would like to lie in bed with your Linux laptop and access your applications from your Windows machine, you can do this with SSH. You first need to enable the following setting in /etc/ssh/sshd_config:

X11Forwarding yes

We can now run The GIMP on 192.168.0.2 with:

ssh -X 192.168.0.2 gimp

Making man pages useful

Difficulty: Easy
Application: man

If you are looking for some help on a particular subject or command, man pages are a good place to start. You normally access a man page with man

man -k login

When you access a man page, you can also use the forward slash key to search for a particular word within the man page itself. Simply press / on your keyboard and then type in the search term.

Talk to your doctor!

Difficulty: Easy
Application: Emacs

To say that Emacs is just a text editor is like saying that a Triumph is just a motorcycle, or the World Cup is just some four-yearly football event. True, but simplified juuuust a little bit. An example? Open the editor, press the Esc key followed by X and then enter in doctor: you will be engaged in a surreal conversation by an imaginary and underskilled psychotherapist. And if you want to waste your time in a better way

Esc-X tetris

will transform your 'editor' into the old favourite arcade game.

Does the madness stop there? No! Check out your distro's package list to see what else they've bundled for Emacs: here at LXF Towers we've got chess, Perl integration, IRC chat, French translation, HTML conversion, a Java development environment, smart compilation, and even something called a "semantic bovinator". We really haven't the first clue what that last one does, but we dare you to try it out anyway! (Please read the disclaimer first!)

Super cow powers

Difficulty: Easy
Application: Debian

A strange but endearing hidden feature within the highly regarded apt-get tool in Debian is its secret cow powers. Type the following command to experience the wrath of the super cow powers:

apt-get moo

Some people really have too much time on their hands...

Generating package relationship diagrams

Difficulty: Easy
Application: Debian

The most critical part of the Debian system is the ability to install a package and have the dependencies satisfied automatically. If you would like a graphical representation of the relationships between these packages (this can be useful for seeing how the system fits together), you can use the Graphviz package from Debian non-free (apt-get install graphviz) and the following command:

apt-cache dotty > debian.dot

The command generated the graph file which can then be loaded into dotty:

dotty debian.dot

Unmount busy drives

Difficulty: Easy
Application: bash

You are probably all too familiar with the situation - you are trying to unmount a drive, but keep getting told by your system that it's busy. But what application is tying it up? A quick one-liner will tell you:

lsof +D /mnt/windows

This will return the command and process ID of any tasks currently accessing the /mnt/windows directory. You can then locate them, or use the kill command to finish them off.

Text file conversion

Difficulty: Easy
Application: recode

recode is a small utility that will save you loads of effort when using text files created on different platforms. The primary source of discontent is line breaks. In some systems, these are denoted with a line-feed character. In others, a carriage return is used. In still more systems, both are used. The end result is that if you are swapping text from one platform to another, you end up with too many or too few line breaks, and lots of strange characters besides.

However, the command parameters of recode are a little arcane, so why not combine this hack with HACK 26 in this feature, and set up some useful aliases:

alias dos2unix='recode dos/CR-LF..l1'
alias unix2win='recode l1..windows-1250'
alias unix2dos='recode l1..dos/CR-LF'

There are plenty more options for recode - it can actually convert between a whole range of character sets. Check out the man pages for more information.

Listing today's files only

Difficulty: Easy
Application: Various

You are probably familiar with the problem. Sometime earlier in the day, you created a text file, which now is urgently required. However, you can't remember what ridiculous name you gave it, and being a typical geek, your home folder is full of 836 different files. How can you find it? Well, there are various ways, but this little tip shows you the power of pipes and joining together two powerful shell commands:

ls -al --time-style=+%D | grep `date +%D`

The parameters to the ls command here cause the datestamp to be output in a particular format. The cunning bit is that the output is then passed to grep. The grep parameter is itself a command (executed because of the backticks), which substitutes the current date into the string to be matched. You could easily modify it to search specifically for other dates, times, filesizes or whatever. Combine it with HACK 26 to save typing!

Avoid common mistypes and long commands

Difficulty: Easy
Application: Shell

The alias command is useful for setting up shortcuts for long commands, or even more clever things. From HACK 25, we could make a new command, lsnew, by doing this:

alias lsnew=" ls -al --time-style=+%D | grep `date +%D` "

But there are other uses of alias. For example, common mistyping mistakes. How many times have you accidentally left out the space when changing to the parent directory? Worry no more!

alias cd..="cd .."

Alternatively, how about rewriting some existing commands?

alias ls="ls -al"

saves a few keypresses if, like us, you always want the complete list.

To have these shortcuts enabled for every session, just add the alias commands to your user .bashrc file in your home directory.

Alter Mozilla's secret settings

Difficulty: Easy
Application: Mozilla

If you find that you would like to change how Mozilla works but the preferences offer nothing by way of clickable options that can help you, there is a special mode that you can enable in Mozilla so that you can change anything. To access it, type this into the address bar:

about:config

You can then change each setting that you are interested in by changing the Value field in the table.

Other interesting modes include general information (about:), details about plugins (about:plugins), credits information (about:credits) and some general wisdom (about:mozilla).

A backdrop of stars

Difficulty: Easy
Application: KStars

You may already have played with KStars, as it was included with the astronomy software that featured in LXF50's Roundup; but how about creating a KStars backdrop image that's updated every time you start up?

KStars can be run with the --dump switch, which dumps out an image from your startup settings, but doesn't load the GUI at all. You can create a script to run this and generate a desktop image, which will change every day (or you can just use this method to generate images).

Run KStars like this:

kstars --dump --width 1024 --height 768 --filename = ~/kstarsback.png

You can add this to a script in your ~/.kde/Autostart folder to be run at startup. Find the file in Konqueror, drag it to the desktop and select 'Set as wallpaper' to use it as a randomly generated backdrop.

Open an SVG directly

Difficulty: Easy
Application: Inkscape

You can run Inkscape from a shell and immediately edit a graphic directly from a URL. Just type:

inkscape http://www.somehost.com/graphic.svg

Remember to save it as something else though!

Editing without an editor

Difficulty: Intermediate
Application: Various

Very long files are often hard to manipulate with a text editor. If you need to do it regularly, chances are you'll find it much faster to use some handy command-line tools instead, like in the following examples.

To print columns eg 1 and 3 from a file file1 into file2, we can use awk:

awk '{print $1, $3}' file1 > file2

To output only characters from column 8 to column 15 of file1, we can use cut:

cut -c 8-15 file1 > file2

To replace the word word1 with the word word2 in the file file1, we can use the sed command:

sed "s/word1/word2/g" file1 > file2

This is often a quicker way to get results than even opening a text editor.

Backup selected files only

Difficulty: Intermediate
Application: tar

Want to use tar to backup only certain files in a directory? Then you'll want to use the -T flag as follows. First, create a file with the file you want to backup:

cat >> /etc/backup.conf
# /etc/passwd
# /etc/shadow
# /etc/yp.conf
# /etc/sysctl.conf
EOF

Then run tar with the -T flag pointing to the file just created:

tar -cjf bck-etc-`date +%Y-%m-%d`.tar.bz2 -T /etc/backup.conf

Now you have your backup.

Merging columns in files

Difficulty: Intermediate
Application: bash

While splitting columns in files is easy enough, merging them can be complicated. Below is a simple shell script that does the job:

#!/bin/sh
length=`wc -l $1 | awk '{print $1}'`
count=1
[ -f $3 ] && echo "Optionally removing $3" && rm -i $3
while [ "$count" -le "$length" ] ; do
      a=`head -$count $1 | tail -1`
      b=`head -$count $2 | tail -1`
      echo "$a      $b" >> $3
      count=`expr $count + 1`
done

Give to this script the name merge.sh and make it executable with:

chmod u+x merge.sh

Now, if you want to merge the columns of file1 and file2 into file3, it's just matter of executing

/path/to/merge.sh file1 file2 file3

where /path/to has to be replaced with the location of merge.sh in your filesystem.

Case sensitivity

Difficulty: Intermediate
Application: bash

Despite the case of a word not making any difference to other operating systems, in Linux "Command" and "command" are different things. This can cause trouble when moving files from Windows to Linux. tr is a little shell utility that can be used to change the case of a bunch of files.

#!/bin/sh
for i in `ls -1`; do
        file1=`echo $i | tr [A-Z] [a-z] `
        mv $i $file1 2>/dev/null
done

By executing it, FILE1 and fiLe2 will be renamed respectively file1 and file2.

Macros in Emacs

Difficulty: Intermediate
Application: Emacs

When editing files, you will often find that the tasks are tedious and repetitive, as LXF's Production Editor knows only too well! To spare your time, you can record a macro. In Emacs, you will have to go through the following steps:

Press Ctrl+X to start recording.
Insert all the keystrokes and commands that you want
Press Ctrl+X to stop when you're done.

Now, you can execute that with

Ctrl -u  Ctrl -x e

where is the number of times you want to execute the macro. If you enter a value of 0, the macro will be executed until the end of the file is reached. Ctrl -x e is equivalent to Ctrl -u 1 Ctrl-x e.

Replacing same text in multiple files

Difficulty: Intermediate
Application: find/Perl

If you have text you want to replace in multiple locations, there are several ways to do this. To replace the text Windows with Linux in all files in current directory called test[something] you can run this:

perl -i -pe 's/Windows/Linux/;' test*

To replace the text Windows with Linux in all text files in current directory and down you can run this:

find . -name '*.txt' -print | xargs perl -pi -e's/Windows/Linux/ig' *.txt

Or if you prefer this will also work, but only on regular files:

find -type f -name '*.txt' -print0 | xargs --null perl -pi -e 's/Windows/Linux/'

Saves a lot of time and has a high guru rating!

Simple spam killing

Difficulty: Intermediate
Application: KMail

Spam, or unsolicited bulk email, is such a widespread problem that almost everyone has some sort of spam protection now, out of necessity. Most ISPs include spam filtering, but it isn't set to be too aggressive, and most often simply labels the spam, but lets it through (ISPs don't want to be blamed for losing your mails). The result is that, while you may have anti-spam stuff set up on the client-side, you can make its job easier by writing a few filters to remove the spam that's already labelled as such. The label is included as a header. In KMail, you can just create a quick filter to bin your mail, or direct it to a junk folder. The exact header used will depend on the software your ISP is using, but it's usually something like X-Spam-Flag = YES for systems like SpamAssassin. Simply create a filter in KMail, choose Match Any of the Following and type in the header details and the action you require. Apply the filter to incoming mail, and you need never be troubled by about half the volume of your spam ever again.

Read OOo docs without OOo

Difficulty: Intermediate
Application: OpenOffice.org

Have you ever been left with an OOo document, but no OpenOffice.org in which to read it? Thought you saved it out as plain text (.txt), but used the StarOffice .sxw format instead? The text can be rescued. Firstly, the sxw file is a zip archive, so unzip it:

unzip myfile.sxw

The file you want is called 'content.xml'. Unfortunately, it's so full of xml tags it's fairly illegible, so filter them out with some Perl magic:

cat content.xml | perl -p -e  "s/<[^>]*>/ /g;s/\n/ /g;s/ +/ /;"

It may have lost lots of formatting, but at least it is now readable.

Find and execute

Difficulty: Intermediate
Application: find

The find command is not only useful for finding files, but is also useful for processing the ones it finds too. Here is a quick example.

Suppose we have a lot of tarballs, and we want to find them all:

find . -name '*.gz'

will locate all the gzip archives in the current path. But suppose we want to check they are valid archives? The gunzip -vt option will do this for us, but we can cunningly combine both operations, using xargs:

find . -name '*.gz' | xargs gunzip -vt

In case the files contain spaces, these commands won't work. The following variant takes care about this case:

find . -name '*.gz' -print0 | xargs -0 gunzip -vt

Use the correct whois server

Difficulty: Intermediate
Application: whois

The whois command is very useful for tracking down Internet miscreants and the ISPs that are supplying them with service. Unfortunately, there are many whois servers, and if you are querying against a domain name, you often have to use one which is specific to the TLD they are using. However, there are some whois proxies that will automatically forward your query on to the correct server. One of these is available at http://whois.geektools.com

whois -h whois.geektools.com  plop.info

Where did that drive mount?

Difficulty: Intermediate
Application: bash

A common problem with people who have lots of mountable devices (USB drives, flash memory cards, USB key drives) is working out where that drive you just plugged in has ended up?

Practically all devices that invoke a driver - such as usb-storage - will dump some useful information in the logs. Try

dmesg | grep SCSI

This will filter out recognised drive specs from the dmesg output. You'll probably turn up some text like:

SCSI device sda: 125952 512-byte hdwr sectors (64 MB)

So your device is at sda.

Autorun USB devices

Difficulty: Expert
Application: hotplug scripts

Want to run a specific application whenever a particular device is added? The USB hotplug daemon can help you! This service is notified when USB devices are added to the system. For devices that require kernel drivers, the hotplug daemon will call a script by the same name in /etc/hotplug/usb/, for example, a script called usb-storage exists there. You can simply add your own commands to the end of this script (or better still, tag a line at the end of it to execute a script elsewhere). Then you can play a sound, autosync files, search for pictures or whatever.

For devices that don't rely on kernel drivers, a lookup table is used matching the USB product and manufacturer ID. Many distros already set this up to do something, but you can customise these scripts pretty easily. See http://jphoto.sourceforge.net/?selected=sync for an example of what can be done.

Rename and resize images

Difficulty: Expert
Application: bash

Fond of your new camera but can't put up with the terrible names? Do you want also to prepare them for publishing on the web? No problem, a simple bash script is what you need:

#!/bin/sh
counter=1
root=mypict
resolution=400x300
for i in `ls -1 $1/*.jpg`; do
        echo "Now working on $i"
        convert -resize $resolution $i ${root}_${counter}.jpg
        counter=`expr $counter + 1`
done

Save the script in a file called picturename.sh and make it executable with

chmod u+x picturename.sh

and store it somewhere in your path. Now, if you have a bunch of .jpg files in the directory /path/to/pictdir, all you have to do is to execute

picturename.sh /path/to/pictdir

and in the current directory you'll find mypict_1.jpg, mypict_2.jpg etc, which are the resized versions of your original ones. You can change the script according to your needs.

Secure logout

Difficulty: Easy
Application: bash

When you are using a console on a shared machine, or indeed, just on your own desktop, you may find that when you logout, the screen still shows a trace of who was logged in and what you were doing. A lot of distros will clear the screen, but some don't. You can solve this by editing your ~/.bash_logout file and adding the command:

clear

You can add any other useful commands here too.

Transferring files without ftp or scp

Difficulty: Easy
Application: netcat

Need to transfer a directory to another server but do not have FTP or SCP access? Well this little trick will help out using the netcat utility. On the destination server run:

nc -l -p 1234 | uncompress -c | tar xvfp -

And on the sending server run:

tar cfp - /some/dir | compress -c | nc -w 3 [destination] 1234

Now you can transfer directories without FTP and without needing root access.

Backing up a Debian package list

Difficulty: Easy
Application: Debian

If you are running Debian and have lost track of which packages you are running, it could be useful to get a backup of your currently installed packages. You can get a list by running:

dpkg --get-selections > debianlist.txt

This will put the entire list in debianlist.txt. You could then install the same packages on a different computer with:

dpkg --set-selections < debianlist.txt

You should bear in mind that you would also need to copy over configuration files from /etc when copying your system to a new computer.

To actually install the selections, use:

apt-get -u dselect-upgrade.

Hardening ssh

Difficulty: Easy
Application: ssh

Although SSH is a pretty secure way to connect to your server, there are two simple changes you can make that will boost its security even further. First, you almost certainly don't want people logging in directly as root - instead, they should logon as a normal user, then use the su command to switch over. You can change this simply in the /etc/ssh/ssh_config file by adding the line:

PermitRootLogin  no

Now the only way to get root privilges is through su, which means crackers now need to break two passwords to get full access. While you are editing that file, find the line which says:

Protocol 2, 1

And change it to:

Protocol 2

This removes the option to fallback on the original SSH protocol, now considered very vulnerable.

Stop replying to pings

Difficulty: Easy
Application: sysctl

While ping is a very useful command for discovering network topology, the disadvantage is that it does just that, and makes it easier for hackers on the network to target live servers. But you can tell Linux to ignore all pings - the server simply won't respond. There are a number of ways to achieve this, but the best is to use sysctl. To turn off ping replies:

sysctl -w net.ipv4.icmp_echo_ignore_all=1

To turn it back on, again use:

sysctl -w net.ipv4.icmp_echo_ignore_all=0

If turning off ping is too severe for you, take a look at the next hack.

Slow down ping rates

Difficulty: Easy
Application: sysctl

You may want to keep the ability to reply to pings, but protect yourself from a form of attack known as a 'ping flood'. So how can you manage such a feat? The easiest way is to slow down the rate at which the server replies to pings. They are still valid, but won't overload the server:

sysctl -w net.ipv4.icmp_echoreply_rate=10

This slows the rate at which replies are sent to a single address.

Clean up KDE on logout

Difficulty: Easy
Application: bash

On Windows there are plenty of programs that do stuff like clean out your web cache, remove temporary files and all sorts of other stuff when you logout. Wouldn't it be cool to do this on Linux too? With KDE, you don't need to even install any new software, as the startkde script will automatically run scripts you put in special places.

First, you need to create a directory called shutdown in your .kde directory:

mkdir /home/username/.kde/shutdown

Now create a script to do any stuff you like on shutdown. Here is an example:

#!/bin/bash
#clear up temp folder
rm -rf ~/tmp/*
#clear out caches
rm -rf ~/.ee/minis/*
rm -rf ~/.kde/share/cache/http/*
# delete konqueror form completions
rm ~/.kde/share/apps/khtml/formcompletions

Now make sure you set the correct permissions:

chmod ug+x ~/.kde/shutdown/cleanup.sh

(or whatever you called it). As well as cleaning up sensitive files, you can also have global shutdown scripts for all users, by placing the script in your default KDE folder, in a subfolder called shutdown. To find out which is your default KDE directory, try:

kde-config --path exe

Password-less ssh

Difficulty: Intermediate
Application: ssh

Tired of typing your password every time you log into the server? ssh also supports keys, so you'll only have to type in your password when you log in to the desktop. Generate a keypair on your desktop machine:

ssh-keygen -t dsa -C your.email@ddress

Enter a passphrase for your key. This puts the secret key in ~/.ssh/id_dsa and the public key in ~/.ssh/id_dsa.pub. Now see whether you have an ssh-agent running at present:

echo $SSH_AGENT_PID

Most window managers will run it automatically if it's installed. If not, start one up:

eval $(ssh-agent)

Now, tell the agent about your key:

ssh-add

and enter your passphrase. You'll need to do this each time you log in; if you're using X, try adding

SSH_ASKPASS=ssh-askpass ssh-add

to your .xsession file. (You may need to install ssh-askpass.) Now for each server you log into, create the directory ~/.ssh and copy the file ~/.ssh/id_dsa.pub into it as ~/.ssh/authorized_keys . If you started the ssh-agent by hand, kill it with

ssh-agent -k

when you log out.

Using rsync over ssh

Difficulty: Intermediate
Application: Shell

Keep large directory structures in sync quickly with rsync. While tar over SSH is ideal for making remote copies of parts of a filesystem, rsync is even better suited for keeping the filesystem in sync between two machines. To run an rsync over SSH, pass it the -e switch, like this:

rsync -ave ssh greendome:/home/ftp/pub/ /home/ftp/pub/

Note the trailing / on the file spec from the source side (on greendome.) On the source spec, a trailing / tells rsync to copy the contents of the directory, but not the directory itself. To include the directory as the top level of what's being copied, leave off the /:

rsync -ave ssh bcnu:/home/six .

This will keep a copy of the ~/six/ directory on village in sync with whatever is present on bcnu:/home/six/. By default, rsync will only copy files and directories, but not remove them from the destination copy when they are removed from the source. To keep the copies exact, include the --delete flag:

rsync -ave ssh  --delete greendome:~one/reports .

Now when old reports are removed from ~one/reports/ on greendome, they're also removed from ~six/public_html/reports/ on the synced version, every time this command is run. If you run a command like this in cron, leave off the v switch. This will keep the output quiet (unless rsync has a problem running, in which case you'll receive an email with the error output). Using SSH as your transport for rsync traffic has the advantage of encrypting the data over the network and also takes advantage of any trust relationships you already have established using SSH client keys.

Asset scanning

Difficulty: Intermediate
Application: nmap

Normally, when people think of using nmap, they assume it's used to conduct some sort of nefarious network reconnaissance in preparation for an attack. But as with all powerful tools, nmap can be made to wear a white hat, as it's useful for far more than breaking into networks. For example, simple TCP connect scans can be conducted without needing root privileges:

nmap rigel

nmap can also scan ranges of IP addresses by specifying the range or using CIDR notation:

nmap 192.168.0.1-254
nmap 192.168.0.0/24

nmap can provide much more information if it is run as root. When run as root, it can use special packets to determine the operating system of the remote machine by using the -O flag. Additionally, you can do half-open TCP scanning by using the -sS flag. When doing a half-open scan, nmap will send a SYN packet to the remote host and wait to receive the ACK from it; if it receives an ACK, it knows that the port is open. This is different from a normal three-way TCP handshake, where the client will send a SYN packet and then send an ACK back to the server once it has received the initial server ACK. Attackers typically use this option to avoid having their scans logged on the remote machine.

nmap -sS -O rigel
Starting nmap V. 3.00 ( www.insecure.org/nmap/ )
Interesting ports on rigel.nnc (192.168.0.61):
(The 1578 ports scanned but not shown below are in state: filtered)
Port       State       Service
7/tcp      open     echo 
9/tcp      open     discard 
13/tcp     open     daytime 
19/tcp     open     chargen 
21/tcp     open     ftp 
22/tcp     open     ssh 
23/tcp     open     telnet 
25/tcp     open     smtp 
37/tcp     open     time 
79/tcp     open     finger 
111/tcp    open     sunrpc 
512/tcp    open     exec 
513/tcp    open     login 
514/tcp    open     shell 
587/tcp    open     submission 
7100/tcp   open     font-service 
32771/tcp  open     sometimes-rpc5 
32772/tcp  open     sometimes-rpc7 
32773/tcp  open     sometimes-rpc9 
32774/tcp  open     sometimes-rpc11 
32777/tcp  open     sometimes-rpc17 
Remote operating system guess: Solaris 9 Beta through Release on SPARC
Uptime 44.051 days (since Sat Nov  1 16:41:50 2003)
Nmap run completed -- 1 IP address (1 host up) scanned in 166 seconds

With OS detection enabled, nmap has confirmed that the OS is Solaris, but now you also know that it's probably Version 9 running on a SPARC processor.

One powerful feature that can be used to help keep track of your network is nmap's XML output capabilities. This is activated by using the -oX command-line switch, like this:

nmap -sS -O -oX scandata.xml rigel

This is especially useful when scanning a range of IP addresses or your whole network, because you can put all the information gathered from the scan into a single XML file that can be parsed and inserted into a database. Here's what an XML entry for an open port looks like:

nmap is a powerful tool. By using its XML output capabilities, a little bit of scripting, and a database, you can create an even more powerful tool that can monitor your network for unauthorized services and machines.

Backup your bootsector

Difficulty Expert
Application Shell

Messing with bootloaders, dual-booting and various other scary processes can leave you with a messed up bootsector. Why not create a backup of it while you can:

dd if=/dev/hda of=bootsector.img bs=512 count=1

Obviously you should change the device to reflect your boot drive (it may be sda for SCSI). Also, be very careful not to get things the wrong way around - you can easily damage your drive! To restore use:

dd if=bootsector.img of=/dev/hda

Protect log files

Difficulty: Expert
Application: Various

During an intrusion, an attacker will more than likely leave telltale signs of his actions in various system logs: a valuable audit trail that should be protected. Without reliable logs, it can be very difficult to figure out how the attacker got in, or where the attack came from. This info is crucial in analysing the incident and then responding to it by contacting the appropriate parties involved. But, if the break-in is successful, what's to stop him from removing the traces of his misbehaviour?

This is where file attributes come in to save the day (or at least make it a little better). Both Linux and the BSDs have the ability to assign extra attributes to files and directories. This is different from the standard Unix permissions scheme in that the attributes set on a file apply universally to all users of the system, and they affect file accesses at a much deeper level than file permissions or ACLs. In Linux, you can see and modify the attributes that are set for a given file by using the lsattr and chattr commands, respectively. At the time of this writing, file attributes in Linux are available only when using the ext2 and ext3 filesystems. There are also kernel patches available for attribute support in XFS and ReiserFS. One useful attribute for protecting log files is append-only. When this attribute is set, the file cannot be deleted, and writes are only allowed to append to the end of the file.

To set the append-only flag under Linux, run this command:

chattr +a  filename

See how the +a attribute works: create a file and set its append-only attribute:

touch /var/log/logfile
echo "append-only not set" > /var/log/logfile
chattr +a /var/log/logfile
echo "append-only set" > /var/log/logfile
bash: /var/log/logfile: Operation not permitted

The second write attempt failed, since it would overwrite the file. However, appending to the end of the file is still permitted:

echo "appending to file" >> /var/log/logfile
cat /var/log/logfile
append-only not set
appending to file

Obviously, an intruder who has gained root privileges could realise that file attributes are being used and just remove the append-only flag from our logs by running chattr -a. To prevent this, we need to disable the ability to remove the append-only attribute. To accomplish this under Linux, use its capabilities mechanism.

The Linux capabilities model divides up the privileges given to the all-powerful root account and allows you to selectively disable them. In order to prevent a user from removing the append-only attribute from a file, we need to remove the CAP_LINUX_IMMUTABLE capability. When present in the running system, this capability allows the append-only attribute to be modified. To modify the set of capabilities available to the system, we will use a simple utility called lcap (http://packetstormsecurity.org/linux/admin/lcap-0.0.3.tar.bz2).

To unpack and compile the tool, run this command:

tar xvfj lcap-0.0.3.tar.bz2 && cd lcap-0.0.3 && make

Then, to disallow modification of the append-only flag, run:

./lcap CAP_LINUX_IMMUTABLE
./lcap CAP_SYS_RAWIO

The first command removes the ability to change the append-only flag, and the second removes the ability to do raw I/O. This is needed so that the protected files cannot be modified by accessing the block device they reside on. It also prevents access to /dev/mem and /dev/kmem, which would provide a loophole for an intruder to reinstate the CAP_LINUX_IMMUTABLE capability. To remove these capabilities at boot, add the previous two commands to your system startup scripts (eg /etc/rc.local). You should ensure that capabilities are removed late in the boot order, to prevent problems with other startup scripts. Once lcap has removed kernel capabilities, they can be reinstated only by rebooting the system.

Before doing this, you should be aware that adding append-only flags to your log files will most likely cause log rotation scripts to fail. However, doing this will greatly enhance the security of your audit trail, which will prove invaluable in the event of an incident.

Automatically encrypted connections

Difficulty: Expert
Application: FreeS/WAN

One particularly cool feature supported by FreeS/WAN is opportunistic encryption with other hosts running FreeS/WAN. This allows FreeS/WAN to transparently encrypt traffic between all hosts that also support opportunistic encryption. To do this, each host must have a public key generated to use with FreeS/WAN. This key can then be stored in a DNS TXT record for that host. When a host that is set up for opportunistic encryption wishes to initiate an encrypted connection with another host, it will look up the host's public key through DNS and use it to initiate the connection.

To begin, you'll need to generate a key for each host that you want to use this feature with. You can do that by running the following command:

ipsec newhostkey --output /tmp/`hostname`.key

Now you'll need to add the contents of the file that was created by that command to /etc/ipsec.secrets:

cat /tmp/`hostname`.key >> /etc/ipsec.secrets

Next, you'll need to generate a TXT record to put into your DNS zone. You can do this by running a command similar to this one:

ipsec showhostkey --txt @colossus.nnc

Now add this record to your zone and reload it. You can verify that DNS is working correctly by running this command:

ipsec verify
Checking your system to see if IPsec got installed and started correctly
Version check and ipsec on-path  [OK]
Checking for KLIPS support in kernel   [OK]
Checking for RSA private key (/etc/ipsec.secrets)   [OK]
Checking that pluto is running   [OK]
DNS checks. 
Looking for TXT in forward map: colossus   [OK]
Does the machine have at least one non-private address   [OK]

Now just restart FreeS/WAN - you should now be able to connect to any other host that supports opportunistic encryption. But what if other hosts want to connect to you? To allow this, you'll need to create a TXT record for your machine in your reverse DNS zone.

You can generate the record by running a command similar to this:

ipsec showhostkey --txt 192.168.0.64

Add this record to the reverse zone for your subnet, and other machines will be able to initiate opportunistic encryption with your machine. With opportunistic encryption in use, all traffic between the hosts will be automatically encrypted, protecting all services simultaneously.

Eliminate suid binaries

Difficulty: Intermediate
Application: find

If your server has more shell users than yourself, you should regularly audit the setuid and setgid binaries on your system. Chances are you'll be surprised at just how many you'll find. Here's one command for finding all of the files with a setuid or setgid bit set:

find / -perm +6000 -type f -exec ls -ld {} \; > setuid.txt &

This will create a file called setuid.txt that contains the details of all of the matching files present on your system. To remove the s bits of any tools that you don't use, type:

chmod a-s program

Mac filtering Host AP

Difficulty: Expert
Application: iwpriv

While you can certainly perform MAC filtering at the link layer using iptables or ebtables, it is far safer to let Host AP do it for you. This not only blocks traffic that is destined for your network, but also prevents miscreants from even associating with your station. This helps to preclude the possibility that someone could still cause trouble for your other associated wireless clients, even if they don't have further network access.

When using MAC filtering, most people make a list of wireless devices that they wish to allow, and then deny all others. This is done using the iwpriv command.

iwpriv wlan0 addmac 00:30:65:23:17:05
iwpriv wlan0 addmac 00:40:96:aa:99:fd
  ...
iwpriv wlan0 maccmd 1
iwpriv wlan0 maccmd 4

The addmac directive adds a MAC address to the internal table. You can add as many MAC addresses as you like to the table by issuing more addmac commands. You then need to tell Host AP what to do with the table you've built. The maccmd 1 command tells Host AP to use the table as an "allowed" list, and to deny all other MAC addresses from associating. Finally, the maccmd 4 command boots off all associated clients, forcing them to reassociate. This happens automatically for clients listed in the table, but everyone else attempting to associate will be denied.

Sometimes, you only need to ban a troublemaker or two, rather than set an explicit policy of permitted devices. If you need to ban a couple of specific MAC address but allow all others, try this:

iwpriv wlan0 addmac 00:30:65:fa:ca:de
iwpriv wlan0 maccmd 2
iwpriv wlan0 kickmac 00:30:65:fa:ca:de

As before, you can use addmac as many times as you like. The maccmd 2 command sets the policy to "deny," and kickmac boots the specified MAC immediately, if it happens to be associated. This is probably nicer than booting everybody and making them reassociate just to ban one troublemaker. Incidentally, if you'd like to remove MAC filtering altogether, try maccmd 0.

If you make a mistake typing in a MAC address, you can use the delmac command just as you would addmac, and it (predictably) deletes the given MAC address from the table. Should you ever need to flush the current MAC table entirely but keep the current policy, use this command:

iwpriv wlan0 maccmd 3

Finally, you can view the running MAC table by using /proc:

cat /proc/net/hostap/wlan0/ap_control

The iwpriv program manipulates the running Host AP driver, but doesn't preserve settings across reboots. Once you are happy with the contents of your MAC filtering table, be sure to put the relevant commands in an rc script to run at boot time.

Note that even unassociated clients can still listen to network traffic, so MAC filtering actually does very little to prevent eavesdropping. To combat passive listening techniques, you will need to encrypt your data.

Check processes not run by you

Difficulty: Expert
Application: bash

Imagine the scene - you read our list of Linux Format Awards nominees this month, saw Crack Attack! on there, and took it upon yourself to give it a (very) thorough testing before casting your vote in its favour. Sadly, to your shock, the game drags to a halt just as you're about to beat your uppity subordinate - what could be happening to make your machine so slow? It must be some of those other users, stealing your precious CPU time with their scientific experiments, webservers or other weird, geeky things!

OK, let's list all the processes on the box not being run by you!

ps aux | grep -v `whoami`

Or, to be a little more clever, why not just list the top ten time-wasters:

ps aux  --sort=-%cpu | grep -m 11 -v `whoami`

It is probably best to run this as root, as this will filter out most of the vital background processes. Now that you have the information, you could just kill their processes, but much more dastardly is to run xeyes on their desktop. Repeatedly!

Courtesy: linuxformat

Here Are 15 Things You Should Do After Installing ubuntu 14.04 Trusty Tahr

2014-04-30T08:52:00.000-07:00

1.Update your system

Here's how you can do that:

$ sudo apt-get update

$ sudo apt-get upgrade

2.Consider installing Aptitude, Synaptic and Gdebi

Here's how you can do that:

$ sudo apt-get install aptitude synaptic gdebi-core

3.Installing Gnome System Monitor

Here's how you can do that:

$ sudo apt-get install gnome-system-monitor

4.Get LibreOffice

Here's how you can do that:

$ sudo apt-get install libreoffice

5.Installing the VLC player

Here's how you can do that:

$ sudo apt-get install vlc

6.Installing extra codecs to play a variety of video/audio formats

Here's how you can do that:

$ sudo apt-get install xubuntu-restricted-extras libavcodec-extra

7.Install the libdvdread4 package to play encrypted dvds

Here's how you can do that:

$ sudo apt-get install libdvdread4

$ sudo /usr/share/doc/libdvdread4/install-css.sh

8.Installing Adobe Acrobat Reader

You can install Adobe Acrobat Reader from canonical partner repository:

$ sudo add-apt-repository "deb http://archive.canonical.com/ raring partner"

$ sudo apt-get update

$ sudo apt-get install acroread

9.Installing Uget download manager: perhaps one of the best file download managers for linux

Here's how you can do that:

$ sudo apt-get install uget

10.Speeding up the user interface

Here's how you can do that:

Create a file named .gtkrc-2.0 in home directory and paste in the following lines:

gtk-menu-popup-delay = 0
gtk-menu-popdown-delay = 0
gtk-menu-bar-popup-delay = 0
gtk-enable-animations = 0
gtk-timeout-expand = 0
gtk-timeout-initial = 0
gtk-timeout-repeat = 0

Save file > close > Logout > Login back

11.Install Gksudo to run gui apps as root

Here's how you can do that:

$ sudo apt-get install gksu

12.Install the rar package

Here's how you can do that:

$ sudo apt-get install icedtea-plugin

13.Turn off Apport

Particularly useful in case you get frequent error messages saying "System program problem detected".

14.Install Skype

Here's how you can do that:

$ wget http://download.skype.com/linux/skype-ubuntu-precise_4.2.0.13-1_i386.deb

15.Install Chrome and Chromium browsers

To install chromium browser:

$ sudo apt-get install chromium-browser chromium-codecs-ffmpeg-extra

To install chrome browser:

64 bit
$ wget https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb

# 32 bit
$ wget https://dl.google.com/linux/direct/google-chrome-stable_current_i386.deb

automount hardisk

2014-04-19T17:19:00.000-07:00

# cp /etc/fstab /etc/fstab.old

# blkid

/dev/sda1: LABEL="System Reserved" UUID="40106FB6106FB198" TYPE="ntfs" 
/dev/sda2: UUID="D2CE71FACE71D767" TYPE="ntfs" 
/dev/sda3: UUID="e6f5cc11-97d4-443f-b97b-71e59fa1c14b" TYPE="swap" 
/dev/sda4: UUID="67b386bf-faa5-4685-8b9b-d2ed82c4efc8" TYPE="ext4" 
/dev/sdb1: UUID="5c43644c-67f1-4d85-8685-70fa4c7f55c9" TYPE="ext4" 
/dev/sdb5: UUID="4177bb75-437d-4408-b360-ff4f802d6bb1" TYPE="swap"

# vi /etc/fstab
UUID=<uuid> <pathtomount> <file system> uid=<userid>,gid=<groupid>,umask=0022,sync,auto,rw 0 0
UUID=D2CE71FACE71D767 /home/data nfts uid=1000,gid=1000,umask=0022,sync,auto,rw 0 0

more info at :

http://www.linuxstall.com/fstab/

Ubuntu 14.4 : Best thing to install

2014-04-19T08:26:00.002-07:00

VLC – Versatile media player
Steam – Game distribution platform
Dropbox - Popular, cross-platform cloud storage service
GIMP – Advanced image editor
Chromium – open-source version of Google Chrome

Change LAMP Server IP Address

2013-08-25T21:33:00.001-07:00

For ubuntu 13.4

File to change ::

1. /etc/hosts
2. /etc/mysql/my.cnf
bind-address = 131.107.2.222

3. restart apache2
service apache2 restart

Best Hosting

2013-08-14T20:53:00.002-07:00

Best Hosting

1. Exabytes - Malaysia best hosting

2. Ipage - Cheap & best value for Money Hosting

3.

php cli

2013-08-14T20:53:00.001-07:00

PHP CLI

checking PHP version

php --version

find / -name "php53" -print

Date

2013-08-13T17:33:00.004-07:00

Format : date(format,timestamp)

$today = date("Y-m-d");

format time stamp : mktime(hour,minute,second,month,day,year,is_dst)

$tomorrow = mktime(0,0,0,date("m"),date("d")+1,date("Y"));

$nextweek = date("Y-m-d",mktime(0,0,0,date("m"),date("d")+7,date("Y")));

PHP : load combo (static option)

2013-08-12T23:57:00.001-07:00

/*
FUNCTION FUNCTION load_visit_type($field_name,$form_name,$curr_item,$add_blank=false,$auto_submit=false,$readonly='',$disabled='') {

   $a_code = array();
   $a_desc = array();

   $a_code[]="1";
   $a_code[]="2";
   $a_code[]="3";
   $a_code[]="4";

   $a_desc[]="Initial Home Assessment";
   $a_desc[]="Follow up Home Assessment";
   $a_desc[]="Routine Home Visist Assessment";
   $a_desc[]="Emergency";

   $opt="";
   if ($auto_submit==true) {
       $opt="<select name='$field_name' onchange='document.".$form_name. ".submit();'>" ;
   } else {
       $opt="<select name='$field_name' ".$readonly." " .$disabled.">" ;
   }   if ($add_blank==true) {
      $opt .= "<option value=''";
      if ( $curr_item == '' ) {
         $opt .= ' selected="selected" ';
      }
      $opt .= ' ></option>' ;
   }

$no_of_element=count($a_code);

for ($i = 0; $i < $no_of_element; $i++) {
     $opt .= "<option value='" . $a_code[$i] ."'";
     if ( trim($curr_item) == $a_code[$i] ) {
         $opt .= ' selected="selected"';
     }
     $opt .= ">". $a_desc[$i]. "</option>";
}
$opt .="</select>";

return $opt;
}

$add_blank=true;
$auto_submit=false;

call by :

$this->load_visit_type("visit_type","form1",$this->visit_type,$add_blank,$auto_submit)

$vtype = $this->load_visit_type("visit_type","form1",$db->record['visit_type'],true,false,'readonly','disabled');

*/

Common Linux Command

2013-07-26T19:08:00.001-07:00

tar
tar -czvf myarchive.tgz mydirectory/

untar
tar -xzvf mystuff.tgz

mount cdrom

wodim --devices : find the cdrom device

 if wodim not found : apt-get install cdrecord

mkdir /media/cdrom

mount -t iso9660 /dev/scd0 /media/cdrom : mount cdrom

mount -t iso9660 /dev/hdc /media/cdrom0/  : mount audio cd

kill gnome screen saver :

 ps -ef | grep amanda | grep gnome-screensaver

 kill -9 {screen saver id}

logout user from gnome :

   gnome-session-quit

or

   pkill -u username

1. arch

This command will show you the architecture of your system.

2. uname-m

This is another command to view the architecture of the system.

3. uname-r

This command is used to check the kernel version that is being used in the system.

4. dmidecode-q

This command give you the hardware components in your system.

5. hdparm-i / dev / hda

This is the command that shows the characteristics of your hard disk.

6. hdparm-tT / dev / sda

This command is used in order to conduct tests readings on hard drives.

7. cat / proc / cpuinfo

These commands can help you in getting CPU information.

8. cat / proc / interrupts

These commands are used to interrupt a process.

9. cat / proc / meminfo

This command verifies the memory usage in your system.

10. cat / proc / swaps

These commands are used in order to swap files.

11. cat / proc / version

These three commands can display the kernel version for your system.

12. cat / proc / net / dev

These four commands are used to view the network adapters and display statistics of the system.

13. cat / proc / mounts

This command shows you the mounted file system.

14. lspci-tv

If you need to view the PCI display devices then this is the command to use.

15. lsusb-tv

This is the command for displaying USB devices.

How to use tcpdump to detect Network Port Traffic
tcppdump dst mail.terangnusa.com and tcp port 587
tcpdump port 80tcpdump -i eth0
tcppdump -i eth0 dst port 25

Kota Jembal Ubuntu / Linux

E: Unable to fetch some archives, m

Install package using tasksel (Ubuntu 16.04)

Network Security tools script

Chkrootkit: chkrootkit is a tool to locally check for signs of a rootkit. It contains a chkrootkit: shell script that checks system binaries for rootkit modification. Installation: Open up the terminal and type the following command to install chkrootkit:

others :

1. DenyHosts

What is DenyHosts?

Features

2. Fail2ban

3. Ubuntu security tools

ssh compromised

others :

1. DenyHosts

What is DenyHosts?

Features

2. Fail2ban

3. Ubuntu security tools

SCP command

Basic syntax of SCP

Provide the detail information of SCP process using -v parameter

Provide modification times, access times, and modes from original files

Make file transfer faster using -C parameter

Select another cipher to encrypt files

Limiting bandwidth usage

Specify specific port to use with SCP

Copy files inside directory recursively

Disable progress meter and warning / diagnostic message

Copy files using SCP through Proxy

Select different ssh_config file

Laravel 4 – simple website with backend tutorial – Part 1

Laravel 4 – simple website with backend tutorial – Part 1

Installing Laravel 4 and all the dependencies

Setup the database and migrations

Our models

Seeding the database

Extra tip on database seeding

Tinker with our models

What is next?

25 Laravel Tips and Tricks

25 Laravel Tips and Tricks

1. Eloquent Queries

2. Flexible Routing

3. Easy Relationships

4. Form Model Binding

5. Cache Database Queries

6. View Composers

7. Simple Authentication

8. Resources

9. Blade Templating

10. Testing Facilities

11. Remote Component

12. Events

13. View All Routes

14. Queues

15. Easy Validation

16. Tinker Tinker

17. Migrations

18. Generators

19. Commands

20. Mock Facades

21. Form Helpers

22. The IoC Container

23. Environments

24. Simple Configuration

25. Top-Shelf Further Learning

12 Type Of Servers And What They Do

15 IT Courses That Will Make You An Industry Hero

Donwload entire web using ubuntu / linux

Hack Into Gmail And Facebook Using Kali Linux!

How To Install Wordpress on Ubuntu 14.04

How To Install Wordpress on Ubuntu 14.04

Introduction

Prerequisites

Step One — Create a MySQL Database and User for WordPress

Step Two — Download WordPress

Step Three — Configure WordPress

Step Four — Copy Files to the Document Root

Step Five — Complete Installation through the Web Interface

Step Six (Optional) — Configure Pretty Permalinks for WordPress

Chkrootkit:
chkrootkit is a tool to locally check for signs of a rootkit. It contains a chkrootkit: shell script that checks system binaries for rootkit modification.

Installation:
Open up the terminal and type the following command to install chkrootkit: