Resolver error al conectarse a SQL Server debido al certificado SSL

20/04/2017
Artículo original

La situación es la siguiente: vas a conectarte a SQL Server desde un equipo remoto usando exactamente las mismas credenciales que usabas para conectarte en local y, al hacerlo, recibes un error como este:

Error mostrado por SQL Server al conectarse

que dice en español algo así como:

Se ha establecido con éxito una conexión con el servidor, pero ha ocurrido un error durante el proceso de autenticación. El certificado recibido del servidor remoto fue emitido por una entidad emisora de certificados que no son de confianza.

Nada, que no hay manera de conectarse. El mensaje habla de un certificado y menciona al proveedor de SSL de SQL Server... Pero tú no has instalado ningún certificad en el servidor... ¿De qué va todo esto?

Cuando SQL Server se instala, salvo que al hacerlo le indiquemos explícitamente que vamos a utilizar un determinado certificado digital para securizar las comunicaciones, el servidor instala un certificado auto-firmado para ello. Este certificado está creado por el propio SQL Server y no se sustenta en una infraestructura de clave pública real. Lo que quiere decir que el certificado sirve para cifrar las comunicaciones y validar su integridad, pero no sirve para asegurar que nos estamos conectando al servidor correcto, ya que la única "autoridad" que nos asegura que el servidor es el correcto, es el propio servidor :-S

De eso precisamente es de lo que va ese mensaje de error. Lo que nos indica es que, por defecto, como no se puede verificar la identidad del servidor, no permite la conexión.

Algo similar ocurre con muchos otros servicios que usan por defecto un certificado auto-firmado. Por ejemplo, al conectarnos por primera vez a un equipo remoto usando Terminal Server (llamado también Escritorio Remoto), se nos pregunta si queremos confiar o no en ese certificado y por lo tanto conectarnos al servidor:

Advertencia mostrada por escritorio remoto al conectarse a un servidor sin certificado de confianza

Es normal, al fin y al cabo los principales propósitos de un certificado digital son tres:

  1. Privacidad de la información, cifrando las comunicaciones en el tránsito
  2. Integridad de la comunicación, combinándolos con resúmenes digitales
  3. Confianza, saber que las comunicaciones vienen de quién dicen venir y que no estamos comunicando con quien creemos.

Las 2 primeras no sirven de mucho si falla la tercera...

¿Cómo lo solucionamos?

Si el error nos lo está dando el propio SQL Server Management Studio, cuando nos queremos conectar desde la pantalla de login, lo que tenemos que hacer es ir a las opciones avanzadas de ese diálogo:

Al entrar, enl a pestaña de "Propiedades de la conexión" veremos que está marcada la opción de "Cifrar conexión":

Siempre podemos desmarcarla y evitar que se produzca el error, pero entonces todo el tráfico entre nuestro equipo y el servidor SQL Server remoto se enviará en claro a través de Internet, así que es una mala idea.

Si vamos a la pestaña "Parámetros adicionales de la conexión", podemos escribir un modificador para que la conexión confíe en el certificado del servidor SQL Server remoto. Este parámetro adicional es:

TrustServerCertificate=True

Basta con escribirlo en el cuadro de texto de esa ventana:

Ahora al pulsar en "Conectar" veremos que el error desaparece y podemos trabajar con normalidad.

Si el error lo está dando una aplicación, solo hay que modificar la cadena de conexión y ponerle al final el mismo parámetro.

Evidentemente, si hacemos esto tenemos que estar seguros de que el servidor al que nos estamos conectando es el que nos interesa de verdad y que no existe un problema de seguridad que pueda estar falseando las DNS para que nos conectemos a otro sitio...

¡Espero que te resulte útil!

Las 10 extensiones de Chrome indispensables para desarrolladores

18/04/2017
Artículo original

Chrome es uno de los navegadores más utilizados del mundo. En gran parte su popularidad se debe a lo fácil que es ampliar sus capacidades mediante el uso de extensiones. El problema muchas veces es encontrar la apropiada entre el enorme mar de opciones que tenemos, ya que existen miles de ellas.

En el caso de los desarrolladores existen unas cuantas extensiones que no debiéramos dejar de utilizar, sobre todo si somos programadores web. En este recopilatorio hemos reunido las 10 que más nos gustan, sin ningún orden en particular.

Si tienes alguna más en el radar que consideres indispensable, háznoslo saber en los comentarios.

