PRACTICA

Aplicación Básica en Java

EJEMPLO 1.
La siguiente aplicación sirve para mostrar, de forma práctica, los conceptos de
clases,objetos,atributos,métodos,herencia.La aplicación en sí se divide en 3 clases:
- La clase Exploit que define los atributos y métodos de los objetos-Exploit
- La clase WinExploit, heredada de la clase Exploit. Hereda los mismos atributos y
métodos que la clase Exploit y, a su vez, define nuevos atributos y métodos a
implementar.
- La clase Pa., que contiene el método Main para la ejecución de la aplicación (clase
principal). En esta clase se crean 2 objetos-Exploit y 2 objetos-WinExploit invocando
a los métodos Constructores de sus respectivas clases. También accede a los
objetos creados a través de sus métodos getters y setters.

Clase Exploit

Código
class Exploit
{
//Definimos las variables o atributos

String Autor;
String Vulnerabilidad;
String Lenguaje;

//Constructor - Construye el objeto-exploit e identifica sus atributos

//con los parámetros recibidos.

Exploit(String a, String v, String l)

{
Autor = a;
Vulnerabilidad = v;
Lenguaje = l;
}

//Métodos

String getAutor()
{
return Autor; //Devuelve autor
}

String getVulnerabilidad()
{
 return Vulnerabilidad;
}

String getLenguaje()
{
return Lenguaje;
}

String getInfoComun() //Devuelve toda la información de golpe

{
return ("\tAutor: " + Autor + "\n\tVulnerabilidad : " + Vulnerabilidad +
"\n\tLenguaje: " + Lenguaje);
}

int setOffset(String o)
{
//Se implementa el parámetro offset en la función que se quiera
System.out.println("\n\n[*] Implementando la direccion offset " + o + "
en el exploit...\n");

//Un ejemplo de esta implementación:

//Se configura el código del exploit en C para que necesite como
// parámetro de entrada la direccion offset. Este método de la
// aplicación Java, realizaría una llamada externa al ejecutable
// del exploit y le pasaría como parámetro de entrada, este offset

//Si se ha implementado con exito, el método devuelve 0.

return (0);

Clase WinExploit
Código
class WinExploit extends Exploit
{
//Además de disponer de los atributos heredados de la clase padre...
//Definimos las nuevas variables o atributos a añadir

String CodigoMS;

//Constructor - Construye el objeto-exploit e identifica sus atributos con los

parámetros recibidos.

WinExploit(String a, String v, String l, String cms)

 {
super(a,v,l); //Estos atributos son implementados por el constructor
de la clase padre
CodigoMS = cms;
}

//Además de disponer de los métodos heredados de la clase padre...

//Definimos los nuevos métodos
String getCodigoMS()
{
return CodigoMS;
}

String getInfoWin() //Devuelve toda la información de golpe

{
String s;
s = this.getInfoComun() + "\n\tCogigo MS: " + CodigoMS;
return s;
}
}

Clase app

Código
class app
{
public static void main (String[] args)
{
//Creamos dos objetos-Exploit llamando al Constructor
Exploit e1 = new Exploit ("Lion", "Serv-U FTPD SITE CHMOD
Command Stack Buffer Overflow", "C");

Exploit e2 = new Exploit ("fiNis", "Jordan Telnet Server Buffer

Overflow", "C");

//Creamos dos objetos-WinExploit llamando al Constructor

WinExploit w1 = new WinExploit ("Wirepair", "Windows Workstation
Service WKSSVC.DLL Buffer Overflow", "C", "MS03-049");

WinExploit w2 = new WinExploit ("HoD", "Lsasrv.dll RPC buffer

overflow", "C", "MS04-011");

//Imprimimos las características de los objetos (se puede hacer de

dos formas)

System.out.println("\nInfo de e1\n");
System.out.println("\tAutor: " + e1.getAutor());
System.out.println("\tVulnerabilidad: " + e1.getVulnerabilidad());
System.out.println("\tLenguaje: " + e1.getLenguaje());

System.out.println("\n\nInfo de e2\n");
System.out.println(e2.getInfoComun());
System.out.println("\nInfo de w1\n");
System.out.println("\tAutor: " + w1.getAutor());
System.out.println("\tVulnerabilidad: " + w1.getVulnerabilidad());
System.out.println("\tLenguaje: " + w1.getLenguaje());
System.out.println("\tCodigo MS: " + w1.getCodigoMS());

System.out.println("\n\nInfo de w2\n");
System.out.println(w2.getInfoWin());

int resultado = w2.setOffset("0x7517123c");

if (resultado == 0)
{
System.out.println("[!] La direccion offset se implemento con
exito\n");

}
else
{
System.out.println("[!] Error durante la implementacion de la
direccion offset\n");
}
}

EJEMPLO 2.
Operador instanceof

El operador instanceof sirve para consultar si un objeto es una instancia de una clase
determinada, o de su padre. Pareciera absurdo tratar de conocer cuál es la clase que
da lugar a una instancia específica, sin embargo es de mucha utilidad cuando se
trabaja con interfaces y herencia a la vez. Veamos un ejemplo:

public class primo {

private int numero;

private int vectorPrimos[];
private int tamañoV;
public primo(){
this.tamañoV=25;
this.vectorPrimos= new int [this.tamañoV];
this.numero=0;
}
}

public class Main {

public static void main(String[] args) {

primo p = new primo();

if (esPrimo(p)){
System.out.println("ES INSTANCIA DE PRIMO");
}
}
public static boolean esPrimo(primo p) {
return (p instanceof primo);
}
}

Lo que realiza este sencillo ejemplo es comprobar si la instancia llamada “p”

corresponde a la clase primo, definida anteriormente, con la ayuda del método
estático “esPrimo” que verifica con el operador instanceof si la instancia que se
traslada por el parámetro es de la clase que se evalúa. El resultado de dicha
operación es true o false.
EJEMPLO 3.
La superclase de dicha jerarquía podría ser muy parecida a ésta:

public abstract class figura {

protected String nombre;

protected int color;
protected int grosorBorde;

public String getNombre(){

return this.nombre;
}
public void setNombre(String n){
this.nombre=n;
}

public int getColor(){

return this.color;
}
public void setColor(int c){
this.color=c;
}

public int getGrosorBorde(){

return this.grosorBorde;
}

public void setGrosorBorde(int g){

this.grosorBorde=g;
}

public abstract void dibujar();

}

Las siguientes clases en el nivel de la jerarquía podrían quedar muy parecidas a

éstas:

public abstract class figura2D extends figura {

public abstract int calcularArea();

public abstract int calcularPerimetro();

}

public abstract class figura3D extends figura {

public abstract int calcularVolumen();

}

Se le pide que forme las clases de la parte inferior de la jerarquía y que

representarían los objetos a instanciarse.

Además, debe de realizar una implementación de esta librería, en donde el usuario

pueda crear nuevas figuras y que éstas se almacenen en un arreglo de figuras.
EJEMPLO 3.
Se le pide que forme las clases de la parte inferior de la jerarquía y que
representarían los objetos a instanciarse.
Además, debe de realizar una implementación de esta librería, en donde el usuario
pueda crear nuevas figuras y que éstas se almacenen en un arreglo de figuras. class
Empleado {
protected:
static const unsigned int SUELDO_BASE = 700; // Supuesto sueldo base para
todos

public:
 /* OTROS MÉTODOS */
virtual unsigned int sueldo() = 0;
};

class Director : public Empleado {

public:
/* OTROS MÉTODOS */
unsigned int sueldo() { return SUELDO_BASE*100; }
};

class Ventas : public Empleado {

private:
unsigned int ventas_realizadas; // Contador de ventas realizadas por el vendedor

public:
/* OTROS MÉTODOS */
unsigned int sueldo() { return SUELDO_BASE + ventas_realizadas*60; }
};

class Mantenimiento : public Empleado {

public:
/* OTROS MÉTODOS */
unsigned int sueldo() { return SUELDO_BASE + 300; }
};

class Becario : public Empleado {

private:
bool jornada_completa; // Indica si el becario trabaja a jornada completa

public:
/* OTROS MÉTODOS */
unsigned int sueldo() {
if (jornada_completa) return SUELDO_BASE/2;
else return SUELDO_BASE/4;
}
};

/* AHORA HAREMOS USO DE LAS CLASES */

int main() {
Empleado* e[4]; // Punteros a Empleado
Director d;
Ventas v; // Estas dos las declararemos como objetos normales en la pila
 e[0] = &d; // Asignamos a un puntero a Empleado la dirección de un objeto del tipo
Director
e[1] = &v; // Lo mismo con Ventas
e[2] = new Mantenimiento();
e[3] = new Becario();

unsigned int sueldo = 0;

for (int i = 0; i < 4; ++i) sueldo += e[i]->sueldo();

cout << "Este mes vamos a gastar " << sueldo << " dinero en sueldos" << endl;
}