Nueva sección - Programan_DoH

Buenas!

Aquí os traigo una nueva sección... ¿Estáis preparados?

Mundo exterior - Matemáticas: Tema III (Integrales dobles - Cambio de variables doble, polares, ejemplos)

Buenas!

Acabamos ya el tema 3, integrales dobles.

En cuanto acabe esta entrada tocará más teoría de Remote Tools, aunque estoy pensando en hacer algún cambio.

Esto es porque hacer blog matemático me ayuda un poco con los estudios, y a la vez avanzo la materia...

Si al final de la entrada anterior vimos cambios de variables, en esta vamos a ver cambios de variables dobles.

Mundo exterior - Matemáticas: Tema III (Integrales dobles - Invertir integral, cambio de variable)

Buenas!

Esta vez ha pasado menos tiempo entre actualizaciones, ¿eh? :-)

Pues estaba estudiando F1V (Funciones de una variable) para mi próximo examen y he pensado... "un poco de blog sería una buena manera de estudiar :^p

Así que, entre estudio y estudio, vamos a ver cómo "invertir" una integral. Es decir, cómo intercambiar los valores de referencia (recordad que la integral interior era en función de la exterior).

¡Vamos allá!

Mundo exterior - Matemáticas: Tema III (Integrales dobles - Cálculo de áreas)

Buenas!

Seguimos "al máximo" con las matemáticas (chiste de funciones MUY MALO, jejeje).

Comentaros que sigo estudiando matemáticas en la UNED (grado de matemáticas), y que, por tanto, en cuanto pueda volcaré mi conocimiento para que aquellos que quieran (y lo necesiten) puedan obtenerlo :-)

¡Más cosas!

Ya tengo preparado mi regalo de navidad... una Raspberry Pi, la cuál será sometida a un proceso de DIY, que documentaré en el blog de Cosplay & DIY (cosplayco), dejando la parte técnica aquí (escepticismoilustrado).

Recordaros también que estoy adelantando una sección de programación en YouTube (¡próximamente dejo links!)

Y, bueno, ahora sí, a lo que vamos...

Break tecnológico

Buenas,

Algunos no lo sabéis, pero el día 25 de Noviembre es mi cumpleaños...

¡Y me han hecho muchos regalos!

Rearranque

Buenas!

Parece que las cosas vuelven a calmarse un poco, y a partir de ahora volveré a tener un poco de tiempo para el blog...

Han ido pasando varias cosas por aquí...

¡Pero eso es otra historia!

Lo que ahora importa es que vuelven las matemáticas, las aventuras, la programación...

y de nuevo los "¡Hasta la próxima!"

:-)

Break

Hola,

Hace un año (largo) que arrancó el blog...

Espero poder seguir con él durante bastante tiempo más... no obstante me veo obligado a hacer un "break" muy largo.

¡Hasta la próxima!

Mundo exterior - Matemáticas: Tema III (Integrales dobles - Introducción)

Buenas!

Siguen los movimientos continuados en la vida... nuestro canal de YouTube va viento en popa (en breve dejaré un enlace permanente en la zona de secciones.

Y bien, mueve moviendo ya casi tengo mi certificado en ISPA (3 meses ya...), y en breve empiezo el grado de matemáticas en la UNED...

Y hablando de matemáticas, estas cinco entradas irán dedicadas al tercer tema de matemáticas de nuestro curso universitario ;-), concretamente, trataremos integrales dobles (tienen mucha fibra, aunque las integrales triples tienen mas :^P)

Remote Tools (V): Teoría de programación - Nmap

Buenas!

¡Que ajetreo de vida!

Tengo un montón de frentes abiertos, y a veces no doy abasto...

Bueno, la entrada de hoy es acerca de Nmap y cómo usarlo en una línea de comandos (y, por ende, comunicarnos a través de programas.).

Veamos un pequeño índice:

1. nmap
1. ¿Qué es?
2. ¿Para qué sirve?
3. Teoría
1. Línea de comandos
2. Comunicación

Remote Tools: Teoría de programación (IV) - FTP con VB.net

Buenas!

Lo prometido es deuda, así que vamos a ver (más bien a repasar) el tema de FTP.

Tengo varias cosas que contar antes de empezar (como de costumbre)...

Estoy preparando mucho (MUCHO) material nuevo para el blog, solo necesito tiempo para estructurarlo... será un curso entero, también (no tan extenso como el de matemáticas, pero tendrá "chicha").

¡¡Ya hemos lanzado nuestro canal de YouTube!! Aquí podéis encontrarlo. Podréis ver cómo DoH (yo), Meryhell (co-propietaria de Cosplay & Co, junto a mi), y James_Strange jugamos a nuestros juegos favoritos... a veces logran sacarnos de quicio (literalmente), jejeje :-)

Interludio

Buenas!

Como es costumbre ya, sigo saturado y hasta arriba de cosas...

No obstante, sigo acordándome del blog, jejeje.

Durante la semana que viene espero poder tener la próxima entrada (Repaso de FTP con VB.net). Así, faltaría una última entrada (todo el tema de nMap), y volveríamos a las matemáticas...

Aunque no avanza todo al ritmo que me gustaría, me alegra ver cómo los proyectos poco a poco van avanzando...

A parte de esto, comunicar dos cosas:

a) ¡Estrenamos canal de Youtube!

Eso es, estamos en pleno proceso de creación de material... nuestro canal se dedicará (principalmente) a hacer gameplays de juegos que nos gustan (somo tres integrantes en el canal). Esto quiere decir que es muy probable que no sean juegos mainstream, o simplemente modernos.

b) Seré desarrollador de Google

La semana que viene me apunto al plan de desarrolladores de Google, y en breve (eso espero, ya que le dedico mucho tiempo) lanzaré mi primera app, basada en una web que estoy desarrollando (la inauguración oficial es el 1 de agosto de 2013).

En fin, esto es todo... espero poder escribir más a menudo.

Como siempre,
¡Hasta la próxima!

Remote Tools: Teoría de programación (III) - Procesos en VB.net

Buenas!

Estos días estoy hasta arriba, así que no podré actualizar el blog tanto como quisiera...

¡Eso no significa que no me acuerde de vosotros! :-P

Sigo aprendiendo cosas nuevas para poder compartirlas en este espacio (aunque, como digo, no tengo demasiado tiempo...)

En fin, vamos a lo que nos concierne: procesos con VB.net.

