The Root Of All Database Security Evils = Input

Input validation and prepared SQL statements crucial to preventing SQL injection attacks

Some of the most embarrassing database breaches of the past few years boil down to one big root cause: poor input validation and sanitization imposed by developers who create Web applications that tap into these data stores. In the rush to get code compiled and out the door, developers create input fields that allow users to type in anything they want. Thats fine for most users who just need to type in their usernames, a search term, or an address and phone number. But when the bad guys get their hooks into these unchecked input fields, theyre one step closer to hacking the database.
User input is the root of all evil, says Trevor Hawthorn, CTO for security consultancy Stratum Security. Ultimately, user input in some way, shape, or form makes its way to the database, and so where that could spell trouble is if a user submits input to a Web application that is then interpreted by the database as database commands rather than what it is -- user input.
[Hackers fixate on SQL injections--CSOs, not so much. See
The SQL Injection Disconnection
.]
According to Hawthorn, SQL injection is the 800-pound gorilla when it comes to input-related problems.
As Bill Karwin, principal consultant for Percona, explains, this most-widespread security risk on the Internet is essentially a coding gaffe where the developer interpolates untested content into SQL queries, giving malicious users the tools to type SQL queries into input fields to directly interact with the database without the application ever acting as a filter.
Developers should make sure their code never executes user input as code, Karwin warns.
Heres why: With that kind of power in the hands of a knowledgeable attacker or even an unknowledgeable one using an automated SQL injection attack tool like Havij, any outside user can input commands that will allow them to retrieve data from the database or add content to a database. This opens up the possibility not only of theft, but also adding malware into a database that powers a website so that it is serving up malicious content to users, or even adding content to something like a story on a news website, Hawthorn says.
For example, one client that his company serviced ran into a situation where a public policy organization had messaging on its site that was diametrically opposed to its policy positions.
They were essentially lobbying against themselves, and nobody noticed it for quite a while, he says. That was a case where it was a SQL injection vulnerability that allowed someone to make just a couple of crucial changes.
Experts agree that a big reason why so many SQL injection vulnerabilities remain out there in the wild is because developers only assume their users will type inputs with good intentions.
From a security professionals perspective, a good programmer will sanitize all data sent to the server, aggressively fuzz their input fields, and constantly patch their components, says Dylan Evans, vice president of operations for Reveal Digital Forensics and Security. However, from the programmers perspective, these concerns may not reach a high priority. The vast majority of Web programmers are familiar with SQL injection -- and its sibling, cross-site scripting -- on a conceptual level. However, understanding why something is dangerous and actively preparing for that danger are two different issues.
Part of that preparation is to not only test and plan for typical use cases, but also those atypical abuse cases. Its the only way that organizations will be able to effectively stamp out
SQLi attacks like the one that hit Adobe this week
, experts say.
If you filter user inputs to only respond to known queries, you are golden, but too many Web applications trust the unknown users input, says Mark Goudie, managing principal for the RISK Team at Verizon Enterprise Solutions. Bad people do bad things with user input and [then] they can access all of your database.
First and foremost, Hawthorn says, developers need to be aware of how data comes into their application.
Understand where your inputs are, how people could abuse them, and what would happen if things were to go seriously wrong, he says, explaining that one of the biggest best practices developers should strive to implement is whitelisting input as much as possible.
Whitelist the types of content you are expecting for a given input, he says.
So, for example, a phone number input box shouldnt accept letters or apostrophes. Hawthorn says he understands that, in many cases, this may not always be feasible, particularly as more sites are built with social features that allow for greater freeform user input functionality. In these cases, developers should seek to use prepared SQL statements so that user input is never entered into the database as code.
So if I enter my username as or 1=1, what the application should do is reach back into the database and say, Do I have a user name or 1=1 ? So what it should do is look in the database for literally the characters that were put in, he says. Thats a good way to solve most of your input validation-based database challenges.
Have a comment on this story? Please click Add Your Comment below. If youd like to contact
Dark Readings
editors directly,
send us a message
.

Last News
▸ ArcSight prepares for future at user conference post HP acquisition. ◂ Discovered: 07/01/2025 Category: security	▸ Samsung Epic 4G: First To Use Media Hub ◂ Discovered: 07/01/2025 Category: security	▸ Many third-party software fails security tests ◂ Discovered: 07/01/2025 Category: security

**Cyber Security Categories**
Google Dorks Database	Exploits Vulnerability	Exploit Shellcodes

CVE List

Tools/Apps

News/Aarticles

Phishing Database

Deepfake Detection

Trends/Statistics & Live Infos

Tags:
The Root Of All Database Security Evils = Input