?

Log in

No account? Create an account
Por mi trabajo este año me ha tocado leer mucho, ya escribiré mis comentarios sobre ellos. Uno de los libros que he terminado de leer hace poco es el CEH v9 Certified Ethical Hacker Version 9 Study Guide de Sean-Philip Oriyano.
En general este es un buen libro, el contenido es muy explicativo y lo puede entender, a mi parecer, un estudiante de primer año de ingeniería, eso lo transforma, como el título promete, en una buena guía de estudio, sin emabrgo, el libro es muy CEH, es decir, la práctica corre por tu cuenta y deberás invertir bastante tiempo en armar tu propio laboratorio para aplicar los conceptos que ahí se explican. ¡fantástico!, si quieres ser hacker no debes preocuparte por el trabajo que se asigna, ¡esa es la parte entretenida ¿no?!.

CEH v9 Certified Ethical Hacker Version 9 Study Guide de Sean-Philip Oriyano
Sean Oriyano (www.oriyano.com) es un experimentado profesional de la seguridad y empresario. En los últimos 25 años ha dividido su tiempo entre la escritura, la investigación, la consultoría y la formación de varias personas y organizaciones sobre una amplia gama de temas relacionados con TI y seguridad. Como instructor y consultor, Sean ha viajado por todo el mundo, compartiendo sus conocimientos, así como ganando exposición a muchos ambientes y culturas diferentes en el camino. Su amplio conocimiento y su manera fácil de entender, junto con una saludable dosis de humor, han llevado a Sean a ser un instructor solicitado regularmente.
Fuera de sus propias actividades comerciales, Sean es miembro del ejército como oficial jefe de órdenes especializado en infraestructura y seguridad, así como en el desarrollo de nuevas tropas. Además, como CWO es reconocido como un experto en la materia en su campo y con frecuencia es llamado a proporcionar experiencia, capacitación y tutoría donde sea necesario.
Cuando no trabaja, Sean es un ávido corredor de carreras de obstáculos, habiendo completado numerosas carreras, incluyendo una carrera de campeonato mundial y una Trifecta Espartana. También le gusta viajar, culturismo, entrenamiento, y el desarrollo de sus habilidades de artes marciales mixtas además de tomar cursos de supervivencia.
Sean posee muchas certificaciones y cualificaciones que demuestran su conocimiento y experiencia en el campo de TI, como el CISSP, CNDA y Security+.

Tags:

Estado estacionario de una cadena Markov

Aquí se presentan algunos cálculos de álgebra lineal básica y simulación a través de un simple ejemplo de cadena Markov. Considere una ciudad teórica, donde el clima se describe por tres estados posibles: (1) 'Fine', (2) 'Cloudy' y (3) 'Rain'. En cada día, dado un cierto estado, hay una distribución de probabilidad para el estado del tiempo del día siguiente. Este modelo meteorológico simplista constituye una cadena Markov discreta (homogénea). Esta cadena de Markov puede ser descrita por la Matriz de Probabilidad de Transición, P, donde la entrada Pi,jindica la probabilidad de pasar al estado jdado que el estado actual es i. Las probabilidades de transición se ilustran en la Figura 1.8.
Una cantidad calculada importante para un modelo de este tipo es la proporción a largo plazo de ocupación en cada estado. Es decir, en estado estacionario, qué proporción del tiempo es el clima en el estado 1, 2 o 3. La obtención de esta distribución estacionaria, denotada por el vector π = [π1, π2, π3](o una aproximación de este), se puede lograr de varias maneras. Por razones pedagógicas y exploratorias utilizamos los siguientes cuatro métodos para resolver la distribución estacionaria:

1. Al elevar la matriz P a una alta potencia, (repetida multiplicación de matriz de Pconsigo mismo), la distribución limitante se obtiene en cualquier fila. Matemáticamente,

πi = limn→∞[Pn]j,i para cualquier index, j.

2. Resolvemos el sistema lineal (sobredeterminado) de ecuaciones,
πP = π   and   sum(i=1-->3) πi=1

Este sistema lineal de ecuaciones se puede reorganizar en un sistema con 3 ecuaciones y 3 incógnitas al darse cuenta de que una de las ecuaciones dentro de πP = πes redundante.

3. Al hacer uso del hecho conocido (Perron Frobenius Theorem) que el eigenvector correspondiente al valor propio de la magnitud máxima, es proporcional a la palabra π. Encontramos este eigenvector y lo normalizamos.

4. Ejecutamos una simple simulación de Monte Carlo generando valores aleatorios del clima de acuerdo con P, y luego tomamos las proporciones a largo plazo de cada estado.

using LinearAlgebra, StatsBase

## Transition probability matrix
P = [0.5 0.4 0.1;
0.3 0.2 0.5;
0.5 0.3 0.2]

##First way
piProb1 = (P^100)[1,:]