Remote Tools: Teoría de programación (II) - Ficheros dinámicos en COBOL

Buenas!

Ha sido una temporada sin escribir... igual hasta os he preocupado jajajaja :-P

La verdad es que últimamente no paro... y en fin, dentro de unos meses acabo la teoría de mi certificación en ISPA, y a la vez empiezo el grado en matemáticas; las cosas van avanzando un poco a mi favor :-)

Bueno, dejemos ya el intermedio de mi vida privada, jejeje.

Esta entrada tratará una situación que alguna vez habrá pasado por la cabeza de los "Coboleros".

¿Cómo hago si tengo que acceder a varios archivos a la vez en COBOL?

Remote Tools: Teoría de programación (I) - Arreglos en COBOL

Buenas!

Se acaban mis vacaciones, pero quedo con la buena sensación de haber descansado y poner ciertas cosas en su sitio...

Los dos próximos meses serán un no parar, así que es posible que esté más ausente que nunca (sobretodo en julio). Es posible que algunos meses también esté "a half" por temas personales.

Pero bueno, uno hace lo que puede, ¿no? y mientras encuentre una hora libre al día podré dedicarme a escribir y plasmar mis conocimientos, que es a lo que venimos aquí :-)

Y bien, en esta entrada nos metemos en la segunda parte de Remote Tools, la herramienta para smartphone que iré desarrollando como método de aprendizaje y como entretenimiento...

Esta parte, al igual que el segundo tema de matemáticas, constará de cinco partes. Vamos a ver el índice y cómo lo estructuraremos.

Mundo exterior - Matemáticas: Tema II (Tabla de derivadas)

Buenas!

Dejo, como anexo, una serie de derivadas que podéis usar cuando os sirvan (nunca está de más...)

Mundo exterior - Matemáticas: Tema II (fuciones de varias variables - ejemplos generales)

Buenas!

Ha sido tiempo sin escribir (creo)... como siempre, ando de culo!

En fin, se acerca el final de este segundo tema, con lo que se acerca también el inicio de la siguiente fase de la aplicación Remote Tools.

En esta entrada veremos varios ejemplos, que servirán para afianzar y repasar conceptos vistos con anterioridad.

Mundo exterior - Matemáticas: Tema II (derivadas segundas)

Buenas!

Llevaba algún tiempo sin escribir... y es que vuelvo a andar liado y hasta arriba!

La parte positiva es que me siento inusualmente activo... jejeje. Por otra parte, queda poco para acabar este tema matemático y volver a saco con COBOL.

En mis ratos libres hago mis pequeñas investigaciones con COBOL para adaptar los requerimientos de la app... también he tenido (recientemente) una revelación: ¿se podría, de alguna manera, tratar un sudoku como una matriz - o conjunto de ellas? en ello estoy, también.

En fin, dejémonos de divagaciones y vamos a las matemáticas.

Esta entrada tratará de segundas derivadas.

Definimos las derivadas segundas como una función lineal que transforma el espacio de R2 en R.

Podríamos aventurarnos a lanzar una primera ecuación correspondiente a una segunda derivada en una función de varias variables, a saber:

f(x,y) ≈ f(a,b) + f_x(a,b)(x-a) + f_y(a,b)(y-b) + ½ [f_xx(a,b)(x-a)² + 2f_xy(a,b)(y-b) + f_yy(a,b)(y-b)²]

f(x,y) ≈ f(a,b) + grad(f(a,b)) * R1 + ½ * R2 * H * R1

donde (por ejemplo) fxx es la derivada parcial de "x" sobre la derivada parcial de "x"; es decir, se aplican varias derivadas parciales sucesivas, tomando como variable la variable indicada.

Por otra parte, R1, R2, y H son matrices, tales que:

R1 = x-a

         y-b

R2 = (x-a   y-b)

H = f_xx    f_xy

       f_yx   f_yy

A "H" se le conoce como matriz Hessiana, y se suele denotar como "H(a,b)".

En el caso que nos atañe (funciones de dos variables), "H" es una matriz 2x2, y se dice que tiene dos valores propios (vaps): fxx y fyy (ya que fxy = fyx).

Veamos qué pasa con estos vaps:

• si det(H) = 0: alguno de los vaps. es 0
• si det(H) > 0: los dos vaps son mayores que 0, por tanto la función está por encima del plano "z"
• si (a+b) > 0: H(a,b) es simétrica, cuadrada, y se puede diagonalizar.
• si det(H) < 0: los dos vaps son menores que 0, por tanto la función está por debajo del plano "z"
• si (a+b) > 0: H(a,b) es simétrica, cuadrada y se puede diagonalizar.

En caso que sea 0, no nos reporta ninguna información útil (al parecer).

Veamos qué son los vaps. de H:

vaps(H(a,b)) = l₁, l₂

l_{1 *} l₂  = det(H) = f_xx*f_yy-f_xy2

l_{1 +} l₂  = f_{xx +} f_yy

veamos un ejemplo en el que se aplique todos estos conceptos:

f(x,y) = x² + y/3 + xy²

Derivada segunda en el punto (7,2)

f(7,2) = 49 + 2/3 + 7*4 = 233/3

f_x = 2x + y² => en (7,2) = 18

f_y = 1/3 + 2xy => en (7,2) = 85/3

f_xx = 2

f_xy = f_yx = 2x

f_yy = -2y

aplicamos fórmulas:

z = 233/3 + 18(x-7) + 85/3(y-2)

H_(a,b) = 2    2y

            2y  2x

H_(7,2) = 2   4

            4  14

det(H_(7,2)) = 12

2 + 14 = 16

_____________

vaps > 0

Plano tangente:

Z = z + ½(2(x-7)² + 2*4(x-7)(y-2) + 14(y-2)²)

Visto el ejemplo, pasemos a un inciso en las derivadas segundas: extremos relativos.

Para obtener los extremos relativos de una función de dos variables debe cumplirse lo siguiente:

fx = 0

fy = 0

Entonces, usando las fórmulas anteriores, obtendremos varios "juegos" de puntos. Basándose en los vaps de H(a,b), podemos saber qué tipo de extremo relativo estamos tratando:

• si los dos vaps > 0: mínimo
• si los dos vaps < 0: máximo
• si un vap > 0 y otro vap < 0: intersección (hacia un eje es mínimo, hacia otro es máximo)
• si algún vap = 0: no aporta información