¡Vamos allá!

1.- Chrome Dev Editor

Chrome Dev Editor

Se trata de un buen editor de código que se ejecuta directamente en el navegador, creado por Google. Aunque su principal intención es que lo uses para desarrollar extensiones para Chrome, lo cierto es que funciona muy bien con cualquier desarrollo web Front-End en general, ya que soporta coloreado de código JavaScript y HTML, plantillas de Polymer, e incluso integración con Git para control de código fuente.

Ofrece multitud de "skins" para mostrar su interfaz de usuario con diferentes colores, y te permite cambiar las teclas rápidas para que coincidan con las de Vim o EMacs.

No va a sustituir a tu editor habitual pero puede venir bien para una urgencia. Además trabaja off-line por lo que se puede usar en un lugar sin cobertura. Si tienes un Chrome Book, sin duda debes instalarlo.

2.- Postman

Postman

Un clásico indispensable si estás desarrollando servicios. Esta aplicación permite probar y analizar de manera sencilla los servicios web REST (aunque tiene un soporte menor para servicios SOAP/XML). Te permite probar con facilidad cualquier método, analizar y manipular la respuesta, guardar un histórico, crear colecciones de llamadas... Tiene una versión de pago para trabajo en equipo y mejoras en la documentación, pero con la gratuita tendrás para cualquier necesidad si eres un desarrollador individual.

Aparte de la extensión para Chrome del enlace anterior ofrece su descarga como app independiente para Windows, Mac y Linux. Toda la información en su sitio web.

3.- Secure Shell

Secure Shell

Un terminal compatible con XTerm directamente en Chrome. Lo puedes usar como un cliente SSH o emulación de terminal, por lo que te puedes conectar al servidor Linux que alberga tu sitio, y gestionarlo sin salir del navegador.

Para funcionar utiliza hterm, el emulador de terminal escrito enteramente en JavaScript, y un port a NativeClient (el sandbox de Chrome para ejecutar código C y C++) de OpenSSH.

Funciona incluso en Chrome Books, donde puede resultar más útil incluso.

Si te interesa el tema, en su FAQ encontrarás multitud de datos interesantes.

4.- Webmaker

Webmaker

¿Conoces Codepen? Pues WebMaker es como si tuvieras Codepen directamente en tu navegador, y con soporte off-line.

Te permite crear pequeños proyectos y pruebas en HTML, CSS y JavaScript y ver en tiempo real cómo responden a los cambios. Puedes añadir referencias a las bibliotecas más populares para trabajar con ellas en tu proyecto. Además soporta Markdown, Jade, SCSS (Sass), LESS, JSX, CofeeScript y TypeScript... y todo ello sin necesidad de estar conectado a Internet ?

Es súper-útil para aprender y practicar, para prototipar de manera rápida algunas utilidades, o trabajar en tu equipo con calma antes de pasarlo a Codepen, web a la que por cierto puedes exportar los proyectos con un solo clic.

Ofrece varias distribuciones de elementos en pantalla, puedes guardar los proyectos en local para abrirlos de nuevo más tarde y sacar capturas de pantalla de lo que has creado.

Y es totalmente gratuito.

Más que recomendable.

5.- Python

Python

¿Estás aprendiendo Python 2.x? ¿Te gusta el lenguaje y te interesa hacer pruebas rápidas sin abandonar tu navegador?

Pues esta extensión es para ti. Se trata de un REPL (Read-Eval-Print Loop) o intérprete interactivo de Python 2.7 que funciona directamente en Chrome gracias a la magia de NativeClient.

Se abre una consola que lanza Python y listo: ya puedes empezar escribir comandos, interpretar fragmentos de código, etc...

6.- Form Filler

Form Filler

Esta interesante extensión te ayuda a probar los formularios de tus aplicaciones web, rellenándolos automáticamente con datos inventados, pero con sentido según el tipo de dato. Para ello hace un emparejamiento según el nombre del campo o su tipo con ciertos tipos de información.

Por ejemplo, si el campo es de tipo email introduce una dirección de correo electrónico dentro de unos dominios determinados, o si su nombre es username se inventa un nombre de usuario.

Estos emparejamientos y muchas otras opciones se pueden especificar desde su configuración (botón derecho sobre su icono en Chrome).

