miércoles, 8 de junio de 2016

IPFire (The Open Source Firewall Distribution), Untangle (Network Policy at Work) Firewalls Bloqueadores de contenido Open Source gratuitos

Hola que tal, si alguna vez has querido controlar el acceso a los usuarios a Internet de tu negocio/empresa, y pues como ya saben todos que el hardware cuesta algo caro y careces de recursos o tu jefe no quiere invertir en tecnología (Así como en todas las empresas) puedes optar por dos muy buenas opciones que te servirán muy bien sabiéndolas administrar de buena manera claro.
IPfire y Untangle, ambos OS basados en Linux son bastante poderosos y muy buenos, solo requieren de una PC con requerimientos mínimos, eso si pues que estén encendida 24/7 y dos tarjetas de red una para la WAN y otra para la LAN, también tiene la opción de hacer failover pero eso yo lo manejaría a nivel de router para un balanceo, si es que cuentan con dos proveedores ISP.
Hay muchos Firewalls y bloqueadores de contenidos, pero estos a mi me ha tocado manejar y me han resultado de mucha ayuda por si no quieres pagar una licencia de un software o router o comprar hardware.

Para descargar los ISO's:
1. IPFire su sitio web es: http://www.ipfire.org/
2. Untangle su sitio web es: https://www.untangle.com/

La configuración de ambas es fácil, debido a que tienen una interfaz bastante amigable al momento de instalar y de configurar, de hecho hay bastantes manuales en Internet de como hacerlo.

Imagenes de IPFire




Imagenes de Untangle


Cualquier duda no duden en escribirme, saludos y espero que les sirva de ayuda.



martes, 7 de junio de 2016

Seguridad de tu red, protección a sitio web, formas mas sencillas de descubrir vulnerabilidades con Linux (Kali), Hackear paginas, correos, facebook

Hola que tal, ya hace mucho que no escribo en el blog debido a que tengo nuevas ocupaciones y actividades que me mantienen bastante ocupado.
En el ámbito de la programación no he puesto nuevos posts debido a que en mi trabajo de hecho no me dedico principalmente a eso si no mas bien me enfoco a lo que es el soporte técnico, las redes y todo lo que conlleva a eso.
Es por eso que decidí crear este post para poder enseñarles un poco de experiencia en la que me he visto envuelto a lo largo de estos días.
Mucha gente me ha preguntado (Pedido en algunas ocasiones) en como poder hackear una cuenta de correo, facebook o poder manipular equipos remotamente, hasta también poder tumbar un sitio web.
Para empezar ninguna cosa es sencilla hacerla, de que se puede pues si se puede pero no te vas a encontrar una aplicación que con un simple clic haga toda la magia, para eso debes de saber utilizar herramientas y aparte en tener un poco de ingenio para poder utilizarlas, todo es un proceso que tienes que ser bastante paciente y como ya te mencione, echarle cabeza.
Cabe decir que esto no lo hago con el fin de que lo utilicen las cosas para mal, como dicen: El conocimiento es libre ya sabrán ustedes con que fin lo hacen.

1. Seguridad de tu red
Existen muchas herramientas en Linux para poder hacer una auditoria de tu propia red LAN y tu red WiFi pero las mas usuales, comunes y fáciles de utilizar son las siguientes:
- Wireshark

- Ettercap

Ambas herramientas son utilizadas para poder leer el trafico de paquetes que están viajando por tu red y poder filtrar el tipo de protocolo y peticiones de los usuarios de tu red, puedes interceptar las tramas y poder muchas veces identificar a que paginas web están pidiendo peticiones, también con los plugins puedes identificar si existe algún tipo de ataque a tu red, incluso identificar si existe un loop dentro de tu red o si existe alguna suplantación de identidad o un ataque MITM.
Son fáciles de usar, el Internet te puedes encontrar miles de tutoriales o manuales de como utilizarlos.

2. Protección a tu sitio web
Es muy probable que algunas veces te haya tocado desarrollar un sitio web o alguna aplicación que debe de estar alojado en un sitio web para poder brindarle un servicio ya sea a clientes a proveedores la cual detrás de la aplicación se compromete una base de datos con información muchas veces confidencial.
Existe una herramienta en Windows bastante poderosa y útil que a mi me ha servido bastante para poder escanear un sitio web o una aplicación, lo único malo es que es de paga. La aplicación se llama Acunetix Web Vulnerability Scanner, ahí búsquenla en Google.

Y como no esta de mas decir que también en Linux existen bastante herramientas pero una de las usadas por hackers son las siguientes
 - SQLMAP: Escanea las vulnerabilidades para poder inyectar código SQL, mas bien conocido como SQL Injection.

 - NMAP: Escanea los puertos del sitio web, es bien sabido que algunos puertos son vulnerables a ataques, solo hay que leer un poco de eso.

