4 Step to Hardening Postgresql 9.0

Posted by admin on January 27, 2012 No comments

Edit init script or start command  (/etc/rc.d/init.d/postgresql-9.0)

This setting should be done if you install postgre almost in Linux Distribution, i use CentOs.

One of the key security controls for PostgreSQL, and indeed many other applications, is to ensure the database server daemon, called postmaster, is being run as an appropriate user. On these distributions PostgreSQL should run as a normal user, usually the Postgre user. You can confirm that the daemon is running as an appropriate user by checking the process.

# ps – aux | grep ‘postmaster’

postgres 12934 0.0 1.2 20896 3156 ? S 02:16 0:00 /usr/bin/postmaster -p 5432 -D /var/lib/pgsql/data

If it isn’t being run as a nonroot user, you should create an appropriate user. You can then change your init script or start command to start PostgreSQL with this user. You can use su to then run PostgreSQL as the appropriate user.

To extend this, you can also run PostgreSQL under SELinux or AppArmor. For example, the SELinux “targeted” policy on Red Hat Enterprise Linux includes support for running PostgreSQL.

Hardening Postgresql

Hardening Postgresql 9.0

 

 

 

 

 

 

 

 

 

 

 

Edit postgresql configuration file (/var/lib/pgsql/9.0/data/postgresql.conf)

Each of these modes are configured in the postgresql.conf configuration file, usually located in your data directory. In Red Hat, for example, it is in the /var/lib/pgsql/data directory.

Control of network bindings is handled by the listen_addresses configuration option (you can also change the port number if you’d like). You can specify an address, addresses or blank to not bind to the network at all.

You can also only bind the network to the localhost.

listen_addresses = ‘localhost’, it will reject all connection from other tcp/ip.

do not set

listen_addresses = ‘*’

because it will alow all connection to your DB Server, please set

listen_addresses = ‘Your DB Server IP’, ex listen_addresses = ’10.10.100.5′

it will allow connection from other tcp/ip in same subnet

 

Edit iptables configuration file (/etc/sysconfig/iptables)

If you do bind to an external interface, you will need to ensure that port 5432 is open on your firewall. It is a good idea to lock down incoming connections to all hosts except those hosts who need to access the database. For example:

# iptables -A INPUT -p tcp -s 10.10.0.10 -d 10.10.0.20 –dport 5432 -m state –state NEW,ESTABLISHED -j ACCEPT # iptables -A INPUT -p tcp –I lo –dport 5432 -m state –state NEW,ESTABLISHED -j ACCEPT # iptables –A INPUT –p tcp –dport 5432 –m state NEW,ESTABLISHED –j DROP

The first rule tells iptables to allow connections from the 10.10.0.10 host to the 10.10.0.20 host (our database host) on port 5432 – PostgreSQL’s default port. The second rule allows access from the localhost. The last rule drops any other PostgreSQL connections. You would then also need to create appropriate outgoing rules.

 

Edit Client Authentication Configuration File  (/var/lib/pgsql/9.0/data/pg_hba.conf)

# Disable all trust connections, its easy to set but it will be very difficult if you have some Backup DB Application which must be allowed do pg_dump without password, my suggestion is create other super user besides postgres and set trust connections at local only.

# Use strong authentication (md5/kerberos etc)

# Limit connections only from allowed IP, don’t forget to set *.*.*.*/32 or /24

 

After configuring how clients connect to PostgreSQL, we need to specify which clients can connect to PostgreSQL. This is done using host-based client access control and is configured in the pg_hba.conf configuration file. The pg_hba.conf configuration file is usually located in the PostgreSQL data directory, for example /var/lib/pgsql.

PostgreSQL has a wide collection of authentication and access mechanisms including password authentication, PAM, LDAP and Kerberos and others. With the pg_hba.conf file you can control connections to local or network sockets, where they connect from and what authentication methods are allowed. The authentication is also sufficiently granular to control which databases can be accessed. Let’s look at some simple examples: # Type DB User Network Mechanism local all all pam host sameuser all 127.0.0.1/32 pam host www www 10.10.0.10/32 md5