En el resto de los campos introduce fragmentos de "lorem ipsum" por lo que requerirá de cierta configuración para afinarlo y adaptarlo a nuestras necesidades, pero una vez hecho nos resultará de bastante ayuda.

7.- Cookies

Cookies

A través de las herramientas del desarrollador de Chrome tenemos la posibilidad de examinar todas las cookies de cada uno de los sitios web (uno a uno), pero no podemos gestionarlas. Desde la dirección chrome://settings/cookies podemos verlas todas juntas, filtrar por dominio e incluso eliminarlas. Pero en ambos casos el control que tenemos sobre ellas es más bien escaso, entre otras cosas porque a Google no le interesa demasiado que lo tengamos, puesto que vive de tenernos controlados a través de ellas.

Esta extensión nos permite ver todas las cookies de nuestro equipo, pudiendo editarlas, eliminarlas e incluso crearlas nuevas, obteniendo un control total sobre las "galletitas".

Una característica adicional interesante es la posibilidad de guardar conjuntos de cookies en un almacenamiento cifrado y protegido por clave de modo que podamos restaurarlas bajo demanda, solo cuando las necesitemos.

Check My Links

El objetivo de esta útil extensión es muy simple: seguir todos los enlaces que hay en una determinada página para verificar si son correctos o no. A medida que las va comprobando va actualizando la gráfica que indica el estado de comprobación, y al final sabremos exactamente cuántos enlaces hay, cuántos son válidos y cuántos y cuáles están rotos.

En su configuración se pueden especificar qué dominios deberá dejar fuera de las comprobaciones (por ejemplo por defecto trae algunos de Google). Se echa de menos el poder introducir una cadencia para evitar ser bloqueado por cortafuegos de aplicación que pueden encontrar el tráfico que genera un tanto sospechoso. Si las pruebas las vas a realizar en local o contra tus propios dominios únicamente, entonces no hay problema.

Si haces sitios web debería estar en tus indispensables, pero en realidad puede resultar útil para muchas otras situaciones.

9.- DOMFlags

DOMFlags

A este cuesta un poco pillarle la gracia, pero cuando se la encuentras, no puedes vivir sin él.

Si has tenido que ajustar el diseño de una página o aplicación web, tocando el CSS de ciertos elementos hasta dar con la combinación apropiada sabrás de qué hablamos: saltar continuamente entre 3 o 4 elementos para tocar alguna de sus propiedades CSS. A veces es un balance entre ajustes por lo que no te queda más remedio que estar saltando de unos a otros para ir probando.

Bein, DOMFlags permite crear "favoritos" dentro de los elementos de una página, y luego saltar de unos a otros con una combinación de teclas rápidas. Basta con marcar un elemento con el atributo domflags para que pase a formar parte de la lista de "bookmarks" de esa página.

Este atributo se le puede poner dinámicamente en las herramientas del desarrollador, a mano o usando un botón específico que te da la herramienta en cada elemento (o la combinación ALT+MAYs+D). O bien puedes ponérselo directamente en tu código fuente para que sean permanentes mientras haces los ajustes.

Una vez establecidos estos "favoritos" puedes cambiar entre ellos pulsándolos en la lista que se genera, o utilizando la combinación de teclas ALT+MAYs+1, 2, 3... dependiendo de si quieres ir al primero, segundo, etc...

Es una utilidad muy simple pero que te puede ahorrar mucho tiempo y mejorar tu productividad.

10.- Library Sniffer

Library Sniffer

Aunque un desarrollador experimentado puede analizar rápidamente el código de un sitio y las cabeceras de las peticiones para saber con gran grado de acierto qué tecnologías utiliza, siempre viene bien que te lo den hecho.

Y esto es precisamente lo que hace esta extensión: coloca una lupa en la barra del navegador que, cada vez que entras en un sitio web te dice qué tecnologías está utilizando tanto en el lado cliente como en el servidor.

Reconoce la mayor parte de las bibliotecas JavaScript conocidas (jQuery, Angular, React...), los sistemas de gestión de contenidos (estilo WordPress y similares), tecnologías de análisis de sitios (como Analytics) e incluso tecnologías de servidor (como ASP.NET, NodeJS, etc...) y servidores web (IIS, Apache, NGinx...) indicando además sus versiones.

Es útil para saber qué usa nuestra competencia o las aplicaciones que nos gustan.

Es Open Source y podemos ver su código fuente en GitHub.