- JOOMSCAN: Escaner para encontrar vulnerabilidades en paginas web desarrolladas con Joomla

- WPSCAN: Escaner para encontrar vulnerabilidades en paginas web desarrolladas con WordPress.

Estas dos ultimas herramientas encuentran los errores o vulnerabilidades de las versiones con las que están hechas y también las de su plugin para poder hacer ataques mitm, xss e injections.


3. Hackear correos (Cuentas facebook)
Un tema bastante complicado pero tampoco fuera del alcance, aquí en esto mas que nada aparte de utilizar técnicas y/o herramientas debes de tener un poco de ingenio, la ingeniería social entra en este ámbito, solo les daré unos tips mas comunes, rápidos y efectivos.
 Paso 1: Crea tu pagina clon (hotmail, facebook, gmail, etc...) de la cuenta que quieras hackear (Por supuesto que tienes que crear tus archivos php para poder cachar y guardar) (Leer en google sobre esto).
 Paso 2: Levanta tu servidor apache y aloja tu pagina clon
 Paso 3: Crea tu dns en servidores de redireccionamiento gratuito (ej. no-ip) y redirecciona tu IP publica en este caso a tu maquina que actua como servidor Apache, o si no lo otro que puedes hacer es alojar tu pagina clon en un hosting gratuito (Pero no lo recomiendo por la publicidad y por la ejecución de ciertos códigos php)
Paso 4: Levantar su servidor de correos falsos o enmascarar una dirección para poder enviar un correo a la victima para que no caiga en SPAM el correo y vaya directamente a la bandeja de entrada (Es claro que deben de saber que como información del correo deben de ponerle al usuario que su cuenta ha expirado que necesita cambiar su contraseña o algo ingenioso que se les ocurra).
Paso 5: Esperar que la victima entre a su pagina clon falsa y registre sus datos.
Este es solo un ejemplo de los muchos que se pueden hacer, si están dentro de una red interna y hay usuarios, o por ejemplo en un Cyber pues simplemente hagan un redirecionamiento con un DNS Spoofing modificando su archivo de hosts por supuesto a su servidor y esperar a que solos entren (De esto también hay mucho material por Internet)
Todo es cuestión de lectura, todo esta en Internet es solo cuestión de leer y aprender.

Nos vemos pronto saludos, cualquier duda escribanla y les responderé con gusto.




jueves, 11 de febrero de 2016

Obtener datos e información de la computadora y exportarla a un archivo de texto o word desde C# .net versión 2012

Que tal colegas, hace bastante tiempo que no publicaba nada y solo me había dedicado a resolver dudas que me han comentando aquí en el blog y han sido resueltas, aparte de que también me he dedicado a otras cosas como lo que es la instalación de redes, equipos cctv, soporte técnico especializado y cosas de ese estilo.
Se me presento en el trabajo una situación la cual puede que a ustedes les haya pasado algo similar, es algo sencillo pero es muy útil la verdad.
El caso es que este pequeño programa su finalidad es que obtiene la información de tu computadora que es el la marca del fabricante, el modelo de la maquina, la versión del sistema operativo instalada y su arquitectura, las memorias ram instaladas, el procesador, los discos duros instalados, las impresoras instaladas ya sea por red o por USB.

Bueno para empezar lo primero que hice es hacer un proyecto de Windows form el cual contiene
2 cajas de texto, 1 label, 1 groupbox, 3 picturebox y un boton para exportar la información a un archivo ya sea de texto o de word, y lo puse de la siguiente manera:


Y sencillamente todo lo programe dentro de la misma clase de la forma, no hay necesidad de hacer capas ni nada puesto que no utiliza puesto que no utilice recursos de bases de datos ni nada especial.

Al objeto label le nombre lblInfo a la caja de texto del procesador le nombre txtProcesador y a la de la memoria ram txtMemoria, aclaro que las cajas de texto deben de ser multilinea para que puedan expandirlas.

En el proyecto al principio de la programación de las lineas yo inicie una instancia para mas adelante poder utilizarla y exportar/escribir en un archivo de texto o de word toda la información que hayan leído o cachado los métodos programados, es sencilla la linea es:

System.IO.StreamWriter file = new System.IO.StreamWriter("c:\\InfoPC.doc")

Y para que no batallen les pondre todo el codigo que debe de llevar dentro de la clase la cual los métodos los puse en Ingles y les explicare un poco de lo que hace cada cosa:

