Tecnológico de Estudios Superiores de San Felipe del Progreso

Tecnológico de Estudios Superiores de San Felipe del Progreso
Ingeniería en informática
Reporte de prácticas
Alumnos:
María Victoria Quintana Lorenzo
Erick Segundo Rojas
José Félix García Quintana
Javier López Sánchez
Docente: Ing. Héctor Caballero Hernández
Asignatura: Seguridad Informática
Grupo: 501
Septiembre de 2013
Seguridad Informática
Contenido
Introducción ....................................................................................................................................... 3
Desarrollo........................................................................................................................................... 4
Diseño y funcionalidad de formularios ...................................................................................... 5
Programación ................................................................................................................................ 8
Conclusiones ................................................................................................................................... 14
Referencias ..................................................................................................................................... 14
2
Seguridad Informática
Introducción
En ocasiones cuando hacemos uso de un servicio como email, cuentas en sitios,
etc. o simplemente cuando accedamos a la cuenta de nuestro sistema operativo
nos piden como regla algún nombre y una contraseña.
Esto se debe a que nadie deberá acceder a lo antes mencionado más que
nosotros mismos, si bien es cierto nuestro nombre de usuario se puede ver, esto
no quiere decir que la contraseña que tecleamos será vista, pues de serlo así, que
seguridad tendremos. Cualquier persona que esté cerca de nosotros vera tal cual
los datos que introducimos.
Claro que si somos lentos para teclear una contraseña, entonces cualquier
persona sabrá lo que introducimos, y en estos casos no se puede proteger más.
Pues bien en esta práctica desarrollaremos un pequeño programa en el cual nos
permitirá almacenar usuarios con sus respectivas contraseñas, igualmente
aplicaremos algunas validaciones, posteriormente también podremos simular que
si teclean su login correcto podemos acceder su cuenta.
Cabe mencionar que se usaran como herramienta de desarrollo el NetBeans IDE
7, y usaremos un gestor de base de datos como el Access.
3
Seguridad Informática
Desarrollo
Para esta práctica se usaron dos tecnologías, la de programación que es
NetBeans IDE 7.0 y un gestor de base de datos que es Microsoft Access.
Para ello los pasos que realizamos fueron los siguientes:
1. Creamos una base de datos en Access con el nombre BaseDatos1.mdb,
dentro de esta hay una tabla llamada Usuario, con campos User y
Password. Una vez hecho eso cerramos la base de datos
2. Posteriormente en NetBeans 7.0 crearemos un nuevo proyecto Java de tipo
escritorio. Con el nombre que deseemos, en nuestro caso se llama Inicio
4
Seguridad Informática
3. Una vez creado nuestro proyecto, agregaremos más formularios para ello
damos clic derecho sobre nuestro proyecto, elegimos New, y finalmente en
JFrame Form. Le damos un nombre en nuestro caso es Elección
Una vez hecho eso agregaremos otros dos JFrame Form repitiendo el paso
anterior. Al final deberemos tener 4 formularios vacíos con sus respectivos
nombres
Diseño y funcionalidad de formularios
Ahora diseñaremos la interfaz de nuestros formularios, solo es cuestión de
creatividad.
Formulario Elección
Este formulario tendrá la función de tener un menú, donde podemos elegir lo
que deseamos hacer.
En este caso los botones que se presentan tienen cierta funcionalidad
5
Seguridad Informática
btnIngresarE (Ingresar): Permite ingresar al formulario Ingreso.
btnNuevoE (Nuevo): Permite ingresar al formulario Nuevo.
btnSalir (Salir): Permite salir completamente del programa.
Formulario Ingreso.
Permite ingresar a otro acceso si es que el usuario y contraseña son correctos,
claro que desde luego los datos ya deben estar alojados en nuestra base de
datos.
Para ello una vez tenido rellenado la caja del Login, y la contraseña los
botones tienen la siguiente funcionalidad:
btnAceptar (Aceptar): Si verifica que los datos introducidos son correctos,
permite desplegar el formulario Bienvenido, de lo contrario mandara un
mensaje de error en lo que se introdujo.
btnCancelar (Cancelar): En es te caso cancela lo que se pretendía hacer, y
sale del formulario e inicia otra vez con el formulario Elección,
Formulario Nuevo
Este formulario permite guardar los datos del usuario a nuestra base de datos,
igualmente en este se valida todo lo que se introduzca.
6
Seguridad Informática
Los botones tienen la siguiente funcionalidad:
btnGuardarU (Guardar): Una vez verificado que estén rellenados los campos,
comienza a comparar lo que se introdujo con los datos de nuestra base de
datos, y si son verídicos mostrara un mensaje de éxito , saldrá de ese
formulario e ira al formulario Elección, en caso contrario mandara un mensaje
de llenar los campos correspondientes, o en otro caso ingresar el tamaño
mínimo y máximo de la contraseña requerida.
btnCancelarU (Cancelar): abandona este formulario y se dirige al formulario
Elección.
Formulario Bienvenido
Su función solo es mostrar algo al usuario que tecleo bien sus datos, en este
caso un mensaje de Bienvenido
En este caso el botón de cerrar cesión lo único que hace es volver al menú
principal es decir al formulario Elección
7
Seguridad Informática
Pues bien hemos definido la interfaz de nuestros formularios y el respectivo
funcionamiento general de nuestro programa, ahora toca la parte de
programación, para ello empezaremos desde lo más básico a lo más complejo
Programación
1. Empezaremos por el formulario que menos código lleva, que es Elección
donde tiene tres botones básicos.
Código ingresar
private void btnIngresarEMouseClicked(java.awt.event.MouseEvent evt) {
Ingreso Val = new Ingreso();//Creamos un objeto para poder ver el formulario Ingreso
Val.setVisible(true);//Hacemos que aparezca el formulario Ingreso
this.dispose();// Cerramos el formulario Eleccion
}
Código Nuevo
private void btnNuevoEMouseClicked(java.awt.event.MouseEvent evt) {
Nuevo Ingreso=new Nuevo();//Creamos un objeto para poder ver el formulario Nuevo
Ingreso.setVisible(true);//Hacemos que aparezca el formulario Nuevo
this.dispose();// Cerramos el formulario Eleccion
}
Código Salir
private void btnSalirMouseClicked(java.awt.event.MouseEvent evt) {
System.exit(0);//Salimos totalmente del programa
}
2. Una vez hecho eso pasamos con otro formulario como el de Bienvenido
que únicamente tiene un botón
Código Cerrar Sesion
private void btncerrarMouseClicked(java.awt.event.MouseEvent evt) {
this.dispose();//Cerramos el formulario de Bienvenido
Eleccion ver =new Eleccion();//Creamos un objeto del formulario Eleccion
ver.setVisible(true);//Visualizamos el formulario Elccion quien es el e principal
}
Hemos programado algo básico, que lo único que hacemos es mostrar a los
formularios y cosas por el estilo
Para entender cómo funciona NetBeans con una base de datos, para ello
necesitamos del siguiente diagrama:
8
Seguridad Informática
Donde necesitamos de un driver para establecer la conexión con el gestor de base
de datos, en nuestro caso usaremos Access, una vez hecha la conexión podemos
aplicar los comandos SQL ya sea para insertar, eliminar, actualizar datos y poder
hacer consultas.
1. Crearemos una nueva clase en nuestro programa llamada Conexión, para
ello damos clic derecho sobre nuestro proyecto, en New y finalmente Java
Class y le damos el nombre
2. Comenzamos a escribir el siguiente código
package inicio;
import java.sql.*;//Importamos esta libreria para nuestros comandos SQL
import javax.swing.*;//Importamos esta libreria para el uso de mensajes de dialogo
public class Conexion {
String CadenaConexion;//Variable para la cadena de conexion
Connection conectar=null;
ResultSet rs =null;
PreparedStatement pst =null;
public Connection ConexionBD ()
{
9
Seguridad Informática
try{//Generamos una excepcion por si la conexion falla
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");//Creamos nuestro driver para access
CadenaConexion="jdbc:odbc:Driver=Microsoft Access Driver" + " (*.mdb);
DBQ=H:/BaseDatos1.mdb";//Nuestra cadena de conexion
conectar=DriverManager.getConnection(CadenaConexion,"","");//Ejecutamos la conexion a la base
}
catch (Exception e)
{
JOptionPane.showMessageDialog(null, "Base de datos no encontrada");
}
return conectar;//Regresamos la ejecucion de la conexion si fue realizada
}
}
Ahora que hemos creado nuestra conexión estamos dispuestos a verificar a un
usuario o a guardar un nuevo usuario
3. Creamos otra clase llamada GuardarUsuario y escribimos el siguiente
código
package inicio;
import java.sql.*;//Importamos esta libreria para nuestros comandos SQL
import javax.swing.*;//Importamos esta libreria para el uso de mensajes de dialogo
public class GuardarUsuario
{
Conexion Conectar=new Conexion();//Este es un objeto para establecer la conexion
Connection conexio=null;
Statement st=null;
ResultSet rst=null;
String Guardar;
public void Guardar(String tabla,String campo, String valores)//Creamos un metodo que recibe valores
{//Estos valores los vamos a obtener de lo que se ingrese en el Formulario Nuevo
try {
//Almacenamos en la tabla correspondiente, nos dirijimos a los campos y posicionamos los datos
Guardar="INSERT INTO "+tabla+" ("+campo+") values ("+valores+")";
conexio=Conectar.ConexionBD();//Ejecutamos la coneccion a nuestra ruta de nuestra base para
guardar
st=conexio.createStatement();
st.executeUpdate(Guardar);//Actualizamos el estado de la tabla
JOptionPane.showMessageDialog(null, "Usuarios y Contraseña guardados");
} catch (SQLException ex) {
JOptionPane.showMessageDialog(null, "La tabla no fue hallada");
}
}
10
Seguridad Informática
}
4. Ahora en nuestro formulario nuevo escribimos lo siguiente
private void btnCancelarUMouseClicked(java.awt.event.MouseEvent evt) {
this.dispose();
Eleccion Abrir=new Eleccion();
Abrir.setVisible(true);
}
private void btnAceptarUMouseClicked(java.awt.event.MouseEvent evt) {
if(txtLogin.getText().equals("") || (Pass.getText().equals("")))//Verificamos si alguno o los dos
controles estan vacios
{
JOptionPane.showMessageDialog(null,"Rellena los campos correspondientes");//Si es asi
mostramos este mensaje
}
else{//Si eso no ocurrio entonces verificamos el tamaño de la contraseña introducida
if(Pass.getText().length()>=10 & Pass.getText().length()<=16)//Si la contraseña esta en un
segmento de 10 a 16 caracteres
{
String VUser,VPass,campos,valores;//Declaramos variables de tipo cadena
VUser=this.txtLogin.getText();//Donde esta sera igual a lo que tenga nuestra caja de texto llamada
txtLogin
VPass=this.Pass.getText();//Esta variable sera igual a lo que tenga nuestro passworfield llamado
Pass
campos="User,Password";//contendra los campos en los que almacenaremos los datos deben
coincidir con los campos de nuestra tabla
valores="'"+VUser+"','"+VPass+"'";
GuardarUsuario Nuevo=new GuardarUsuario();//Creamos un objeto de nuestra clase
GuardarUsuario
Nuevo.Guardar("Usuario", campos, valores);//Pasamos los valores Tabla, campos, valores
JOptionPane.showMessageDialog(null, "Uusuario y Contraseña guardados");//Mostramos un
mensaje de exito
this.dispose();//Cerramos el formulario Nuevo
Eleccion otraves=new Eleccion();//Creamos un objeto para poder usar el formulario Eleccion
otraves.setVisible(true);//Visualizamos el formulario Eleccion
}
else// si la contraseña no esta en el intervalo de carcateres susgeridos
{
//mostramos este mensaje
JOptionPane.showMessageDialog(null,"Ingresa Contraseña en un limite de 10 a 16 caracteres");
// y borramos los cotroles
Pass.setText("");
11
Seguridad Informática
}
}
}
5. Ahora creeremos otra clase, llama VerificarUsuario, este nos servirá para
poder comprobar si los datos introducidos son verdaderos, escribimos el
siguiente.
package inicio;
import java.sql.*;//Importamos esta libreria para nuestros comandos SQL
import javax.swing.*;
public class VerificarUsuario
{
Conexion Conectar=new Conexion();//Creamos un objeto para hacer posible la conexion
Connection conex=null;
Statement st=null;
ResultSet rst=null;
String Consulta; // Creamos una Variable para ejecutar la consulta
public boolean verificar(String Usuario, String Contraseña)
{
int bandera=0;
Consulta="SELECT
*
FROM
Usuario
WHERE
Password='"+Contraseña+"'";
try
{
conex=Conectar.ConexionBD();
st=conex.createStatement();
rst=st.executeQuery(Consulta);
User='"+Usuario+"'
and
while(rst.next())
{
if(rst.getString(1)==null)
bandera=0;
else
bandera=1;
}
}
catch(Exception e)
{
JOptionPane.showMessageDialog(null, "No se pudo actualizar");
}
if(bandera==1)
return true;
12
Seguridad Informática
else
return false;
}
}
6. Ahora en nuestro formulario tecleamos el siguiente código, para los botones
que se tienen
private void btnAceptarMouseClicked(java.awt.event.MouseEvent evt) {
if(txtUsuario.getText().equals("") || (Contraseña.getText().equals("")))
{
JOptionPane.showMessageDialog(null,"Rellena los campos correspondientes");
txtUsuario.setText("");
Contraseña.setText("");
}
else{
VerificarUsuario ver=new VerificarUsuario();
if(ver.verificar(this.txtUsuario.getText(),this.Contraseña.getText()))
{
this.dispose();
Bienvenido Abrir2=new Bienvenido();
Abrir2.setVisible(true);
}
else
{
JOptionPane.showMessageDialog(null, "Usuario y/o Contraseña Incorrectos");
txtUsuario.setText("");
Contraseña.setText("");
}
}
}
private void btnCancelarMouseClicked(java.awt.event.MouseEvent evt) {
this.dispose();
Eleccion Abrir= new Eleccion();
Abrir.setVisible(true);
}
Finalmente eso sería todo y funcionaria correctamente nuestro pequeño programa
13
Seguridad Informática
Conclusiones
Hemos aprendido que la seguridad es demasiada importante, si bien es cierto este
pequeños programa solo es complemento de ello, hay varias técnicas de proteger
una contraseña, donde los niveles de seguridad son más complejos.
El robo de contraseñas, es algo que desde años se viene presentando debido a la
vulnerabilidad de servidores, es por ello que principalmente en el desarrollo web la
seguridad es tan importante, pues como sabemos hoy en día la mayoría de la
información viaja a través de la web depende que no haya ataques y robo de
información.
Para finalizar nos damos cuenta que proteger información es muy complejo, pues
es como decirle a los hackers que aquí estamos, debido a que ellos son expertos
podemos sufrir cualquier ataque, y para evitar ello debemos aprender hacking
ético.
Referencias
Fundamentos de bases de datos, 4ta edición Abraham Silberschatz
http://lefunes_wordpress_com-2008-02-11-centrar-un-jframejdialog-en
pantalla.html
http://ingenieriadesistemas_wordpress_com-java-obtener-texto-no-encriptado-deun-jpasswordfield.htm
14