Para obtener esto puntos, debemos ejecutar lo siguiente:

 - Obtenemos "fx" y "fy"

 - Obtenemos "fxx", "fxy", "fyy"

 - Igualamos "fx" y "fy" a 0, creando un sistema de ecuaciones

 - Resolvemos el sistema de ecuaciones

 - Para cada juego de soluciones, aplicamos H(a,b)

Y bien, con esto acabamos la cuarta entrega del segundo tema... las dos próximas serán cortas (ejemplos y utilidades).

Os dejo, y como siempre, ¡Hasta la próxima!

Mundo exterior - Matemáticas: Tema II (Curvas de nivel, gradientes, etc)

Buenas!

Volvemos de nuevo con las matemáticas. Esta entrada tratará sobre curvas de nivel, gradientes, derivadas de una función en un punto... vamos por partes:

Curvas de nivel:

Cuando hablamos de las curvas de nivel de una función de dos (o varias) variables, solemos hacerlo como "la curva de nivel con z=k" (donde k es un número entero).

Esta curva de nivel es una función lineal que transforma (en el caso de las funciones de dos variables) un espacio de R2 en un espacio de R.

¿Y en qué consiste? En hallar todos los puntos de f(x,y) en los que ésta valga "k"; dicho de manera resumida:

f(x,y) = k

Veamos, como siempre, un ejemplo:

f(x,y) = 4 – x² – 2y²

Si queremos encontrar la curva de nivel de esta función con "k=0", tendríamos:

4 – x² – 2y² = 0;

x² + 2y² = 4

Y esto, como se puede ver, es una elipse con centro (0, 0) y radio sqrt(2)

Para la misma función, la curva de nivel con "k=2", sería:

4 – x² – 2y² = 2;

x² + 2y² = 2

Si hacemos varias curvas de nivel (k=0, k=1, k=2...), obtendríamos un conjunto de elipses concéntricas, con centro en (0, 0).

Es decir:

4 – x² – 2y² = k;

x² + 2y² = 4 - k;

Existe si 4 - k >= 0 (si k <= 0)

Obtenemos una elipse con centro (0, 0) y radio [(±sqrt(4 - k), 0), (0, ±sqrt((4 - k) / 2))]

Bien, ahora que ya sabemos cómo hacer curvas de nivel, es hora de pasar a las derivadas en un punto.

Derivadas de una función de varias variables en un punto

Definimos la derivada de una función de varias variables en un punto como el límite de un cociente incremental. 

Para resolver este tipo de derivadas, suele ser necesario el uso de derivadas parciales.

¿Qué es una derivada parcial? Es asumir una variable como tal, y el resto como constantes. Teniendo esta cláusula asumida, procedemos a hacer la derivada de la función como tal, aplicando más tarde (si lo hubiera) el conjunto de valores dados en la derivada.

Vamos a verlo mejor con un ejemplo:

Partimos de una función:

f(x,y) = x²y – 3x + e^2y

Y queremos obtener la derivada de esta función en el punto (2, -3). Así, procedemos a hacer las derivadas parciales de "x" e "y".

df/dx = 2xy – 3 + 0

df/dy = x² + 0 + 2e^2y

Comprobamos como, mediante las reglas básicas de derivación podemos obtener estas expresiones.

Ahora no queda más que aplicar los valores dados en el enunciado, y obtenemos un vector (x, y) tal que:

f'(x, y) (2, -3) = (-15, 4,005)

A este vector se le llama "gradiente". Vamos a ello:

Gradientes:

Veamos algunas de sus propiedades:

• La dirección y el sentido de derivada direccional máxima es cuando el vector (v1, v2) es el gradiente. Este pendiente máximo (derivada direccional) vale la longitud del gradiente (ya que cos = 1)
• La dirección y el sentido de derivada direccional mínima es cuando el vector (v1, v2) es la inversa del gradiente (ya que cos = -1)
• Si el vector (v1, v2) es perpendicular al gradiente de la función en (a, b), la derivada en el punto (a, b) de f(v1, v2) es 0.

Ahora, veamos qué pasa si los combinamos con las curvas de nivel:

Si las líneas de la curva de nivel de una función están juntas entre si, significa que, a poca variación de "x", hay mucha variación de "y", y, por tanto, el gradiente de f(x,y) es más grande.

Suponiendo que el punto (x, y) está cerca de (a, b):

f(x,y) ≈ f(a,b) + (x – a)*(df/dx) + (y – b)*(df/dy) ≈ f(a,b) + (x – a, y – b) * grad(f(a,b))

Y definimos el plano tangente "Z" como:

Z = f(a,b) + (x – a, y – b) * grad(f(a,b))

(a ≈ x, b ≈ y)

Si el plano "Z" es nulo ("Z" = 0), nos encontramos ante un punto de inflexión:

 - Máximo

 - Mínimo

 - Max/Min

La utilidad de esto lo veremos en la próxima entrada, dedicada íntegramente a derivadas dobles.

Así, el planning queda así:

 Parte IV: derivadas dobles

 Parte V: ejemplos

 Parte VI (anexo): utilidades y tabla de derivadas inmediatas

Como siempre, ¡Hasta la próxima!

Mundo exterior: Matemáticas - Tema II (Representación de funciones con dos variables)

Buenas!

Seguimos con las "mates"; pero antes, un pequeño inciso (como viene siendo costumbre últimamente).

Ya le he dado uso a mi disco duro externo: he colocado todas las distro que uso, he usado y (en un futuro) usaré. Dejo la lista:

• Hiren's Boot 15
• WifiWay 3.4
• AVG Rescue CD
• Dr.Web Live CD
• Kaspersky Rescue Disk
• BackTrak 5
• Ophcrack XP
• Ophcrack Vista/7
• Partition wizard
• Linux Mint Mate x86
• Helix3 R1

Y, aparte, tengo destinado un futuro emplazamiento para mis tablas rainbow y demás (capturas de tráfico, informes...) jejeje.

En fin, sigamos con las matemáticas: en esta entrada veremos la representación de funciones de dos variables.

Para ello, distinguiremos dos tipos de funciones:

 - Cónicas

 - No cónicas

Empecemos con el primer tipo:

Cónicas:

Las funciones cónicas tienen la siguiente forma:

f(x, y) = Ax² + By² + Cxy + Dx + Ey + F = 0

El término "Cxy" determina la orientación de la función: si "C" vale 0, los ejes de la cónica serán rectos.

No cónicas:

A riesgo de parecer muy obvio, si no cumple la forma anterior, no es cónica...