##Second way
A = vcat((P' - I)[1:2,:],ones(3)')
b = [0 0 1]'
piProb2 = A\b

##third way
eigVecs = eigvecs(copy(P'))
highestVec = eigVecs[:,findmax(abs.(eigvals(P)))[2]]
piProb3 = Array{Float64}(highestVec) /norm(highestVec,1);

##Fourth way
numInState = zeros(3)
state = 1
N = 10^6
for t in 1:N
numInState[state] += 1
global state = sample(1:3,weights(P[state,:]))
end
piProb4 = numInState/N

[piProb1 piProb2 piProb3 piProb4] ##this dont work

print(piProb1, piProb2, piProb3, piProb4)

julia>
[0.4375, 0.3125, 0.25][0.4375; 0.3125; 0.25][0.4375, 0.3125, 0.25][0.437279, 0.312761, 0.24996]

Referencia:

[1]  H. Yoni y Y. Nazarathy, Statistics with Julia: Fundamentals for Data Science, Machine Learning and Artificial Intelligence [DRAFT]. 2019.

He terminado de leer el libro Beginning Julia Programming For Engineers and Scientists de Sandeep Nagar, este es un libro fantástico para introducirse en temas como ciencia de datos, el aprendizaje automático y las aplicaciones de computación científica.
El libro refleja muy bien como Julia es un lenguaje de programación fantástico y tan fácil de usar como R y Python, aunque personalmente Python lo encuentro increíblemente bueno, pero Julia es un lenguaje que es mucho más intuitivo y ágil para programar sistemas con operaciones complejas y las librerías Numpy, Scikit-Learn y Panda de Python parecen código espagueti al lado de los packages de Julia. Lo siento, se tenía que decir, y se dijo.
El libro en si trata temas como instalación, trabajo con paquetes, Orientación a Objetos, matemáticas básicas desde REPL (read-eval-print loop), números complejos, números racionales e irracionales, funciones, arrays, matrices, string, control de flujos, entrada y salida y plotting y visualización de gráficos.
Sin embargo, la versión 0.5.0 de Julia utilizada en el libro es muy antigua respecto de la actual versión 1.1.1, esto hace que algunas instrucciones y código de ejemplo del libro estén obsoletas o su sintaxis deba ser actualizada para que el código funcione, pero no le restan valor a todo lo que puede aprender sobre este fantástico lenguaje de programación.
Sin duda es un gran trabajo el que hizo Sandeep Nagar con su libro que para mi sorpresa es el mimso autor de un libro de Octave, que alguna vez también estudié, pero no escribí sobre ello.


Beginning Julia Programming For Engineers and Scientists de Sandeep Nagar

Autor
Sandeep Nagar. PhD in material science de KTH. Profesor en G. D. Goenka University y consultor Julia para la ciencia de datos / análisis.

 

Gráficos en Julia

Para machine learning y data science, es indispensable la gráfica de datos, en Julia un ploteo es un objeto gráfico que requiere un terminal gráfico.
Un objeto gráfico tiene muchas propiedades. Los siguientes son algunos de ellos:

  • Tamaño: Longitud y amplitud de una parcela tal como aparece en un terminal de gráficos

  • Forma: Relación de aspecto (la relación de longitud y amplitud de una gráfica)

  • Título: La cadena que declara el tema de una trama

  • Ejes: Los ejes que muestran puntosde datos de referencia

  • Etiquetas: Las etiquetas asociadasa ejes que muestran una cadena descriptiva

  • Marcadores: Símbolos de varias formas que representan puntos de datos

  • Resolución: Medida en ppp (puntos por pulgada) porque, durante la impresión, la resolución de una imagen viene determinada por la capacidad de la impresora para definir píxeles individuales como un punto y el número de puntos por pulgada definirá el grado de pixelación de la figura

  • Formato de archivo: Una gráfica se puede almacenar en muchos formatos reservados para fotografías y otro tipo de medios.

  • Nombre de archivo: Un nombre de archivo proporciona un marcador de identificación para un objeto en un sistema informático.

Un objeto de trazado Julia tiene un método para tratar con todas estas propiedades. Con este método, puede modificar las entidades. Es posible guardar un perfil para que todos los objetos puedan derivar valores para sus propiedades del perfil, evitando así la necesidad de definirlos cada vez que se necesite crear un nuevo objeto y también mantener la uniformidad.
Además, un objeto de trazado se representa mediante un motor gráfico. Una vez más se puede utilizar una variedad de motores de gráficos de diferentes capacidades. Algunos son más poderosos en términos de sus habilidades para producir parcelas de propiedades más ricas y producirlas más rápido. Mientras se trabaja con diferentes paquetes, algunos motores de gráficos proporcionan una manera de definir un motor determinado para la representación en el back-end. La corrección de este aspecto alivia las preocupaciones sobre la uniformidad de las configuraciones, la calidad y los formatos de los objetos gráficos.
Plots Package
Plots es un paquete de trazado de alto nivel. Proporciona potentes capacidades gráficas que normalmente se desean para la mayoría de los requisitos informáticos de alto rendimiento. Se interconecta con otros paquetes de trazado (denominados back-ends o motores gráficos)para producir archivos gráficos de una manera flexible. Cada uno de estos back-ends gráficos también puede funcionar como paquetes de trazado independientes, pero Plots proporciona una interfaz fácil de usar, sencilla y coherente.
Antes de su uso, se debe importar un paquete en Julia mediante el comando import <packageName>:
julia>import Pkg

julia>Pkg.add("Plots")
 Updatingregistry at `~/.julia/registries/General`
 Updatinggit-repo `https://github.com/JuliaRegistries/General.git`
Resolvingpackage versions...
InstalledShowoff ─────────── v0.3.1
InstalledMeasures ────────── v0.3.0
. . .
julia>using Plots
[ Info: Precompiling Plots [91a5bcdd-55d7-5caf-9e0b-520d859cae80]

julia>x = Array([1,2,3,4,5])
5-element Array{Int64,1}:
1
2
3
4
5

julia>y = x.^2
5-element Array{Int64,1}:
 1
 4
 9
16
25

julia> plot(x,y)

Es importante señalar que los colores y la resolución de las ventanas serán dictados porla configuración del terminal gráfico dentro del sistema operativo de la máquina del usuario.
También se pueden elegir otros motores de trazado para cambiar el comportamiento. Por ejemplo, las unicodeplots() se pueden invocar y utilizar de la siguiente manera:
julia>Pkg.add("UnicodePlots")
Resolvingpackage versions...
InstalledUnicodePlots ─ v1.1.0
 Updating`~/.julia/environments/v1.1/Project.toml`
  [b8865327]+ UnicodePlots v1.1.0
 Updating`~/.julia/environments/v1.1/Manifest.toml`
[b8865327]+ UnicodePlots v1.1.0

julia>Pkg.build("UnicodePlots")

julia>unicodeplots()
[ Info: Precompiling UnicodePlots [b8865327-cd53-5732-bb35-84acbb429228]
Plots.UnicodePlotsBackend()

julia>x=1:10e4;

julia> plot(x,y)

Julia proporciona una manera de pasar implícitamente un argumento para que los argumentos de la segunda trama existan mediante el uso de plot! () sintaxis, que cambia la gráfica original desde el ! la versión modifica el objeto existente producido por el comando plot().

julia> eq1(x) = sind(2x)+sin(3x)
eq1 (generic function with 1 method)

julia> plot!(eq1,1:500)

¿Necesita un histográma?, no hay problema:

julia>x = rand(20);

julia> Plots.bar(x)

Las gráficas de dispersión simplemente colocan un punto para los datos x e y en la coordenada hecha por x e y. En nuestro ejemplo, el eje x ha distribuido linealmente 100 números de 1 a 100 y el eje Y tiene 100 números aleatorios. El siguiente código Julia realiza el trabajo de trazar un gráfico de dispersión.

julia> x=1:100;

julia> y=randn(100);

julia> Plots.scatter(x,y)



Julia es un lenguaje de programación muy ágil y fexible y las gráfica se manejan muy fácilmente, tal como se puede hacer con R y Python, estos son ejemplos muy básico de su utilización, sin embargo, en https://juliaplots.github.io/podrá encontrar tutoriales y ejemplos fantásticos.

Nuevo Flickr




Love



Flickr y su nueva política ha hecho que mi antigua cuenta quede abandonada, publiqué fotos ahí desde el 2006, pero ahora es imposible ordenar las fotos para reducir la cantiad de fotos a solo 1000 según la nueva política, así que he decidido abrir un nuevo flickr y también estoy experimentando con 500px, que se ve bueno, pero aún no me convence, además desconozco aún su política, no se si 500px también tiene restriccion de imágenes o baja la resolución, etc.
Instagram, definitivamente no me gusta, no se por qué, tal vez solo sea la maña de huir de las modas.
Si alguno pasa por aquí, comente por favor, ¿Flickr o 500px?
No se como aún hay muchas personas que siguen usando esta red social. Ahora Edin Jusupovic (@oasace), dice en twitter que había "notado una anomalía estructural al mirar un volcado hexadecimal de un archivo de imagen de un origen desconocido sólo para descubrir que contenía lo que ahora entiende es una instrucción especial IPTC." El IPTC (International Press Telecommunications Council) establece normas técnicas de publicación, incluidas las de metadatos de imagen.


A través de esta técnica Facebook puede rastrear fotos fuera de su propia plataforma con un nivel de precisión inquietante sobre quién subió originalmente la foto (y mucho más), esta es otra forma de aprender asociaciones entre las personas, por ejemplo, la  Persona 1 subió un montón de las mismas fotos que Persona 2 ya había subido, ahora pude mostrar a los dos los mismos anuncios. O bien, podrá saber su preferencias políticas o sociales al descargar los memes que otros comparten y que tu descargas.

Enlace:
https://www.forbes.com/sites/zakdoffman/2019/07/14/facebook-is-embedding-hidden-codes-to-track-all-your-uploaded-photos-report/#1b2bf7501592

Presentaciones BSDCan

Los vídeos de presentaciones en BSDCan 2019 están en el canal de YouTube. Y también se pueden encontrar en el sitio de OpenBDS.

Tags:

Microsoft ha tomado razón y recomienda evitar C y C++, sin duda estos lenguajes ya no debiera usarse para programar sistemas, y en las universidades tampoco debieran enseñarlo, personalmente me ha tocado dictar clases de ese lenguaje.
Ahora Microsoft recomienda Rust, uno de mis lenguajes de programación favoritos, sus características de seguridad ayudan al programador a no cometer corrupción de memoria, pues obviamente siempre será mejor no cometer los errores, que ir tras ellos, a pesar de que existen herramientas de revisión de código.

En mantención

Si, mantencion, algunos diran que lo escribi mal, pero es que nosotros usamos esta palabra, no la que le sobra una U.
hoy fue el dia de la mantencion, me di el tiempo para arreglar la bici y el auto, el auto no pude hacer la mantencion que necesitaba pues me faltaba una herramienta fundamental, La Gata, ne la robaron y recien me di cuenta jajaja.
Con la bici si pude continuar con lo que habia dejado inconcluso, hace un par de dias le puse neumaticos nuevos uno Ozono y otro Kenda, veremos como se comportan pues los ultimos que conpre eran unos neumaticos lisos, de pista y no duraron nada, estos son multi uso y debieran aguantar mas exigencia que los de velodromo, ademas le habia hecho limpieza general retirando desperdicion de aceite y cosas que s epegan a la cadena al rodar.

Ahora le cambie los frenos pues la bici ya lloraba con los que tenia que no recuerdo la marca, ahora les puse unos Tekpro mas o menos descentes.

Tags:

He leído bastante este fin de semana a pesar del poco tiempo.
Indexación
El índice de un elemento es la dirección del mismo elemento dentro de una matriz. La indexación en Julia comienza a la 1. Por ejemplo, en una matriz 1D, el índice de un elemento es el número de la posición del elemento desde la izquierda. Julia no tiene indexación negativa. En otras palabras, los elementos sólo se pueden acercar desde la izquierda.
julia> a = [12,4,6,3,6]
5-element Array{Int64,1}:
12
4
6
3
6

julia> a[3]
6

julia> a[1]
12
Creación de subarrays utilizando : operador
Utilizando índices y el operador : puede crear subarrays. Esto se conoce a veces como cortar una matriz. Por ejemplo, si una matriz se almacena en una variable denominada a, entonces a[n:m] devolverá otra matriz con un elemento que comienza desde el índice n a m. Dado que los : definen un rango de elementos, a veces se conoce como operador de rango. El siguiente ejemplo hará que este concepto sea más claro:
julia> a = [12,4,6,3,6]
5-element Array{Int64,1}:
12
4
6
3
6

julia> a[2:4]
3-element Array{Int64,1}:
4
6
3

julia> a[range(2,length=4)]
4-element Array{Int64,1}:
4
6
3
6
fin
Usando la palabra clave end, se puede acceder al último elemento de una matriz de la siguiente manera:
julia> A = [1,2,3,4,5]
5-element Array{Int64,1}:
1
2
3
4
5

julia> A[1]
1

julia> A[end]
5

julia> A[end-2]
3
Esto también se puede utilizar para crear un subconjunto de una matriz determinada:
julia> a = collect(1:7)
7-element Array{Int64,1}:
1
2
3
4
5
6
7

julia> a[2:2:end]
3-element Array{Int64,1}:
2
4
6
a = collect(1:7) crea una matriz con números del 1 al 7. Después a[2:2:end] crea una nueva matriz que comienza con 2 y va hasta elfinal de la matriz original a en pasos de dos (elementos 2, 4, 6).
Un equipo de investigadores del MIT ha desarrollado un nuevo lenguaje de programación que, según los autores, facilita el ingreso a principiantes en el mundo de la inteligencia artificial.

En un artículo presentado esta semana en la conferencia de Diseño e Implementación de Lenguajes de Programación, los investigadores describen un novedoso sistema de programación probabilística llamado "Gen” cuya aplicación abarca desde temas como la visión por computador, robótica y estadísticas, y les abstrae de lidiar con ecuaciones y tener que escribir manualmente código de alto rendimiento. Gen también permite a los investigadores expertos escribir modelos sofisticados y algoritmos de inferencia, utilizados para tareas de predicción, que antes eran inviables.
Las principales contribuciones son:

  • Gen, un sistema de programación probabilística integrado en Julia, en el que los usuarios (i) definen modelos en lenguajes de modelado embebidos y (ii) implementan programas de inferencia de alto nivel en el lenguaje host.

  • Interfaz de función generativa, una abstracción de caja negra para modelos probabilísticos que separa la lógica para el cálculo eficiente del diseño del algoritmo de inferencia.

  • Tres lenguajes de modelado interoperables: uno que es Turing completo para una máxima expresividad del modelo, uno que es susceptible al análisis estático, y otro basado en TensorFlow.

  • Tres combinadores de funciones generativas (map, unfold, recurse), que producen funciones generativas que explotan patrones comunes de independencia condicional.

  • Una evaluación empírica de la expresividad y la eficiencia de inferencia del modelado de Gen en relación con otros sistemas en cinco desafiantes problemas de inferencia.

Para instalar Gen primero debe tener instalado Julia versión 1.0 o posterior, luego escribir ] para entrar en pkg: una vez en Pkg escribr add http://github.com/probcomp/Gen

julia>

(v1.1) pkg> add http://github.com/probcomp/Gen
Updating registry at `~/.julia/registries/General`
Updating git-repo `https://github.com/JuliaRegistries/General.git`
Cloning git-repo `http://github.com/probcomp/Gen`
Updating git-repo `http://github.com/probcomp/Gen`
Resolving package versions...
Installed PDMats ──────────────── v0.9.7
Installed Missings ────────────── v0.4.1
Installed QuadGK ──────────────── v2.0.3
Installed CommonSubexpressions ── v0.2.0
Installed OrderedCollections ──── v1.1.0
Installed JSON ────────────────── v0.20.0
Installed StaticArrays ────────── v0.11.0
Installed Distributions ───────── v0.19.2
Installed Rmath ───────────────── v0.5.0
Installed ForwardDiff ─────────── v0.10.3
Installed StatsFuns ───────────── v0.8.0
Installed SpecialFunctions ────── v0.7.2
Installed FunctionalCollections ─ v0.5.0
Installed ReverseDiff ─────────── v0.3.1
Installed StatsBase ───────────── v0.31.0
Installed DataStructures ──────── v0.17.0
Installed DiffResults ─────────── v0.0.4
Installed DiffRules ───────────── v0.0.10
Installed FunctionWrappers ────── v1.0.0
Installed Arpack ──────────────── v0.3.1
Installed Compat ──────────────── v2.1.0
Installed BinaryProvider ──────── v0.5.6
Updating `~/.julia/environments/v1.1/Project.toml`
[ea4f424c] + Gen v0.3.1 #master (http://github.com/probcomp/Gen)
  Updating `~/.julia/environments/v1.1/Manifest.toml`
[7d9fca2a] + Arpack v0.3.1
[9e28174c] + BinDeps v0.8.10
  [b99e7846] + BinaryProvider v0.5.6
[bbf7d656] + CommonSubexpressions v0.2.0
.
.
.
[cf7118a7] + UUIDs
[4ec0a83e] + Unicode
Building Rmath ───────────→ `~/.julia/packages/Rmath/Py9gH/deps/build.log`
Building SpecialFunctions → `~/.julia/packages/SpecialFunctions/fvheQ/deps/build.log`
Building Arpack ──────────→ `~/.julia/packages/Arpack/cu5By/deps/build.log`

Luego en Julia se debe indicar el uso del package.

julia> using Pkg; Pkg.test("Gen")
Testing Gen
Resolving package versions...
  Status `/var/folders/p1/2sjzc3f16dz8fjcg_05_vg5m0000gn/T/tmpZyh3dJ/Manifest.toml`
  [7d9fca2a] Arpack v0.3.1
[9e28174c] BinDeps v0.8.10
.
.
.

En el sitio de Gen[1] se proporciona la documentación y tutoriales que se pueden seguir para lograr los primeros resultados en esta versión muy preliminar. persnamente probé un ejemplo de programa muy corto que hace regresión lineal bayesiana: dado un conjunto de puntos en el plano (x, y), se quiere encontrar una línea que se adapte bien a ellos.

Hay tres componentes principales para un programa Gen típico.

En primer lugar, se define un modelo generativo: una función Julia, extendida con alguna sintaxis adicional, que, conceptualmente, simula un conjunto de datos falso. El modelo debajo de los ejemplos de los parámetros de slope e intercept y, a continuación, para cada una de las coordenadas x que acepta como entrada, muestrea una coordenada y correspondiente. Se nombran las decisiones aleatorias quese toman con @trace, por lo que se puede referir a ellas en el programa de inferencia.

using Gen

@gen function my_model(xs::Vector{Float64})
  slope = @trace(normal(0, 2), :slope)
  intercept = @trace(normal(0, 10), :intercept)
    for (i, x) in enumerate(xs)
        @trace(normal(slope * x + intercept, 1), "y-$i")
    end
end


En segundo lugar, se escribe un programa de inferencia que implementa un algoritmo para manipular los seguimientos de ejecución del modelo. Los programas de inferencia son código Julia regular y hacen uso de la biblioteca de inferencia estándar de Gen.

El siguiente programa de inferencia toma un conjunto de datos y ejecuta un algoritmo MCMC iterativo para ajustar los parámetros de pendiente e interceptación:

function my_inference_program(xs::Vector{Float64}, ys::Vector{Float64}, num_iters::Int)
    # Create a set of constraints fixing the
    # y coordinates to the observed y values
  constraints = choicemap()
    for (i, y) in enumerate(ys)
      constraints["y-$i"] = y
    end
 
    # Run the model, constrained by `constraints`,
    # to get an initial execution trace
  (trace, _) = generate(my_model, (xs,), constraints)
 
    # Iteratively update the slope then the intercept,
    # using Gen's metropolis_hastings operator.
    for iter=1:num_iters
      (trace, _) = metropolis_hastings(trace, select(:slope))
      (trace, _) = metropolis_hastings(trace, select(:intercept))
    end
 
    # From the final trace, read out the slope and
    # the intercept.
  choices = get_choices(trace)
    return (choices[:slope], choices[:intercept])
end

Finalmente se ejecuta el programa y se obtiene los resultado:
xs = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]
ys = [8.23, 5.87, 3.99, 2.59, 0.23, -0.66, -3.53, -6.91, -7.24, -9.90]
(slope, intercept) = my_inference_program(xs, ys, 1000)
println("slope: $slope, intercept: $intercept")

La ejecución en REPL sería algo como lo siguiente:

julia> using Gen


julia> @gen function my_model(xs::Vector{Float64})
         slope = @trace(normal(0, 2), :slope)
         intercept = @trace(normal(0, 10), :intercept)
         for (i, x) in enumerate(xs)
               @trace(normal(slope * x + intercept, 1), "y-$i")
           end
     end
DynamicDSLFunction{Any}(Dict{Symbol,Any}(), Dict{Symbol,Any}(), Type[Array{Float64,1}], ##my_model#364, Bool[false], false)

julia> function my_inference_program(xs::Vector{Float64}, ys::Vector{Float64}, num_iters::Int)
         # Create a set of constraints fixing the
         # y coordinates to the observed y values
         constraints = choicemap()
         for (i, y) in enumerate(ys)
             constraints["y-$i"] = y
         end
        
         # Run the model, constrained by `constraints`,
         # to get an initial execution trace
         (trace, _) = generate(my_model, (xs,), constraints)
        
         # Iteratively update the slope then the intercept,
         # using Gen's metropolis_hastings operator.
         for iter=1:num_iters
             (trace, _) = metropolis_hastings(trace, select(:slope))
             (trace, _) = metropolis_hastings(trace, select(:intercept))
         end
        
         # From the final trace, read out the slope and
         # the intercept.
         choices = get_choices(trace)
         return (choices[:slope], choices[:intercept])
     end
my_inference_program (generic function with 1 method)

julia> xs = [1., 2., 3., 4., 5., 6., 7., 8., 9., 10.]
10-element Array{Float64,1}:
  1.0
2.0
3.0
4.0
5.0
6.0
7.0
8.0
9.0
10.0

julia> ys = [8.23, 5.87, 3.99, 2.59, 0.23, -0.66, -3.53, -6.91, -7.24, -9.90]
10-element Array{Float64,1}:
8.23
5.87
  3.99
2.59
0.23
-0.66
-3.53
-6.91
-7.24
-9.9

julia> (slope, intercept) = my_inference_program(xs, ys, 1000)
(-2.059831593709758, 10.979679334853522)

julia> println("slope: $slope, intercept: $intercept")
slope: -2.059831593709758, intercept: 10.979679334853522

Habrá que ver si los investigadores Marco F. Cusumano-Towner, Feras Saad, Alex Lew, Vikash Mansinghka, presentan alguna demo en el próximo JuliaCon [2] que estará muy bueno, espero haya streaming, el paper ACM original lo pueden descargar aquí[3].

[1] https://probcomp.github.io/Gen/
[2] https://pretalx.com/juliacon2019/talk/GVYCEL/
[3] https://dl.acm.org/citation.cfm?id=3314221.3314642

Arreglos en Julia

Al igual que los enteros, los números de coma flotante, los números complejos, los tipos de datos de números racionales y los tipos de datos de números irracionales definen valores únicos de tipos diferentes, también existe un host de otros tipos de datos que contienen varios valores al mismo tiempo. Estos tipos de datos incluyen Array, Tuple (tuples), Dict (diccionario) y Set (sets).
Las matrices son particularmente interesantes ya que se utilizan para definir vectores, tablas y matrices para la informática científica:
·       Una matriz 1D (unidimensional) actúa como un vector o una lista.
·       Una matriz 2D se puede utilizar como una tabla o matriz.
·       Las matrices 3D y más D pueden representar matrices multidimensionales.
Una matriz es una colección ordenada de elementos. Una matriz es un objeto que contiene varias entradas de datos identificadas por sus índices. A diferencia de muchos lenguajes de programación, el índice de matriz Julia comienza en 1, no 0. Una matriz es una colección de objetos, donde estos objetos recopilados se almacenan en una cuadrícula multidimensional.
En el caso más general, una matriz puede contener objetos de tipo Any, lo que significa esencialmente que puede almacenar cualquier variedad de tipos de datos numéricos. Sin embargo, mantener una uniformidad de las estructuras de datos ayuda a administrar los recursos computacionales y evitar errores computacionales numéricos. Por lo tanto, para la mayoría de los propósitos computacionales, las matrices deben contener objetos de un tipo más específico, como Float64 o Int32. Por lo tanto, los objetos de tipo de datos Array pueden contener valores de diferentes tipos de datos o restringirse a valores de un tipo de dato específico.
Construcción
Las matrices a menudo se indican con corchetes y elementos separados por comas. El código siguiente muestra la forma más sencilla de crear matrices a mano:
julia> a = [1,2,3,4]
4-element Array{Int64,1}:
1
2
3
4

julia> b = [1 2 3 4]
1×4 Array{Int64,2}:
1  2  3  4

julia> size(a)
(4,)

julia> size(b)
(1, 4)

julia> ndims(a)
1

julia> ndims(b)
2
Usando el comando a = [1,2,3,4] en REPL hace un array de 4 elementos donde cada elemento se almacena como tipo Int64 (porque los valores de entrada de matrices son enteros y el tipo de datos predeterminado de enteros es Int64) y la matriz se define como una colección de cuatro entradas. La referencia a un objeto de matriz se representa mediante el nombre de variable a. Por otro lado, cuando el comando b = [1 2 3 4] (cada elemento está separado por un espacio en blanco), obtenemos una matriz de 1 x 4. La diferencia entre los dos se puede sondear mediante la emisión de los comandos size() y ndims(), que dan el tamaño en términos de números de filas y columnas. Además, cuando se crea la matriz a, se observa la información 4-element Array{Int64,1}: lo que significa que se trata de una matriz unidimensional que almacena cuatro elementos del tipo de datos Int64, donde como b informa de que 1x4 Array{Int64,2}. En otras palabras, es una matriz bidimensional con la forma 1 x 2 (1 fila y 2 columnas) que almacena elementos del tipo de datos Int64.
Alternativamente, también se puede definir una matriz que contenga números aleatorios con la estructura de comandos Array{data_type}(undef, Number) donde el tipo de datos se define entre llaves y el número de elementos se define entre corchetes simples (). Tenga en cuenta que los elementos se asignan aleatoriamente por lo que el resultado será diferente cada vez que se ejecuta el comando.
Undef: El Alias para UndefInitializer(), que construye una instancia del tipo singleton UndefInitializer, se utiliza en la inicialización de la matriz para indicar que el array-constructor-caller de matriz desea una matriz no inicializada.
Por ejemplo, cuando se emite dos veces el comando a = Array{Int64}(undef,3) , se obtiene una matriz con tres elementos de números aleatorios para el tipo Int64:
julia> a - Matriz-Int64-(undef,3)
Matriz de 3 elementos- Int64,1:
4537699648
4608255472
4608273952

julia> a - Matriz-Int64-(undef,3)
Matriz de 3 elementos- Int64,1:
4537754448
4608245744
4608243248
Matrices de múltiples dimensiones
Del mismo lado que definió una matriz 1D, puede definir matrices multidimensionales introduciendo el número de elementos en cada dimensión. Por ejemplo, a = Array{Int64}(undef,2,3,4) creará una matriz del tamaño 2 × 3 × 4.  La primera dimensión tiene dos valores, la segunda dimensión tiene tres valores y la tercera dimensión tiene cuatro valores:
julia> a = Array{Int64}(undef,2,3,4)
2×3×4 Array{Int64,3}:
[:, :, 1] =
31  34  38
33  36  56

[:, :, 2] =
58  60  85
59  84  86

[:, :, 3] =
4620497920  4620498016  4620498160
4620497968  4620498064  4620498208

[:, :, 4] =
4620498256  4620498352  4620498448
4620498304  4620498400  4608242672
La notación [:,:,1] se aclarará en las secciones posteriores.
Arreglos de Flotantes
Si incluso un elemento de un objeto se define como un número de punto flotante, el tipo de datos de todos los elementos numéricos se convierte en Float64:
julia> a = [1,2.0,3,4]
4-element Array{Float64,1}:
1.0
2.0
3.0
4.0
Vale la pena señalar que la matriz a utiliza 32 bytes para su almacenamiento, ya que cada elemento es de tipo Float64, que utiliza 8 bytes de 8 x 4 = 32 bytes. Por lo tanto, es importante estimar el tamaño necesario para almacenar una matriz cuando contiene un gran número de elementos. Esto es particularmente importante para dispositivos y aplicaciones donde la memoria no es un lujo como los ordenadores de una sola placa (Raspberry Pi, por ejemplo).
Una matriz de números aleatorios se puede crear de una manera similar a la de los enteros:
julia> a = Array{Float64}(undef,7)
7-element Array{Float64,1}:
2.297622476e-314
2.2976225077e-314
2.2976225235e-314
2.2976225393e-314
2.2767736963e-314
2.297622555e-314
2.297817114e-314

julia> a = Array{Float64}(undef,2,3,4)
2×3×4 Array{Float64,3}:
[:, :, 1] =
7.65802e-322  2.28283e-314  1.23516e-322
1.23516e-322  7.70742e-322  2.28283e-314

[:, :, 2] =
8.34971e-322  2.28283e-314  1.23516e-322
1.23516e-322  8.34971e-322  2.28283e-314

[:, :, 3] =
1.55631e-321  2.28283e-314  3.16202e-322
3.16202e-322  1.56125e-321  2.28283e-314

[:, :, 4] =
1.62548e-321  2.28283e-314  3.16202e-322
3.16202e-322  1.62548e-321  2.2911e-314
Matriz de funciones
Dado que los elementos de una matriz pueden ser de cualquier tipo de datos, incluso las funciones matemáticas pueden ser un elemento de una matriz. Una matriz de funciones matemáticas se puede definir de la siguiente manera:
julia> a = [sin,cos,tan,log]
4-element Array{Function,1}:
sin
cos
tan
log
Matrices de tipos de datos mixtos
También es posible crear una matriz de tipos de datos mixtos. Por ejemplo, a = [sin,1,1.5,2+5im,2//3] crea una matriz donde los elementos pertenecen a los tipos de datos Function, Int64, Float64, Complex(Int64) y Rational-Int64:
julia> a = [sin,1,1.5,2+5im,2//3]
5-element Array{Any,1}:
   sin
  1   
  1.5 
2 + 5im
2//3 
Creación de matrices
Hasta este punto, acabamos de aprender a hacer matrices más pequeñas donde el número de elementos es pequeño. ¿Qué sucede si necesita crear una matriz de un gran número de enteros o números de punto flotante separados por valores definidos, digamos enteros impares de 1 a 1000? No le gustaría alimentar estos elementos de matrices a mano. El operador : es útil en este caso.
El operador n:m define un rango de n a m y, por lo tanto, se puede utilizar para crear una matriz de una secuencia de números. Usando la función collect(), se puede construir una matriz para un rango predefinido de números. Los números de inicio y parada también pueden ser números de punto flotante:
julia> collect(1:5)
5-element Array{Int64,1}:
1
2
3
4
5
julia> collect(1.1:5.6)
5-element Array{Float64,1}:
1.1
2.1
3.1
4.1
5.1

julia> collect(1:2:1000)
500-element Array{Int64,1}:
   1
  3
  5
  7
  9
11
13
15
17
19
  
983
985
987
989
991
993
995
997
999
Vale la pena señalar que el incremento (diferencia) entre los elementos se establece en 1 de forma predeterminada. Esto se puede cambiar según sea necesario de la siguiente manera:
julia> collect(1:2:9)
5-element Array{Int64,1}:
1
3
5
7
9

julia> collect(1.5:2.2:9.9)
4-element Array{Float64,1}:
1.5
3.7
5.9
8.1
Los argumentos se presentan como start:increment:stop. También stop indica el número más grande que puede contener la matriz. Los elementos de una matriz deben ser, como máximo, el número de detención o menos.
Los incrementos también pueden ser números negativos. Por ejemplo:
julia> collect(10.5:-1.2:3.3)
7-element Array{Float64,1}:
10.5
9.3
8.1
6.9
5.7
4.5
3.3

julia> collect(10:-3.2:1)
3-element Array{Float64,1}:
10.0
6.8
3.6

julia> collect(10:-3:1)
4-element Array{Int64,1}:
10
7
4
1

julia> collect(1:-3:10)
0-element Array{Int64,1}
El comando collect(1:-3:10) produce una matriz nula (una matriz con cero elementos) ya que los incrementos negativos no se pueden implementar a partir de 1 a 10.
Creación de una matriz mediante el operador de puntos suspensivos
El operador de puntos suspensivos ... se puede utilizar para crear una matriz con un rango de objetos sin utilizar la función collect():
julia> a = [1:5...]
5-element Array{Int64,1}:
1
2
3
4
5

julia> a = [1:2:9...]
5-element Array{Int64,1}:
1
3
5
7
9

julia> a = [1.2:2.2:9.9...]
4-element Array{Float64,1}:
1.2
3.4
5.6
7.8
Matrices similares
La función integrada similar() crea una matriz que es similar a una matriz determinada pero que puede ser diferente en el tipo de datos de los elementos. Por ejemplo, supongamos que se ha creado una matriz de 2 x 3 con el tipo de datos Float64 y se guarda en el nombre de variable A. A continuación, se puede crear una nueva matriz guardada en el nombre de variable A1 de la misma forma pero con el tipo de datos Int8:
julia> A = Array{Float64}(undef,2,3)
2×3 Array{Float64,2}:
2.29765e-314  2.29765e-314  2.29765e-314
2.29765e-314  2.29765e-314  2.29782e-314

julia> similar(A,Int8)
2×3 Array{Int8,2}:
64  -28  1
66   18  0
Del mismo modo, se puede crear una matriz de tipo de datos Float64 a partir de una matriz de números booleanos:
julia> A = Array{Bool}(undef,2,3)
2×3 Array{Bool,2}:
false  false   true
true  false  false

julia> similar(A,Float64)
2×3 Array{Float64,2}:
0.0  0.0  0.0
0.0  0.0  0.0
Propiedades de los arrays
Se puede utilizar una variedad de funciones integradas para sondear varias propiedades de objetos de matriz. Aquí dos de ellos, size()y ndims():
eltype: Tipo de elemento
julia> A = [1,2,3,4]
4-element Array{Int64,1}:
1
2
3
4
julia> eltype(A)
Int64

longitud: Número de elementos
julia> A = [1.1,-2.9,3.7,4.9]
4-element Array{Float64,1}:
1.1
-2.9
3.7
4.9

julia> length(A)
4
ndims: Número de dimensiones
julia> A = Array{Int64}(undef,2,3,5)
2×3×5 Array{Int64,3}:
[:, :, 1] =
0  0  0
0  0  0

[:, :, 2] =
0  0  0
0  0  0

[:, :, 3] =
0  0  0
0  0  0

[:, :, 4] =
0  0  0
0  0  0

[:, :, 5] =
0  0  0
0  0  0
julia> ndims(A)
3

julia> A = Array{Float64}(undef,6)
6-element Array{Float64,1}:
2.2134070974e-314
2.2124618905e-314
2.2785901504e-314
2.213408947e-314
2.2125587985e-314
2.278590593e-314

julia> ndims(A)
1
size(): Tamaño de la matriz (cuántos elementos existen en cada una de sus dimensiones)

julia> size(A) # No elementos en cada dimension
(2, 4, 3)

julia> size(A,3) # No elementos en la 3ra dimension
3

julia> size(A,2) # No elementos en la 2ra dimension
4

julia> size(A,1) # No elementos en la 1ra dimension
2

Referencias:
Beginning Julia Programming: For Engineers and Scientists. Sandeep Nagar. Apress
Esto es grave, y las pruebas que se puedan hacer en un hospital o clínica deben ser tratadas con máximo cuidado, incluyendo los Ethical Hacking que un hospital pueda contratar.


La empresa CyberMDX ha descubierto una vulnerabilidad de dispositivos médicos de anestesia y dispositivos respiratorios de GE
Riesgo: Medio. Se ha calculado un grado CVSS v3 de 5.3 .
La cadena del vector CVSS es AV: N / AC: L / PR: N / UI: N / S: U / C: N / I: L / A: N
Fecha descubierta por CyberMDX : 29 de octubre de 2018
Fecha de asesoría de ICS-CERT: 9 de julio de 2019

Resumen
El equipo de investigación de CyberMDX descubrió una vulnerabilidad relacionada con los dispositivos GE Aestiva y GE Aespire (modelos 7100 y 7900). Si un atacante obtiene acceso a la red de un hospital y si los dispositivos GE Aestiva o GE Aespire están conectados a través de servidores terminales, el atacante puede obligar a los dispositivos a volver a una versión anterior y menos segura del protocolo de comunicación y modificar los parámetros de forma remota. sin autorización Cuando se implementa utilizando servidores de terminal, estas modificaciones también se pueden realizar sin ningún conocimiento previo de las direcciones IP o la ubicación de la máquina de anestesia. El ataque podría llevar a:

·     Ingreso de composición de gas no autorizada: alteración de la concentración de oxígeno inspirado/expirado, CO2, N2O y agentes anestésicos.
·     Manipulación de los ajustes de presión barométrica y selección del tipo de agente anestésico.
·     Silencio remoto de alarmas.
·     Alteración de los ajustes de fecha y hora.
Esto podría afectar la confidencialidad, integridad y disponibilidad de un componente del sistema.

Dispositivos afectados
La vulnerabilidad en cuestión se refiere específicamente a las máquinas GE Aestive y GE Aespire, versiones 7100 y 7900 respectivamente (4 combinaciones en total).

Contexto de ataque
Los anestesiólogos generalmente tendrán protocolos estrictos que requieren que documenten los procedimientos, las dosis, los signos vitales y más.
Esta es la razón principal por la que las máquinas de anestesia están conectadas a la red: informar y documentar su estado y acciones. (Es en este sentido que las alteraciones en la configuración de la fecha y la hora pueden ser importantes, lo que hace que se mezclen con la cronología de los registros y socave la eficacia de los logs de auditoría).
Estas máquinas tienen un puerto de comunicación en serie y la integración de la red se logra a través del terminal server.

Comandos habilitados vía ataque

  • Entrada de composición del gas: establece la concentración de oxígeno inspirado/expirado, CO2, N2O y agentes anestésicos; También es capaz de ajustar la presión barométrica y seleccionar el tipo de agente anestésico.

  • Alarmas de silencio: la alarma de la máquina está diseñada para generar un ruido fuerte y continuo hasta llamar la atención de alguien y atender las condiciones subyacentes del paciente/dispositivo. (La explotación de la vulnerabilidad en cuestión puede permitir que un usuario mal intencionado envíe comandos para silenciar la alarma para que el ruido se escuche brevemente).

  • Fecha y hora establecidas.

Pruebas de campo

El equipo de investigación de CyberMDX realizó varias pruebas de campo con las máquinas en cuestión y confirmó exitosamente la vulnerabilidad.
Sin embargo, se debe tener en cuenta que el equipo solo intentó el comando de silenciar la alarma del dispositivo, ya que los ajustes en la configuración de la composición química y el tiempo pueden tener consecuencias complicadas y potencialmente duraderas que deberían evitarse en un entorno hospitalario real.

Caracteristicas de ataque

Según el CVSS 3.0 vulnerability scoring rubric, se aplican las siguientes características:

  • Vector de ataque: la red. Este ataque es sobre TCP.

  • Complejidad: baja. Solo requiere conocimiento de las convenciones de mando.

  • Privilegios requeridos: ninguno. La máquina no requiere ni utiliza autenticación.

  • Interacción del usuario: Ninguna, esto se hace de forma remota sin que se necesite nada en el lado del usuario.

  • Alcance: Sin cambios.

  • Confidencialidad: Ninguna. Un atacante puede ver las dosis y los nombres de los medicamentos utilizados por los pacientes en una habitación.

  • Disponibilidad: Baja. Las alarmas de silenciamiento y el ajuste de la hora/fecha pueden afectar la confiabilidad de la información .

Mitigaciones y Recomendaciones
GE Healthcare planea proporcionar actualizaciones e información de seguridad adicional sobre esta vulnerabilidad para los usuarios afectados. Por favor, consulte su sitio web para más información.

Crédito
Elad Luz , jefe de investigación en CyberMDX

Este es el review más actual que he leído, es una breve historia de los ataques realizados contra sistemas de control industrial y sistemas SCADA en particular, identificando los CVE y exploit existentes.
Los exploits que se mencionan en este trabajo han sido utilizados para campañas de ataque contra empresas industriales. De los cuales destacan dos vecores de ataques más notorios:

  1. Campañas de spearphishing contra empleados

  2. Ataques a la infraestructura industrial

El phishing y el spearphishing son prácticas comunes para adversarios malintencionados que tienen la intención de obtener información sobre los secretos de la empresa al obtener acceso a la infraestructura de TI y robar datos. En el documento se proporciona una cronología de campañas de spearphishing conocidas con antecedentes industriales. En cuanto al phishing, las víctimas no sospechan que se envían correos electrónicos con contenido malicioso, a menudo un enlace a un sitio web que está infectado con malware. Los archivos adjuntos con contenido malicioso son otra forma común de phishing. Las posibilidades de un atacante para conseguir una víctima para seguir el enlace se pueden aumentar mediante la personalización del correo electrónico mediante ingeniería social.
Los ataques contra la infraestructura industrial tiene varios exponentes notables, la operación aurora talvez sea la más conocida, sin embargo se mencionan otras igualmente importantes como Night Dragon, Nitro, Greek Oil, Balck Vine, Dragonfly, Black Energy y otras campañas que no llevan nombre dirigida a la extracción de información confidencial sobre la fabricación de ICS en la industria energética.

Two Decades of SCADA Exploitation: A Brief History [enlace].
Resumen: Desde principios de 1960, el control de procesos industriales ha sido aplicado por sistemas eléctricos. A mediados de la década de 1970, surgió el término SCADA, que describe el control automatizado y la adquisición de datos. Dado que la mayoría de las redes industriales y de automatización estaban aisladas físicamente, la seguridad no era un problema. Esto cambió, cuando a principios de la década de 2000 las redes industriales se abrieron a la Internet pública. Las razones eran suficientes. El aumento de la interconectividad condujo a una mayor productividad, simplicidad y facilidad de uso. Disminuyó la sobrecarga de configuración y los tiempos de inactividad para los ajustes del sistema. Sin embargo, también condujo a una abundancia de nuevos vectores de ataque. En los últimos tiempos, ha habido una cantidad notable de ataques a empresas e infraestructuras industriales. En este artículo se analizan los ataques conocidos a los sistemas industriales. Esto se hace investigando las vulnerabilidades que están disponibles en fuentes públicas. Los diferentes tipos de ataques y sus puntos de entrada se revisan en este documento. Se introducen tendencias en la explotación, así como campañas de ataque dirigido contra empresas industriales.

Un Accidente Afortunado

“El motor de una organización es la voluntad de las personas que la forman”.
Andrino Arias, Daniel. Un accidente afortunado (Spanish Edition).
Un accidente afortunado es un libro muy entretenido, son de esos libros que se salen de la categoría de libros de auto ayuda, pues a través de las lecciones que da, proporciona un método eficaz para entender el liderazgo y a quienes hoy ejercen dichas posiciones, de tal manera, entender si ellos son efectivos o no en ejercer tal posición.
Por otra parte, este es un libro muy al estilo de libro de cocina, es muy adecuado para seguir la receta fácilmente y si ejecutas bien lograr ese liderazgo efectivo que tantos profesionales esperan.
Este libro trata de un alto ejecutivo, de esos de lujos y Rolex en la muñeca, que después de seis años se ha tomado vacaciones para hacer un viaje por el áfrica salvaje. Su alta posición lo hacía valorar muy fuertemente el lujo y la vanidad, y comienza relatando sus primeras impresiones de su viaje centrado en el mundo materialista occidental del que proviene, con cámara digital de última generación, equipamiento safari, botas, cantimplora etc. Como si fuera Indiana Jones, sin embargo, luego de un accidente con elefantes y quedar a merced de un león bien especial llamado Jumbé, se trama una historia que debe entender postrado en el hospital, una historia que es contada por un Mwalimu, algo así como un anciano consejero de la tribu y cuyas enseñanzas se traducen en un manual de liderazgo que posteriormente podrá aplicar de regreso a su trabajo.
Un libro que todos debieran leer, no solo altos ejecutivos, sino también reportistas, entrenadores, profesores etc.
el libro está disponible en Amazon, también en Edición Kindle.

Tags:

El día 4 de julio tuve la oportunidad de dar una charla de concienciación en ciberseguridad en el Instituto Macional de Estadística (INE) titulada Privacidad - Cuida Tu reputación Madre Foca, cuya presentación pueden descargar aquí. La conferencia estuvo organizada por SOCHISI y contó con varios exponentes que, sin duda, dejaron bien informados a los asistentes que en su mayoría eran usuarios no técnicos, puede ver la nota del INE aquí e imágenes del evento aquí.

El Ladrón de Bicicletas

Hoy viendo videos de Internet, me acordé de esta gran película, si pasa por aquí, véala y comente.

Tags:

sí, cumplí cuarenta




Sí, cumplí 40 una cifra rara, pues si en promedio una persona vive 80 años, ya estoy en los descuentos, el reloj ya ha vaciado la mitad de la arena. No lo imaginé así, pero uno se pone más reflexivo con este numerito.
Recuerdo que cuando trabajaba en el Ministerio de Defensa cantaba “Estoy rodeado de viejos vinagres”, bueno, ahora pienso en “la juventud, divino tesoro”. Si hago una retrospectiva, a los 15 años me fijé 2 objetivos de vida, hasta ahora he logrado solo uno, por el segundo, he arriesgado mucho, más de lo que debiera pienso aveces, pero o quiero morir sin antes haber vivido.
Por otra parte, tengo una familia maravillosa, con tres hijos increíbles y una esposa excepcional pero siempre recordando mis muertos, que están resguardados en la tierra de Pemuco donde crecí. Hace un par de días mi esposa me decía que ya no quedaba mucho del Punk Loco Rorro, sin embargo siento que mientras más viejo me pongo más rebelde y rabioso estoy, debiera ser todo lo contrario ¿no?, tampoco renuncio a mi música y estilo de vida, huyendo siempre del glamour o cualquier cosa que sea medio burguesa, eso de tanto tienes, tanto vales no va conmigo y sigo usando mi bicicleta para casi todos mis viajes. En fin, creo que soy un “jodido cuarentón”.

DamienMiller, desarrollador de OpenBSD e investigador de seguridad en Google. Ha implementado un hack que agrega protección para claves privadas de OpenSSH cuando están en memoria y no están en uso, lo que hace más difícil para un adversario extraerlas a través de ataques de canal lateral aprovechando las vulnerabilidades de hardware como Spectre, Meltdown, Rowhammery el más reciente RAMBleed.
“Este cambio cifra las claves privadas cuando no están en uso con una clave simmética que se deriva de una "preclave" relativamente grande que consta de datos aleatorios (actualmente 16KB).
Los atacantes deben recuperar toda la preclave con alta precisión antes de poder intentar descifrar la clave privada blindada, pero la generación actual de ataques tienen tasas de error de bits que, cuando se aplican acumulativamente a toda la preclave, hacen que esto sea poco probable.”
Se espera también que esta funcionalidad sea retirada una vez el hardware sea seguro nuevamente.
Los archivos modificados son:
usr.bin/ssh  :
authfd.c
authfd.h
krl.c
krl.h
ssh-agent.c
ssh-keygen.c
sshconnect.c
sshconnect.h
sshd.c
shkey.c
sshkey.h

 

Sindicar

RSS Atom

Perfil

deoxyt2
Juan Rodrigo Anabalón R.
Website

Acerca de mi

He estado escribiendo sobre temas de seguridad en Livejournal desde el 2008 y en mi horrible y extinto MSN Spaces desde el 2006. En la actualidad, soy CISO en MonkeysLab y Presidente en ISSA Chile.




MonkeysLab




Copyleft

Copyleft: Atribuir con enlace.







Flickr


ISSA Chile



contador de visitas


contadores gratis

Último mes

September 2019
S M T W T F S
1234567
891011121314
15161718192021
22232425262728
2930     

Tags

Powered by LiveJournal.com
Designed by Lilia Ahner