Método para obtener información acerca de los discos duros instalados:

        private string getDrives()
        {
            StringBuilder StringBuilder1 = new StringBuilder(string.Empty);
            foreach (System.IO.DriveInfo DriveInfo1 in System.IO.DriveInfo.GetDrives())
            {
                try
                {
                    if (DriveInfo1.DriveType.ToString() != "Network")
                    {
                        StringBuilder1.AppendFormat("\t Drive: {0}\r\n\t\t VolumeLabel: " +
                          "{1}\r\n\t\t DriveType: {2}\r\n\t\t DriveFormat: {3}\r\n\t\t " +
                          "TotalSize: {4}\r\n\t\t AvailableFreeSpace: {5}",
                          DriveInfo1.Name, DriveInfo1.VolumeLabel, DriveInfo1.DriveType,
                          DriveInfo1.DriveFormat, DriveInfo1.TotalSize, DriveInfo1.AvailableFreeSpace);
                    }
                }
                catch
                {
                    //
                }
            }
            return StringBuilder1.ToString();
        }

Método para obtener la información del sistema operativo instalado

        private string getOSInfo()
        {
            OperatingSystem os = Environment.OSVersion;
            Version vs = os.Version;
            string operatingSystem = "";

            if (os.Platform == PlatformID.Win32Windows)
            {
                switch (vs.Minor)
                {
                    case 0:
                        operatingSystem = "95";
                        break;
                    case 10:
                        if (vs.Revision.ToString() == "2222A")
                            operatingSystem = "98SE";
                        else
                            operatingSystem = "98";
                        break;
                    case 90:
                        operatingSystem = "Me";
                        break;
                    default:
                        break;
                }
            }
            else if (os.Platform == PlatformID.Win32NT)
            {
                switch (vs.Major)
                {
                    case 3:
                        operatingSystem = "NT 3.51";
                        break;
                    case 4:
                        operatingSystem = "NT 4.0";
                        break;
                    case 5:
                        if (vs.Minor == 0)
                            operatingSystem = "2000";
                        else
                            operatingSystem = "XP";
                        break;
                    case 6:
                        if (vs.Minor == 0)
                            operatingSystem = "Vista";
                        else
                            operatingSystem = "7";
                        break;
                    default:
                        break;
                }
            }
            if (operatingSystem != "")
            {
                operatingSystem = "Windows " + operatingSystem;
                if (os.ServicePack != "")
                {
                    operatingSystem += " " + os.ServicePack;
                }
            }
            return operatingSystem;
        }


Método para obtener la información del fabricante

        private string getManufacturer()
        {
            string manufacturer = null;
            ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
            ManagementObjectCollection moc = mc.GetInstances();
            if (moc.Count != 0)
            {
                foreach (ManagementObject mo in mc.GetInstances())
                {
                    manufacturer = (mo["Manufacturer"].ToString());
                }
            }
            return manufacturer;
        }

Método para obtener la información del modelo del fabricante

        private string getModel()
        {
            string model = null;
            ManagementClass mc = new ManagementClass("Win32_ComputerSystem");
            ManagementObjectCollection moc = mc.GetInstances();
            if (moc.Count != 0)
            {
                foreach (ManagementObject mo in mc.GetInstances())
                {
                    model = (mo["Model"].ToString());
                }
            }
            return model;
        }

Método para obtener el tipo de computadora (Laptop o Escritorio)

        private string getTipo()
        {
            PowerStatus powerStatus = System.Windows.Forms.SystemInformation.PowerStatus;
            if (powerStatus.BatteryChargeStatus != BatteryChargeStatus.NoSystemBattery)
            {
                return "Portatil";
            }
            else
                return "Escritorio";
        }

Método para obtener el modelo del monitor instalado

        private string getMonitor()
        {
            Screen[] monitors = Screen.AllScreens;

            string monitor = null;
            try
            {
                ManagementObjectSearcher searcher =
                    new ManagementObjectSearcher("root\\CIMV2",
                    "SELECT * FROM Win32_DesktopMonitor");

                foreach (ManagementObject queryObj in searcher.Get())
                { 
                    monitor = (queryObj["Description"]).ToString();
                }
            }
            catch (ManagementException e)
            {
                MessageBox.Show("An error occurred while querying for WMI data: " + e.Message);
            }

            return monitor;
        }