De momento, pasaremos a otro punto importante, para luego retomar la identificación de las cónicas. Hablemos ahora de los dominios de las funciones.

El dominio de una función de dos variables es una función tal que convierte el espacio R2 en R. En esta "transformación", tenemos que evaluar (pues pueden resultar conflictivos) una serie de casos, a saber: 

• A / B => si B = 0
• √A => si A < 0
• Ln(A) => si a <= 0
• arcsin(A) => si |A| >= 1

Como vemos, son casos problemáticos, pues producen "fallo" en los cálculos. Así, el análisis de dominio de una función se basará en estos puntos. Vamos con un ejemplo:

f(x, y) = sqrt((x² – y² + 4) / ((x – 1)² + y² – 9)) (sqrt() = raíz cuadrada)

He coloreado los paréntesis para que se puedan distinguir fácilmente. Veamos qué casos son "peligrosos" para la evaluación de esta función:

a) ((x – 1)² + y² – 9) = 0

b) (x² – y² + 4) / ((x – 1)² + y² – 9) < 0

Vamos a justificar ambos casos:

 - Si la expresión "a" se cumple, se haría una división por 0, por lo que de la raíz cuadrada ni hablamos.

 - Si la expresión "b" se cumple, no podemos hacer  la raíz cuadrada (al menos dentro del cuerpo de los reales, que es donde trabajamos)

El procedimiento para evaluar estas anomalías creo que será conocido: miramos qué condiciones hay que cumplir para que pase:

a) ((x – 1)² + y²) = 9

Si se cumple esto, tendríamos un problema. Vemos que la función de arriba define una circunferencia caracterizada por los siguientes datos:

 * Origen: (-1, 0)

 * Radio: 3 (sqrt(9))

Para los que no sepáis de donde viene esto, un inciso: la función que define una circunferencia es la siguiente:

f(x, y) = (x+a)^2 + (y+b)^2 = c

De aquí obtenemos:

 * Origen: (a, b)
 * Radio: sqrt(c)

b) Se divide en dos:

b1) ((x – 1)² + y²) = 9 (ya resuelta)

b2) (x² – y²) = -4 => ±sqrt(x² + 4) = y => y = ±(x+2)

La solución de "b2" es una fórmula de circunferencia, pero con "c" negativo (por lo que es, en realidad, una parábola doble).

Para no abusar tanto del escaneo de apuntes, voy a echar mano de mi amigo "Corel" para ilustrar un poco el panorama: 

Si representamos ambas soluciones, quedan delimitadas 7 zonas, marcadas arriba. Del mismo modo que en la entrada anterior, comprobamos el signo de las ecuaciones "a" y "b" y calculamos su "total".

En este caso, nos interesan las zonas que sean mayores que 0 (positivas), ya que a fin de cuentas tendremos que hacer una raíz cuadrada.

Diríamos, en este caso, que la función solo tiene dominio en las zonas 2, 3, 5, y 6.

Una vez visto un ejemplo de aplicación de dominio, volvamos a las cónicas.

Identificación de cónicas:

f(x, y) = Ax² + By² + Cxy + Dx + Ey + F = 0 (suponemos "C" = 0)

Pongamos un ejemplo:

4x² – y² + 3x + 2y – 25 = 0

(2x + ¾)² – 9/4 – (y² – 2y) – 25 = 0

(2x + ¾)² – 9/4 – [(y – 1)² - 1] – 25 = 0

(2x + ¾)² – (y – 1)² = 105/4

Vamos a explicar un poco cómo llegamos a la forma de abajo (antes os comentaba que era la función que define una circunferencia).

Paso 1: Tenemos la ecuación tal cual

Paso 2: Agrupamos los términos con "x" (marcados en rojo), y factorizamos. Agrupamos también los términos con "y" (marcados de azul verdoso)

Paso 3: nos valemos de la siguiente expresión inmediata para ejercer el cambio sobre los términos "y":

(ax + b)² = a²x² + 2abx + b²

Ya que se cumple, podemos sustituir.

Paso 4: Despejamos para dejar en forma de "circunferencia".

Ahora bien, una vez tenemos nuestra ecuación "arreglada", tenemos que ver varias cosas:

Si sig("A") != sig("B") => hipérbola

Si sig("A") = sig("B") => elipse o circunferencia (puede ser imaginaria)

"sig()" es una función que obtiene el signo del coeficiente especificado.

Si tenemos una circunferencia es fácil dibujarla (buscamos el centro y usamos el radio); si es una hipérbola,  una elipse, o en general, procedemos así:

• Buscamos el centro
• Buscamos los puntos "x" e "y" en el centro
• Dibujamos los puntos

Vamos por partes, con una versión un poco diferente al ejemplo anterior ((2x + ¾)² + (y – 1)² = 105/4):

Obtener el centro:

Para ello, tomamos parte de la ecuación (la correspondiente a cada variable, sin cuadrado) y la igualamos a 0, tal que: 

2x + 3/4 = 0 => x = -3/8

y - 1 = 0 => y = 1

Obtenemos nuestro punto (-3/8, 1), que es el centro.

Puntos "x" e "y" en el centro

Usando los valores del centro, resolvemos la ecuación correspondiente a la variable contraria, usando el cuadrado, tal que: 

(para x = -3/8): (y - 1)² = 105/4; y = 1±sqrt(105/4)

(para y = 1): (2x + 3/4)² = 105/4; x = (±sqrt(105/4) - 3/4)/2

y obtenemos estas dos expresiones: 

x = (±sqrt(105/4) - 3/4)/2

y = 1±sqrt(105/4)

Que usaríamos para dibujar (en este caso) nuestra elipse.

En el caso anterior (con los términos restando) obtenemos que en "y" no hay punto aplicable (ya que queda "y = 1±sqrt(-105/4)", y no hay solución real para ello), y "x" queda igual.

Con esto acabamos por esta vez. La próxima entrada tratará de curvas de nivel, gradientes y demás cosas similares (mis apuntes tienen una estructura un poco caótica... jejeje).

Como siempre, ¡Nos vemos!

Mundo exterior: Matemáticas - Tema II (Inecuaciones)

Buenas!

Llevaba tiempo sin escribir... en parte es "buena señal", ya que eso indica que hay algunos cambios.

Y sobre eso hablaremos antes de meternos de lleno en las matemáticas (funciones de diversas variables).

Siendo concretos, hay dos temas a comentar:

a) Un par de cambios
b) Un nuevo hilo "bloguero" a raíz de los cambios anteriores.

a) Ayer (jueves 25/abril) se celebró en mi ciudad el campeonato local de Robocode. Para el que no conozca este proyecto, lo explico brevemente:

Tomas un código fuente JAVA (también está la versión en C, que aún no he probado), y con él programas un tanque (robot). Esta programación no se basa en eventos interactivos (es decir, no lo tripulas, simplemente lo "sueltas" en el campo de batalla), sino en eventos a tiempo real. Principalmente hay cuatro interacciones que hacen saltar estos eventos:

 - El tanque choca contra una pared
 - El tanque choca contra otro tanque
 - El tanque es golpeado por una bala
 - El tanque detecta otro tanque

En base a estos eventos podemos "decirle" al tanque que haga ciertas cosas, como, por ejemplo:

"Cuando detectes otro tanque, dispara".

Obviamente, en JAVA, usando la API de Robocode.

Pues bien, me presenté, así como en la anterior edición (en la que gané en el sector individual), y este año si bien no rasqué nada en individual sí que quedé subcampeón en la modalidad de equipos (un grupo de 5 tanques programados por una persona).

Y me llevé como premio un disco duro externo WD passport de 2tb con conexión USB 3.0

De momento su uso está siendo pensado, ya que en casa tengo otro disco externo de 2tb...

b) Dejaré en la lista de hilos un tema dedicado a mi próxima creación para el próximo campeonato de Robocode.

Es decir, documentaré desde el inicio de la idea (ya en mi cabeza) hasta las clases JAVA que use.

Y bien, vayamos ahora a las matemáticas!

Entramos en el tema II, funciones de diversas variables.

En esta entrada veremos (de momento) las inecuaciones, a modo de introducción.

Antes de entrar en temario, vamos a definir formalmente una función:

f: Rⁿ  à R^m

Es decir, toman un espacio de Rn (véase tema anterior) y lo adaptan a Rm. Ni "n" ni "m" tienen por que ser iguales o siquiera guardar un orden específico.

Ahora si, vayamos a las inecuaciones.

¿Qué es una inecuación?

Es una desigualdad que marca una relación entre valores conocidos y valores desconocidos. Un ejemplo:

2x - 4 > (2/3) - 7x

Vamos a resolverla:

[Pasamos -7x de un lado al otro como +7x, mientras que -4 lo pasamos como +12/3 a la otra parte]

9x > 14/3

x > 14/27

Como se puede apreciar, no es más que un poco de sentido común y aplicar las reglas de las ecuaciones. Amén de tener en cuenta una serie de cosas:

• No simplificar ninguna variable
• No multiplicar por "X" (o "Y", o ...)
• No dividir por "X" (...)
• Mantener las proporciones (hemos de tener en cuenta que al ser inecuaciones, hemos de vigilar que se mantenga la desigualdad)

La inecuación que hemos visto antes era una simple (1º grado). Vamos ahora con las inecuaciones de 2º grado:

x² + x >2

x² + x – 2 > 0

x² + x – 2 = 0

x = 1; x = -2

Expliquemos:

Primero "inigualamos" a 0. Una vez hecho, lo pasamos a una ecuación de 2º grado normal, y calculamos los valores de X. De ahí obtendremos lo que llamaremos "puntos de corte". Lo podemos representar así:

Vemos tres zonas: rojo, azul, y verde. La primera y la tercera toman valores positivos (>0), y ya que lo que buscamos es una x tal que sea positiva, podemos concluir que la solución a la inecuación es el conjunto:

(-∞, -2)U(1, +∞)

Con este concepto claro, vayamos ahora un paso más allá: inecuaciones racionales. Como antes, un ejemplo que lo ilustre:

(x² + x) / (x + 3) >= 2

((x² + x) / (x + 3)) – 2 >= 0

(x² - x - 6) / (x + 3) >= 0

a) x² - x – 6 = 0

x = 3;x = -2

b) x+ 3 = 0

x = -3

Expliquemos: 

Dejamos "desigualado" a 0 (como antes). Una vez hecho, intentamos simplificar (en este caso, hemos "subido" el 2 multiplicado por "x+3" y lo hemos sumado al numerador). Ahora solo nos falta igualar tanto el numerador como el denominador a 0; esto nos dará dos ecuaciones que podemos calcular, obteniendo dos juegos de soluciones ("a" y "b").

De nuevo, tenemos más puntos de corte. En este caso, algo así:

Vamos a explicar esta confusión de números, colores y líneas:

La franja de arriba corresponde a la ecuación del numerador; la de arriba al denominador. En ambas están marcados los cambios de signos. A saber:

Numerador: Rojo > 0, azul < 0, violeta > 0

Denominador: Naranja < 0, verde > 0

Las líneas grises que cruzan ambas zonas son las soluciones anteriores (-3, -2, y 3). Esto crea cuatro zonas "comunes", que serán sobre las que calcularemos la solución.

Para saber el signo de estas zonas, tenemos que "sumar" (usando la ley de los signos) los resultados obtenidos en las zonas de cada ecuación.

Ya que la primera zona (la de más a la izquierda) es "positivo + negativo", obtenemos "negativo". Vamos haciendo para las cuatro zonas.

Así, ya que buscamos un "x >= 0", podemos concluir que la solución es:

(-3, -2] U [3, ∞)

A continuación, quedan dos pasos de dificultad, que veremos a la vez (escaneado de mis viejos apuntes):

 - Inecuaciones don dos variables

 - Inecuaciones de 2º grado con dos variables

El procedimiento para resolver ambas es similar al anterior:

"Desigualamos" a 0, pasamos a ecuación normal, despejamos "y", y usamos el resultado como una función (f(x)). Seguidamente representamos la función, la cual nos delimita las zonas (así como antes eran líneas, ahora son funciones). Basta con tomar vectores (a, b) estratégicamente para saber el signo de las zonas, para obtener la zona que nos pida la inecuación.

Y con esto tenemos cubierta la primera parte del tema II.

Como siempre, ¡Hasta la próxima!

Interludio

Buenas!

De nuevo por aquí...

Acabada está ya la primera parte de nuestro remote tools... la próxima será, por tanto, matemáticas (tema II, ya).

Pero antes, hay varias cosas que anunciar.

a) Se ve a la vista un nuevo blog personal
b) Surgieron varios temas durante la pasada sección que dejo en cola. A saber:
  b1) Criptología
  b2) Hacking wifi
  b3) Obtención de datos
