Archivo de la categoría ‘Tecnología’

Fotografía RAW: Sensores CFA, Demosaicing y Dcraw

Share on Google+Share on FacebookTweet about this on Twitter

 

Los Objetivos de Hoy:

  • Poder realizar capturas RAW con la gran mayoría de terminales móviles
  • Entender como son realmente las capturas RAW
  • Ser capaces de “revelar” dichas capturas RAW sea cuales sea su formato
  • Crear nuestras propias herramientas cuando lo que tenemos fuera no nos soluciona el problema
  • Versión Dcraw Modificada para dar soporte específico al Xiaomi Mi6 (Ver apuntes finales)

Como pequeña introducción, los amantes de la fotografía que usen Android, sabrán que este tiene dos APIs fundamentales a día de hoy: Camera1 y Camera2/HAL3.x. En teoría la segunda viene a sustituir la primera desde hace mucho tiempo ya, pero la vagancia de algunos fabricantes y el uso para variar de APIs propias de otros, hace que como todo se tomen su tiempo. La ventaja de usar Camera2/HAL 3.x es enorme, ya que de forma nativa Android permite la captura RAW, controlar controles ISO, tiempo de exposición, focus… y de ahí existe la extraña creencia que todo ello no puede hacerse en Camera1. Sí se puede, ojo, la diferencia es que es más complicado y no tan eficiente. Y ahí es donde todo esto empieza, por mi cabezonería. El Xiaomi Mi6, por ejemplo, es totalmente compatible con Camera2, pero no está habilitado por defecto. Así que me decidí a lograr capturas RAW sin usar Camera2 (que es trivial). Lo que no tenía ni idea es que iba a dar para tanto.

Siempre he dicho que yo no soy un genio, genio son aquellos que tienen las capacidades y habilidades de crear los códigos tan ingeniosos que crean. Que yo sepa programar y pueda en un momento dado crearme mis herramientas, utilidades y otros es una cosa, pero la capacidad de algunos compañeros para plasmar tanto problemas matemáticos, algoritmos… en código, siempre la he envidiado. Con esto quiero mandar un saludo especial a los creadores de las mismas herramientas que he usado/uso, y algunas que he modificado.

La primera, pienso que es la mejor aplicación de cámara en Android en cuanto a versatilidad y grado técnico. Por desgracia recientemente su creador, troop, eliminó no solo el repositorio de github, sino que terminó borrando casi todo rastro de sí mismo. Llego a estar en el PlayStore, y cada actualización era mejor que la anterior. No se saben bien los motivos, unos dicen que se cansó, otros que realmente la aplicación tenia malware… sea como sea, está oficialmente retirada, pero tenemos forks en github. La última versión que lanzó fue la 4.1 Alpha 5, de este mismo Julio. Por cierto, hablo de FreedCam. Y tengo que decir que fue la que empezó todo esto. Esta app tiene una peculiaridad (bueno tiene muchas) importante, y es que te permite cambiar de Camera1 a Camera2 (si el terminal es compatible), y usar en cada caso lo mejor que tu cámara pueda darte. Y es mucho, porque posiblemente no vas a encontrar otra cámara que en Camera1 sea capaz de hacer una captura RAW. Y sí, la hace… bueno, siempre y cuando claro el terminal exponga en su Driver que admite al menos la captura en algún formato que no sea JPG, y ya os digo que la mayoría puede!! Y sin usar Camera2. Pero todo esto lo veremos más adelante.

La segunda, ha sido la que después de mucho quebrarme el coco, me ha dado todo el código que necesitaba para que con unas simples modificaciones (realmente añadidos) me haya permitido “revelar” mis RAW. ¿Por qué? Bueno, porque aunque con Camera1 es posible hacer capturas RAW, estas capturas nada tienen que ver con las clásicas capturas RAW de Camera2 (DNG generalmente) o de otras cámaras, estos RAW suelen ser RAW pero RAW, sin cabecera, sin nada. En este caso ha sido el software de Dave Coffin el que lo ha hecho posible. Ahí tenemos la gran importancia del código abierto, por sí mismo su software no pudo ayudarme, pero su simplicidad y su buena estructura me hizo que fuese relativamente sencillo modificarlo. Y en este caso me refiero a su utilidad DCRaw, cuyo código fuente tenemos en su propia Web y podemos compilar/reescribir o hacer lo que queramos.

 

¿Por qué RAW?

Tengo que confesar que, entre otros muchos problemas o defectos, llevo muy mal eso de no entender algo. Por supuesto que nadie tiene conocimiento universal, me refiero a estar con algo entre manos y tener más preguntas que respuestas. Soy bueno el algunos campos, pero es obvio que en muchos otros soy un principiante o un completo negado. Y es lo que me ha pasado siempre con la fotografía, es un campo que me apasiona desde un punto de vista técnico y físico, no estético. Si me hubiesen preguntado hace una semana que era un Sensor CFA Bayer sin ponerlo en ningún contexto, sinceramente habría respondido con un: “No tengo ni puñetera idea”. Y eso me encanta, porque si es algo que me interesa tengo asegurados unos cuantos días de estrujamientos de sesos, y en el peor de los casos habré aprendido unas cuantas cosas. Así que si algún aficionado a la fotografía encuentra algún error en mis palabras o algo que no sea así, por favor, que me corrija, soy “nuevo” en esto.

Como me suele pasar siempre, suelo tener algo entre manos, de eso salto a lo otro, de lo otro a otra cosa… y al final estoy hasta arriba. Todo lo que voy a contar a continuación está basado en un Xiaomi Mi6 (Mi terminal actual), pero es aplicable de un modo u otro a cualquier (o casi) dispositivo Android e incluso en muchos aspectos a cualquier cámara de fotos en general.  Hace ya tiempo escribí un artículo principalmente versado sobre software fotográfico, hablando de características principales de las cámaras, HDR, RAW: Luces, Cámaras y… Software!!. La idea no es hacer una segunda parte, sino centrarme en puntos muy específicos dentro de la fotografía digital: La captura RAW.

La captura RAW ha ido aumentando en popularidad desde hace ya mucho tiempo, imprescindible para los profesionales, querida por los aficionados, y generalmente ignorada o desconocida para el resto. Llamamos fotos en RAW de forma genérica a cualquier foto digital que haya sido tomada por una cámara (DSLR, móvil, compacta…) sin que haya sido procesada por el propio dispositivo, o mínimamente procesada. Ya digo que para el aficionado o profesional esto es de primero, pero para la mayoría lo único que saben es que disparan y se genera un archivo digital, generalmente una imagen JPG. Pero esa imagen final que obtienen es el resultado de una serie de procesados internos que transforman/convierten las señales eléctricas recibidas por el sensor, la organización de estos datos, la interpretación, correcciones, interpolaciones… Digamos que el JPG es la foto revelada, mientras que la foto en RAW es el negativo, por tanto. ¿Y esto es importante? Bueno, para el usuario casual es indiferente, las cámaras hacen un procesado y post-procesado bastante decente y no necesitan más. Pero para quien busca ese digamos… “punto extra” o toque artístico añadido, o un resultado mucho más limpio y certero… entonces necesitas trabajar tú personalmente ese negativo. Hay una lógica aplastante en esto: Si un móvil o cualquier cámara de fotos a día de hoy es capaz de realizar todas esas conversiones, adaptaciones, interpretaciones… para obtener al final la imagen JPG, y lo hacen en tiempo real (de forma más o menos aceptable), imaginad el resultado que podría obtener un equipo de sobremesa que tiene infinitamente más potencial, sin necesidad de hacerlo en tiempo real y pudiendo usar filtros/algoritmos mucho más exactos, o que nos gusten más.

A todo ello hay que añadir un enorme problema adicional que hay en la fotografía digital. Los formatos de imagen como pueda ser JPG (el más usado), es un formato con pérdida, lo que significa que aun cuando el procesamiento de las señales fuese perfecto y todo acorde a nuestros deseos, el simple echo de inscribir dicha información como un archivo jpg, estaría ocasionando una pérdida importante de información. A lo mejor en una imagen de 20MP con una cámara profesional y para una foto de tamaño normal no se aprecia, pero para una foto con resoluciones más bajas o cuando necesitamos sacar un detalle concreto o… no son pocas veces las que vemos claramente los errores de compresión que provoca JPG, como “anillos”, “pixelado” de color y otros artefactos debidos a la cuantificación.

Si ampliamos y nos fijamos bien, se pueden apreciar diferencias en cada uno de todos los pasos, siendo por supuesto los dos últimos muy extremos. Entre Q100 y Q75 pude parecer correcta la imagen en cierto modo, pero si nos fijamos bien con Q75 la imagen tiene mucho más ruido, y la hélice ya empieza a generar un pequeño halo. Para Q50 los colores de la mitad derecha, sobre todo el cuarto superior empiezan a verse incluso bloques, para Q25 el efecto es visible en toda ella y a Q1… bueno, no es que quede mucha imagen. La mayoría de cámaras permiten seleccionar de un modo u otro este grado de cuantificación que por defecto suelen establecer entre 80 y 90. A valor más alto, la imagen como es natural tendrá un mayor tamaño.

RAW es indistinto a todo esto. No es que se trate de un formato de imagen sin pérdidas como pueda ser PNG, puesto aun así lo que se guardaría en el PNG sería la imagen procesada. Una imagen en RAW por lo general contiene casi con exclusividad la información pixel a pixel que se ha tomado. Ya depende de la decena de archivos RAW que usan los fabricantes, el como incluyan la información, en que formato, si añaden metadatos… y esto es un gran dolor de cabeza, porque al no existir un estándar de facto, cada fabricante genera el que cree mejor, y así al final se requieren suites como Adobe CameraRaw o RawTherapee (O por supuesto DCRaw del que ya hablaremos) para poder tratar dichos ficheros. Al contener en la medida de lo posible la información en crudo, por otro lado, son archivos mucho más pesados que sus homólogos comprimidos como JPG.

Pero… ¿Donde empieza todo?

 

Sensores CFA: Bayer

La fotografía digital es totalmente diferente a la tradicional en cuanto a como la luz queda al final plasmada en un formato digital. En la fotografía tradicional es una película fotosensible la que capta la luz externa desde el objetivo. En la fotografía digital, el sensor de imagen es el que es bombardeado por los fotones de la luz, los hace converger, y es capaz de generar pequeñas tensiones en función de la intensidad/variaciones de estos fotones. Como es de suponer su versión más simplista sería un sensor que tan solo fuese capaz de percibir la intensidad de luz, pero a día de hoy sabemos que tenemos sensores de alta definición con una gama de colores enorme. 

El color es un problema, puede que para el ojo humano sea bien sencillo, pero para la electrónica causa dolores de cabeza. Pensar en un sensor en realidad es sencillo, imaginar algo así como una superficie plana rectangular como un colador, que tiene un agujerito por cada pixel de resolución que tiene dicho sensor. Si el sensor es de 4032×3016 pues tendría dicho número de agujeritos. El sensor sería capaz de tomar la luz por cada uno de esos agujeritos, y registraría el estado de cada una de esas celdas fotosensibles, que pasaría luego a un formato digital. ¿Pero que pasa con el color? Esas “células” fotosensibles que habría debajo de cada agujerito no pueden conocer de forma genérica la longitud de onda que les llega… podrían saber si es rojo o azul, azul o verde, verde o… pero no tener una lectura completa de todo. A este problema existen varias soluciones.

La más obvia es usar sensores con diferentes “capas”, las cuales, cada una de ellas es capaz de atrapar la intensidad de uno de los tres colores primarios (Rojo, Verde y Azul, RGB), pero esto es caro. Así que al final, prácticamente la totalidad de cámaras de fotos usan una aproximación realmente al problema, y usan sensores CFA: Color filter array. Los sensores CFA son mucho más baratos, pero hacen trampa. Cada “celda” del sensor no es capaz de capturar la intensidad de más de un color, cada celda sólo sabe capturar el de uno sólo, pero se crea una matriz, un mosaico compuesto de dichas celdas, organizados de un modo muy concreto, y así dar la sensación de que cada celda (pixel) posee color propio. Pero es una ilusión. La efectividad de un sensor CFA empieza por tanto en el patrón o la organización concreta de esas celdas (que pueden ser rojas, verdes o azules) que tendrán en el propio sensor:

(Wikipedia)

 

 

Dentro de los sensores CFA, nosotros nos vamos a centrar a su vez en los sensores Bayer. Bayer fue el inventor del patrón mostrado en la imagen anterior. Bayer se dio cuenta que el ojo humano es mucho más sensible al color Verde que al color Rojo y Azul, tomando pues el Verde como el componente lumínico y el Rojo y Azul como componentes cromáticos. Así que estableció lo que a día de hoy se conoce como Mosaico Bayer o patrón Bayer, que es sencillamente la repetición de un mosaico/bloque de 2×2, que contienen dos componentes verdes siempre enfrentados, y un componente azul y otro rojo. Estos patrones Bayer se nombran en función del orden en el que aparecen dichos componentes, y como es lógico solo hay 4 posibilidades: RGGB, BGGR, GRBG y GBRG. Recordar que el patrón es un bloque de 2×2, no 4 celdas alineadas. En la imagen anterior vemos un patrón BGGR, que se repite indefinidamente. El por qué de tomar el sensor Bayer de ejemplo, es porque a día de hoy es de lejos el tipo de sensor más usado. Pero ojo, no es el único, y no es tampoco nada raro ver sensores CFA de otro tipo, con otros patrones diferentes.

Si nos fijamos en la imagen de arriba, vemos la trampa y en parte el problema. Vale, tenemos distribuidas celdas capaces de captar los tres colores (e intensidad de estos claro), pero si hemos dicho que cada celda representa por así decirlo un pixel… ¿¿como diablos representamos eso?? Que cada celda recogiese en sí misma toda la información RGB tendría sentido, un pixel, un color RGB asignado. Pero en el sensor bayer cada pixel sólo recoge un color, una intensidad. Si tenemos una imagen de 2MB (1920×1080), según el patrón BGGR mostrado, el resultado sería de todo menos fotográfico, veríamos claramente un efecto “mosaico” en la foto, no una imagen colorida y hermosa. Además, tendríamos la peor parte… si usamos bloques de 2×2, podríamos pensar que realmente “1 pixel” real correspondería a cada bloque, lo que implicaría que el sensor tuviese que tener el doble de tamaño. Y ya os digo que esto no es así.

 

Demosaicing (Teoría)

(Nota: Cuidado, si se hace clic pasa a la versión completa, 11MB)