Con estas extensiones lograrás tener una mayor productividad mientras trabajas o aprendes.

¿Conoces algunas extensiones para desarrolladores sin las que no puedas vivir? Déjanos una descripción y para qué las usas en los comentarios.

Kotlin 1.1 también es para desarrolladores Android

17/04/2017
Artículo original

Este artículo fue publicado originalmente en el blog oficial de Kotlin.

Estamos muy emocionados con el lanzamiento de Kotlin 1.1. Las nuevas características incluidas en esta versión son extremadamente útiles para los desarrolladores de Java y para llevar el desarrollo JVM a un nuevo mundo de posibilidades.

Pero estas nuevas características, como las coroutines, o los type aliases (por poner un par de ejemplos), parecen ciencia ficción para desarrolladores de Android.

Todavía estamos atrapados en el antiguo Java 6 con pequeñas mejoras que nos obligan a desarrollar de formas casi olvidadas para la mayoría de los desarrolladores de cualquier otra plataforma.

Por lo tanto, sería normal preguntarse: ¿el equipo de Kotlin ha sido capaz de mantener la compatibilidad con Java 6 mientras saca todas estas nuevas características? La respuesta es: ¡por supuesto!

Kotlin11blogbanner1

Todas estas nuevas características están disponibles para Java 6 y, por extensión, para desarrolladores de Android. Y hoy, quiero mostrarte algunas de ellos, y cómo pueden hacer tu vida aún más fácil al desarrollar aplicaciones de Android.

Type aliases: puedes hacer que tu listener sea mucho más legible

Por supuesto, los type aliases tienen muchas aplicaciones diferentes. Pero lo primero en lo que pensé fue la capacidad de hacer que los listeners sean más legibles, sin dejar de usar lambdas.

Todas estas nuevas características están disponibles para Java 6 y, por extensión, para desarrolladores de Android

Si no has oído hablar antes de los type aliases, son básicamente una forma de cambiar el nombre de los tipos complejos a otros más legibles.

Por ejemplo, podrías tener un RecyclerViewadapter que recibiera un listener. Como sabrás, RecyclerView no tiene una forma estándar de tratar los clicks en los items, como pasa en un ListView, por lo que tenemos que salir al paso usando los que hayamos creado.

Vamos a imaginar que queremos un listener que tenga acceso a la vista. Nuestra clase adapter podría ser parecida a esta:

class MyAdapter(val items: List, val listener: (View) -> Unit) : RecyclerView.Adapter() {
    ...
}

Y tu ViewHolder probablemente también tendría que recibir ese listener, para asignarlo a la vista:

class ViewHolder(itemView: View) : RecyclerView.ViewHolder(itemView) {
    fun bind(item: Item, listener: (View) -> Unit) {
        itemView.setOnClickListener(listener)
    }
}

Este no es un caso muy complicado, pero como puedes ver, necesitamos repetir la definición de la lambda y eso, fuera de contexto, puede dificultar la lectura.

Pero podemos crear un type alias que represente un click listener:

typealias ClickListener = (View) -> Unit

Y luego utilizarlo en todos los lugares que necesitamos el listener:

class MyAdapter(val items: List, val listener: ClickListener)

o

fun bind(item: Item, listener: ClickListener) { ... }

Las data classes ahora son más potentes

Las data classes son geniales porque evitan una gran cantidad de código boilerplate. Pero carecían de cierta potencia, que las hacía inútiles en algunos casos.

Una de las nuevas características de Kotlin 1.1 es la herencia: las data classes ahora pueden heredar de otras clases. Esto permite que las data classes sean parte de las clases sealed:

sealed class UiOp {
    object Show : UiOp()
    object Hide : UiOp()
    data class Translate(val axis: Axis, val amount: Int): UiOp()
}

Y ahora, como las clases sealed pueden ser definidas fuera de la clase padre, esto también podría escribirse así:

sealed class UiOp
object Show : UiOp()
object Hide : UiOp()
data class Translate(val axis: Axis, val amount: Int): UiOp()

Desestructuración en lambdas

Las data classes pueden ser desestructuradas desde la primera versión gracias a los métodos componentX() que generan. Podrías distribuir el contenido de una data class en varias variables de esta manera:

data class Item(val text: String, val url: String)

val (text, url) = item

Pero faltaba una característica realmente potente: Poder hacer esto en lambdas. ¡La espera ha terminado! Ahora puedes hacer algo como esto:

fun bind(item: Item) = item.let { (text, url) ->
    textView.text = text
    imageView.loadUrl(url)
}

También es muy útil para usarlo en pares o conjuntos de clave/valor en un mapa de datos, por ejemplo.

Delegación de propiedades locales

La delegación de propiedades ha demostrado ser realmente útil para proporcionar habilidades extra a las propiedades de nuestras clases.

Por ejemplo, uno de los casos más útiles es la delegación perezosa (lazy delegation), que retrasa la asignación hasta que la propiedad se utiliza por primera vez.

Pero lazy también podría ser muy útil también en las variables, y Kotlin carecía de esta característica.

Ahora, con la delegación de propiedades locales, podemos hacerlo:

fun testLocalDelegation() {
    val database by lazy { createDatabase() }
    val cache by lazy { createMemoryCache() }

    if (mustUseDatabase()) {
        database.use { ... }
    } else {
        cache.use { ... }
    }
}

Aunque este ejemplo puede resolverse sin usar la delegación lazy, ayuda a entender el concepto.

la delegación *lazy* retrasa la asignación hasta que la propiedad se utiliza por primera vez

Tenemos un par de objetos pesados que pueden usarse o no. Mediante el uso de lazy, podemos retrasar la instancia hasta que estamos seguros de que vamos a utilizarlo.

La primera vez que se utilice, el código dentro de las llaves se ejecutará, y se almacenará en caché en caso de que se necesite de nuevo más tarde.

Olvídate de declarar las variables no utilizadas en lambdas

Era muy común tener que declarar variables para argumentos de lambdas que al final no se usaban en ninguna parte.

Se debía a que en Kotlin 1.0 no teníamos una forma de descartar parámetros que no utilizáramos.

Como ejemplo, en el artículo donde expliqué cómo actualizar el adapter de RecyclerView usando delegación, terminé con este código:

var items: List by Delegates.observable(emptyList()) {
    prop, old, new ->
    autoNotify(old, new) { o, n -> o.id == n.id }
}

El atributo prop se utilizaba pero, hasta ahora, era necesario declararlo. Ahora puedes evitar incluirlo utilizando un guión bajo:


var items: List by Delegates.observable(emptyList()) {
    _, old, new ->
    autoNotify(old, new) { o, n -> o.id == n.id }
}

Pero era peor el caso en el que no se usaba ninguno de ellos. Si tienes más de un argumento para una lambda, debes escribirlos todos aunque no los uses.

Ahora podemos ignorarlos:


var items: List by Delegates.observable(emptyList()) {
    _, _, _ ->
    notifyDataSetChanged()
}

No sólo se están definiendo menos variables, sino que también el código se vuelve más legible. No es necesario detectar si esos argumentos se utilizan o no. Queda mucho más claro.

Coroutines

Las coroutines son las mejores noticias que hay en Kotlin 1.1. Aunque finalmente se dejaron como experimentales en este lanzamiento, son completamente funcionales y puedes comenzar a utilizarlas en tus proyectos desde hoy.

Las coroutines te permitirán escribir código asíncrono de manera síncrona, lo que permite suspender su ejecución en algún momento y esperar a un resultado, todo mientras se escribe código secuencial.

Una cosa que sabrás sobre las coroutines en Kotlin es que no son una biblioteca o una implementación específica, son una característica del lenguaje que permite crear las bibliotecas sobre ella.

Las coroutines en Kotlin son completamente funcionales y puedes comenzar a utilizarlas en tus proyectos desde hoy

Por lo tanto, aunque el código resultante puede parecer similar, es importante saber cuál es el "engranaje" que están creando esos hilos secundarios y volver al hilo principal, lo que es muy importante en Android.

Afortunadamente, la comunidad de Kotlin se mueve rápido y ya hay varias bibliotecas que traen la potencia de las coroutines a Android. Aquí tienes algunos ejemplos:

Los primeros que te pueden interesar son los oficiales que ofrece Jetbrains:

  • Kotlinx-coroutines-android, que proporciona una implementación de las coroutines lista para ser usada en Android.
  • Anko, que en su última versión beta incluye compatibilidad con coroutines para muchos listeners del framework.

Pero también hay muchas otras bibliotecas de terceros que implementan sus propias versiones de las coroutines:

Te animo no sólo a usarlas, sino también a comprobar cómo se implementan. Es la magia del open source.