c) He desarrollado una pequeña función JS/HTML para blogger (lo veremos más abajo)
d) Tengo un nuevo "juguete" del que escribir
e) Hay un pequeño cambio (¡por fin!)

Así que vamos por partes.

Blog personal:

Pues eso... estoy pensando en hacer un pequeño blog donde meter todos mis pensamientos y textos... a ver si podemos fomentar la escritura y el pensamiento (al menos lo intentaré). Os mantendré informados, y, como siempre, si me decido, lo encontraréis más allá de los confines de mi blog.

Temas:

Éstos - y otros que quizás salen durante este tiempo - los guardo en mi pila de ToDo's de mi despacho (tengo un corcho bien grande lleno de papelitos con ideas...)

Función JS/HTML:

Bien, he creado una pequeña galería fotográfica (pensada para el blog de cosplay). Es una de las cosas que blogger no acaba de hacer: al subir varias fotos cuesta cuadrarlas (salen casi siempre una abajo de otra, y cosas así), así que cuando tengo que poner varias queda bastante "cutre".

Así que me estrujé el cerebro, y como soy tan y tan escéptico, no quise coger galerías de terceras personas, sino más bien hacerme una para mi (que de eso va este blog, ¿no?, ¡DIY!).

Y me gustaría compartir con vosotros mi aporte. Por tanto, vamos a ir paso a paso para ver cómo funciona la pequeña galería.

Para empezar, dejo un esquema general de cómo está estructurada la galería:

Para la notación usaré la siguiente convención (ejemplos):

elemento.clase

elemento#id

elemento.clase subelemento#id:estado

El elemento "global" es "div.blogMarquee". Dentro tenemos tres elementos: "div.blogMarqueePhoto", "marquee#bm" y "div.blogMarqueeScroll".

Dentro del primero hay un elemento: "img#cp".

Dentro del segundo están las imágenes, es decir, un conjunto de "marquee#bm img".

Dentro del tercer elemento hay dos "div": "div#bMSL" y "div#bMSR"

El contenido de "marquee#bm" lo tendremos que introducir de manera manual, y será lo único que varíe de una entrada a otra (es decir, la estructura es siempre la misma, solo cambiaremos las imágenes).

Igual os preguntáis que es eso de "marquee". Para los que no hayan usado nunca este elemento NO ESTÁNDAR de HTML decir que es, de manera general, un div cuyo contenido se mueve. De este movimiento podemos definir:

• Velocidad
• Frecuencia de movimiento
• Dirección de movimiento
• Modo de movimiento
• Cantidad de ciclos de movimiento

Cuando veamos el código explicaré un poco más cómo funciona.

Entonces, el funcionamiento es el siguente:

 - Las imágenes pasan por "marquee#bm".

 - Al pasar por encima de "marquee#bm", el movimiento cesa, y se muestran flechas de dirección ("div#bMSL" y "div#bMSR").

 - Al pulsar sobre una imagen, ésta se "colocará" en "div.blogMarqueePhoto img#cp".

 - Al pulsar sobre las flechas, podremos navegar por las imágenes (mientras se mantenga el ratón pulsado)

 - Al pulsar sobre "div.blogMarqueePhoto img#cp", la imagen se abrirá a tamaño real en una ventana nueva.

Aquí vemos dos cosas a destacar:

a) Hay un solapamiento de eventos javascript.

b) Tenemos que controlar cuándo el ratón está pulsado sobre "div#bMSL" y "div#bMSR".

Teniendo estas dos cosas en cuenta, vamos a pasar a ver la estructura HTML de nuestra galería:

<div class="blogMarquee">
<div class="blogMarqueePhoto">
                <img src="" alt="" width="400" height="300" id="cp" onclick="external(this);">
         </div>
<marquee id="bM" onmouseout="setAmount(this,5);" onmouseover="setAmount(this,0);" srcollamount="5">
<!-- imágenes aquí, en formato: width=320 height=240 -->
</marquee>
<div class="blogMarqueeScroll" onmouseover="setAmount(ge('bM'),0);">
<div id="bMSL" class="binv" onmousedown="action([ge('bM'),10,false],true);" onmouseup="action([ge('bM'),0,false],true);"> < </div>
<div id="bMSR" class="binv" onmousedown="action([ge('bM'),10,true],true);" onmouseup="action([ge('bM'),0,true],true);"> > </div>
</div>
<script type="text/javascript">addId(ge('bM'));</script>
</div>

(No me gusta que desfase el ancho del blog... pero así se ve mejor)

Como vemos, al final hay una llamada JavaScript. Ésta sirve para dar "id" a cada imagen dentro de marquee (ya veremos cómo, en un momento).

Antes de entrar en JS, vamos a estudiar un poco el HTML.

Como vemos, tenemos la estructura comentada, así que no pararemos ahí, sino que veremos el el elemento "marquee#bm".

Vemos que tiene "scrollamount=5". Esto indica la velocidad (5, en este caso) a la que se mueven los elementos. La dirección la veremos más adelante.

Ahora, vamos a por el JS (explicado con comentarios):

/**
 * variable global para el solapamiento
 */
var b_max=2;

/**
 * función action. 
 * Actúa como manejador de solapamiento de eventos entre "marquee#bm img:click" (a) y ("div#bMSL" | "div#bMSR") (b).
 * (a) lanza cphoto
 * (b) lanza move
 * Recibe dos parámetros:
 * @param v: array de parámetros de subllamada
 * @param f: valor de flag 
 */
function action(v,f){
b_max--;

if(f&&b_max>0){
move(v[0],v[1],v[2])
}else{
if(!f){
cphoto(v[0])
}
}

if(b_max==0||f){
b_max=2
}
}

/**
 * función ge.
 * Sinónimo de función "document.getElementById".
 * Recibe un parámetro y retorna un elemento:
 * @param e: id del elemento a retornar
 * @return: elemento cuyo id corresponde a "e"
 */
function ge(e){
return document.getElementById(e)
}

/**
 * función setAmount.
 * Ajusta la velocidad (scrollAmount) del elemento "e" a la velocidad "a".
 * Si la velocidad es 0, se muestran las flechas; en caso contrario se ocultan.
 * Recibe dos parámetros:
 * @param e: elemento a ajustar
 * @param a: velocidad
 */