Each configuration line in the pg_hba.conf file is made up a number of fields. The first field tells PostgreSQL what type of connection we are securing. The two most common types are “local” for local file socket connections and “host” for network connections. You can specify multiple authentication mechanisms for each type.

The DB field specifies which database you can connect to and includes two special options values: “all” and “sameuser”. The “all” option indicates that incoming users on this connection type can connect to all databases. The “sameuser” option will only allow an incoming user to connect to a database with the same name as the connecting user.

So the second line in our example above would allow the user “ben” to connect to a database called “ben” but not to a database named “jerry”. You can also specify multiple databases by separating each with a comma.

The user field controls which user ids are allowed to connect. Again, we can use the “all” value for all user ids to connect or the name of a specific user. You can also specify multiple users by separating each with a comma.

For network connections — though obviously not local sockets — we can specify which hosts and network can connect in the form of an IP address and subnet. In the second line above we limit connections to the loopback address and in the third line to the IP address 10.10.0.10.

Objek di PHP

Posted by admin on September 11, 2011 No comments

Menurut ilustrasi mobil di atas dapat dikatakan bahwa objek “diperanakkan” dari kelas. Untuk mendefinisikan sebuah objek digunakan sintaks sebagai berikut:

$namaobjek = new namakelas;

    Setelah objek didefinisikan, maka seluruh variabel dan fungsi yang terdapat dalam sebuah kelas otomatis terdapat pula dalam objek namaobjek tersebut. Untuk merujuk pada fungsi atau variabel yang dimiliki oleh kelasnya, maka digunakan juga tanda ->. Berikut akan diberikan contoh bagaimana menggunakan objek dan kelas dengan menggunakan contoh kelas hitung dan hitung_juga yang telah diberikan di atas.

<HTML>
<HEAD>
<TITLE> Kelas dan Objek </TITLE>
</HEAD>
<BODY>
<?
class hitung {
    var $hasil;

    function kali($x,$y) {
        $this->hasil = $x * $y;
    }

    function bagi($x,$y) {
        $this->hasil = $x / $y;
    }

    function tambah($x,$y) {
        $this->hasil = $x + $y;
    }

    function kurang($x,$y) {
        $this->hasil = $x - $y;
    }
}
$a = 9;
$b = 6;
echo "Nilai \$a = $a <BR>";
echo "Nilai \$b = $b <BR><BR>";
$calc = new hitung;

echo "Perhitungan angka \$a dan \$b menggunakan Kelas <b> hitung </b> dan Object <b> calc </b> <br>";
echo "\$a kali \$b sama dengan ";
$calc->kali($a,$b);
print $calc->hasil;
echo "<BR>";

echo "\$a bagi \$b sama dengan ";
$calc->bagi($a,$b);
print $calc->hasil;
echo "<BR>";

echo "\$a tambah \$b sama dengan ";
$calc->tambah($a,$b);
print $calc->hasil;
echo "<BR>";

echo "\$a kurang \$b sama dengan ";
$calc->kurang($a,$b);
print $calc->hasil;
echo "<BR> <BR>";

class hitung_juga extends hitung {
    function pangkat($x,$y) {
        $this->hasil = pow($x,$y);
    }
}

$calc_juga = new hitung_juga;

echo "Perhitungan angka \$a dan \$b menggunakan Kelas <b> hitung_juga </b> dan Object <b> calc_juga </b> <br>";
echo "\$a kali \$b sama dengan ";
$calc_juga->kali($a,$b);
print $calc_juga->hasil;
echo "<BR>";

echo "\$a bagi \$b sama dengan ";
$calc_juga->bagi($a,$b);
print $calc_juga->hasil;
echo "<BR>";

