Como Proteger tus consultas PHP-MySQL del Sql Injection

El Sql-Injection es una gran preocupación a la hora de crear sitios o sistemas web para los desarrolladores, es una tecnica de hacking en donde el atacante puede obtener informacion importante y llegar a corromper o destruir tu base de datos.

Una practica simple puede ayudarte a proteger tu aplicación y por que no decir hasta tu "negocio" de intrusos que no deseas. En PHP es la manera más fácil de transmitir sus datos a través de la función mysql_real_escape_string. Al escapar los caracteres especiales en los campos donde el usuario puede manipular la base de datos, usted evitar ser vulnerables.

Ejemplo :

// This is a vulnerable query.
$query = "SELECT * FROM products WHERE name='$productname'";
mysql_query($query);

// This query is more secure
$query = sprintf("SELECT * FROM products WHERE name='%s'",
mysql_real_escape_string($productname));
mysql_query($query);

La parte más importante de ti mismo es poner fin a la protección de los usuarios de ser capaces de pasar sin alterar la base de datos de manipulación de los caracteres especiales, como comillas simples.

Patron de Diseño Builder, Java

El Patrón de diseño Builder o Constructor es usado para permitir la creación de una variedad de objetos complejos desde un objeto fuente(Producto), el objeto fuente se compone de una variedad de partes que contribuyen individualmente a la creación de cada objeto complejo a través de un conjunto de llamadas a interfaces comunes de la clase Abstract Builder.

Este patrón es medianamente usado.

Su intención es de abstrae el proceso de creación de un objeto complejo, centralizando dicho proceso en un único punto, de tal forma que el mismo proceso de construcción pueda crear representaciones diferentes.

Las clases y/u objetos que participan en este patron son los siguientes:

• Builder
• Define una interfaz abstracta para crear productos
• ConcreteBuilder
• Implementación de la interfaz Builder
• Construye y reune las partes necesarias para construir los productos
• Director
• Construye un objeto usando la interfaz Builder
• Producto
• El objeto complejo bajo construcción
• Metodos Propios

Puedes bajar el ejemplo y probarlo en tu pc. Fue desarrollado en Eclipse con Java 1.6SE
[descargar]

Este es el codigo:

public class Director {

//Builder uses a complex series of steps
public void Construct(Builder builder)
{
builder.BuildPartA();
builder.BuildPartB();
}

}

public abstract class Builder {

public abstract void BuildPartA();
public abstract void BuildPartB();
public abstract Product getResult();
}

public class ConcreteBuilder1 extends Builder{

private Product product = new Product();

@Override
public void BuildPartA() {
product.Add("PartA");

}

@Override
public void BuildPartB() {
product.Add("PartB");

}

public Product getResult()
{
return product;
}

}

public class ConcreteBuilder2 extends Builder{

private Product product = new Product();

@Override
public void BuildPartA() {
product.Add("PartX");

}

@Override
public void BuildPartB() {
product.Add("PartY");

}

public Product getResult()
{
return product;
}

}

import java.util.ArrayList;


public class Product {

ArrayList parts = new ArrayList();

public void Add(String part)
{
parts.add(part);

}

public void Show()
{
System.out.println("\nProduct Parts -------");
for(Object part:parts)
System.out.println(part);
}

}



public class Main {

/**
* @param args
*/
public static void main(String[] args) {
// Create director and builders
Director director = new Director();

Builder b1 = new ConcreteBuilder1();
Builder b2 = new ConcreteBuilder2();

// Construct two products
director.Construct(b1);
Product p1 = b1.getResult();
p1.Show();

director.Construct(b2);
Product p2 = b2.getResult();
p2.Show();


}

}

Saludos

Askpipe99

Patron de Diseño Abstract Factory

Provee una interfaz para crear objetos sin especificar sus clases concretas
Este patrón de diseño se utiliza muy frecuentemente

Las clases y/u objetos que participan en este patron son los siguientes:

• AbstractFactory
• Declara una interfaz para operaciones que crean productos abstractos
• ConcreteFactory
• Implementan las operaciones para crear los objetos de productos concretos
• AbstractProduct
• Declara una interfaz para un tipo de objeto producto
• Product
• Define un objeto producto para ser creado por el correspondiente concrete factory
• Implementa la interfaz AbstractProduct
• Client
• Usa la interfaz declara por las clases AbstractFactory y AbstractProduct

Puedes bajar el ejemplo y probarlo en tu pc. Fue desarrollado en Eclipse con Java 1.6SE
[descargar]

Este es el codigo:

public abstract class AbstractFactory{
public abstract AbstractProductA CreateProductA();
public abstract AbstractProductB CreateProductB();

}

public class ConcreteFactory1 extends AbstractFactory
{
public AbstractProductA CreateProductA()
{
return new ProductA1();
}
public AbstractProductB CreateProductB()
{
return new ProductB1();
}
}


class ConcreteFactory2 extends AbstractFactory
{
public AbstractProductA CreateProductA()
{
return new ProductA2();
}
public AbstractProductB CreateProductB()
{
return new ProductB2();
}
}

public abstract class AbstractProductA {

}


abstract class AbstractProductB{
public abstract void Interact(AbstractProductA a);

}

class ProductA1 extends AbstractProductA
{
}

public class ProductB1 extends AbstractProductB
{
public void Interact(AbstractProductA a)
{
System.out.println(this.getClass().toString() + " interactua con " + a.getClass().toString());
}
}

public class ProductA2 extends AbstractProductA
{
}

public class ProductB2 extends AbstractProductB{

@Override
public void Interact(AbstractProductA a) {
System.out.println(this.getClass().toString() + " interactua con " + a.getClass().toString());
}

}

public class Client {


private AbstractProductA abstractProductA;
private AbstractProductB abstractProductB;

// Constructor
public Client(AbstractFactory factory)
{
abstractProductB = factory.CreateProductB();
abstractProductA = factory.CreateProductA();
}

public void Run()
{
abstractProductB.Interact(abstractProductA);
}


}

public class Main {

/**
* @param args
*/
public static void main(String[] args) {
// Abstract factory #1
AbstractFactory factory1 = new ConcreteFactory1();
Client c1 = new Client(factory1);
c1.Run();

// Abstract factory #2
AbstractFactory factory2 = new ConcreteFactory2();
Client c2 = new Client(factory2);
c2.Run();
}

}


Este patrón de diseño es muy usado en aplicaciones web, dando muy buenos resultados cuando se separan sistemas.

Suerte

Patron de Diseño Singleton

Una clase de la cual solamente una instancia puede existir.
Asegurar una clase tiene solamente un caso y proporciona un punto global del acceso a él.









Es usado frecuentemente en los desarrollos de software
Puedes bajar el ejemplo y probarlo en tu pc. Fue desarrollado en Eclipse con Java 1.6SE
[descargar]

A Continuación el código del ejemplo para que lo veas sin descargarlo


public class Singleton {

private static Singleton instance;

public Singleton()
{
}

public static Singleton Instance()
{

if (instance == null)
{
instance = new Singleton();
}

return instance;
}

}


public class Main {

public static void main(String[] args) {

Singleton s1 = Singleton.Instance();
Singleton s2 = Singleton.Instance();

if (s1 == s2){
System.out.println("Objects are the same instance");
}

}
}

Primer Post :D

Mi Blog Comienza, aqui hablare de arquitectura de software, de ocio y lo que venga por ahi.

Pronto posteare ejemplos del uso de patrones de diseño en Java e intentare colocarlos en .NET, dejare el codigo fuente para que puedan descargarlo. Estos ejemplos seran realizados en Eclipse, que para mi gusto es uno de los mejores IDE.

See you