function setAmount(e,a){
e.direction='left';
e.scrollAmount=a;

if(a==0){
ge('bMSL').className='bMSL';
ge('bMSR').className='bMSR'
}else{
ge('bMSL').className='binv';
ge('bMSR').className='binv'
}
}

/**
 * función addId.
 * Itera sobre el elemento con id "e", y sobre sus hijos, asigna id's de forma secuencial.
 * Del mismo modo, asigna un handler "click" a cada elemento.
 * Recibe un parámetro:
 * @param e: id del elemento a iterar
 */
function addId(e){
am=0;

for(i=0;i<e.childNodes.length;i++){
try{
e.childNodes[i].setAttribute('id','el'+am);
e.childNodes[i].setAttribute('onclick','action([this],false)');
am++
}catch(err){
}
}
}

/**
 * función move.
 * Mueve el elemento "e", en la dirección indicada por "t" a una velocidad "a".
 * Recibe tres parámetros:
 * @param e: elemento a mover
 * @param a: velocidad a fijar
 * @param t: dirección (true para derecha, false para izquierda)
 */
function move(e,a,t){
if(t){
e.direction='right'
}else{
e.direction='left'
}

e.scrollAmount=a
}

/**
 * función cphoto.
 * Muestra el elemento "e" sobre el elemento "#cp"
 * Recibe un parámetro:
 * @param e: elemento a mostrar sobre "#cp"
 */
function cphoto(e){
ge('cp').setAttribute('src',e.getAttribute('src'))
}

/**
 * función external.
 * Abre, en una ventana nueva, el elemento "e".
 * Recibe un parámetro:
 * @param e: elemento a abrir
 */
function external(e){
if(e.getAttribute('src')!=null){
window.open(e.getAttribute('src'))
}
}

Ahora, trataremos los dos asuntos:

a) Solapamiento: usamos este sistema para evitarlo.
b) Se generan dos eventos: onmousedown (cuando la tecla está pulsada) y onmouseup (cuando se suelta la tecla). En el primero, indicamos que se mueva hacia la dirección indicada; en el segundo, indicamos que pare.

Por último, falta indicar el estilo de nuestra nueva función:

img{
border:0;
}

.blogMarqueePhoto{
height:300px;
width:400px;
margin-left:auto;
margin-right:auto;
padding:10px;
}

.blogMarqueePhoto img{
width:400px;
height:300px;
border:1px solid #CCC;
 padding:0px
}

.blogMarqueePhoto img:hover{
cursor:pointer;
border-color:#FFF;
}

#bM{
height:245px;
}

.blogMarqueeScroll div{
top:-245px;
width:100px;
height:240px;
position:relative;
font-familt:arial;
font-size:180px;
color:#FFF;
line-height:240px;
opacity:.5;
-moz-opacity:.5;
filter:alpha(opacity=50);
background:#000;
}

.bMSL{
float:left;
}

.bMSR{
float:right;
}

.binv{
display:none;
}

#bM img{
 padding:0px;
}

#bM img:hover,.bMSR:hover,.bMSL:hover{
cursor:pointer;
}

Y ya solo falta rellenar con imágenes y colocarlo en una entrada.

Aquí podéis ver un ejemplo en funcionamiento. Un consejo: usad el ingenio para "importar" fotos desde facebook ;-)

"Juguete":

Aquí está. Es una lámpara-tecla que compré en la feria del cómic de Barcelona. Mide unos 15cm de largo y se queda en mi despacho.

Ahora ya puedo decir que tengo la luz bajo control ;-)


Cambios:

Hace tiempo que voy detrás de graduarme en la universidad, pero lo que quería hacer estaba fuera de presupuesto (aunque tengo que admitir que de hacer algo relacionado 100% con la informática me gustaría hacerlo); un Bachelor en un centro adscrito a la universidad de Gales. Son tres años de carrera repleta de asignaturas con muy buena pinta...

Pero se va de presupuesto, así que vivía resignado.

Hasta que repasando los apuntes de mates me picó el gusanillo otra vez... así que ahí lo dejo:

¡Me voy a graduar en matemáticas!

Ya me he visto la carrera que voy a hacer y es buena, barata y a distancia. ¡Ale! así, entre curso y curso, podré hacer cursillos de informática (nunca hay que dejar de estudiar)... con este paso estoy más cerca de ser doctor... :-)

Desde luego no es un cambio que haya estado "esperando", más bien vino así de golpe... pero ya está bien.

Remote Tools: Presentación (V)

Buenas!

En esta entrada terminamos la presentación de la herramienta "Remote Tools".

Después de esta, habrá un breve interludio en el que os pondré al día de todo (hay varias cosas que tratar que no he expuesto por no alterar el ritmo de las publicaciones), y seguidamente a éste volveremos a las matemáticas (tema II).

Y bien, ahora toca hablar de la herramienta nmap.

Quizás alguno de mis lectores (aunque no comentéis se que estáis ahí, y me alegro de que me leáis - y sobretodo si os ayuda en algo :-) ) ya conoce de la existencia de esta herramienta; no obstante, vamos a hacer un repaso rápido.

Nmap es una herramienta de diagnóstico de redes. Nos permite ejecutar varias "operaciones" sobre un trozo de la red.

Vamos a ver un poco su interfaz:

Se distinguen varias zonas claras:

• Tipo de perfil: seleccionamos la acción a realizar. Hay una cantidad considerable de perfiles. En este caso tenemos seleccionado simplemente un "Ping Scan".
• Rango de IP: rango de IP a analizar con el perfil seleccionado. Permite IP única (por ejemplo 192.168.1.1) o un rango (por ejemplo 192.168.1-2.1-255).
• Comando a ejecutar: es la petición que se lanzará (lo veremos más adelante)
• Lista de Host: Host/s que han respondido a la petición.
• Output: salida de texto que lanza el programa.
• Filtro: podemos filtrar los hosts usando esta barra de filtro.

En este caso, he realizado un ping a toda mi red local. Esto podría servir (por ejemplo) para ver si hay algún intruso, ya que al finalizar el trabajo, tendremos una lista con todos los dispositivos conectados a la red (en este caso: router, pc y mi teléfono).

Más adelante (cuando haga la sección) podremos ver como podríamos "burlar" esto, pero valga esto como ejemplo.

Aparte de esto, tiene otras herramientas, como un panel donde se muestran los puertos abiertos (si hacemos un escaneo más potente) del host seleccionado. En concreto, tiene las siguientes opciones (pestañas):