Puede parecer una broma, pero, en la imagen podemos ver realmente la información que capta un sensor Bayer (El Xiaomi Mi6 usa un sensor RGGB). Vista en la previsualización es posible que no lo percibamos, y sólo veamos una imagen completamente verde (poco que ver con la imagen con la que empecé este artículo. Pero si tenéis una conexión mínimamente decente, os invito a hacer clic, ampliar y ver que está pasando. Y se ve, creerme que se ve. Si ampliamos la imagen unas 1600 veces, para quien no tenga ganas de abrirla, esto es lo que va a ver:

 

Ahora no parece tan verde… ahora podemos apreciar perfectamente cuales son los píxeles con las distintas intensidades verdes, y cuales los azules y rojos. El patrón siempre es el mismo, bloques 2×2 RGGB, RGGB…

Pero falta información en la imagen o eso parece… ¿¿donde están realmente los colores?? Es cierto que sabemos que con RGB podemos crear cualquier color, pero aquí tenemos filas y filas del mismo patrón, y dado que hay el doble de píxeles verdes, toda la imagen toma en este caso un color claramente verdoso, El color final se encuentra codificado en la información de la intensidad de los píxeles que les rodea. El patrón Bayer hay que deshacerlo para reconstruir los colores reales, el valor RGB de cada pixel, y no sólo uno de sus componentes. A este proceso es al que se llama demosaicing, que realmente es una interpolación de colores. Como tal, y como ya se dijo, es siempre aproximada, el sensor jamás será capaz de captar los colores “reales” en toda su resolución, pero gracias al software y a la física podemos reconstruir de un modo muy fidedigno la imagen original. Sí, no deja de ser un truco, pero en este caso un gran truco.

Por supuesto el resultado por tanto va a depender en gran medida del modo de interpolación que sea usado. No existe un modo de hacer este proceso de forma única, hay tantos como algoritmos de interpolación existan o queramos crear. Y esto no es exclusivo del sensor Bayer, de echo casi todas las cámaras a día de hoy sino todas, si no usan Bayer usan otro sensor CFA con otro patrón, que también hay que interpolar. Un equipo de sobremesa podría en todo momento aprovecharse de esto para cargar la foto sin “desmosaizar”, y aplicar diferentes algoritmos para ver cual de todos ellos da mejor resultado para dicha toma, o por fines puramente artísticos. Además un equipo puede permitirse el lujo de hacerlo ya no en tiempo real, sino todo tipo de algoritmos que sean complejos y sobrepasen la capacidad de cálculo de cualquier móvil o cámara de fotos.

Cuando empecé a ver todo esto, sinceramente me pareció una locura, sabía como funcionaban más o menos los sensores de imagen, pero creía que cada “celda” del sensor en realidad se subdividía en 2-3 subceldas cada una de ellas captando la intensidad de un color y conformando en sí misma un pixel completo, no tenía ni idea que realmente cada pixel tomado de forma independiente no poseía en sí mismo un valor completo de color RGB. Muchos pueden pensar que puede ser más o menos interesante, pero que a fin de cuenta que importa, si al final es el resultado lo interesante. Por supuesto, pero desde un punto de vista técnico, hay una importancia infinita, y es por culpa del desconocimiento que tenía en estas cosas por el cual no era capaz de “revelar” mi primera captura RAW que realicé con mi terminal con Camera1.

Soy un amante de Photoshop, pero si quieres un control más fino del revelado RAW o tener opciones más flexibles, quizás es mejor probar en esos momentos un poco de RawTherapee, además de ser gratuito. Puede mejorar en millones de cosas, pero a veces nos da ese algo más que no tenemos en PS. Por ejemplo, entre otras cosas, diferentes algoritmos  para “desmosaizar”

 

Parsear archivos RAW

Se desde hace tiempo que se podían hacer capturas RAW con algunas aplicaciones y potencialmente obtener del sensor los datos tal cual los captura, pero de ahí a interpretar dichos datos hay un abismo. Si fuera tan sencillo no existiría Adobe CameraRaw y sus constantes actualizaciones, precisamente para ir soportando poco a poco más formatos. Como he dicho cada fabricante usa sus propios formatos. Al menos incluso en esos casos podemos llamarlos “formato” de archivos. Si lees la información directamente del sensor, poco o nada tiene que ver con esos archivos. Cuando una cámara normal hace una fotografía en RAW o incluso con las APIs “normales” de Android, se genera un archivo RAW generalmente conocido, que además de incluir información a nivel pixel a pixel, incluye la información necesaria que después cualquier “revelador” RAW podría necesitar. Por ejemplo, los parámetros con los que se tomó la foto (exposición, distancia focal, lente, marca, modelo….), el tipo de sensor que usa, si Bayer que patrón Bayer usa, que matrices de color o multiplicación se han aplicado… un largo etc de lo que podemos llamar “metadatos”. Algunos tan importantes, por supuesto, como la resolución de la foto, la profundidad de bits de color… Realmente no componen la imagen en sí mismos, pero si aportan información de todo ello necesaria. Sin ella es poco probable que algún revelador RAW puede interpretarla.

Este es el caso que nos atañe. Sí, después de capturar una imagen RAW con Camera1 con Mi6 obtengo efectivamente un archivo pesado, de unos 15Mb, exactamente (y esto es importante) 15482880Bytes. Hace ya días me preguntaban que sí, que sabían que podía capturarse en RAW con Camera1, pero que les había sido imposible “abrirlas” (revelarlas). A diferencia de otras formas de captura, aquí la información que tenemos es mínima, y solo podemos empezar a teorizar, después de intentar pasarlo sin éxito por diferentes aplicaciones RAW. Cuando las herramientas disponibles no nos valen, hay que hacerse las herramientas, y ver que pasa. Por suerte no es la primera ni la segunda vez que parseo archivos… es decir, analizo archivos en principio de índole binaria, soy capaz de encontrar o identificar cabeceras, datos… y en función de la estructura de estos crear un parser que pueda interpretarlos de algún modo. Con el tiempo aprendes a ver “patrones” en los editores hexadecimales que te hacen pensar sobre que tipo de contenido pueden tener: Comprimido, cifrado, información de color, espacial… y siempre por supuesto no con un archivo, a ser posible al menos con 2 o 3 diferentes, así poder encontrar patrones similares, ideales para cabeceras, tamaños/offsets y otros.

Distribución más o menos uniforme, sin cabecera visible. Si tenemos en cuenta que estamos tratando con archivos de imágenes, y dada la estructura que a simple vista podemos ver, parece razonable pensar que el archivo generado es sencillamente la sucesión de pixeles de la imagen. En principio cada uno de los Bytes podría ser cualquier cosa, pero para empezar podríamos pensar que cada Byte representa la intensidad de color de un Pixel, y aun cuando no conociésemos que es un sensor Bayer, lo primero que pensaría es que los pixeles estarían representados por cada 3 Bytes, pongamos que el primer byte es la intensidad Roja, el segundo Verde y el tercero Azul, y se repite por cada pixel. No parece que exista cabecera y eso es un problema, ya que el archivo en sí mismo no nos da ningún tipo de información extra, que es totalmente necesaria, así que hay que extrapolarla de las cosas que sí sabemos.

Lo que sabemos:

Archivo: 15482880 Bytes
Resolución Foto Tomada: 4032 x 3016

Por lo general un archivo JPG tiene una profundidad de color de 8Bits por canal (24Bits en total), es decir que tanto para el canal Rojo, El Verde y el Azul, se usan 8bits en cada uno que indican su intensidad, y los 3 Bytes conforman el pixel. 1Byte permite 256 valores diferentes, así que una profundidad de 24Bytes podría darnos unos 16.7 Millones de colores posibles. Esto es más que suficiente, pero cada vez exigimos más, y en fotografía profesional, Juegos (ahora de moda), HDR y otras cosillas, se requieren profundidades de color mayores. No es nada raro a día de hoy por tanto ver cámaras que disparan RAW a 10, 12 y 16 Bits por canal, incluso los propios monitores soportan profundidades ya mayores a los 32Bytes de siempre (24Bytes+8 Bytes más del canal Alpha). Sin especificaciones en la cabecera y sin que nadie nos pueda ayudar, sólo nos queda presuponer y hacer cuentas, que no es complicado.

El archivo parece mantener la estructura de principio a fin, aunque si mirásemos al final del archivo veríamos una parte que está totalmente vacía y si miramos otros archivos siempre es el mismo tamaño… así que no es mala idea apuntar ese “extra” de archivo, siempre 282240 Bytes. Bueno, pues si es así sólo hay que multiplicar/dividir para adivinar que pasa. Si suponemos que cada byte es un pixel (un componente RGB), ¿cual debería de ser el tamaño final del archivo?? La resolución la conocemos de antemano

4032 x 3016 = 12160512 pixeles x 3Bytes (1Byte por componente, 8 bits de profundidad) = 36481536 Bytes. Un valor bastante superior al tamaño que realmente tenemos de archivo, con lo que si usásemos una profundidad de color aun mayor, el tamaño sería mucho mayo, y obviamente no vamos a tener menos de 8bits por canal.

Podríamos hacer otra hipótesis, y pensar que realmente no existen 3 componentes por cada pixel, es decir, 24bits por pixel, y tan solo 8bits por pixel, pero entonces tendríamos la percepción de tener una resolución 3 veces inferior. Aun así, vamos a ver como quedaría:

4032 x 3016 = 12160512 pixeles x 1 Bytes= 12160512 Bytes. Un valor mucho más cercano al tamaño original, pero aun no coincide, ni siquiera si sustrajésemos el espacio vacío de 282240 de final de archivo.

Una opción es seguir probando, otra sería hacerlo al revés, partir del tamaño original y ver que pasa:

 

15482880 Bytes x 8 = 123863040 Bits / 4032  = 30720 / 3016 = 10,185 Muy cerca, demasiado… podrían ser 10 Bits por componente, o 10 bits para los tres componentes. El caso es que teniendo en cuenta la resolución y el tamaño, cada pixel está codificado por algo más de 10bits. A ver que pasa si descontamos al tamaño completo el espacio en blanco final de archivo:

15200640 Bytes x 8 = 121605120 Bits / 4032 = 30160 / 3016 = 10 clavados.

Así que una de dos, o cada pixel se codifica con 10 Bits para las tres componentes, o cada “pixel” se representa con una sola componente y 10Bits, que teniendo en cuenta es una imagen RAW, es lógico que se use una profundidad de más de 8bits por canal. Aquí es donde automáticamente recordamos los sensores Bayer y como funcionan, y podemos sacar en conclusión que:

-El archivo no contiene ninguna cabecera
-El contenido del archivo es una sucesión de pixeles consecutivos, cada uno de ellos codificado a 10Bits
-Cada pixel codificado de este modo tan sólo posee una componente, lo cual coincide con lo que cabría esperar en un sensor Bayer.

Todo esto es sólo hipótesis, por ahora no hay una imagen de nada. Lo bueno de Bayer es que como cada pixel se codifica sólo como una componente, podríamos tratar toda la imagen como si no existiese color, y cada pixel sólo tuviese información en la escala de grises. Si fuese así, representar eso en cualquier editor tendría que darnos una imagen en escala de grises de la fotografía original. Eso sería trivial con cualquier aplicación, incluso en PS podemos forzar la apertura de una imagen RAW indicando la resolución, los bits por componente y cuantos canales. El problema que tienen todos esos editores es que la mayoría no contemplan profundidad de 10 Bits. Photoshop por ejemplo te permite forzar la apertura para 8, 16… pero no para 10. Otros si te lo permiten pero entonces no te permiten forzar que lo interpreten sólo como un canal… y ya sin entrar en las diferentes formas de codificar en 10 bits pueden existir.

Aunque sólo fuese para ver si vamos por buen camino, podríamos intentar usar alguna herramienta de conversión para transformar esos 10bits en 16 o en 8. Por ejemplo, cada 10bits leídos escribir 2 Bytes en otro archivo. El archivo final aumentaría el tamaño claro está, por usar 16bits por canal. Otra opción sería el proceso inverso, pasar esos 10bits a 8bits por interpolación, y el archivo final tendría un menor tamaño. Pero de cualquier modo por desgracia no existen herramientas sencillas para esto.

Lo más cercano que tenemos, sin entrar en programar nosotros mismos, quizás sea con ImageMagick, y su utilidad Convert, que precisamente hace cosas similares. Si definimos nuestra imagen de entrada como una sencilla representación gris en 10bits y con la resolución concreta, podemos pedirle que nos lo pase a 16bits:

convert.exe -size 4032×3016 -depth 10 GRAY:MiImagen.raw -depth 16 imagen_16bits.raw

Vemos que efectivamente el tamaño crece para acomodarse a 16bits por componente, y ser mucho más sencillo poder verla con cualquier visor. Tal cual, usando Photoshop o cualquier editor, especificando repito resolución profundidad (16bits ahora) y canales (1 en este caso, gris), tendríamos lo siguiente:

No es una imagen muy definida que digamos, pero sí que podemos ver realmente el motivo. Así que desde luego desencaminados no vamos. Ojo, si no hemos cometido error a este paso la imagen tendría que verse en escala de grises de forma correcta. Pero por ahora pueden ser muchas cosas… podría ser debido a la conversión realizada por ImageMagick y como ha mapeado los niveles de 10 a 16bits, o podría ser que pese a que cada 10bits represente un pixel, podría ser que dichos píxeles no estuviesen organizados, como hemos presupuesto, uno tras otro. Podrían estar organizados de otros modos. Está claro que muy diferente no puede ser, o no tendríamos imagen. De todos modos podemos ver que hace algo mal… podemos apuntar la cadena de Bits y comprobar a mano el valor que tendrían por ejemplo los 10 primeros pixeles en 10bits, y compararlo con el valor que después de la conversión a 16bits estos mantienen… y vemos que el valor no se corresponde, ni siquiera se acerca. Posiblemente porque ImageMagick remapee todo el rango y lo escale, o simplemente tomemos mal los bits.

A este punto, se nos han acabado los amigos que nos solucionen la papeleta. Toca picar código. Para la tarea de crear un pequeño parser según lo que sabemos y a ver que pasa, podríamos hacerlo de cero de forma simple casi en cualquier lenguaje, o podemos hacerlo sobre alguna aplicación ya pensada para estos menesteres. En realidad hacer nosotros el parser por nuestra cuenta tiene la ventaja de no depender de nada mas y el código es simple, pero usar en este caos Dcraw nos da muchas más opciones a la hora de procesar. En principio la tarea es “sencilla”, un script/app que lea el archivo original y cree otro transformando cada 10bits en 16Bits. Mi primera idea, y creo que la lógica, es no mapear ningún tipo de color, sencillamente tomar  de 10 en 10bits, y meterlos cada uno en 16bits, conservando el mismo valor. Así si los primeros 10bits poseen un valor de por ejemplo 958, codificado en 2 Bytes sería 0x03be. El archivo final debería de poseer un tamaño 1.6 Veces mayor, ya que cada pixel pasaría a tener en teoría una profundidad de 16bits, aunque de ellos sólo se usarían 10. Recordamos que buscamos un resultado que podamos abrir y veamos claramente una imagen adecuada en escala de grises. El pseudocódigo de esto sería algo así, pensando en el stream de bytes como si se tratase de una “matriz” de bytes

Ancho_de_matriz = (Resolución_horizontal * 10) / 8
Columna = Fila = 0
Imagen = prueba.raw
Puntero_ArchivoNuevo = ImagenFinal.raw
Buffer, Buffer_Aux

Para (Fila < Resolución_vertical, Fila ++)
  Almacenar en Buffer la cantidad de Ancho_de_Matriz Bytes desde imagen //En cada interacción lee a partir del último valor leído
  Para (Columna < Resolución_horizontal, Columna += 4, Puntero_ArchivoNuevo += 5. Buffer_aux = Buffer)
    ArchivoNuevo [Fila, Columna] = (Buffer_aux [0] << 2) | (Buffer_aux [1] >> 6)
    ArchivoNuevo [Fila, Columna+1] = ((Buffer_aux [1] & 0x3f) << 4) | (Buffer_aux [2] >> 4)
    ArchivoNuevo [Fila, Columna+2] = ((Buffer_aux [2] & 0xf) << 6 )| (Buffer_aux [3] >> 2)
    ArchivoNuevo [Fila, Columna+3] = ((Buffer_aux [3] & 0x3) << 8) | Buffer_aux [4]

Visto así no hay quien lo entienda… pero en realidad es muy sencillo, es lioso porque hay que trabajar a nivel de Bits, y no de Bytes. La premisa es que hay un patrón que se repite, constantemente, y de ahí los dos bucles anidados. El patrón que se repite son las 4 sentencias finales. El bucle externo itera sobre cada fila, el interno por columnas. La única salvedad es que la iteración de columnas no toma columna a columna (byte a Byte) sino de 5 en 5 bytes. La razón es sencilla, si se codifican 10bits por pixel, el valor entero más cercano que a la vez sea múltiplo de 10 y de 8 es el 40. 40 Bits son 4 píxeles (columnas en archivo viejo) y a la vez son 5 Bytes leídos. Así que tratamos directamente con 5 Bytes a la vez, y repetimos hasta terminar.

La conversión lo único que hace es ir almacenando en otro archivo/buffer cada 10bits extraídos en 16bits, y para hacer eso lo más cómodo es desplazando los bits para un lado u otro. Vamos a ilustrar esto, pero de un modo mucho más sencillo, imaginemos que estos son los primeros 5 Bytes, y para facilitar la visualización vamos a obviar que usamos binario y que obviamente no podemos usar otros caracteres que no sean 0/1. pero hacer el seguimiento a los números es más cómodo.

Queremos pasar de esto: 11111111 22222222 33333333 44444444 55555555
A 16 bit, algo como esto: 00000011 11111122 00000022 22223333 00000033 33444444 00000044 55555555

Ejemplo paso a paso de las dos primeras columnas, las otras dos serían similares

Columna 0

Tomamos el primer Byte completo: 11111111, pero ahora tratamos los datos como 16 bits puesto que ArchivoNuevo está definido como tal, luego realmente tenemos: 00000000 11111111.
Lo desplazamos 2 posiciones hacia la izquierda: 00000011 11111100
Tomamos el segundo Byte competo: 22222222, y al igual que antes, tenemos realmente 00000000 22222222
Desplazamos hacia la derecha 6 posiciones: 00000000 000000022
Operamos con OR lógico los dos resultados previos: 00000011 11111100 OR 00000000 00000022 = 00000011 11111122

Columna 2

Tomamos el Segundo Byte completo: 22222222, realmente tenemos: 00000000 22222222.
Aplicamos una máscara AND antes de desplazar para evitar propagar los 2bits superiores, seteándolos a cero: 00000000 22222222 & 00000000 00222222 = 00000000 00222222
Lo desplazamos 4 posiciones hacia la izquierda: 00000022 22220000
Tomamos el Tercer Byte competo: 33333333, realmente 00000000 33333333
Desplazamos hacia la derecha 4 posiciones: 00000000 000003333
Operamos con OR lógico los dos resultados previos: 00000022 22220000 OR 00000000 00003333 = 00000022 22223333

 

Por desgracia, este primer parser nunca me funcionó. Tenía un resultado ligeramente mejor que el anterior expuesto, pero muy muy similar. Quizás ImageMagick hacía un trabajo parecido después de todo. Pero lo bueno de hacerlo uno mismo es que una vez realizado, modificar algunos detalles es trivial, solo hay que modificar, compilar y probar de nuevo. Después de darle unas cuentas vueltas opté por algo muy sencillo… pensemos en compatibilidad… en 5 Bytes tenemos 4 píxeles, ¿¿y si realmente la mayoría de esa información que nos interesa estuviese realmente en esos 4 píxeles?? Es decir, que pasa si eliminamos el quinto Byte y tratamos realmente cada Byte como tal (con una profundiad de 8 bits y no de 10) Contamos 5, usamos y asignamos los 4 primeros y descartamos el quinto. Además es mucho más fácil programarlo, es trivial, sólo hay que asignar directamente sin desplazamientos ni historias.

    ArchivoNuevo [Fila, Columna] = Buffer_aux [0]
    ArchivoNuevo [Fila, Columna+1] = Buffer_aux [1]
    ArchivoNuevo [Fila, Columna+2] = Buffer_aux [2]
    ArchivoNuevo [Fila, Columna+3] = Buffer_aux [3]

Compilamos, convertimos, el quinto no será usado nunca, ya que en el iterador interno contamos de 5 en 5:

No sé como tendréis calibrado los monitores, porque está algo oscura, pero para mi que eso es una imagen perfecta en escala de grises (bastante oscura eso sí), a la original. Pero entonces, ¿para que sirve ese 5 Byte? Bueno, en realidad cuando llegas a este punto piensas que es lógico. El sensor manda los datos en 10Bits, y que mejor forma que hacerlo por cuestiones de compatibilidad que “empaquetados” en Bytes normales, + 1Byte adicional que porta los 2Bits restantes de cada uno de los 4Bytes (píxeles) anteriores. Como en la prueba simplemente fueron eliminados, la conclusión es clara, el quinto Byte contiene los 2 bits LSB de cada uno de los otros, es decir, los Bits de menos peso en esos 10 Bits. La idea original era errónea:

11111111 22222222 33333333 44444444 aabbccdd
No pasa a ser:
00000011 11111122 00000022 22223333 00000033 33444444 00000044 aabbccdd

Pasa a ser:
00000011 111111dd 00000022 222222cc 00000033 333333bb 00000044 444444aa

Lo cual implica una gran diferencia. En realidad podrían asignarse al revés, y suponer que la asignación se hace al contrario, es decir que al primer byte le corresponde los dos MSB del 5º byte, y no los 2 LSB. Por desgracia los resultados son demasiado similares como tener una certeza exacta ahora mismo de cual de las dos asignaciones es la correcta. Sería necesario hacer capturas muy concretas para que las diferencias se diesen en un borde o un cambio suficientemente brusco como para percibirlo. Actualmente he optado por la segunda, por ser más simétrica, los 2 MSB para el primero, los dos siguientes para el segundo… pero da igual una que otra realmente. La implementación, teniendo en cuenta ya expuesta las otras dos, creo que es sencilla, así que la dejo en manos de quien le interese como ejercicio, y en todo caso si le interesa a alguien y no puede, que la pida. El resultado es similar al anterior, aunque una imagen bastante más clara. Si ampliásemos, podríamos observar, aunque en escala de grises, el patrón Bayer, en este caso en monocromo. Se podría multiplicar la imagen anterior para obtener una imagen mucho más clara, Si podemos capturar 10 Bits en vez de en 8 Bits, es precisamente para poder tener una mejor precisión de color y poder representar una paleta mayor, si en la conversión eliminásemos esos 2 bits de más empaquetados en el 5º byte, , pues la verdad es que le quitamos gran parte de la gracia al asunto.

La importancia de la imagen en escala de grises es por la propia naturaleza del sensor Bayer. En realidad cada pixel no representa una tonalidad de gris, sino una intensidad Roja, Verde o Azul, pero mientras que no se deshaga el mosaico bayer, podemos tratarla como si cada pixel fuese ni más ni menos como un pixel gris. Podríamos representarla tal como es, pero al menos que yo sepa no existe ningún visor digamos… Bayer, que represente el color de cada pixel en función de un patron dado, para dar una imagen similar a la expuesta en la apertura de la sección de Demosaicing. No obstante se podría hacer uso de Photoshop para representar el mosaico de un modo bastante fidedigno, creando el patrón RGGB, rellenando una capa sobre la imagen con dicho patrón… pero sería complicar las cosas, cuando lo principal está terminado. Photoshop es cierto que no posee ningún filtro o sistema sencillo para realizar la interpolación de colores (a menos que se haga desde CameraRaw e identificando la imagen), con lo que dcraw nos va a servir para hacer la interpolación. De ahí que, una vez creado el parser, si lo implementamos dentro de dcraw, tendremos en la misma herramienta todo lo que necesitamos. Por supuesto este es el caso específico del Mi6, pero como dije en su momento es extrapolable a cualquier otra imagen RAW capturada por los teléfonos/cámaras… con los correspondientes ajustes, por supuesto.

 

Dcraw

Una gran utilidad, y al ser además de código abierto podemos meternos en sus tripas, editar lo que deseemos, añadir… en realidad nos viene perfecta, ella misma está preparada para gran cantidad de formatos de cámaras, y hace precisamente todo lo que queremos hacer nosotros. Si hemos sido capaces de crear un parser para nuestra cámara, siempre y cuando no esté incluida ya, implementarlo/añadirlo a dcraw es sencillo, además de poder luego procesarla. El código de dcraw está publicado en la propia web del autor ya mencionado, quien quiera una copia fresca la puede obtener de AQUI. Está creada de forma sencilla en C sin dependencias raras y se compila sin problema con gcc:

gcc -o dcraw -O4 dcraw.c -lm -DNODEPS -l ws2_32

En este caso sería compilado para Windows, de ahí la inclusión de ws2_32 por ejemplo, pero se puede compilar para cualquier OS realmente.

Llos cambios necesarios son escasos. Necesitaremos crear el parser por un lado, una metadescripción de nuestro formato y una llamada a nuestro parser cuando se encuentre/identifique nuestra imagen. Como digo el código de dcraw es bastante limpio y con un poquito de tiempo se comprende bastante bien.

Así pues nuestra primera parada es la descripción de nuestro archivo. Sobre la línea 8300 vemos una tabla ya creada con lo que parecen descripciones de diferentes cámaras, así que la idea es incluir la nuestra. Esto podemos hacerlo no sólo con una, sino con las que queremos. Pero recordar que aquí sólo describimos por así decirlo la cámara. Para nuestro caso sería algo así:

{ 15482880,4032,3016, 0, 0, 0, 0, 1,0×94,0,0,”Xiaomi”,”Mi 6″ }

Es necesario buscar en el código el significado de cada campo, en la misma estructura queda más o menos puesto:

fsize: Tamaño del archivo en bytes
rw, rh: Resolución horizontal y vertical respectivamente
lm, tm, rm, bm: Márgenes izquierdo, superior, derecho e inferior
lf; load_flag (usado en varias partes del código para “marcar” ciertos archivos
cf; Filtro a usar, en este caso tendremos que especificar que queremos usar un filtro Bayer RGGB, 0x94.
max: máxima profundidad de bits usada
flags: Diferentes flags, como inversión de imagen y otros.
make: Fabricante
model: Modelo

Hay que tener en este caso concreto algo claro e importante. Recordemos que en el caso del Mi6 el archivo que se genera añade al final del archivo unos miles de Bytes adicionales. Si queremos procesar el archivo directamente sin necesidad de eliminar previamente dichos Bytes, tendremos que especificar el tamaño completo, con dichos bytes incluidos, y en nuestro parser asegurarnos que no se lee más allá. En el pseudocódigo anterior esto no es problema, ya que se lee hasta que la fila leída coincida con la resolución vertical, con lo que el resto se ignorará. Pero hay que tenerlo en cuenta, si el parser lee el archivo completo hasta final de archivo, podría incluir dichos Bytes. Es más cómodo especificar el archivo completo, y no hay que estar metiendo tijera, o en el propio parser tener que cortarlo. La captura RAW lee todo el sensor, así que la resolución siempre será la  máxima por regla general, y el tamaño de archivo también.

Una vez definido nuestro archivo, esta tabla permitirá que el archivo sea reconocido y pueda seguir adelante, aunque no significa que hayamos terminado. Esta tabla es muy útil porque si por ejemplo tenemos otro terminal que captura de un modo muy similar, casi tan sólo tendríamos que añadirlo a la tabla para que directamente funcionase, y usar el mismo parser creado. Sea como sea, lo siguiente es crear el parser tal como quedó dicho anteriormente, cada uno que lo desarrolle como quiera. Podemos colocar el código por ejemplo encima de “minolta_rd175_load_raw” y para seguir con la misma nomenclatura llamar a nuestro parser: “xiaomi_load_raw”. Podemos servirnos de los propios métodos ya creados en dcraw para facilitarnos el parser, pero la cuestión es que al final la “imagen” final resultante quede en raw_image, accedida desde RAW(row,col)

Y para finalizar, sólo queda añadir el salto a xiaomi_load_raw cuando detectemos el archivo en cuestión. Pensar que el parser creado no es específico para xiaomi, en realidad es un parser MIPI de 10bits, y dcraw carecía de él. dcraw sí incluye ya parser parecidos incluso para parsear raw bayer en 10bits, pero tendríamos algo similar al primer resultado que obtuvimos al presuponer que que los bits estaban totalmente serializados, y no empaquetados, como al final fue el caso. Así que podemos hacer uso de esa misma función, sobre la línea 8595 más o menos vemos diferentes case, para 8, 10, 12… bits. Desdoblamos el Case 10, y simplemente llamamos a  nuestra función del mismo modo que hacen otros:

load_raw = &CLASS xiaomi_load_raw; break;

Eso es todo, compilar y listo. Si todo es correcto tan sólo tendremos que invocar dcraw como dice en su propio manual y con los parámetros que queramos. La idea de usar Dcraw es múltiple. Por un lado podemos hacer uso de sus propias funciones para facilitarnos la tarea de crear nuestro parser, pero además nos va a permitir realizar a la imagen diferentes transformaciones/conversiones. Por supuesto, principalmente lo que haremos será la interpolación de colores para convertir nuestro mosaico Bayer en una imagen todo color, pero también es muy útil para ajustar algunos parámetros antes de realizar la interpolación. Recordar que es una imagen RAW, es decir, vemos lo que ha tomado el sensor, sin procesar, sin aplicar matrices correctivas, cambios de espacios de color… nada. Pero precisamente por eso usamos RAW, ¿no? Si queremos precisamente una imagen procesada, nos quedamos con el JPG.

 

Uso de Dcraw

Dcraw es algo así como un revelador RAW, toma una imagen RAW de entrada y la convierte/interpreta a un formato más amigable. Ya sabemos que cuando se lo ordenemos nos va a decodificar la imagen Bayer en una ¿bonita? imagen, pero depende de lo que le digamos, la salida será realmente sin procesar o podrá realizarle algunos ajustes básicos. Cuando una cámara dispara una foto en RAW, por lo general adjunta en ella un perfil DCP que especifica las transformaciones de color, tipo de sensor… y otros ajustes que deberían de ser necesarios (al menos de forma orientativa), para que la imagen sea visualizada de forma correcta. De echo gracias a estos perfiles incrustados la mayoría del software RAW que existe en el mercado (Como Adobe CameraRAW) se basa en estos perfiles para automáticamente aplicar dichos ajustes a la imagen y tener nosotros algo bonito en pantalla.

Muchos podrían pensar que estos ajustes matan el principio del propio RAW, que es tomar una imagen sin procesar. Realmente los perfiles no dictan como se ha procesado la imagen, sino como se podría procesar en función de la información del sensor que el aporta. Así podemos usar el perfil tal como está, o podemos realizar en el editor los ajustes que deseemos, pero desde luego nos suelen servir de base. Aquí de todos modos tenemos un pequeño problema añadido… al archivo RAW nuestro no se le añade ningún tipo de información adicional, ni cabecera. Eso quiere decir que la imagen que vamos a obtener en este caso es totalmente RAW sin perfiles que especifiquen nada… ya no sólo información para que el software de tercero sea capaz de parsearla, sino tampoco ajustes básicos que habría que tener en cuenta del sensor: Matrices de Color, de conversión de espacio de Colores, punto negro… y no es una tontería, porque la no tener una referencia de estos, tendremos que valernos de nuestras habilidades para ajustar correctamente tanto colores como balances de blancos y otros, de nuestra imagen. Sobre la pregunta obvia de si sería posible implementar en Dcraw igualmente matrices de ajuste específicas para cada cámara/dispositivo, la respuesta es que por supuesto, pero esto varía enormemente de sensor en sensor, con lo que no se trata de poder usar una de otro modelo para ajustar la nuestra. Por supuesto si damos con los parámetros que nos gustarían, podríamos hacer que aplicase dichas transformaciones, cosa que hacen muchos otros modelos/dispositivos. Yo no he tocado las matrices, no hay correcciones de nada en principio, quitando eso sí los ajustes al vuelo que permite realizar Dcraw y que ahora veremos. Recordamos que en Dcraw realmente ya especificamos resolución, tamaño de archivos… así que será por este tipo de identificadores por los cuales Dcraw sabrá que imagen estamos metiendo de entrada, no importa la extensión o el nombre.

Algunos ejemplos sencillos y las salidas resultantes:

1. Conversión “estándar”. Imagen resultante no lineal, en 8bits, interpolada, y escalada: dcraw -v -c Camera1_bayer10.bayer > Test1.pgm

Es muy similar a lo que sería la imagen JPG resultante procesada, excluyendo el balance de blancos y un estrechamiento en los niveles. Por razones evidente este tipo de conversiones no son lo que deseamos, para eso menos lío realizando la fotografía normal. La idea de RAW es poder jugar con el máximo de información de la propia imagen para procesarla nosotros de un modo mucho más fino, y en este caso hemos de un plumazo eliminado la linealidad de la imagen, así como la mayor profundidad de colores. Esto se puede solucionar especificando que se realice la conversión en 16bits (manteniendo los 10bits que capturó el sensor), o directamente especificando que se mantenga la linealidad en la imagen, que por defecto también fuerza la salida en 16bits, en vez de 8.

 

2. Conversión manteniendo la linealidad de la imagen y los 10bis de profundidad (convertidos a 16), interpolada y escalada: dcraw -v -c -4 Camera1_bayer10.bayer > Test2.pgm

Pese a lo que pueda parecer, es muy diferente a la anterior. En este caso no sólo existe un mayor rango de colores (no apreciables aun), sino que la imagen es lineal, de ahí a que parezca más oscura (incluso estando escalada). Esto es importante. Prácticamente la totalidad de los sensores de las cámaras tienen un comportamiento lineal, es decir, que el “valor” de cada celda/pixel que es recogido debido a la intensidad de los fotones que llega a ellos, es siempre proporcional. Dicho de otro modo, si por ejemplo para 10 fotones el sensor registrase en dicho pixel un valor de 20, para 20 fotones recogería un valor de 40. Esto puede parecer una tontería, pero la cuestión es que el ojo humano y nuestra percepción es de todo menos lineal. Las imágenes lineales suelen comprimirse sobre todo en las sombras, mientras que las no lineales se expanden hacia los medios tonos e iluminaciones, produciendo un comportamiento, aparente, de más homogeneidad:

Se puede apreciar perfectamente los dos efectos. Los picos o “vacíos” que se encuentran entre las diferentes curvas en la primera imagen se deben a la reducción de la profundidad de color, no presentes en la segunda. Así mismo se puede observar perfectamente la linealidad de la imagen, mientras que el primer histograma se esparce por la mayoría de la escala, la segunda imagen, lineal, se condensa en la parte izquierda, en las sombras. La cuestión es simple, si queremos tratar lo más RAW posible una imagen, es de sentido común que no la transformemos en no-lineal como se hacía en el anterior ejemplo. Aquí no no la convertimos en lineal, sino que la mantenemos lineal, al igual que mantenemos su profundidad de 16bits (1obits). Obtenemos una imagen mucho más fiel a lo que realmente capturó originalmente el sensor.

 

3. Salida RAW pura (sin interpolar), escalada y sin escalar: dcraw -v -c -4 -d/-D Camera1_bayer10.bayer > Test3.pgm

Cuando hablamos que la imagen no está interpolada, significa que no se ha revertido el filtro Bayer. Como ya dijimos no es que la imagen esté en escala de grises, es que realmente cada pixel corresponde a la intensidad de un color concreto. Esta imagen la hemos visto anteriormente. Si se representase en vez de en escala de grises en color, el resultado sería la imagen verdecina que vimos anteriormente. Por lo general, cuando se representan las imágenes sin deshacer el mosaico Bayer, es así como lo hacemos.

Por otro lado, hasta ahora todas las imágenes que se han puesto están escaladas. ¿Que significa esto? Recordar que estamos tratando con imágenes de 16 bits de profundidad y encima lineales. Eso quiere decir que en teoría cada pixel de dicha imagen puede tomar un valor entre 0 y 65535 (debido a los 16bits), y que debido a la linealidad “empezamos” en el cero (negro absoluto, ausencia de fotonos). Pero en cambio el blanco absoluto no existe como tal concepto, dado que el sensor en teoría siempre podría ser más sensible, captar más fotones y aumentar el valor aun más, con lo que hablaríamos del concepto llamado blanco más allá del blanco. Por eso vemos siempre una condensación en el extremo izquierdo en fotos lineales. Bien, ya hemos hablado de la linealidad, ¿pero el escalado? Bueno, es útil/necesario por dos motivos. El primero como se ha dicho debido a la linealidad y la compresión en el lado izquierdo, pero también porque nuestro sensor no es sensible a 16bits, es decir, a los 65536 posibles valores. Para 10bits, nuestro sensor “solo” es capaz de distinguir entre 1024 valores diferentes (recordar que todas las imágenes que vemos en fotos y otros generalmente están a 8bits, 256 valores diferentes), con lo que a efectos prácticos si no escalamos los valores esta sería negra o prácticamente negra entera (de ahí que no vaya a poner una imagen haciendo la prueba). Esto se soluciona de un modo sencillo, y es multiplicando literalmente el valor de cada pixel. En este caso tenemos 10bits = 1024, 65536 / 1024 = 64. Es decir, un factor de escala de x64. Dado que el sensor no es capaz de ir más allá de los 10bits, no vamos a tener pérdida de información, aunque por supuesto no se nos escapa que si el sensor fuese más sensible podríamos captar más detalle en los colores.

Si hacemos, esto, si escalamos la imagen, el resultado pasa de ser negro a ser la imagen que he puesto anteriormente. El parámetro d/D en Dcraw especifica siempre que la salida será sin interpolar, sin deshacer el filtro Bayer, la elección de un parámetro u otro, es que D no escala la imagen, mientras d la escala automáticamente en función del valor que el estima que es el adecuado analizando internamente la imagen. En este caso acierta, y aplica un escalado de x64. Hay que indicar que el mismo resultado lo podemos obtener perfectamente sin escalar la imagen, y haciéndolo manualmente. Por ejemplo en Photoshop, podemos acceder a los ajustes de niveles de la imagen y modificar la salida. Photoshop independientemente de la profundidad de color que se use, usa sliders de 256 valores, pero pese a que sólo muestra 255 saltos mantiene igualmente la información intacta y escala en función a ello. En este ejemplo concreto si no escalásemos la imagen, para tener el mismo resultado tendríamos que desplazar el slider de photoshop al valor 3. Sí, desplazar el medidor derecho que está en 255 al 3. Y magia, la oscuridad desaparece (256/64 = 4, 3 teniendo en cuenta que el cero cuenta.)

 

4. Conversión lineal, interpolada, escalada, con ajuste de balance de blancos, y otros: dcraw -v -c -4 -T -a -k 50 Camera1_bayer10.bayer > Test1.tiff

El parámetro k permite especificar el punto negro. Dado que escalamos la imagen, esta tiene a desplazarse hacia la derecha, haciendo que se produzca un “agujero” en la zona inferior. El cero absoluto originalmente es el cero, pero si cuando se tomó la imagen el valor más pequeño era el 100 (por ejemplo), al multiplicarse por 64 deja un hueco más… “grande” en el negro. Este ajuste permite desplazar de nuevo la imagen hacia la izquierda, restaurando el negro “puro”. Obviamente eso produce un oscurecimiento generalizado debido a que el desplazamiento es a toda la imagen, cosa que luego se podría corregir. Aun en este punto la imagen seguiría siendo lineal.

El otro punto importante es el balance de Blanco. El sensor capta lo que capta, y aquí no está calibrado hacia nada. Es por eso que la imagen se muestra verdosa si se interpola y no se toca nada más, los colores no son los que deberían de ser. El ajustar el balance de blancos pone punto y final al problema. Por desgracia esos ajustes dependen de la fotografía tomada y del sensor. Dado que no tenemos datos más o menos fiables del sensor, sólo podemos probar diferentes ajustes en función claro está de lo que vemos… prueba error. Dcraw incluye el parámetro “a” que permite evaluar la imagen completa y estimar el balance de blancos adecuado, pero como todo es siempre relativo. Por ejemplo para la imagen anterior, dcraw calcula que los valores adecuados para el balance de blancos sería:

1.122304 1.000000 1.947417 1.000437

Dcraw especifica el ajuste de blancos multiplicando cada componente (antes de la interpolación por supuesto) por un valor concreto. En un filtro Bayer tenemos 4 componentes recordemos, en nuestro caso es un sensor RGGB, así que cada multiplicador se aplica a cada uno de ellos, aunque no en ese orden. El orden de aplicación es R G1 B G2. Si nos fijamos, la imagen es muy verdosa, y efectivamente ambos componentes tienen un valor de 1 (o cercano a él). Por el contrario aumenta de forma considerable el componente azul. La imagen resultante es mucho mejor, pero como es natural no está a la altura.

Si creásemos el parser como un complemento en Photoshop para CameraRaw, este tipo de cambios serían totalmente interactivos, al igual que lo usamos para otro tipo de formatos. Por desgracia Photoshop no tiene forma humana de interpretar nuestro archivo, pese a que no es muy complejo. Eso nos “limita” en tanto que si queremos realizar un ajuste de blancos antes de la interpolación, lo tenemos que hacer manualmente. Por supuesto podemos corregir luego todo lo que queramos a la imagen, pero recordemos que ya será sobre la imagen interpolada. De cualquier modo, aun estaríamos con una imagen lineal, y de ahí la apreciación de una imagen “triste”, sin un colorido importante. Ya hemos dicho que el ojo humano no percibe la realidad igual que la tecnología, así que para que la imagen se ajuste a algo más vistoso, el paso final sería retocarla en cualquier editor para romper la linealidad y ajustar correctamente el resto de parámetros.

 

Apuntes finales

Aunque la modificación realizada a Dcraw afecta únicamente en primera instancia al Mi6, es extrapolable a cualquier otro teléfono o dispositivo que sea capaz de capturar imágenes de un modo similar. Gracias a la granularidad de Dcraw, añadir o quitar “perfiles” de cámara es sencillo, y si usan un sensor similar o un sistema que transfiera los datos de igual modo, es suficiente con añadir resolución, tamaño y patrón bayer correspondiente a la lista. No importa que sea un Mi6 o un Mi5 o por supuesto terminales de otros fabricantes, si la cámara reporta que es capaz de capturar RAW en algún formato, podemos añadirlo. Como es lógico, añado sólo el terminal con el que he andado jugando, pero animo a cualquiera que pruebe si le interesa.

No me gusta distribuir binarios, prefiero que el usuario se las apañe y aprenda a compilar por si mismo, pero dado que voy a publicar la herramienta en otro lado también, no creo que haga mal en esta ocasión a nadie distribuirla, y ahorrar el trabajo a algunos. La versión usada es la más actual hasta la fecha de Dave, 1.477, que he cambiado a 1.478. Los únicos cambios realizados son los expuestos: Añadir el parser, desdoblar la rutina de reconocimiento de 10bits para llamar al parser e incluir el Mi6 dentro de la tabla de cámaras. Realmente debido a las pruebas que hice tengo creado 4-5 parser diferentes, pero a efectos del código compilado es indiferente:

Enlace a dcraw compilado

 

Dado el interés que se han tomado algunos, en la medida que tenga tiempo y me manden los archivos necesarios, añadiré soporte a otros dispositivo, incluyendo obviamente el Mi6.

 

Actualizado (15 Sept 2017):

Soporte adicional para los siguientes dispositivos:

-Xiaomi Mi 6
-Xiaomi Mi 5

HTTPS no añade legitimidad o credibilidad a una Web, brinda seguridad

Share on Google+Share on FacebookTweet about this on Twitter

Llevo ya días que al despertarme me topo con alguna noticia relativa a HTTPS, supongo que los responsables son Mozilla y Google, que desde primeros de años decidieron aplicar algunas medidas coercitivas en sus navegadores, lo que sucede es que como siempre si el usuario medio no entiende lo que quiere decirle un cartel de advertencia, al final da igual.

 

Brevemente, sobre el mensaje “nuevo” que estas dos compañías han instaurado. Es un ejemplo más que muestra el trabajo que cuesta a veces a los usuarios de perfil medio la diferencia entre seguridad y legitimidad de una página. Muchos empezaron a decir incluso que Google iba a advertir con mensajes a los usuarios sobre que una web no era segura… no tiene nada que ver con eso, de echo tanto Firefox como Chrome muestran exactamente lo que tienen que mostrar, la lectura que otros le quieran dar es diferente:

La primera es el mensaje que muestra Firefox, el segundo Chrome, este último también traslada un mensaje en la URL. En esencia dicen exactamente lo mismo. Ambas compañías simplemente muestran en pantalla ese mensaje cuando se dan dos circunstancias: La primera, estamos en un formulario que se reconoce un campo de contraseña donde vamos a introducirla. La segunda es que la Web en cuestión en la que vamos a introducir dicha contraseña no está bajo HTTPS con un certificado válido. Dicho de otro modo, al no estar la web bajo HTTPS, los datos que pongamos tanto en la contraseña como en el nombre de usuario, es posible que sean enviados en “texto plano”, es decir, tal como los introducimos, y por ende podrían ser potencialmente interceptados por alguien que “pinchase” la conexión en cualquier punto de esta.

Hay que entenderlo, no significa que la web sea insegura realmente, o que no sea legítimas. Lo que nos avisa es que si nuestra red no es segura (nos están robando WIFI, tenemos un familiar/amigo travieso conectado a ella, usamos una red pública…), alguien podría potencialmente leer ese tráfico, y claro… a lo mejor no importa tanto saber que visitas una web concreta o incluso el contenido de ella, pero si importa y mucho si lo que capturan es la contraseña de tu correo electrónico, de acceso a un servicio. Pero repito, nada tiene que ver con legitimidad o fiabilidad, y es más, esa advertencia puede no ser importante si sabemos perfectamente desde donde nos conectamos.

 

Volviendo al asunto original del artículo, estoy aburrido de leer “noticias” sobre HTTPS, Certificados TLS/SSL, “seguridad”… y casi todos ellos sesgados. El último ha sido esta tarde… no me gusta tirar tierra a nadie y respeto el trabajo de cualquiera, pero creo que hay que ser más riguroso en lo que se escribe, y por citarlos, hablo de un artículo en Xataka. A veces una coma o el modo de decir las cosas no importa y se sobre entiende, pero otras veces el significado es muy diferente sólo con que falte un acento. En este caso, y cito textualmente encontramos el problema de siempre, algunas frases muy poco afortunadas:

“Esto quiere decir, que una dirección web en la que tengas que empezar escribiendo https:// en vez del clásico http:// será siempre mucho más segura, ya que certifica que la web visitada es legítima…”

“Chrome están empezando a señalar como inseguras todas las páginas que no lo utilicen”

No voy a valorar el resto del artículo, por supuesto dice cosas totalmente ciertas, el problema es que hay otras que no lo son.

Por un lado, sobre el comentario que se hace de Chrome, es falso, siempre he dicho que una media verdad no deja de ser una mentira, intencionada o no. Chrome NO SEÑALA las webs como inseguras cuando no están bajo HTTPS, Chrome, al igual que Firefox, lo que hacen es mostrar un aviso en el campo contraseña (y Chrome también en la URL) cuando existe un campo contraseña, y ese aviso, aunque pueda usar la palabra “insegura”, especifica bien claro a que se refiere, al envío de información cuando se rellena un formulario o cualquier otra cosa. Este aviso no aparece si dicha web carece de cualquier campo de este tipo, esté en HTTPS o no.

Sobre la primera frase, realmente es lo que me llevó a volver al blog, no por Xataka realmente, lo de ellos ha sido una noticia más haciendo alusión a eso de dar legitimidad a una web o no.

 

¿Qué es y qué no es HTTPS?

HTTPS se basa en autentificación y cifrado entre el equipo de origen, y el servidor destino, de forma bilateral (por lo general la autentificación la realiza sólo el cliente, no el servidor). Que un servidor use HTTPS para servir sus webs, poco o nada tiene que ver con que esa Web sea más segura, o que dicha web sea quien dice ser, con la única excepción de que use certificados tipo EV en todo caso (en lo relativo con la identidad, es decir legitimidad).

La necesidad de HTTPS nace precisamente de los cartelitos que ahora muestran Firefox o Chrome. Cada vez más usamos las conexiones inalámbricas, cada vez más hay desconfianza de los ISP (proveedores de internet) e incluso de los propios estados!! Quien no conoce a día de hoy los casos de Wikileaks y tantos otros. El cifrado no es algo nuevo, y creo que todos lo entendemos bien… algo que no esté cifrado no significa que no sea seguro, significa que si alguien lo intercepta lo va a poder leer.

No veamos HTTPS como un ente tan extraño, se puede simplificar enormemente, pensemos en vez de HTTPS y páginas web en una carta, en que quiero hacer llegar una carta a mi amada, y para ello no tengo más opción que dársela a un amigo para que a su vez se la entregue a ella. A nadie se le escapa el problema, incluso si pusiésemos un lacre sellado, mi amigo podría abrirla y leer el contenido, y si el contenido de la carta no usa un código secreto que sólo entendiese ella y yo, pues mi amigo se enteraría de todo. En función de la relevancia de las letras que ponga en esa carta, usar un código secreto entre los dos puede ser simplemente un juego, a ser totalmente necesario.

En Internet, el amigo puede ser tu hermano conectado a tu misma red, puede ser un vecino que te roba WIFI, puede ser un desconocido conectado a la misma red pública (WIFI o cable), puede ser incluso si quisiese tu ISP, por supuesto el gobierno… y eso sin contar absolutamente cualquier punto por el que tus datos son transferidos hasta llegar al servidor final. Al margen de conspiraónicos y que los gobiernos y los ISP nos espíen, el principal problema no son ellos, son las redes en las que nos conectamos. Puede que no me haga gracia que, en caso de hacerlo, un gobierno quiera interceptar mis comunicaciones, pero a fin de cuentas tampoco tengo nada que considere “personal” para ellos, más me preocupa que desconocidos puedan conocer mis datos personales, cuentas y otros.

 Sí, el cifrado puede ser algo positivo, pero desde luego desde mi punto de vista indispensable cuando manejamos información personal o evidentemente confidencial, y HTTPS soluciona esto. Ya hablé en su día largo y tendido sobre ello en uno de mis artículos, y recientemente también en el de Let’s Encrypt, donde por encima explicaba todo esto, aunque en menor medida.

Inicialmente hablaba de legitimidad… HTTPS trata sobre cifrado de datos, no sobre legitimidad. Sí, el servidor se autentifica/identifica de cara al usuario, pero no para certificar que el contenido de la página es legítimo, ni siquiera que la propia web lo sea!! Lo que certifica en todo caso (de tener un certificado digital reconocido y excluyendo los certificados EV que veremos luego) es que dicho certificado fue emitido para dicho dominio específicamente, nada más. Dicho de otro modo, que el certificado que nos llegue a nuestro equipo, poder ser validado para estar seguros que quien nos los mandó es la web que tenemos delante.

Y en ese párrafo está toda la madre del cordero. Xataka dice que certifica que la web que tenemos delante es legítima… no es cierto, la web puede decir que es Paypal, la web puede ser un calco perfecto de cualquier página de un banco, e incluso podrían tener un dominio similar!! y por supuesto, podrían usar perfectamente un certificado digital (y usar HTTPS) validado. Evidentemente a mi modo de ver las cosas, no considero eso como una web legítima. Esto es algo que se está empezando a hacer de forma masiva, por la falsa creencia precisamente del usuario de creer que si ve el candado verde la web es fiable, y es un error de base. Sí, la comunicación con dicha web se hace de forma cifrada y ningún vecino nos intercepta la comunicación, pero los datos que enviamos llegan igualmente al servidor, y si esa web la hace una persona malintencionada, evidentemente tiene acceso a dichos datos, datos que nos acaba de robar por creer nosotros que por tener candadito verde la web era legítima de fiar.

Pero por supuesto, que son unas letras sin una buena imagen. Ni siquiera he tenido que invertir tiempo en hacer una prueba propia sobre esto, simplemente me ha bastado con  mirar en cualquiera de los servidores usados para los registros de transparencia de certificados (por ejemplo https://crt.sh), que registran los certificados emitidos por las diferentes agencias CA que los usan, y mirar los dominios para los cuales se registran. Yo he buscado por Paypal, que contengan los dominios “Paypal”, por ejemplo, y el primer certificado que he encontrado que contenía su nombre ha sido el que pongo ahora en la imagen:

Antes de terminar de escribir este artículo, habré reportado dicha web, con lo que es posible que si alguien intenta acceder Google SafeBrowser la esté ya indicando como página de Phising, pero ahora mismo esta totalmente operativa. Como podemos ver perfectamente, la web está protegida por HTTPS, con su candadito verde, su “Es seguro”, con una URL similar a alguna que pueda tener una página real de Paypal, y por supuesto su contenido un calco. Bien, este es un ejemplo sencillo, poco o nada tiene que ver con que esté bajo HTTPS y el certificado sea válido, el contenido puede ser totalmente fraudulento. Ni que decir tiene que posiblemente de meter ahí los datos, se los enviaríamos a una personal mal intencionada, pero muchos creerían que como la URL parece ser “buena”, y que pone “es seguro”, es de fiar. ERROR!!

 

Let’s Encrypt, el CA del que ya hemos hablado en otra ocasión, está siendo foco de grandes críticas por muchos (no hace falta ser un genio para saber que la mayoría de todas ellas por no decir todas vienen de los otros CA). Se les acusa de emitir certificados fraudulentos. Bien, primero tendríamos que matizar que es un certificado fraudulento, porque el ejemplo que he puesto anterior de Paypal, no es un certificado fraudulento, es un certificado totalmente legítimo, lo que no es legítimo y lo que es fraudulento es el contenido de la web mostrada, así como el uso evidentemente de la propiedad intelectual de Paypal y la suplantación de identidad. El certificado es legítimo siempre y cuando quien lo solicitó demostrase que era el dueño de dicho dominio, y recordemos que el dominio no es Paypal.com, el dominio comprado en este caso es “paypal-secure-info.gq”. Dado que las normativas sobre dominio permiten el registro de dicho dominio (lo cual es normal, no pueden vetar un dominio simplemente porque contenga una palabra que es marca comercial), sería totalmente injusto vetar la emisión de un certificado para dicho dominio. El problema no es el dominio, el problema no es el certificado… el problema es el uso que se haga de ello.

Algunos dicen que Let’s Encrypt en la “poca” vida que llevan, ya ha emitido muchísimos más certificados de este tipo que llaman “fraudulentos” que el resto de CA juntos. No lo dudo, es muy posible, pero por una razón sencilla… con los otros CA tienes que rascarte el bolsillo, 50-100€, pero te los emitirían igualmente por mucho que digan algunos que no permitirían certificados en dichos dominios, a fin de cuentas si el dominio está registrado correctamente, la emisión de un certificado estándar (de tipo DV, validación de Dominio) solo requiere para cumplir con las estrictas normas de seguridad la validación del propio dominio, nada más.

Ante esto Let’s Encrypt ya ha dicho más de una vez lo mismo. Ellos no son la policía ni el organismo competente para censurar el uso que puedan o no dar otros a las web, eso será cuestión de otros, y que por suerte herramientas como Google SafeBrowser o Internet SmartScreen, están para eso. Repito, lo mismo sucede con cualquier otro CA. De echo, para curarse en salud, Let’s Encrypt tan solo emite certificados DV.

Muy diferente es el caso cuando se desea un certificado EV, esos certificados que añaden antes de la URL el nombre de la compañía. Esos certificados emitidos por un CA requieren una serie de verificaciones y burocracia muy superior, que precisamente buscan eso, que se pueda tener cierta confianza de que la web visitada corresponde al contenido que tienen. En el caso de la web de paypal fraudulenta puesta arriba, les sería imposible lograr que pusiese delante de la URL lo que realmente veríamos en una web de Paypal:


El contenido es exactamente el mismo, y al margen de que la URL sean diferentes, evidentemente, en esta vemos el “sello” del certificado EV “Paypal, Inc. US”. La anterior sería imposible que lo lograse, incuso lograr algo similar sería casi imposible, a caso iban a crear una empresa llamada Paypal Secure bla bla bla y lograr todo lo que se requiere?? No, no lo lograría. Pero eso no invalida el certificado DV, ni tampoco le quita la gran importancia/necesidad que estos certificados (DV) tienen. De echo, como explicaba en el artículo de Let’s Encrypt, los certificados EV son muy caros, y la mayoría de entidades no los usan por no ser necesarios, mucho más importante que mirar el sello EV es mirar la URL, que ojo… puede engañar también (otro día hablaré de ello), pero pensar que si tomásemos una empresa no conocida podría tener legítimamente su sello EV y ser igualmente fraudulenta por el contenido que tiene.

 

Hace unos días apareció la noticia de que Google castigaba duramente a los certificados EV de Symantec (uno de los grandes CA) por detectar durante años la emisión de EVs de estos sin las necesarias y más estrictas condiciones. Recordar que un CA es fiable sólo en la medida que los navegadores Web y otros software se fían de ellos y añaden en sus productos los certificados raíces de estos. Dicho de otro modo, en cualquier momento tanto Google, Mozilla, Microsoft… podrían bloquear/anular los certificados raíces del CA que quisieran, dejando los miles o millones de certificados emitidos por ellas totalmente inservibles. Es por eso que son aquellos que crean el software que nos conecta los que deciden que certificados añadir y que normas y condiciones tienen que cumplir para permitirles estar dentro de su software, y si no lo cumplen o detectan irregularidades, no tienen problemas en eliminarlos o castigarlos del modo que estimen. Y sí, han caído empresas grandes cuyo principal volumen de ingresos era la emisión de certificados porque los navegadores los bloquearon por emitir certificados fraudulentos.

Vale, pero he dicho que los certificados fraudulentos no son tales… en que quedamos. Bueno, he dicho que el ejemplo anterior no es un certificado fraudulento, pero claro que se pueden emitir certificados fraudulento. El ejemplo más sencillo, si mañana me pongo en contacto con un CA y les pido que me emitan un certificado para google.es, y me lo mandan, es un certificado fraudulento, y no porque ya exista uno legítimo, eso es indiferente, es fraudulento porque el dominio google.es no es mío, e incluso un certificado DV se debe de emitir sólo si se puede verificar la propiedad de dicho dominio. Peor aun si hablamos de certificados OV o EV.

En el caso de Google y Symantec, según se ha dicho en la nota de prensa, Google detectó irregularidades en la emisión de certificados tipo EVs, y ha optado por medidas bastante serias, y durante un año irá invalidando dependiendo de las fechas de emisión de estos, los certificados EVs de Symantec (si leí bien). Y esto no es poca cosa, eso causa un daño enorme a Symantec. Es en una de esas pocas cosas que vemos el tremendo poder que puede tener una empresa que desarrolla una navegador Web para con otras multinacionales de gran peso e importancia.. bueno, google es un gigante, pero pensemos en Google como desarrollador de Chrome. Por supuesto Symantec les ha respondido, que han exagerado los datos, que les parece un “castigo” desmedido, que en el peor de los casos que Google lo lleve a cabo re-emitirá certificados nuevos para todos los afectos para que no se vean afectos… etc etc etc.

 

Conclusión

Por supuesto la credibilidad y fiabilidad de un sitio es o debería de ser muy importante, el problema es que no existe un sistema para ello. La mejor forma de legitimar una web es conociéndola, mirando siempre muy bien las URL, usar tecnologías como Google SafeBrowser (usada en Firefox o Chrome) o Smart-Screen usada en Internet Explorer. Tener siempre la seguridad, sobre todo cuando vamos a introducir cualquier dato sensible que la web que tenemos delante ES la web que dice ser, y no fiarnos de si usa HTTPS para eso o no. HTTPS nos asegura un cifrado, no la identidad que pueda parecer decir ya sea por el contenido o por la URL. Eso no invalida para nada la necesidad de HTTPS, puesto que incluso aunque una web sea fraudulenta, puestos a escoger, dentro de los males el menos malo sería que usase HTTPS, al menos tendremos la seguridad de que los datos sólo nos lo roba quien hizo la web fraudulenta, y no además otro que nos espíe la conexión por no usar HTTPS.

Con la aparición de Let’s Encrytp la web ha dado un buen giro, y donde antes nadie usaría certificados, ahora el uso se está expandiendo enormemente, ya sea un blog personal (ya, lo sé, no se lo tengo puesto al blog, en casa del herrero cuchillo de palo), ya sean empresas, tiendas online… y eso es bueno, con independencia de que algunos los quieran usar para otros fines.

Pero no nos equivoquemos, la culpa no la tienen esos desalmados, ellos simplemente se aprovechan como siempre del desconocimiento de los usuarios, las empresas de CA se han empeñado durante años a decir que los certificados son necesario para la confianza, para la fiabilidad… y muchas campañas se han hecho acerca de esto, así que el usuario normal ha tomado por válido ciertas cuestiones, como que si la web tiene un certificado seguro, la página es segura = fiable = de_confianza.

HTTPS sí, siempre que sea posible y el certificado sea válido, pero por favor… no dejéis nunca de revisar bien y mucho ante la duda la web que los use.

¿Son realmente necesarios los Antivirus? ¿Causan más mal que bien?

Share on Google+Share on FacebookTweet about this on Twitter

Buenas compañeros.

Es de estas veces que… digamos que estás haciendo alguna cosa sin demasiada importancia y sin necesidad de atención, mientras lees algunas publicaciones aquí o allí. Y de pronto me he topado con un artículo publicado por Robert O’Callahan, persona bien conocida (en el mundillo) y que sigo desde hace tiempo, con un gran talento como ingeniero de software, y un poco siempre controvertido. Robert O’Callahan ha sido Ingeniero de Mozilla durante muchos años, siendo una pieza fundamental de ellos, un gran programador, experto en seguridad y bueno… creerme, es cierto que siempre ha sido políticamente incorrecto, pero sabe de lo que habla.

El artículo no tenía desperdicio, animo a todos a leerlo: “ Disable Your Antivirus Software (Except Microsoft’s)“. Cuando cualquiera escribe sobre temas que conoce (o cree conocer), sus palabras pueden ser más o menos escuchadas y tenidas en cuenta por un grupo de seguidores o lectores, pero cuando personas de cierto y conocidas por su trabajo hacen comentarios tan tajantes, se arma un revuelo… y no es para menos.

Para quien no quiera leerse el artículo o vaya regular en Ingles, se lo resumo de forma sencilla:

En primer lugar, O’Callahan aprovecha para recordar que al no estar de momento en Mozilla (espero sinceramente que vuelva), tiene “libertad” en poder expresarse de forma abierta ya que a fin de cuenta no representa ni la opinión ni palabras de Mozilla y está desvinculado de ellos. Esto nos dice que muy posiblemente Mozilla piensa igual en general, sólo que como es normal no puede hacer afirmaciones tales por las repercusiones que tiene, como veremos luego.

A continuación, hace un pequeño resumen exponiendo que los Antivirus, lejos de hacer nuestros sistemas más seguros, por lo general lo que logran es hacerlo más inseguros, crearle agujeros de seguridad, son invasivos, matan el rendimiento y generalmente por raro que parezca no cumplen las normativas básicas de seguridad de software, con un código mal optimizado y problemático. Y desde el punto de vista de ellos como desarrolladores de software, específicamente navegadores Webs, afirma también que una parte muy importante del tiempo dedicado por los desarrolladores es precisamente tener que lidiar con los fallos de seguridad y otros de los propios antivirus, por supuesto da ejemplos de ello.

Muchos han visto esto como un guiño a Microsoft, por Windows Defender, pero en lo personal no creo que sea así, y en parte lo explica. La gran diferencia entre Windows Defender (En Windows) y cualquier otro AV como pueda ser Symantec, Avira, Avast… (pongo 3, pero en general cualquiera), es que Defender en primer lugar está integrado en el sistema y mucho más optimizado, en segundo lugar Microsoft por política somete a todo su software a estrictos controles de seguridad y estándares que deben de seguir, cosa que la mayoría de empresas de software no hacen, y en tercer lugar porque para lo que sirve un AV, Defender cumple con lo que necesita cualquiera. Dicho de otro modo… Windows ya tiene su propio AV/AntiMalware que funciona bien, para que usar software de terceros que puede provocar todo tipo de problemas.

Bien… cualquier que me conozca, sabrá lo que pienso al respecto: Estoy totalmente de acuerdo con sus palabras.

Es complicado hacer este tipo de afirmaciones y más para ellos, como bien dice. los desarrolladores de Software tienen que trabajar a fin de cuenta codo con codo con los desarrolladores de AV, y es evidente por qué… creéis que a cualquier desarrollador de software le gustaría que un AV salte una advertencia de seguridad o que hagan un comunicado diciendo que el software de X no es seguro?? Es indiferente si dicha afirmación o dicha alarma es cierta o no, el daño lo hacen, porque son compañías que tienen mucho peso. Yo puedo hacer los comentarios que quiera, puedo dar mi opinión y ninguna empresa de AV puede “influenciarme” de ningún modo, pero la mayoría no puede hacer eso.

Las empresas de AV se aprovechan de la historia y del desconocimiento de los usuarios, intentando venderte no su software, sino la idea de que si no usas un AV, tu equipo está desprotegido, y que el suyo es el mejor. Y esto es falso… al menos de un punto de vista global, y he hablado de ello muchas otras veces. Los AV tienen su utilidad, pero es limitada en el mejor de los casos, y por lo general causan un mal mucho peor que la posibilidad de coger algún tipo de malware. El desconocimiento es tal, que por paradójico que sea, la mayoría deshabilita las actualizaciones de Windows para mantener su equipo en buena forma y seguridad, mientras que usan AV para “protegerlo”, cuando es exactamente al contrario!! Lo más importante para la lucha contra CUALQUIER tipo de malware, es TENER ACTUALIZADO EL SOFTWARE empezando evidentemente por el OS.

Pues han pasado unos días desde que el señor O’Callahan escribiese dicho artículo, y al margen de lo polémico que ha sido muchas veces (que no es sinónimo de no tener razón), esta vez se le ha unido incluso algunos Ingenieros de Google, que aunque han sido algo más suaves, han venido a darle la razón, aludiendo que al margen de las estadísticas y otros que sacan las propias empresas de AV, ellos tienen sus propios datos que muestran que tales afirmaciones son ciertas, y que duela a quien duela, Defender es digamos mucho menos problemático que el resto de los AV.

No es normal que expertos de cierto calibre hagan afirmaciones tales: “Deshabilita/Desinstala tu Antivirus”, pero me alegra que por fin algunas voces se atrevan a decirlo. Como queda dicho, hay demasiados intereses económicos, y luchar contra empresas de importante tamaño te puede pasar factura, sobre todo si tu producto puede verse afectado por el producto de otro.

 

Mi opinión personal es bien conocida para todos mis círculos, y alguna vez la he expresado aquí. Cualquier tipo de Malware es introducido en el equipo o por interacción directa del usuario o por algún agujero de seguridad. Lo primero se evita con una educación mínima de como usar Internet y otros, a fin de cuenta repito entra porque el usuario instala o ejecuta algo que no debía. Lo segundo se evita actualizando el Software, sobre todo cualquier programa de cara a Internet, como navegadores Web, Sistema operativo y otros. Y no, en ninguna de esas dos luchas contra el malware aparece un AV. Sí, en algunos momentos específicos puede ser bueno poder disponer de un AV para analizar un archivo del cual no estamos seguro o dudamos… pero para eso tenemos una herramienta mejor a todo ello:

http://virustotal.com/

Tengo que decir que siempre que tengo que recomendar configurar un equipo, software a instalar… o incluso a amigos/familiares que soy quien se encarga de ello, el AV lo tengo vetado. Por lo general, es cierto que les dejo habilitado Defender, aunque en mi círculo más cercano, también lo tengo deshabilitado. Esto no es una recomendación ni lo deja de ser, porque al final como dice también O’Callahan, si recomiendas algo y alguien termina con problemas por ello, se contará siempre la negativa y no la positiva, sólo digo que a todo en lo que tengo o pueda tener mano, los AV de terceros están totalmente vetados, y en mis círculos más cercanos, todos.

Por supuesto… cada cual es libre de creer, hacer 🙂

Google I/O 2016

Share on Google+Share on FacebookTweet about this on Twitter

De nuevo, otro año más, volvemos a la carga, y de nuevo antes de las vacaciones de verano. En esta ocasión parece ser que que el Keynote será retransmitido en 360º, así que ya tenemos la primera novedad de todas. Está claro que este año se va a seguir apostando por la realidad virtual, y casi con toda seguridad veamos un nuevo CardBoard (o la evolución de este). Pero… que más??

Está claro que se van a hablar de muchas cosas, pero creo que al final podemos resumir las novedades en dos grupos:

El primero y quizás más importante son aquellas que van enfocadas directamente a los productos actuales y que afectan o pueden afectar desde hoy. Recordemos el gran éxito que fue Google Photos y sus novedades el año pasado.

El segundo son productos igualmente interesantes o servicios que podremos tener más cerca. Quizás un nuevo Cardboard?? Quizás unas nuevas Google Glass?? Un ChromeCast?? o mejor aun, alguna novedad que ahora mismo no podemos siquiera hacernos idea ¿?

Bien, comienza la cuenta atrás, en unas horas lo sabremos. Lo mejor de todo es que por suerte o desgracia, y aunque suene mal decirlo por el poder que ostenta Google en ello, de lo que salga esta tarde del Keynote tendrá una repercusión directa y enorme en la gran mayoría, a fin de cuenta, quien es capaz de decir a día de hoy que no usa algún servicio de Google 😉

 

Router Mitrastar HGW-2501GN-R2: Shell e Ingeniería inversa (para crear firmwares modificadas, por ejemplo) (Actualizado)

Share on Google+Share on FacebookTweet about this on Twitter

mitrastar
Introducción

La historia es sencilla. Aunque en la medida de lo posible siempre uso mis propios dispositivos, me gusta igualmente exprimir cualquier otro chisme que tenga por casa. Unos fuman… yo cacharreo.

En este caso, este fue el router que me entregó el ISP para mi conexión de Fibra, Mitrastar HGW-2501GN-R2. Duró conectado a la línea el tiempo de irse el instalador, pero lo saqué recientemente del “trastero” al ver por los foros de soporte oficiales (y no oficiales) que estaba dando un sin fin de problemas a los usuarios. Como siempre he dicho, opinar podemos hacerlo todos, pero si queremos dar soluciones que sean lo más acertadas posibles, es mejor comprobar las cosas por uno mismo y poder estudiarlas como dios manda. Así que le saqué el polvo y me puse a desentrañar sus más y sus menos.

Un dispositivo es bueno o malo sencillamente a razón de dos cuestiones sencillas, y es lo bueno o malo que sea su hardware y su software. Si el hardware es “malo” las ataduras de manos siempre son mucho peores, porque salvo modificaciones directamente en el hardware poco podemos hacer. Un hardware bueno tampoco hace del dispositivo algo bueno, es fundamental el Software, y sobre el software podemos decir lo mismo.

En el caso del Mitrastar, tenemos un poco de todo. Respecto al hardware no es ni mucho menos de lo peor que podemos encontrarnos en un router como muchos puedan pensar, pero eso no quiere decir que no se hubiese podido mejorar sustancial, sobre todo lo referente a su interfaz wifi. Eso no podemos cambiarlo, tenemos que aguantarnos con lo que hay. No he conectado aun el router por puerto de serie ni lo he sacado de su carcasa, así que los siguientes datos pueden no ser exactos del todo. Por lo que podemos saber el hardware se compone de una arquitectura MIPS:

CPU1: Ralink RT63368F (En Placa)/RT63365 (En Software)
Switch: Realtek RTL8368MB
Wl0: Ralink RT5392
RAM: 128MB
Flash: 64MB

El Switch debe de contar con unos 7 puertos diferentes, apoyado principalmente por el SOC RT63365. El adaptador inalámbrico dista mucho de ser una maravilla, nos encontramos ante un disposotivo 802.11n de dos streams unibanda. Por otro lado contamos con una cantidad más que suficiente de RAM y Flash para todo, lo cual siempre se agradece el no ir siempre bajo mínimos.

El principal problema que se ha tenido es que el software del router (la firmware) ha estado lejos de ser aceptable, salvaguardando por supuesto las propias limitaciones del hardware. Entre las quejas más frecuentes han sido los enormes problemas de batería causados por el router a dispositivos portátiles, la interfaz web de configuración con constantes problemas… En un mundo ideal, como se trata de Software, en el peor de los casos podríamos decir: “Pues si no quieren hacer ellos su trabajo, al menos voy a ver si puedo yo mejorar o corregir alguno de esos problemas de software”. Pero nunca suele ser tan sencillo, las firmwares y los sistemas se protegen precisamente para impedir cualquier tipo de modificaciones al software, siguen sin entender que cuanto más abierto sea un software más probabilidad hay que funcione mejor y con menos fallos/problemas.

 

Acceso Básico

Manos a la obra, partamos desde cero. Instalamos el router, lo tenemos todo funcionando… ¿ahora que?. Aquí entra en juego el primer escollo, y la culpa de esto la tiene principalmente los ISP, nada que ver con los fabricantes del hardware o el software que se instala (por lo general). Los dispositivos que nos entregan actualmente (No solo Movistar) vienen precargados con una configuración básica por defecto con los ajustes básicos de la compaña, como puedan ser los SSID, ajustes de WAN… ahora debido a los servicios avanzados como VoIP o IPTV suele ser necesario además de todo esto ajustes adicionales específicos para cada cliente, así que el router está preparado para conectar a los servidores de ellos después de un reset o cada X tiempo para reconfigurarse con los datos de la línea del cliente. Esto es perfecto porque evita configuraciones manuales uno a uno.

Lo primero que quiero o puede querer cualquiera es realizar pequeños ajustes a nuestro router, ya sea abrir un puerto, configurar una IP diferente… eso lo hacemos como toda la vida de dios, lo más básico y sencillo: La interfaz web del Router. El problema aparece porque la mayoría de los ISP se preocupan y hacen TODO LO POSIBLE para que el usuario, el cliente, tenga acceso a cuantas menos funciones posible del router mejor. Esto se hace por lo general con la creación de usuarios con permisos mucho más restrictivos a los usuarios tipo admin/root con acceso completo. Estos usuarios que crean tienen al final acceso para modificar 3 parámetros y medio y no poder consultar muchas otras configuraciones que pueden ser de interés, con lo que nos limita enormemente, incluso a usuarios con un perfil básico. Esto es algo que la mayoría no toma en cuenta cuando contrata un ISP u otro, pero para mí es esencial y marca mucho el tipo de compañía que tienes delante. Muchos de los amigos que me leen saben mi opinión sobre Apple, y se resumen sencillamente en que no permito que una compañía me diga que puedo hacer o no hacer con mi hardware.

Dependiendo del dispositivo que tengamos instalado y dependiendo del ISP, podremos acceder de mejor modo o no la configuración de nuestro router. En el caso concreto del Mitrastar, tengo que decir sinceramente que chapó por Movistar, ha hecho lo que tenía que haber echo hace tiempo y hacer TODOS. El Mitrastar, como viene siendo ya costumbre desde hace tiempo en los dispositivos de Movistar tiene dos interfaces web, una sencilla para usuarios nóveles que quieren cambiar 3 cosas (llamada Movistar Home Station, aka mhs, y una avanzada. El Mitrastar posee 3 usuarios (en realidad son 4, pero el usuario samba lo obviamos), cada uno con permisos diferentes enfocados a necesidades diferentes:

-“admin”: La contraseña de este usuario podemos encontrarla debajo del router en una pegatina. Este usuario y contraseña nos da acceso a las dos interfaces del router. Es el acceso normal a la interfaz mhs, y si accedemos a la avanzada a través de mhs (o a través de la dirección http://IP/cgi-bin/main.html) nos encontraremos con limitaciones en cuanto que podemos modificar. Esta cuenta por otro lado carece de acceso por terminal (SSH/Telnet…)

-“1234”: La contraseña coincide con la contraseña anterior, y en este caso sería lo más similar a un usuario root. Tiene acceso completo a las opciones de configuración de la interfaz, y es la cuenta que usa el portal Alejandra igualmente para configurar de forma remota nuestros dispositivos (si los tenemos asociados al portal).

-“supervisor”: La contraseña en este caso es siempre la misma, zyad1234, y posee permisos similares al usuario 1234, con el añadido de que con este usuario se tiene acceso por la interfaz web a poder modificar los permisos de los otros usuarios y de sus contraseñas igualmente.

mhs
web

Ahora entenderéis porqué digo que en este caso chapó por Movistar. Cualquiera puede tener acceso completo (al menos por web) al Mitrastar, sin hacer cosas extrañas, sin tener que pelearse, sin acudir a… dicho de otro modo, los técnicos de Movistar no tienen un mejor acceso que nosotros. Gracias a estos usuarios podremos no sólo consultar la mayoría de todas las configuraciones del router, sino que también ajustarlas a nuestro antojo.

Por otro lado, lo primero que se le ocurre a cualquiera es ver como son los archivos de configuración (backup) del router, así que como primer paso para entender un poco todo lo que cualquiera haría sería descargar dicho archivo desde mantenimiento, quizás sea legible o haya algo o algún ajuste que pueda ser de interés. El archivo de configuración del Mitrastar, por suerte, no está cifrado y parece ser un xml totalmente legible, pero que algunas opciones curiosamente las enmascara, todas aquellas donde hay contraseñas. Por qué es esto interesante?? Bueno, yo he dicho que la contraseña de admin y 1234 es la misma, pero a veces no es tan sencillo como prueba/error, o mejor dicho… a veces es más sencillo no tener que estar probando… pero como vemos el archivo de configuración no permite ver estos datos. En cualquier caso, vemos que estos campos llamados “encrypted” comienzan todos por: “41455300”, casualidad que 41 45 53 = AES, lo cual nos daría a pensar que el resto es posible que sea el texto codificado en AES.

 

Acceso Limitado por Terminal

El 99% de las veces nos sobra la interfaz web, pero que pasa cuando nos gustaría poder modifica o consultar cualquier cosilla que no esté presente o tengamos acceso por la interfaz web?? A fin de cuenta presuponemos que nuestro router estará corriendo algún tipo de Linux debajo de él. Para eso es indispensable acceso mediante SSH o Telnet. El problema es que como aplican la mayoría de fabricantes, para negarnos la posibilidad de toquetear las tripas, lo que nos dan es acceso es a una shell limitada… muy limitada. Así, en el caso del Mitrastar si intentamos acceder mediante supervisor o 1234, nos encontramos ante un panorama… “triste”:

ssh

Así pues podemos acceder con las credenciales por defecto, pero los únicos comandos que nos muestra la interfaz como válidos son: ?, exit, save, sys, restoredefault, lan, igmp, wlan, nat. La mayoría de todos ellos tienen subcategorías. No hay nada interesante a priori que podamos hacer desde la shell que no podamos hacer desde la interfaz web. Dos comandos “al azar” muestran dos resultados interesante: mtd y sh, ninguno de los dos listados en los comandos disponibles. El primero nos devuelve que el comando está prohibido, el segundo directamente que introduzcamos una contraseña… ¿quizás existe una contraseña para poder acceder a la shell que hay debajo? Por descontado ninguna de las contraseñas que disponemos es aceptada como válida.

Algo relativamente común a las shell limitadas es que permiten realizar copias de la configuración. A priori podríamos pensar que esos “dump” son iguales que los que podemos obtener desde la interfaz web, pero… que pasa si introducimos por shell limitada “sys dumpcfg”?? Sí, nos devuelve en la consola exactamente el archivo de configuración que pudimos descargar con anterioridad… pero con una salvedad, en esta ocasión los campos de contraseña están en texto plano. Bingo!!

username=”supervisor” web_passwd=”zyad1234″ console_passwd=”zyad1234″

La contraseña es la misma, pero en cambio en el archivo de configuración cifrado vemos que el “resultado” es diferente. Asumimos que además de poder estar cifrado con AES usa algún tipo de SALT, y no sólo una key cualquiera. Aun así esto tampoco nos abre la puerta a mucho más, esta contraseña es de hace mucho conocida y compartida en muchos productos.

 

Acceso a la Shell que hay debajo

Lo que nos interesa es acceder detrás de la shell limitada a la que tenemos acceso. Parece que para esto existe directamente un medio para hacerlo, a través del comando “sh” desde la shell limitada, pero esto nos solicita una contraseña que es totalmente desconocida para nosotros. Aquí empieza realmente el trabajo duro, ingeniárselas de algún modo para poder acceder debajo, aunque sólo sea una vez, y poder echar un vistazo desde una shell completa. No voy a detallar, por cuestiones de seguridad, como logré ese primer acceso, pero sí de que se trata.

Presuponemos que tenemos Linux debajo, con lo que realmente lo primero que desearíamos sería echarle un ojo al archivo /etc/passwd y/o /etc/shadow. Estos dos archivos, en linux, son los que contienen las credenciales de los usuarios y sus contraseñas (cifradas claro está). Pero además contienen la shell que será ejecutada a cada usuario. Es posible que el router posea otro usuario/contraseña que desconocemos o a saber…

Pongamos que gracias a la interfaz web logramos ejecutar de algún modo algún comando dentro de la shell y sacar los datos por el navegador. “cat /etc/shadow” cat /etc/passwd” sería sin duda alguna las primeras pruebas, y pongamos que en un momento dado la interfaz web nos devuelve lo deseado, nada para shadow, y para passwd:

1234:$1$$xxxxxxxxxxxxxxxxxxxx:0:0:root:/:/bin/cmdsh
admin:$1$$xxxxxxxxxxxxxxxxxxxx:0:0:root:/:/bin/sh
supervisor:$1$$xxxxxxxxxxxxxxxxxxxx:0:0:root:/:/bin/cmdsh
samba:$1$$xxxxxxxxxxxxxxxxxxxx:500:500:Linux User,,,:/home/samba:/bin/sh

Bingo!! (de nuevo). Parece ser que además de existir un cuarto usuario, samba, el usuario 1234 y el usuario supervisor (que son los dos únicos que tienen acceso por shell) ejecutan una shell extraña llamada “cmdsh”. Sea como sea, si logramos ejecutar con suerte cat, podríamos igualmente intentar sobrescribir el contenido del archivo, igual no existe una protección contra escritura… como dicen, probar no cuesta nada… usando incluso de nuevo cat, se puede enviar el mismo archivo pero modificando la shell a ejecutar, en vez de /bin/cmdsh, /bin/sh. Lanzamos la petición, volvemos a lanzar otra para ver el contenido y… se ha modificado!!. Ejecutemos de nuevo una sesión Telnet/SSH, usuario 1234 (es al usuario que le cambie la Shell), su contraseña… y efectivamente no más shell limitada:

login as: 1234
1234@192.168.1.1’s password:
# ls
bin      boaroot  dev      etc      lib      linuxrc  proc     sbin     sys      tmp      userfs   usr      var
# uname -a
Linux MitraStar 2.6.36 #1 SMP Thu Aug 13 14:04:19 CST 2015 mips unknown
#

 Llegados a este punto ya lo tendríamos todo?? Sí y no. Esto habría que repetirlo siempre, porque si reiniciásemos el router veríamos que el cambio que habíamos realizado al archivo passwd se perdería, teniendo que repetir todo el proceso constantemente. Aun así al menos ya habríamos logrado acceder a la Shell de debajo con plenos permisos administrativos. ¿Podemos mejorar esto? Por supuesto.

Lo primero que viene a la cabeza es: Bien, puedo acceder gracias un exploit, pero parece ser que la shell cmdsh tenía un comando “sh” que solicitaba una contraseña para acceder, y no hay que ser muy listo que lo que permite es acceder precisamente a una shell completa. ¿Donde puede estar esta contraseña? Personalmente el primer lugar donde miraría, teniendo en cuenta que no parece existir otros usuarios en el archivo /etc/passwd, es en el binario de la propia shell, o sino este sabrá de donde obtenerla, dado que es esta shell la que lo solicita. Ya sabemos donde está, así que sólo tenemos que extraerlo. Esto puede hacerse de mil y una forma, dependiendo de las herramientas que tengamos disponibles claro está en la firmware del router:

-ssh/sftp/ftp/scp
-curl/wget
-netcat/nc
-base64
-usb
-…

Cualquier sistema nos vale para enviar donde queramos el archivo en cuestión y poder manipularlo en condiciones, la elección de un sistema u otro dependerá de las utilidades que tenga la firmware y de lo sencillo o no que nos resulte a nosotros mover los archivos. Una vez tengamos el archivo, tan solo tendríamos que decompilarlo y echar un vistazo rápido. Vamos a lo sencillo, si cuando introducimos a través de sh una contraseña cualquiera recibimos: “Password incorrect !” Podemos empezar buscando por ahí, o mirar directamente las posibles funciones… eso nos lleva al siguiente trozo de código:

diss

Curiosamente, justo unas líneas de ahí encontramos una extraña cadena alfanumérica. Bueno, además de que el código en ensamblador es bastante legible, lo que está claro es que compara un string (lo que introducimos por teclado) con el string “c93vu02jp4z04“. Si la comparación es incorrecta, vemos que salta a la posición 0x00402408 (=contraseña incorrecta), mientras que salta a otra posición en caso de que la comparación sea acertada. Dicho y hecho, tan solo tenemos que verificar que ese string es realmente la contraseña para acceder a la shell completa desde la shell limitada. Y no hace falta decir que efectivamente esa es la contraseña de acceso a la Shell.

Llegados a este punto lo tenemos todo, hemos podido acceder gracias a un exploit, hemos podido extraer la contraseña que nos da acceso a la shell completa, con lo que podemos ya hacer con nuestro router lo que deseemos… ¡No tan rápido! ¿Seguro que ya tenemos total libertad?.

 

Acceso (y modificación) a la “nvram” – Autentificarse

Como vimos en la parte del exploit, y si empezamos a jugar con la shell interna, antes o después nos topamos con un problema bastante importante. Sí, podemos usar todas las utilidades de nuestro router, podemos añadir reglas a iptables, ver el estado de todo, controlarlo todo!! ¿Pero como podemos hacer para que los cambios que hagamos sean persistentes?

Vimos que si intentábamos modificar el archivo passwd este volvía de nuevo a su “ser” al reiniciar. Esto nos dice que al menos la raiz de la firmware está protegida contra escritura de algún modo, y de echo no hay que ser demasiado imaginativo para ir entendiendo que el sistema de archivo del router usa SquashFS, un sistema de archivos de sólo lectura que se monta en cada inicio. Ademeás, si miramos realmente la ubicación de la carpeta /etc tenemos esto:

# ls -la /etc
lrwxrwxrwx    1 1234     root            8 Aug 13  2015 etc -> /tmp/etc

La carpeta /etc desde la cual accedemos a /etc/passwd ni siquiera se encuentra en el sistema de archivos SquashFS, sino que el bootloader/kernel genera el archivo de algún modo en cada inicio, por eso pudimos modificarlo con el exploit entre otras cosas, está fuera de la “prisión” de SquashFS. Se genera en cada inicio, con lo que nuestros cambios se pierden. Pero sabemos que todo no es tan negro, porque en realidad debe de existir una zona o partición donde se puedan inscribir datos y estos sean persistente, o algún sistema para poder hacerlo, ya que a fin de cuenta podemos configurar el router a través de la interfaz web, y los datos son persistentes a cada reinicio. Si cambiamos por ejemplo la contraseña del usuario 1234 dicho archivo al iniciar será diferente al original y reflejará el cambio que hicimos por la interfaz Web. Quizás no podamos modificar el sistema de archivo raiz (lo haremos, pero más adelante), pero cuanto menos en teoría deberíamos de ser capaces de realizar cualquier cambio persistente que permita la interfaz web, y eso como mínimo, porque es de suponer que esté donde esté ese “espacio” contendrá quizás otros datos de interés.

Así es realmente como funcionan la mayoría de dispositivos. Los routers suelen tener una zona llamada nvram (RAM no volatil), que contiene parámetros que pueden ser leídos y almacenados con independencia del sistema de archivos. Esto es necesario para poder realizar configuraciones de cualquier tipo, pero incluso el propio router necesita este “espacio” para poder funcionar y configurarse a sí mismo. En muchos dispositivos es bien conocida la herramienta “nvram”, pero si lo intentamos veremos que aquí al menos no disponemos de una herramienta similar. Así que queda hacer un poco de detective y ver si disponemos de alguna utilidad que nos brinde algo similar.

Como podemos acceder a la shell podemos recorrer rápidamente los directorios donde sabemos que es más que posible que se encuentren: /bin, /sbin, /usr/bin… la mayoría de todas las utilidades podemos conocerlas los amantes de linux y muchas otras deducirlas. Otras en cambio podemos ir directamente probando a ver que pasa. Si no damos con la “tecla”, tenemos otro sistema sencillo para hacernos una idea… si la interfaz web cambia los ajustes, la interfaz web debe de saber o tener idea de como realizar esto. Antes o después llegaremos a la conclusión de que hay ciertos binarios que parecen ser los encargados de manejar todo esto, aquellos que empiezan por “tc” que es el acrónimo de TrendChip. Si nos movemos por las carpetas de la interfaz web (/boaroot) veríamos también rápidamente las referencias constantes a tcwebapi, y mira tu por donde tenemos un binario llamado: “tcapi”. Si lo invocamos:

# tcapi
set unset get show commit save read readAll staticGet

 Parece ser que hemos dado con la interfaz que interactúa con la nvram. Con un poco de paciencia y de estudio aprendemos a usar esta interfaz. tcapi funciona de un modo similar a nvram, con show podemos mostrar lo que deseemos (no existe un show all), pero tenemos que especificar que nodo queremos visualizar. Los nodos son precisamente las etiquetas xml que están dentro de nuestros archivos de configuración. Si miramos nuestro archivo de configuración veremos por ejemplo uno de los primeros nodos, “Wan”, así que “tcapi show Wan” nos devuelve efectivamente todo lo almacenado en ese nodo. Podemos pensar que esto no tiene demasiada utilidad ya que a fin de cuenta tenemos el archivo de configuración, pero no hay que ser muy listo para presuponer que el archivo de configuración es sólo una parte de todo. De echo podemos almacenar los valores que queramos en la nvram existan o no existan en el arcivo de configuración, o modificar cualquier otro.

Si alguien ha usado anteriormente nvram (la utilidad) sabrá que para que los cambios se apliquen hace falta realizar un “commit” y seguido de un “save” si se quiere que los cambios se guarden (aplicar no significa guardar, y viceversa). Aquí tenemos lo mismo. “tcapi save” guarda todos los cambios realizados en la nvram, mientras que “tcapi commig nodo” aplica los cambios efectuados al nodo citado. Cuidado!! Estamos modificando la nvram, si guardamos los cambios y estos han sido incorrectos podemos encontrarnos en que sea necesario resetear el router para que vuelva a sus ajustes por defecto.

Quien llegue a este punto se habrá dado cuenta que, de echo, aunque puede usar show, no puede realizar un save y peor aun, un set, devolverá lo mismo que sucedía cuando intentábamos teclear mtd. El acceso por alguna razón a ciertos comandos, incluso teniendo permisos administrativos y a la shell completos, siguen estando restringidos, hace falta algo más para desbloquear esto. Aquí tendríamos de nuevo que empezar a investigar donde buscar y encontrar esto. Podríamos empezar por cmdsh y encontraríamos referencias a un supuesto archivo llamado “/tmp/Authentication”. Antes o después (grep es un gran amigo), daríamos con el binario /usr/bin/syscmd. Si decompilamos y echamos un ojo llegaríamos pronto a una sección bastante interesante:

auth

Vemos demasiada información, pero todo de gran utilidad. Por un lado vemos que aparece de nuevo el archivo nombrado, pero esta vez precedido de un comando completo, y además curiosamente justo encima vemos un “Correct Key imput. Auth…”. Eso ya nos está diciendo que el sistema parece importarle más que el usuario esté “autentificado” ante ciertos comandos que cualquier otra cosa, y que parece que lo verifica seteando el archivo /tmp/Authentification con authenticated. Podríamos hacer la prueba: “echo authenticated > /tmp/Authentication” y veríamos que funcionan mágicamente a partir de este momento tcapi set/save y otros

Antes de irnos a otro lado, podemos ver igualmente en el trozo desensamblado de nuevo la contraseña de acceso a la Shell, y un “EncryptKey” y un “Account_Common”. Quien haya estado ya jugando con la nvram sabrá que en esta se separan los nodos de otros subnodos con guiones, así que por curiosidad si miramos la información del nodo “Account_Common” con tcapi:

# /userfs/bin/tcapi show Account_Common
EncryptKey=MSTC

El resultado es un string: MSTC, que según aparece en la nvram es un “EncryptKey”. Demasiado cerca del código que hace estar autentificado para no tener nada que ver. Si vemos desde la shell que podemos hacer con syscmd, vemos que existe curiosamente un comando que es authKey, y que efectivamente:

# syscmd authKey
Error!
# syscmd authKey MSTC
Correct key input. Authentication done.

Así que en realidad el proceso “real” implicaría autentificarse a través de syscmd con la EncryptKey almacenada en la nvram, MSTC, y eso a su vez produce que el sistema setee el archivo anteriormentes citado. Así que en realidad podríamos realizar la autentificación de cualquiera de las dos maneras: por lo “legal” y a lo “bruto”. Ahora sí, después de esto, podríamos usar algunos de los comandos más particulares (y también peligrosos), como puedan ser: sys memwl, sys memww, sys erase, sys romd, tcapi set, tcapi save…

La nvram permite acceder a todos los parámetros almacenados en nuestra configuración, y además acceder a otros parámetros que podrían ser interesantes, pero eso para otro día. Veamos mejor que más podemos hacer… podemos modificar la nvram, podemos ejecutar cualquier herramienta que tengamos dentro del router, ahora iremos un pasito más, esta vez como poder “modificar” lo que nos queda, el sistema de archivos, e incluso poder instalar/actualizar componentes en ella.

 

Ejecución de comandos desde el archivo de configuración (Nuevo)

Por azares de la vida, me topé días después con que resultaba relativamente sencillo realizar ejecución de código directamente desde el archivo de configuración del router, que no deja de ser gran parte de la nvram. El secreto reside en el nodo “Autoexec”, que si miramos en nuestro archivo tan sólo existe como cierre.

El cfg_manager, por suerte para nosotros, parsea el cfg en cada inicio para cargarlo a la nvram. Al llegar a dicho nodo, si no está vacío, pasa TODO lo que hay en él (sin el nombre de la entrada, sólo los valores de estas) a un archivo llamado autoexec.sh en /etc/, le da permisos de ejecución y acto seguido lo ejecuta. Dicho de otro modo, podemos añadir todo el código que queramos ahí, que será ejecutado al inicio en el Router. Evidentemente de saber esto anteriormente, el proceso de acceso inicial al router hubiese sido mucho más sencillo.

El potencial de esto ya no está realmente en los expertos que sepan modificar la firmware o entrar y salir del Router de forma sencilla, sino que el usuario novel puede de forma sencilla gracias a esto solucionar problemas que pueda tener en el router, o aplica ajustes concretos especiales.

El formato que siguen estas instrucciones es similar al de otros nodos:

<Autoexec>     <Entry
arp_fix=”sysctl -w net.ipv4.neigh.br0.mcast_solicit=0″
dhcp_fix=”echo ‘* * * * * ebtables -D FORWARD -p ipv4 –ip-proto 17 –ip-source-port 67:68 -j DROP’ &gt; /etc/admin; crond -c /etc/” />
</Autoexec>

Ese por ejemplo sería el bloque modificado para realizar dos fixs a la firmware B21, uno el problema de la batería y otro el problema que posee el router que bloquea todo el tráfico DHCP que no sea el suyo propio. Es sólo un ejemplo sencillo, en realidad podríamos realizar casi cualquier cosa. Como vemos la entrada en sí no importa su nombre, es su contenido el que será pasado al archivo autoexec.sh. Tan sólo hay que añadir el bloque que queramos, guardar, cargar la configuración y solucionado.

 

 

Modificando el sistema de archivos raíz

El router usa como hemos dicho SquashFS para montar su raíz. El problema que esto nos origina es que no podemos realizar cambios en él directamente. Para poder hacer esto, en principio, lo que se necesita es modificar directamente la imagen SquashFS con los cambios que deseemos y volver a cargarla. En un sistema más potente o con otras herramientas podríamos incluso pensar hacer el proceso directamente bajo la misma shell, pero aquí estamos limitado tanto en espacio, herramientas y memoria del router, con lo que esta opción no es muy viable. La opción que nos queda es realizar la modificación fuera del router, y volver a escribir el sistema de archivos de vuelta al router.La teoría en realidad es sencilla, la práctica es algo más complicada porque hay que ver como podemos hacer esto.

A priori se me ocurren dos formas. Una, extrayendo en la partición que se encuentre (en caso de ser así) el sistema de archivos, modificarlo, copiarlo de nuevo dentro y volver a copiarlo a su partición con dd/mtd (lo cual puede resultar bastante peligroso si hacemos algo mal y tampoco tengo claro que pueda realizarse sin hacerlo desde el bootloader), o aprovecharnos del propio sistema de actualización de firmware del router, es mucho más seguro pero implica conocer bastante bien como es la imagen de actualización, para poder no solo modificarla, sino también hacer que el router la acepte. Yo he tomado la segunda opción, no quiero tener que llamar a Movistar para decirles que misteriosamente el Mitrastar ha muerto.

Dicho esto, se abren por desgracia una serie de puntos que pueden ser “largos”, pero necesarios. Si queremos modificar la firmware, lo primero que necesitamos es precisamente al firmware, el binario de actualización, y dado que las actualizaciones se realizan por telecarga puede no ser tan sencillo tener una copia de ella, a menos que conozcamos a algún amigo de un amigo que buenamente nos la suministre. Por suerte… hoy tenemos respuestas y medios para todos.

 

Estructura interna de las particiones de memoria

Antes que nada hay que “estudiar” como está organizada la memoria flash del router, hay que ver realmente que particiones hay:

# mount
/dev/mtdblock3 on / type squashfs (ro,relatime)
proc on /proc type proc (rw,relatime)
ramfs on /tmp type ramfs (rw,relatime)
devpts on /dev/pts type devpts (rw,relatime,mode=600)
usbfs on /proc/bus/usb type usbfs (rw,relatime)
sysfs on /sys type sysfs (rw,relatime)
# cat /proc/mtd
dev: size erasesize name
mtd0: 00020000 00020000 “bootloader”
mtd1: 00020000 00020000 “romfile”
mtd2: 0014e7e3 00020000 “Kernel_main”
mtd3: 01090000 00020000 “Rootfs_main”
mtd4: 00006292 00020000 “Defcfg_main”
mtd5: 01d40000 00020000 “Tclinux_main”
mtd6: 0014e7e3 00020000 “kernel”
mtd7: 010b0000 00020000 “rootfs”
mtd8: 00006292 00020000 “defcfg”
mtd9: 01d40000 00020000 “tclinux”
mtd10: 00020000 00020000 “romd”
mtd11: 00020000 00020000 “second_romfile”

Con eso tenemos una visión más que completa del mapa del router, de como se compone internamente.Efectivamente comprobamos que la partición raiz es SquashFS, las particiones /sys, /proc son las habituales. A parte de ello se monta una partición como “ramfs” que como vimos contenía el archivo /etc/passwd, y por otro lado uan con el extraño nombre “usbfs”… es posible que el router tenga internamente puertos USB después de todo, y de echo la interfaz tiene configuraciones para SAMBA.

Lo que se refiere al particionado de la Flash, vemos hasta 12 particiones, y por suerte para nosotros los nombres son relativamente descriptivos. Vemos además que las particiones mtd2-5 estan duplicadas, o al menos eso parece, lo que nos hace pensar en un sistema de doble imagen, muy usado en los sistemas para evitar una mala actualización. Bootloader, kernel, rootfs y rom/cfg parecen evidentes su contenido, mientras que tenemos otra partición algo más extraña con el nombre de tclinux. El tamaño de las diferentes particiones también nos dan otra idea, siendo tclinux la partición más grande con diferencia, más que la suma de las demás, lo que posiblemente nos indique que tclinux es de algún modo “todo”, y de echo, lo es.

Pero pongamos por caso que tenemos la imagen de actualización, nos será más sencillo para explicar su estructura, y más adelante veremos como poder extraerla si queremos desde el router, que es secundario.

 

Estructura de la imagen de la firmware

Actualmente tan sólo existe una firmware completamente oficial, la B14, aunque la B21 se ha distribuido a muchos usuarios debido a los problemas ocasionados por la B14:

Mitrastar b14 113WJI0b14.bin b79d53bb663cbae480532942cc0e961a
Mitrastar b21 113WJI0b21.bin 770a5a52069066dc87978dba949cb1fd

Tomemos la segunda por caso. En lo personal, me gusta siempre antes de cualquier otra cosa, echarle un vistazo a través de un editor hexadecimal a ver que veo. Haciendo un barrido sin demasiada observación, vemos en primer lugar lo que parece claramente una cabecera al comiendo de la imagen, y curiosamente al final de todo el archivo nos encontramos también que termina con “</ROMFILE>” que es precisamente como termina también nuestro archivo de configuración. Si hacemos una pequeña búsqueda con esto, podemos localizar también el inicio de esta parte, que parece que tiene una pequeña cabecera que lo precede especificando que está comprimido y el tamaño que posee, eso lo vemos en el offset 0x011d27d6.

firmware

Como sabemos también que se supone es una imagen SquashFS, podemos buscar su cabecera y ver si se encuentra alguna correspondencia, buscando por los valores “68737173”, y sí… encontramos también una correspondencia de este en el offset ox0014e7e3, que termina de echo justo cuando comienza el archivo de configuración antes citado. Con esto tenemos prácticamente, y sin necesidad de usar ninguna utilidad, el contenido completo de la firmware (aunque queda ver y analizar aun unas cuantas cosas). Lo único que nos queda es una parte, que se encuentra después de la cabecera y antes de la imagen squashfs. Teniendo en cuenta que tenemos la información anterior de las particiones mtd, la respuesta es evidente: Es el kernel. Recordemos que en las particiones teníamos 3 en concreto que estaban duplicadas con el mismo nombre, con la única diferencia a priori de que las particiones más bajas tenían la coletilla main. Bien, por pura lógica asociamos defcfg al archivo de configuración que hemos encontrado, roofs a la imagen squashfs y el otro pedazo que nos queda es el Kernel. Además, como tenemos el tamaño de las particiones vemos también que efectivamente, si dividimos cada parte independientemente, corresponden sus tamaños a los tamaños de las particiones (ojo que dado que el tamaño de erasesize es de 0x00020000, el espacio de las particiones es múltiplo siempre de este valor, con lo que el tamaño excedente se rellena). Con este pequeño análisis, podríamos ya extraer la imagen squashfs a nuestro equipo, y a priori modificarla como nos diese en gana, volver a crear la imagen squashfs y ver como poder volver a montar la imagen de actualización con todo sin romper nada.

 A partir de aquí, tendríamos el trabajo farragoso. Es necesario comprender las cabeceras, el contenido tan sólo es lo sencillo. Diseccionar las cabeceras es un trabajo más meticuloso y estar haciendo comprobaciones, sumas, cuentas, mirar binarios del router en busca de más información… es tedioso. En mi caso empiezo siempre desde el comienzo, identifico lo que parecen ser los “Magic Number”, cadenas de texto descriptivas que pueden indicar versiones, conjuntos de bytes que indiquen tamaños y desplazamientos, checksums… en definitiva, lo que se puede esperar de cualquier cabecera. Diseccionar totalmente la cabecera (las dos que hay) fue lo que más tiempo me llevó. Os desgloso lo que sería la estructura integral de la firmware, incluyendo por supuesto la estructura de su cabecera. Digamos que la imagen de actualización se compone de tres “partes”. La cabecera, la firmware en sí (compuesta de kernel+rootfs/sistema_archivos) y el archivo de configuración:

0x00000000 Header
    0x0000 Cabecera “Magic Number” 04 D0 FC 9C
    0x0004 chipID = “36 33 33 36 38 00 00 00” = 63368 (8Bytes)
    0x000C Padding (16 Bytes)
    0x001C ModelID = 5A596004 (4Bytes)
    0x0020 Tamaño total archivo .bin, incluído cabeceras (4Bytes)
    0x0024 Offset en Memoria rootfs (0x40000 + offset bin) | 0x40000 = Bootloader 0x20000 + romfile 0x20000
    0x0028 Tamaño Rootfs (4Bytes)
    0x00CC Offset en Memoria Kernel
    0x0030 Tamaño Kernel (4Bytes)
    0x0034 Offset en Memoria cfgfile
    0x0038 Tamaño cfgfile (4Bytes)
    0x003C ¿Magic Number?? 01 00
    0x003E Tipo de imagen | main (0x0003),  esclava (0x0002), bin de actualización (0x0001)
    0x0040 Versión Firmware (32Bytes)
    0x0060 Descripción Firmware (32Bytes)
    0x0080 Checksum Rootfs (4Bytes)
    0x0084 Checksum Kernel (4Bytes)
    0x0088 Checksum cfgfile (4Bytes)
    0x008C Padding

0x00000100 Firmware
    0x00000000 Header
        0x000 Cabecera “Magic Number” 32 52 44 48 (4Bytes)
        0x004 Tamaño de cabecera (4 Bytes)
        0x008 Tamaño de la “Firmware” incluyendo su cabecera
        0x00C checksum SquashFS, las particiones _main no llevan CRC, la firm no lo computa en cualquier caso.
        0x010 versión de 2rdh?? Termina con salto de linea (32Bytes)
        0x030 “Salto de linea”/padding (32Bytes)
        0x050 Offset squashfs/tamaño kernel (4Bytes)
        0x053 Tamaño squashfs (4Bytes)
        0x058 Padding
        
    0x00000100 Kernel, lzma
    0x0014e6e3 rootfs Squashfs 4.0 lzma | Sistema de archivos

0x011d27d6 Configuración romfile
    0x0000 Header
    0x0028 romfile comprimido.  ¿Algoritmo fastlz?

 

 Modificación/Creación de una firmware nueva

Bien, teniendo toda la estructura de la imagen de actualización, debería de ser trivial realizar cualquier cambio (añadir, eliminar, modificar) dentro de la firmware. Con linux tan sólo necesitaremos tener las herramientas para crear y extraer squashfs, teniendo en cuenta que la imagen original fue creada en SquashFS 4.0+, usando la compresión LZMA. Esto significa que si no usaron un SquasFS modificado tuvieron que usar SquasFS 4.1, 4.2 o 4.3, ya que hasta la versión 4.1 no se dio soporte oficial a LZMA. Yo lo he realizado todo con SquasFS 4.3, usando como compresor LMZA el SDK de 7zip. Es necesario eso sí, modificar el makefile para habilitar lzma.

Extraída la imagen en nuestro equipo y modificada a voluntad (o añadido los archivos/paquetes que deseemos…) volvemos a empaquetar nuestra imagen squashFS. De nuevo, recordemos que debemos de usar LZMA y realizar la creación sin el padding a 4K. Llegados a este punto, como tenemos toda la estructura de como tiene que la estructura de la imagen de actualización, tan sólo tenemos que realizar el proceso inverso y corregir todas las cabeceras que sean necesarias. Sería muy sencillo crear una pequeña utilidad que pasándole la imagen modificada, el kernel y el archivo de configuración nos crease el archivo final de actualización con todas las cabeceras corregidas. Pero ni he tenido tiempo ni tengo ganas de hacerlo. Así que sigamos.

Con la imagen SquashFS ya modificada, podemos empezar a empaquetar nuestra nueva imagen de actualización. Por suerte para nosotros, la cabecera de la sección perteneciente al kernel+rootfs no se verifica en ningún momento, y aunque podemos por supuesto calcularla, no es necesario ser muy rigurosos. La parte más tediosa es el cálculo del checksum, así que podemos establecerlo tan ricamente como “00 00 00 00” y no pasa nada.

Añadimos al final de la imagen squashfs el archivo de configuración previamente extraído de la imagen inicial. Añadimos encima de este el kernel, y encima del kernel la cabecera secundaria. No es necesario, pero por tener un mínimo de decencia corregimos en esta el tamaño de la “firmware” (que es el tamaño de la cabecera secundaria+kernel+squashFS), el checksum no nos complicamos y lo dejamos en 00 00 00 00, el offset de squashfs no ha cambiado con lo que lo dejamos igual y modificamos el nuevo tamaño que tiene nuesetra imagen squashfs (ahora sí, tan sólo el tamaño de nuestro squashfs modificado)

Por último queda realmente lo que es más delicado, que es reconstruir realmente la cabecera que va a judgar si nuestra firmware es válida, por no decir que si metemos la pata siempre podemos bloquear e inutilizar el router, así que cuidado aquí. Los valores a modificar en realidad son pocos, si tan sólo hemos tocado el sistema de archivos:

    0x0020 Tamaño total archivo .bin -> Es necesario modificarlo porque el tamaño de nuestro squashFS será diferente
    0x0028 Tamaño Rootfs -> El valor es el mismo que se puso en la cabecera secundaria, y hay que modificarlo por lo mismo que el anterior
    0x0034 Offset en Memoria cfgfile -> Al cambiar el tamaño del rootfs, el offset del archivo de configuración cambia. Recordemos que hay que sumar siempre 0x40000
    0x0080 Checksum Rootfs (4Bytes) -> Que checksum??

Bien, tenemos todo menos el checksum de rootfs, el resto son los mismos porque no hemos realizado ninguna modificación. La pregunta del millón es como diablos calcula Mitrastar este valor, puesto que ha podido usar cualquier técnica conocida o desconocida. La mala noticia es que usa un algoritmo propio para calcularlo, la buena noticia es que ya lo tengo recreado, y la mejor noticia es que incluso nos podemos ahorrar su cálculo si sabemos donde mirar (una pena que descubriese esto último más tarde, pero al menos tengo igualmente el algoritmo.

El checksum usado por Mitrastar es una modificación al conocido CRC32, usando una lockup table para agilizar los cálculos, y podemos encontrarlo en el binario cfg_manager. Se puede buscar la función y decompilarla. Es necesario este valor porque el bootloader y el propio cfg_manager comprobarán dicho valor, y si no corresponde al que ellos calculan, el router rechazará dicha imagen. No sólo se usa este checksumo para verificar la firmware, igualmente se verifican tamaños y otros, pero ya hemos dado por supuesto que la cabecera la hemos calculado bien.

Bien, he dicho que aunque tengo creado el algoritmo para calcular el crc32 modificado no es necesario. Esto es porque por suerte para nosotros ya lo calcula el cfg_manager por nosotros. Cuando actualizamos el router (o lo intentamos), justo antes de que este se reinicie (sea la firmware válida o no) escupe en la consola de registro los cálculos pertinentes, sacando por pantalla los checksum calculados y los que tenemos en nuestra firmware. Dicho de otro modo… si actualizamos aun con la cabecera con los checksum incorrectos, y mientras esta el proceso miramos el registro con dmesg, obtendremos algo como esto:

***** MitraStar Confidential Firmware *****
compressedLen = 25194
pTag->kernelChksum = 11b8cc8b
pTag->rootfsChksum = da3878fa
pTag->defcfgChksum = 35842e0b
cal kernelChksum = 11b8cc8b
cal rootfsChksum = da3878fa
cal defcfgChksum = 35842e0b

pTag->modelId = 5a596004
pTag->chipId = 63368
len = 011d8a68
mrd->modelId = 5a596004
mrd->chipId = 63368

Update slave image version

Ready to flash image…

Si los checksum calculados no se corresponden a los nuestros, el proceso fallará, pero podremos anotar el crc calculado, modificar los nuestros para que correspondan y volver a actualizar. Eso le quita a cualquiera tener que decompilar el código en cfg_manager, extraer el algoritmo de verificación y recrearlo en C o en el lenguaje que le guste. Por supuesto el echo de que se calcule el CRC no hay que verlo sólo como para impedir que se realicen modificaciones, sino para garantizar la integridad de estas y evitar una mala actualización.

Si todo ha ido bien, el cfg_manager copiará la imagen de actualización a 4 particiones esclavas, mtd6-9, cada una con su contenido. Al reiniciar el router, el bootloader realizará comprobaciones similares a las realizadas por cfg_manager, y si todo es correcto procederá a copiar las particiones esclavas mtd6-9 a las principales mtd2-5. Si el router se reiniciase (funcionando) sin aparentemente ningún cambio efectuado, posiblemente el bootloader encontró algún problema en la firmware modificada y anuló la copia a las particiones principales, con lo que habría que ver el problema, solucionarlo y volver a cargarla.

Si todo ha sido correcto, llegados a este punto, tendríamos nuestra propia firmware modificada con lo que necesitásemos, ya fuesen arreglos de los problemas que tiene la firmware oficial o nuestros propios añadidos.

Recordemos que dije que no es necesario tener una imagen de actualización. Podemos extraerla a partir de las particiones mtd5 o mtd9, tan sólo con una apreciación: Las particiones mtd5 y 9 estarán posiblemente padeadas para rellenar el resto del erasesize, con lo que hay que eliminar dicho bloque. Por otro lado hay que modificar un byte en la cabecera que especifica el “tipo de partición”. El archivo de actualización tiene que estar en 01, no en 02 o 03. Quitando estos dos cambios, el resultado será una copia 1:1 (exacta) del archivo de actualización original. No es mal truco después de todo.

 

¿Instalación/Actualización de componentes y otros paquetes?

Ahora mismo no he añadido ningún componente extra, pero es más que factible. Hay que tener en cuenta que el router usa una arquitectura MIPS, y que tendríamos que recompilar cualquier paquete o binario para esta arquitectura. Aquí la idea he de decir que no fue mía y me llegó leyendo a un blogero en algún lado, y es que el router usa uClibc como motor, y el proyecto uClibc posee por suerte para nosotros imágenes listas para iniciar desde linux en las que podremos tener las herramientas necesarias para compilar el códígo y paquetes que deseemos, y una vez realizado sacarlo de ahí y meterlo en nuestra firmware modificada:

http://www.uclibc.org/downloads/binaries/0.9.30/


 

Conclusión

Bien, creo que eso ha sido todo. Sin duda alguna un buen entretenimiento del que siempre se aprende, y yo el primero. Quizás lo más útil en este caso no es instalar paquetes o actualizar otros (al menos en principio), pero puede que sí lo sea el poder realizar pequeños cambios aquí y allá, instalar algunos binarios extras como tcpdump, aplicar configuraciones específicas, filtros… tenemos espacio en memoria de sobra a fin de cuenta, y posiblemente tardemos nosotros mismos menos tiempo en corregir algunos de los problemas de la firmware, que esperar que Mitrastar los arregle por nosotros y que Movistar la distribuya.

Por ejemplo, para corregir el problema de la batería de los ARP en la B21, bastaría en principio con hacer el siguiente cambio permanente:

echo 0 > /proc/sys/net/ipv4/neigh/br0/mcast_solicit

Aunque como digo, tan solo es un ejemplo más…

Volver a arriba

Sobre Mí

Cambiar a la versión para móviles

Creative Commons License
Alma Oscura por Theliel is licensed under a Creative Commons Reconocimiento-No comercial-Sin obras derivadas 3.0 Unported License.
Basado en el trabajo de blog.theliel.es.
Para otros permisos que puedan exceder el ámbito de esta licencia, contactar en blog.theliel.es/about/contactar.