echo "\$a tambah \$b sama dengan ";
$calc_juga->tambah($a,$b);
print $calc_juga->hasil;
echo "<BR>";

echo "\$a kurang \$b sama dengan ";
$calc_juga->kurang($a,$b);
print $calc_juga->hasil;
echo "<BR>";

echo "\$a pangkat \$b sama dengan ";
$calc_juga->pangkat($a,$b);
print $calc_juga->hasil;
echo "<BR>";
?>
</BODY>
</HTML>

Bila script di atas dijalankan, akan menghasilkan output seperti dibawah ini :

Kelas di PHP

Posted by admin on September 11, 2011 No comments

Kelas adalah sebuah kumpulan variabel dan fungsi-fungsi yang bekerja dengan variabel tersebut. Untuk mendefinisikan kelas, sintaks yang digunakan adalah sebagai berikut:

class namakelas {
    var $namavariabel;
    ...Kumpulan fungsi...
}

Di dalam kelas, variabel didefinisikan dengan pernyataan var. Di dalam sebuah kelas secara default dikenal sebuah variabel bernama $this yang mereferensikan kelas itu sendiri. Kemudian untuk merujuk kepada variabel yang didefinisikan dengan pernyataan var digunakan tanda ->.
Untuk lebih jelasnya berikut akan diberikan contoh sebuah kelas yang berisi fungsi-fungsi perhitungan matematika sederhana:

<?
class hitung {
    var $hasil;
    
    function kali($x,$y) {
        $this->hasil = $x * $y;
    }

    function bagi($x,$y) {
        $this->hasil = $x / $y;
    }

    function tambah($x,$y) {
        $this->hasil = $x + $y;
    }

    function kurang($x,$y) {
        $this->hasil = $x - $y;
    }
}
?>

Sebuah kelas dapat merupakan perluasan dari kelas yang ada sebelumnya. Misalnya pada contoh kelas di atas fungsi-fungsi yang ada hanyalah kali(), bagi(), tambah(), kurang() dan mungkin itu dirasakan kurang. Jika ingin didefinisikan sebuah kelas lain yang juga mengandung fungsi-fungsi kali(), bagi(), tambah(), dan kurang() serta ditambah sebuah fungsi lagi misalnya pangkat(), maka tidak perlu dibuat sebuah kelas yang baru sama sekali yang mengandung kelima fungsi tersebut. Kelas tersebut dapat merupakan perluasan dari kelas hitung dan hanya mendefinisikan sebuah fungsi baru yaitu pangkat(). Dalam PHP untuk melakukan perluasan terhadap sebuah kelas digunakan pernyataan extends yang sintaksnya adalah sebagai berikut:

class namakelas extends kelaslain {
    var $namavariabel;
    ...Kumpulan fungsi...
}

Contoh:

<?
class hitung_juga extends hitung {
    function pangkat($x,$y) {
        $this->hasil = pow($x,$y)
    }
}
?>

Dari contoh ini dapat disimpulkan bahwa kelas hitung_juga akan memiliki variabel dan fungsi-fungsi yang terdapat pada kelas hitung ditambah dengan sebuah fungsi baru yaitu pangkat().
Perluasan kelas semacam ini dapat dikategorikan sebagai sifat inheritance dari pemrograman berorientasi objek. Kelas hitung_juga pada contoh di atas merupakan inherit dari kelas hitung.
Dalam melakukan perluasan ini, kelas yang merupakan inherit dari kelas lain dapat mendefinisikan fungsi dengan nama yang sama. Contoh:

class A {
    function contoh() {
        echo "Aku adalah fungsi contoh yang asli";
    }
}

class B extends A {
    function contoh() {
        echo "Aku adalah fungsi contoh yang didefinisikan ulang";
    }
}

Dalam hal ini fungsi contoh() di kelas A disebut dengan shadowed dan tidak dapat dipergunakan lagi. Unsur polymorphism terpenuhi di sini.