• Nmap output: muesta el output.
• Ports/Hosts: muesta los puertos escaneados del host seleccionado.
• Topology: muestra la topología de los hosts (un tracert).
• Host details: muestra detalles del host: SO, nº de puertos abiertos...
• Scans: muestra una lista de los scans realizados.

Y bien, como podéis intuir esta herramienta es muy potente; pero no todo acaba ahí. Nmap tiene una parte "oculta"... usa un "bridge" (API, si queréis) basado en cmd.

Es decir, podemos ir a nuestro cmd, a la carpeta donde tengamos nmap (o desde donde sea si lo tenemos en PATH) y ejecutar consultas ahí mismo, usando el comando adecuado.

¿Y qué comando usamos? precisamente el que sale en nmap cuando ejecutamos los perfiles.

Entonces, podríamos hacer, por ejemplo: 

nmap -sn 192.168.1-2.1-255 > test.dat

Y tendríamos un archivo "test.dat" con la información de output de nmap.

Entonces, el objetivo de Remote Tools es hacer este tipo de llamadas para obtener información de las diferentes LAN.

Usando esto con cabeza, podemos agilizar las auditorías un poco...

Y bien, con esto acabamos el primer apartado de nuestra futura aplicación... ¡espero que os guste!

¡Hasta la próxima!

Remote Tools: Presentación (IV)

Buenas!

Llegamos casi al final de la presentación del proyecto Remote Tools... los cambios siguen (como siempre) demorados; pero otro tipo de cambios han sucedido...

En parte me alegro por los cambios que ya han tenido lugar; no obstante, me gustaría que sucediera por fin el cambio que tanto ansío...

En fin... sigamos con lo que vamos.

En esta entrada toca hablar de la fuerza bruta (aplicada a la informática).

¿Habéis oído eso de "más vale maña que fuerza"? Pues está relacionado...

Siguiendo con el ejemplo de la entrada anterior, vamos a introducir el concepto de fuerza bruta, y, sobretodo, cómo aplicarla de manera correcta (es decir, aplicar fuerza con maña).

Si recordamos, hablábamos de una función para calcular claves por defecto, tal que:

f(x, y, z) = subs(enc(z + 2y + ent(x/z)), 20)

Ahora bien: obtenidos todos los datos, obteníamos una única solución, por lo que no hacía falta nada más.

Pero claro, si yo fuera un fabricante de routers, haría la cosa algo más complicada, por ejemplo:

f(x, y, z) = con(subs(enc(z + 2y + ent(x/z)), 15), k)

donde "x", "y", y "z" serían los mismos valores; "subs", "enc", y "ent" las mismas funciones. Además:

 - "con": función de concatenación de todos los ítems de la lista
 - "k": variable que (valga la redundancia) es variable para cada router, y no hay manera de saber

Entonces... ¿Cómo calculamos ahora la clave del router?

La respuesta está en la fuerza bruta.

Podríamos empezar a pensar, y podemos intuir que, si antes tenía 20 dígitos de longitud, la clave seguirá teniendo los mismos dígitos.

Si eso es cierto, sabemos que "k" es un valor de 5 dígitos de longitud.

Ahí tenemos algo acotado ya: sabemos que:

k = abcde

de manera que "a", "b", "c", "d", y "e" pueden tomar cualquier valor alfanumérico posible.

Como su nombre indica, la "fuerza bruta" consiste en acceder por la fuerza, probando todas las combinaciones posibles de manera automática hasta dar con la correcta.

Y para aplicar la fuerza tenemos dos maneras:

 - Manera óptima
 - Manera bruta

Primero, ya que es más corto, explicaremos la manera "bruta":

Consiste en probar absolutamente todo. En este caso, sabiendo que tenemos 20 caracteres, haríamos cadenas de 20 caracteres y las iríamos probando "a saco". Haciendo unos cálculos obtenemos:

 * Números del "0" al "9" => 10 caracteres
 * Letras de la "a" a la "z" (la "ñ" no cuenta en este caso) => 26 caracteres
 * Letras de la "A" a la "Z" => 26 caracteres

Por tanto, tenemos 62 posibilidades en cada posición, por 20 posiciones:

n = 62^20 = 704.423.425.546.998.022.968.330.264.616.370.176 posibilidades

Bien, a una velocidad de 5.000 posibilidades probadas por segundo, tardaríamos 1630609781358791719834097834.7601161481481481481483 días (4467424058517237588586569.4103016880771182141045159 años aprox.) en completar nuestra búsqueda.

Como se ve, ciertamente imposible...

La manera óptima, sin embargo, es más optimista, ya que haríamos lo siguiente:

 * Sabemos que "k" tendrá 5 caracteres, por lo tanto:

n = 62^5 = 916.132.832 posibilidades

Wow, hasta podemos ver que son menos de un billón (la cifra anterior cuesta de ver, incluso). Con el cómputo anterior (5.000 posibilidades/segundo) tendríamos:

t = n/(60*60*24*5000);
t = 2.1206778518518519h

Bueno, un par de horas; podríamos ir a tomar algo dejando el ataque en marcha, y al volver tendríamos nuestra clave :-)

En definitiva, aplicar la fuerza bruta es cuestión de maña...

No obstante, hay veces que simplemente no se puede. Estas situaciones son, entre otras:

 - Passwords "personales" (definidos por cada usuario)
 - Claves propias
 - Todo aquello que no sea computado

En estos casos, podemos hacer varias pruebas, como jugar con longitudes, juegos de caracteres, o usar la ingeniería social (o técnicas maliciosas como keyloggers, sniffers, phishing...).

En nuestra aplicación, empezaremos con un concepto "global" de fuerza bruta: es decir, generaremos diccionarios (conjuntos de posibilidades) acorde a los parámetros que de el usuario, y los devolveremos. Será cuestión del usuario usarlos.

Como en cada una de estas entradas, dejo un tema pendiente: obtención de datos mediante diversas técnicas (estas entradas irán con un banner más grande que un bocadillo de surimi con wasabi).

Si no ha quedado claro en el párrafo anterior, cuando abordemos (más adelante) este tema, será como contramedida; es decir, de manera informativa y para estar informados y al loro de las maneras en las que nos podrían engañar (en ningún momento recomiendo usar técnicas maliciosas para robar información, ya que puede ser delito).

La próxima entrada abordará el tema de un programa que nos puede ser útil: nmap.

Como siempre digo,

¡Hasta la próxima!