Linux Advisory Watch – August 12, 2005

Today on Hacks From Pax we’ll be discussing PHP web application security. PHP
is a great language for rapidly developing web applications, and is very friendly
to beginning programmers, but some of its design can make it difficult to write
web apps that are properly secure. We’ll discuss some of the main security “gotchas”
when developing PHP web applications, from proper user input sanitization to
avoiding SQL injection vulnerabilities.

Many PHP application vulnerabilities are caused by not properly initializing
variables. This is an example of how PHP, by not requiring the developer to
initialize a variable before using it, sacrifices security for ease of use.
For example, the following code is easily exploitable.

   if (user_auth()) {
    $access = true;
  }
    if ($access) {
    do_sensitive_things();
  }

This could be exploited by tacking an ?access=true to the end of the url, and
the if ($access) test would be passed despite the user_auth() function returning
false. This hole could be closed easily by adding a $access = false; at the
top of the script, but not all security holes are this easy to spot.

Thankfully, PHP now defaults the register_globals option to off. This setting
would pass the access variable sent by the url to the script as $_GET[access]
rather than just $access. This closes off many of these types of vulnerabilities,
but when writing PHP code, especially code for distribution, you should never
assume that this option will be set correctly, and always initialize your PHP
variables. Users in a shared hosting environment may not have the ability to
set these options to their most secure setting.

• Always initialize PHP variables before using them.
• Always set register_globals to off, but never write code that assumes this
  setting.
• You can use the ini_get() function to determine if register_globals is set
  at runtime.

Read Entire Article:
http://www.linuxsecurity.com/content/view/120043/49/

LinuxSecurity.com
Feature Extras:

Linux File
& Directory Permissions Mistakes – One common mistake Linux administrators
make is having file and directory permissions that are far too liberal and
allow access beyond that which is needed for proper system operations. A full
explanation of unix file permissions is beyond the scope of this article,
so I’ll assume you are familiar with the usage of such tools as chmod, chown,
and chgrp. If you’d like a refresher, one is available right here on linuxsecurity.com.

Introduction:
Buffer Overflow Vulnerabilities – Buffer overflows are a leading type
of security vulnerability. This paper explains what a buffer overflow is,
how it can be exploited, and what countermeasures can be taken to prevent
the use of buffer overflow vulnerabilities.

Getting
to Know Linux Security: File Permissions – Welcome to the first
tutorial in the ‘Getting to Know Linux Security’ series. The topic explored
is Linux file permissions. It offers an easy to follow explanation of how
to read permissions, and how to set them using chmod. This guide is intended
for users new to Linux security, therefore very simple. If the feedback is
good, I’ll consider creating more complex guides for advanced users. Please
let us know what you think and how these can be improved.

 

Take advantage of our Linux Security discussion
list! This mailing list is for general security-related questions and comments.
To subscribe send an e-mail to security-discuss-request@linuxsecurity.com
with “subscribe” as the subject.

Thank you for reading the LinuxSecurity.com
weekly security newsletter. The purpose of this document is to provide our readers
with a quick summary of each week’s most relevant Linux security headline.