Algunas otras cosas interesantes para desarrolladores Android

Hay muchas otras mejoras en esta versión, pero quiero resaltar algunas que están más centradas en el desarrollo de Android.

La potencia que Kotlin trae a los desarrolladores de Android está fuera de toda duda

La primera de ellas es que ahora puede habilitar el soporte con el compilador Jack usando: jackOptions {true}. Google ha anunciado que está deprecando las herramientas de Jack, pero si las utilizas para Java 8, esto puede serte útil hasta que se publique la versión final de Android Studio 2.4.

Además, existe una nueva intention que utilizará @JvmOverloads para implementar los constructores de vistas personalizadas, que permite, literalmente, implementar constructores para vistas personalizadas en una línea (bueno, una línea muy larga) utilizando un constructor y valores predeterminados para los argumentos:

class CustomView @JvmOverloads constructor(
        context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
) : View(context, attrs, defStyleAttr) {
    ...
}

Conclusión

Kotlin 1.1 ha venido con un buen montón de nuevas características impresionantes que hacen que dejar de seguir utilizando Java sea aún más inevitable.

La potencia que Kotlin trae a los desarrolladores de Android está fuera de toda duda, y puedes comenzar a escribir sus aplicaciones de Android en Kotlin a partir de ahora.

Y si quieres aprender Kotlin para Android desde cero mientras desarrollas una aplicación, puedes apuntarte a este vídeo-training gratuito sobre Kotlin para desarrolladores Android que lancé hace unos días.

También te recomendamos

7 trucos rápidos para cuidarte el rostro (sin dejarte la piel ni el presupuesto)

¿Será 2017 el año de Kotlin? Repasamos su evolución y por qué deberías darle una oportunidad

Kotlin: La Máquina Virtual de Java tiene un nuevo aliado

-
La noticia Kotlin 1.1 también es para desarrolladores Android fue publicada originalmente en Genbeta Dev por Antonio Leiva .

Errores de SEO que deberías evitar como autor

13/04/2017
Artículo original

La optimización de una web para SEO no acaba con un buen diseño de esta. Cada vez que escribes una nueva entrada en tu blog, no deberías cometer ninguno de los errores de SEO On Page y Off Page que te comentamos. ¿Cómo evitarlos? Es más fácil de lo que parece.

The post Errores de SEO que deberías evitar como autor appeared first on Nelio Software.

FRIKADAS: Ofuscación extrema de código JavaScript con JSFuck

12/04/2017
Artículo original

Lenguaje JSFuck

Hace unos meses os hablábamos aquí mismo de los lenguajes esotéricos. Estos lenguajes se caracterizan por ser súper-crípticos, es decir, incluso teniendo el código delante es casi imposible saber qué hacen. Uno de los más famosos es BrainFuck, que se caracteriza por utilizar tan solo unos pocos símbolos como el mayor (>), menor (<) la suma (+), etc...

Por ejemplo, este sería el "Hola Mundo" en BrainFuck:

++++++++++[>+++++++>++++++++++>+++>+<<<<-]>++.>+.+++++
++..+++.>++.<<+++++++++++++++.>.+++.------.--------.>+.>.

Ininteligible, vamos.

Inspirándose en BrainFuck, el programador alemán Martin Kleppe (un frikazo de todo y lomo, y si no me crees échale un vistazo a su página personal) ha creado el lenguaje JSFuck.

JSFuck utiliza tan solo 6 caracteres, a saber: []()!+, pero lo más alucinante es que con ellos puedes crear cualquier programa JavaScript que funcionará en cualquier navegador moderno ?

Por ejemplo, este fragmento aparentemente sin sentido:

[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+
[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]
[([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+
[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]]+
[])[!+[]+!+[]+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]
+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+
!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+([][[]]+[])[+!+[]]+(![]+[
])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[+!+[]]+([][[]]+[])[
+[]]+([][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[
]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[
]]]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[][(![]+[])[+[]]+(
[![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(
!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[+!+[]+[+[]]]+(!![]+
[])[+!+[]]]((![]+[])[+!+[]]+(![]+[])[!+[]+!+[]]+(!![]+[])[!+[]+
!+[]+!+[]]+(!![]+[])[+!+[]]+(!![]+[])[+[]]+(![]+[][(![]+[])[+[]
]+([![]]+[][[]])[+!+[]+[+[]]]+(![]+[])[!+[]+!+[]]+(!![]+[])[+[]
]+(!![]+[])[!+[]+!+[]+!+[]]+(!![]+[])[+!+[]]])[!+[]+!+[]+[+[]]]
+[+!+[]]+(!![]+[][(![]+[])[+[]]+([![]]+[][[]])[+!+[]+[+[]]]+(!
[]+[])[!+[]+!+[]]+(!![]+[])[+[]]+(!![]+[])[!+[]+!+[]+!+[]]+(!![
]+[])[+!+[]]])[!+[]+!+[]+[+[]]])()

Produce una alerta por pantalla con el número 1, es decir, es equivalente a:

alert(1);

Vale, no es muy útil, y ocupa varias veces más que el código original, pero puedes convertir cualquier otro programa JavaScript a JSFuck y se ejecutará perfectamente, aunque la conversión es muuuy lenta.

Por cierto, en el transformador de pruebas que viene en la página no intentes poner nada más largo de unos pocos caracteres: te colgará el navegador.

Es decir, lo alucinante de esta tremenda "ida de olla" que es JSFuck es que no deja de ser código JavaScript que funciona en cualquier lado. No necesita un compilador especial: simplemente lo metes en una página y funciona.

Por ello, es posible utilizarlo para ofuscar de manera tremenda ciertos fragmentos de código JavaScript. Esto, que puede ser incluso útil en algunas aplicaciones lícitas, también es un problema si lo que se está insertando es código malicioso para hacer ataques de tipo XSS, por ejemplo, donde el código malicioso pasaría inadvertido para muchos analizadores que tratan de detectarlo.

¿Cómo funciona esto?

En cualquier caso es un experimento muy interesante. Las particularidades del lenguaje JavaScript hacen que expresiones sin sentido aparente como esta:

!+[]+!+[]

Realmente funcionen en cualquier compilador. ¿Sabes qué es ese fragmento?: pues nada menos que el número 2. La explicación viene de considerar por un lado las conversiones implícitas de tipos de datos que hace JavaScript al usar ciertos operadores matemáticos, y por otro la precedencia (orden de aplicación) de dichos operadores.

Así, por ejemplo, si intentamos sumar una matriz vacía a nada, o sea esto:

+[]

Obtendremos el número 0 ya que la matriz se convierte a un número para poder sumarla y al no tener un operando por la izquierda se considera que es 0. Así que lo anterior es equivalente a 0+0, que es 0.

Si además le añadimos un ! delante, es decir, lo negamos, entonces obtenemos un true (el contrario en booleano de un 0 (false) es true), y si repetimos la operación de la suma sin nada a la izquierda, lo convierte en el número equivalente (1) y por lo tanto obtenemos un 1, por lo que el 1 se escribe en JSFuck así:

+!+[]

Siguiendo esa lógica, para conseguir un 2 solo tenemos que sumarle otro 1, pero no tenemos que empezar de cero porque ya tenemos un 1 en la expresión anterior, así simplemente con conseguir otro 1 a la izquierda con !+[] ya es suficiente, y queda:

!+[]+!+[]

Que es lo que vimos antes, facilísimo ¿verdad? ?

Para obtener las diferentes letras del abecedario de manera ofuscada utilizan conversiones que dan palabras clave como undefined o NaN y luego las extraen con la sintaxis de elementos de matrices (o sea, corchetes), que también funciona para cadenas. Por ejemplo, se puede obtener un undefined con esta expresión:

[][[]]

Y se puede convertir en una cadena simplemente intentando concatenarla (con +) con algo que no se aun número, así que esta expresión:

[][[]]+[]

Resulta en la cadena "undefined".

Por lo que si ahora la rodeamos con un paréntesis para obtener el resultado y cogemos su primera letra, obtenemos la "u", así:

([][[]]+[])[0]

Con la segunda letra (posición 1) tendríamos la "n" y así sucesivamente.

Hacen esto mismo con el resto de letras posibles y otras palabras clave.

Bueno, pues con esto y unos cuantos trucos más del estilo al final es posible crear un código totalmente indescifrable que ejecute casi cualquier cosa en JavaScript.

En la página de GitHub del proyecto puedes ver el código fuente completo, pero también tiene una buena explicación de cada uno de los trucos que usa.

Más allá de una simple curiosidad y de la frikada, se trata de un proyecto muy interesante que muestra la flexibilidad que posee JavaScript (que es un arma de doble filo y que hace que muchos lo odien). Y nunca se sabe para qué podrías necesitar algo como esto ?

JDBI como alternativa a JDBC, JPA, Hibernate ...

11/04/2017
Artículo original

Para todos aquellos que estén cansados de usar siempre lo mismo (JDBC, JPA, Hibernate, etc.) cuando trabajan con base de datos en sus aplicaciones pueden optar por usar JDBI, una librería que promete facilitarnos la existencia. Su página oficial dice:

JDBI is a SQL convenience library for Java. It attempts to expose relational database access in idiommatic Java, using collections, beans, and so on, while maintaining the same level of detail as JDBC. It exposes two different style APIs, a fluent style and a sql object style

No me dejaran mentir al decir que cuando se trabaja con aplicaciones demasiado robustas los desarrolladores sufrimos al trabajar con extensos archivos confusos y difíciles de mantener. Peor aún cuando el equipo original de trabajo "olvido" documentar el proyecto.

leer más

Mi experiencia en la GameJam 2017

11/04/2017
Artículo original

Hace unas semanas participé en mi primera GameJam. Nunca había programado un juego así que tenía curiosidad y fue todo un reto para mi. Teníamos 48 horas para presentar un prototipo mínimo. Nuestro equipo decidió usar el motor Godot. En total estábamos cuatro personas: @Cristina, @ElenoideArt, @JJ Ramos y yo.

Descripción del juego

Unlimitosis
Unlimitosis

@ElenoideArt fue nuestra diseñadora y también es bióloga, así que pensamos en un juego en el cual aparecen células en la pantalla y eventualmente se vuelve cancerígenas, el jugador debe eliminarlas antes de que se reproduzcan. A continuaión muestro una grabación del juego en acción:

Como puedes ver, el juego es bastante sencillo, pero bueno, ninguno sabíamos hacer juegos el día de antes de la GameJam. Si quieres mejorar, probar o jugar, el código está en Repo Unlimitosis.

Documentación

Para desarrollar el juego nos bastó con la documentación de Godot, extensa y bien explicada. También existe un repositorio GitHub con montones de ejemplos.

Prueba el juego

Gracias a JJ Ramos tenemos una versión web del juego, puedes probarla en juanjoseramos.com/unlimitosis/.

Guías de estilo de programación para WordPress

11/04/2017
Artículo original

Uno de los motivos por los cuales WordPress ha triunfado es su naturaleza open source, permitiendo que cualquiera pueda contribuir. ¿Podemos conseguir que algo hecho por miles de personas sea coherente y uniforme?

The post Guías de estilo de programación para WordPress appeared first on Nelio Software.

Hola Mundo en EmberJS

10/04/2017
Artículo original

Ejemplos Programación EmberJS

EmberJS es un framework Javascript que nos permite crear aplicaciones SPA de una forma muy sencilla utilizando un patrón MVC. En este caso vamos a crear un Hola Mundo en EmberJS para tomar contacto con el framework. En posteriores artículos iremos publicando más ejemplos sobre el uso de EmberJS. Lo primero para poder crear nuestro [...]

La entrada Hola Mundo en EmberJS aparece primero en Línea de Código.

Crear objecto a partir de una clase

10/04/2017
Artículo original

Buen día a todos.

Me gustaría implementar lo siguiente:

Tengo un servicio al cual le llegan x parámetros y en uno de esos le mando el nombre de la clase "llave" por ejemplo y usando el siguiente código obtengo la clase y solo ocuparia castear al objecto usuario.
 Class.forName("llave").newInstance()

hasta aquí todo bien pero lo que realmente me gustaría hacer es no tener que castear el objeto ya que lo envió a un método (sobrescrito).

les comparto el comparto un pequeño código de prueba:

public class Main {

        public static void main(String[] args) throws Exception {
                String class1 = "clases.llave";
                String class2 = "clases.lente";
                metodoInvocado((llave) Class.forName(class1).newInstance());
        }

        //METODOS SOBREESCRITOS
        public static boolean metodoInvocado(llave tipo) {
                System.out.println("ENTRO LLAVE");
                return true;
        }

        public static boolean metodoInvocado(lente tipo) {
                System.out.println("ENTRO LENTE");
                return true;
        }
}

leer más

Página Anterior Página Siguiente