Metodo para obtener las impresoras instaladas

        private string getPrinters()
        {
            StringBuilder StringBuilder1 = new StringBuilder(string.Empty);
            var printerQuery = new ManagementObjectSearcher("SELECT * from Win32_Printer");
            foreach (var printer in printerQuery.Get())
            {
                var name = printer.GetPropertyValue("Name");
                var port = printer.GetPropertyValue("PortName");
                var isDefault = printer.GetPropertyValue("Default");
                var isNetworkPrinter = printer.GetPropertyValue("Network");

                if (port.Equals("USB001"))
                {
                    StringBuilder1.AppendFormat("\t\r\nConectada por USB: " + name.ToString());
                }
                else
                {
                    if (isDefault.Equals(true))
                    {
                        StringBuilder1.AppendFormat("\t\r\nPredeterminada: " + name.ToString());
                        StringBuilder1.AppendFormat("\t\r\nPuerto impresora: " + port.ToString());
                    }
                }
            }
            return StringBuilder1.ToString();
        }

Enseguida los dos métodos que pondré son algo específicos y son los que tienen un poco mas de cuidado al utilizarlos, es donde podrían tener errores pero nada graves de que preocuparse

Este método lo que hace es obtener toda la información del dispositivo según la librería que se le pida, pero te obtiene todo en general nada en especifico y con ese método vamos a jugar con varias cosas:

        private string DeviceInformation(string stringIn)
        {
            StringBuilder StringBuilder1 = new StringBuilder(string.Empty);
            ManagementClass ManagementClass1 = new ManagementClass(stringIn);
            ManagementObjectCollection ManagemenobjCol = ManagementClass1.GetInstances();
            PropertyDataCollection properties = ManagementClass1.Properties;
            foreach (ManagementObject obj in ManagemenobjCol)
            {
                foreach (PropertyData property in properties)
                {
                    try
                    {
                        StringBuilder1.AppendLine(property.Name + ":  " +
                          obj.Properties[property.Name].Value.ToString());
                    }
                    catch
                    {
                        //
                    }
                }
                StringBuilder1.AppendLine();
            }
            file.WriteLine(StringBuilder1);
            return StringBuilder1.ToString();
        }

Y en el siguiente método es donde vamos a hacer uso de TODOS los métodos anteriores

        private string SystemInformation()
        {
            StringBuilder StringBuilder1 = new StringBuilder(string.Empty);
            try
            {
                StringBuilder1.AppendFormat("Operation System:  {0}\r\n", getOSInfo());
                if (Environment.Is64BitOperatingSystem)
                    StringBuilder1.AppendFormat("\t\t  64 Bit Operating System\r\n");
                else
                    StringBuilder1.AppendFormat("\t\t  32 Bit Operating System\r\n");
                    StringBuilder1.AppendFormat("SystemDirectory:  {0}\r\n", Environment.SystemDirectory);
                    StringBuilder1.AppendFormat("ProcessorCount:  {0}\r\n", Environment.ProcessorCount);
                    StringBuilder1.AppendFormat("UserDomainName:  {0}\r\n", Environment.UserDomainName);
                    StringBuilder1.AppendFormat("UserName: {0}\r\n", Environment.UserName);
                    StringBuilder1.AppendFormat("Fabricante: {0}\r\n", getManufacturer());
                    StringBuilder1.AppendFormat("Modelo: {0}\r\n", getModel());
                    StringBuilder1.AppendFormat("Tipo: {0}\r\n", getTipo());
                    StringBuilder1.AppendFormat("Monitor: {0}\r\n", getMonitor());
                    StringBuilder1.AppendFormat("Impresoras: {0}\r\n", getPrinters());
                    StringBuilder1.AppendFormat("LogicalDrives: {0}\r\n", getDrives());
                    StringBuilder1.AppendFormat("SystemPageSize:  {0}\r\n", Environment.SystemPageSize);
                    StringBuilder1.AppendFormat("Version:  {0}\r\n", Environment.Version);
            }
            catch
            {
                //
            }
            file.WriteLine(StringBuilder1);
            return StringBuilder1.ToString();
        }


Bueno ya teniendo todos los métodos dentro de la misma clase, lo que hice fue poner dentro de el metodo onload de la forma principal lo siguiente:

           lblInfo.Text = SystemInformation();
            txtProcesador.Text = DeviceInformation("Win32_Processor");
            txtMemoria.Text = DeviceInformation("Win32_PhysicalMemory");

Que lo que hago sencillamente es llamar a los métodos creados para que al momento de abrir la forma se ejecuten automáticamente y me las muestre en cada caja objeto correspondido en la forma.

En el evento onclic del boton lo que hago es lo siguiente

            file.Close();
            MessageBox.Show("Archivo InfoPC.doccreado en la unidad C: a continuacion se abrira el explorador");
            System.Diagnostics.Process.Start(@"C:\");

Que básicamente es cerrar y crear el filestream para que me cree el archivo y me abra la ventana de C que es donde le estoy dando la ubicación del guardado.

De todos modos les subiré el proyecto ya compilado para que lo tengan.

Saludos!

Ing. Misael Ontiveros Rodriguez