La Unión Europea habría solicitado a Google cambios en su política de privacidad

ALT1040



http://da.feedsportal.com/c/33160/f/538984/s/24803b46/l/0Lalt10A40A0N0C20A120C10A0Cue0Ecambios0Epolitica0Eprivacidad0Egoogle/ia1.htm

Han pasado 7 meses desde que Google pusiese en práctica su nueva política de privacidad , una política que nos anunció a finales de enero y unificaba bajo un mismo documento los 70 documentos legales que regulaban la política de privacidad de sus servicios. Este cambio, que entró en vigor el 1 de marzo, era un símbolo más de esa unificación de servicios (o experiencia unificada) que está impregnando a Google desde hace más de un año en la que los datos de los usuarios fluyen de un servicio a otro como si se tratasen de uno solo; un hecho que hizo saltar las alarmas en Europa desde el primer momento y que, según parece, habría llevado a la Unión Europea a solicitar a Google algunos cambios en los términos del servicio.

Desde un primer momento, esta reunificación de la política de privacidad y el flujo de datos entre los distintos servicios de Google (por muy nobles que fueran los motivos para mejorar la experiencia del usuario) hicieron saltar algunas alarmas dentro de las agencias y organismos encargados de la protección de los datos personales en los países miembros de la Unión Europea. Francia fue uno de los primeros en comentarlo pero también se ha sumado Reino Unido a esta corriente hasta el punto de haberse enviado una misiva a Google (firmada por los organismos de cada país) solicitando algunos cambios y haciendo recomendaciones sobre este cambio de política.

Por un lado, la Unión Europea le indica a Google que antes de unificar el tratamiento de los datos (que se gestionaban por separado) debería obtener el consentimiento explícito de los usuarios antes de asumir que con un cambio en los términos del servicio es suficiente y, por otro lado, se apunta a que las compañías de Internet no deberían redactar acuerdos complejos, inteligibles únicamente por abogados o excesivamente largos. Además, le piden a Google que detalle algo más sus intenciones para combinar los datos de los usuarios y gestionarlos de manera unificada.

¿Y para qué enviarle una carta a Google? La intención de la Unión Europea es que Google realice cambios en su política de privacidad siguiendo estas pautas, haciéndola algo más fácil de entender a los usuarios para que estos puedan tener claro, desde un primer momento, qué están aceptando y qué tratamiento sufren nuestros datos.

La verdad es que es raro encontrar una política de privacidad o unos términos de servicio que estén redactados para ser “entendidos por un ser humano” puesto que adolecen, en exceso, de una verborrea legal que no todo el mundo llega a comprender por completo y, de hecho, no todos los usuarios leen las condiciones que aceptan cuando se registran en un servicio (una mala práctica propiciada por la forma que tienen las compañías de redactar estas cláusulas). No sé si Google responderá favorablemente a este requerimiento pero, en general, la carta que ha enviado la Unión Europea es de aplicación a Google y otras tantas empresas.

Ex-convento de Quecholac

via Instagram http://instagr.am/p/Qp03Oas3Lg/

Sandwich triple

via Instagram http://instagr.am/p/QefD4as3MG/

Monitorizar conexiones de Apache en tiempo real con Bash

Cristalab



http://www.cristalab.com/tutoriales/monitorizar-conexiones-de-apache-en-tiempo-real-con-bash-c108092l/?utm_source=feedburner&utm_medium=feed&utm_campaign=Feed%253A+clab+%2528Cristalab%2529



Bash (Bourne again shell) es un programa informático cuya función consiste en interpretar órdenes, está basado en la shell de Unix y es el intérprete por defecto de la mayoría de las distribuciones de Linux.



Bash contiene una gran variedad de formas de interpretar los recursos del sistema de modo matemático y renderizar los resultados en un formato fácil de entender. Esto es especialmente útil cuando hay la necesidad de optimizar alguno de los recursos por defecto de Linux, como MySQL, servidor de correo, Apache, ect...



En este ejemplo vamos a mirar y analizar los recursos que están en uso de Apache, la memoria que está siendo utilizada por los procesos actuales de Apache, las posibles conexiones disponibles y el uso general de memoria de la máquina.



Hemos elegido este script para el tutorial porque utilizamos las funciones matématicas internas de Bash para números enteros. Utilizamos llamadas a BC (módulo de cálculos de Bash) para números reales y utilizamos expresiones regulares y manipulación de arrays. Veremos sentencias condicionales, uso de bucles WHILE y uso de funciones.

Código :

#!/bin/env bash

# Definimos la función
function doStat()
{
# Define variables
# Iniciación de variables que vamos a usar
  cnt=0 
  cpl=0
  di1=1
  di2=$((1024*1000))
  di3=1024
  max=0
  statusbar=38
  tot=0
  ty1="Mb"
  ty2="Mb"
  ty3="Mb"
  ty4="Mb"
  ty5="Mb"

# Compruebo si estamos en un servidor con cPanel instalado, ya hay ligeras variaciones en el formato de "TOP"
# Aquí vemos una sentencia condicional, siempre empieza por if, hay que observar que despúes del corchete "[" siempre hay que dejar un espacio. Igualmente, hay que dejar un espacio antes del corchete de cierre.
  if [ -d /usr/local/cpanel ]; then
    cpl=1
    di1=100
  fi
# Cerramos la sentencia con "fi"
# Comprobar si la memoria encontrada en top contiene el caracter "m" para saber que si los resultados se presentan en Mb o Kb
  mck=`top -b -c -n 1|grep -E "apache|httpd"|awk '{print$6}'|grep -c m`
  if [ $mck -ne 0 ]; then
    di1=1
  fi
# Cargamos en la variable fre la memoria disponible
  fre=`grep -E "^MemFree:" /proc/meminfo|awk '{print$2}'`
# Cargamos en la variable total la memoria instalada
  total=`grep -E "^MemTotal:" /proc/meminfo|awk '{print$2}'`

# Cargamos en mem la memoria usada por Apache. La sacamos de la función top.
  mem=`top -b -c -n 1|grep -E "apache|httpd"|grep -v grep | awk '{print$6}'|sed -e 's/[a-zA-Z]//g'`

# Bucle para mirar cada proceso y calcular ( por proceso )
# avg - media
# max - máxima memoria usada
# tot - total de memoria usada

  for m2 in $mem
  do
# Comprobamos si la memoria es un valor entero o un valor real. Aquí usamos una expresión regular en la condicional.
    if [[ $m2 =~ ^[0-9]{1,3}\.[0-9]{1,3}$ ]]; then
#IFS es el valor interno de Bash para el separador de variables internas
      OIFS=IFS
      IFS='.'
      m2=($m2)
      IFS=$OIFS
# La parte real del número la guardo en m1
      m1=${m2[1]}
# La parte entera la guardo en m2
      m2=${m2[0]}
# Miramos el número de caracteres que hay en la parte real. Para hacer las conversiones
      m3=${#m1}
      m4=10
      if [ $m3 -eq 2 ]; then  m4=100; fi
      if [ $m3 -eq 3 ]; then  m4=1000; fi
# Convertimos a decimal
      m3=$(((m1*1024)/m4))
# Calculamos tamaño del decimal
      m2=$(((m2*1024)+m3))
    fi
# Fin de la comprobación de números reales
    m=$((m2/di1))
# Cargamos en max el proceso que más memoria ocupa
    if [ $m -gt $max ]; then
      max=$m
    fi
# Incrementamos contador y total
    cnt=$((cnt+1))
    tot=$((tot+m))
    avg=$((tot/cnt))
  done
# Fin del bucle
mxu=$((tot*1024))

# Comprobamos la media y evitamos la división por cero
  if [ $avg -eq 0 ]; then
    avg=1
  fi

# Obtenemos el número total de los procesos de apache
# escuchando o conectado
  cnt=`lsof -i :80|grep -iE "esta|ist|esc"|wc -l`

# Calculamos los procesos disponibles de la máquina
  ava=$(((fre/avg)/100))
  wst=$(((fre/max)/100))
# Aquí usamos BC. Necesitamos un número real y bash no permite operaciones con estos de forma interna
  pct=`echo "scale=2;($fre/$total)*100"|bc`
  out=`echo "scale=2;($pct/100)*$statusbar"|bc|awk -F\. '{print$1}'`

# Ajustamos para cPanel si es necesario
  if [ $cpl ] && [ "$out" == '' ]; then
    out=0
  fi

# Calculamos el uso de la memoria y convertimos a Gb si es necesario
  if [ $fre -ge $di2 ]; then
    ty1="Gb"
    fre=`echo "scale=2;$fre/$di2"|bc`
  else
    if [ $fre -ge $di3 ]; then
      fre=`echo "scale=2;$fre/$di3"|bc`
    fi
  fi
  if [ $mxu -ge $di2 ]; then
    ty2="Gb"
    mxu=`echo "scale=2;$mxu/$di2"|bc`
  else
    if [ $mxu -ge $di3 ]; then
      mxu=`echo "scale=2;$mxu/$di3"|bc`
    fi
  fi
  if [ $total -ge $di2 ]; then
    ty3="Gb"
    total=`echo "scale=2;$total/$di2"|bc`
  fi
  if [ $avg -ge $di2 ]; then
    ty4="Gb"
    avg=`echo "scale=2;$avg/$di2"|bc`
  fi
  if [ $max -ge $di2 ]; then
    ty5="Gb"
    max=`echo "scale=2;$max/$di2"|bc`
  fi

# Bucle para mostrar una barra de estado
  sloop=$statusbar
  statusbar=$((statusbar+3))
  nline=`seq -s "=" $statusbar|sed 's/[0-9]//g'`

# Mostramos resultados
  printf "%s\n" $nline
  printf "Apache processes and memory usage.\n"
  printf "%s\n" $nline
  printf "Total installed memory: %s%s\n" $total $ty3
  printf "Availiable memory:      %s%s\n" $fre $ty1
  printf "Free percentile:        %s\45\n" $pct

# Mostramos la memoria usada en la barra de estado. Observamos que en el bucle while, los corchetes llevan sus espacios después y antes, como en el if que hemos descrito antes.
  printf "Status bar:\n|"
  while [ $sloop -ge 1 ]; do
    cc="-"
    if [ $sloop -ge $out ]; then
      cc="+"
    fi
    printf "%s" $cc
    sloop=$((sloop-1))
  done
  printf "|\n"

  printf "%s\n" $nline
  printf "Current usage\n"
  printf "%s\n" $nline
  printf "Current processes: %d\n" $cnt
  printf "Average memory:\t   %s%s\n" $avg $ty4
  printf "Maximum memory:\t   %s%s\n" $max $ty5
  printf "Overall memory:\t   %s%s\n" $mxu $ty2
  printf "%s\n" $nline
  printf "Projected usage\n"
  printf "%s\n" $nline
  printf "Concurrent best:  %d more connection(s)\n" $ava
  printf "Concurrent worst: %d more connection(s)\n" $wst
  printf "%s\n" $nline
}
# Fin de la función
# Ejecutamos la función
doStat

El resultado mostrado quedaría más o menos así:

Código :

========================================
Apache processes and memory usage.
========================================
Total installed memory: 4.09Gb
Availiable memory:      3.31Gb
Free percentile:        80.00%
Status bar:
|+++++++++-----------------------------|
========================================
Current usage
========================================
Current processes: 28
Average memory:    76Mb
Maximum memory:    80Mb
Overall memory:    1.99Gb
========================================
Projected usage
========================================
Concurrent best:  446 more connection(s)
Concurrent worst: 424 more connection(s)
========================================

Espero vuestros comentarios y sugerencias. Si os gusta, seguiremos publicando artículos sobre el uso de Bash

3 años...

via Instagram http://instagr.am/p/Pze3okM3Iy/

Asi quedo la llanta de mi compa

via Instagram http://instagr.am/p/Pw_dEKM3Lq/

Seguridad en la carpeta “uploads” de WordPress

Ayuda WordPress



http://ayudawordpress.com/seguridad-en-la-carpeta-uploads-de-wordpress/

Imagen creada por Noreboo

Una de las más posibles vías de entrada de intrusos en una instalación WordPress es la carpeta “uploads“, situada en la ruta “…/wp-content/uploads“, pues debe tener permisos de escritura para que el mismo WordPress pueda almacenar las imágenes y documentos que subes a través del cargador de medios.

Es por ello que es especialmente importante asegurar lo máximo esta carpeta, para evitar cargas de archivos indeseadas, especialmente si tu WordPress tiene habilitada la publicación de artículos por terceros, incluso invitados y, por supuesto, por hackers indeseables, que los hay.

Lo primero que debes tener en cuenta son los permisos correctos de carpetas en WordPress y, una vez comprobado, podemos añadir un control de seguridad adicional mediante unas líneas de código en un archivo, y al que llamaremos .htaccess (no olvides el punto delante del nombre), y crearemos en la misma carpeta “uploads“.

Sería algo así:

# seguridad de subida de archivos en carpeta
<Files ~ ".*\..*">
        Order Allow,Deny
        Deny from all
</Files>
<FilesMatch "\.(jpg|jpeg|jpe|gif|png|bmp|tif|tiff|doc|pdf|rtf|xls|numbers|odt|pages|key|zip|rar)$">
        Order Deny,Allow
        Allow from all
</FilesMatch>

Lo que hacemos es evitar la carga de cualquier archivo salvo los especificados en ‘FilesMatch‘ que, como puedes adivinar, puedes adaptar a tus necesidades (el ejemplo contempla imágenes, pdf, documentos de varios procesadores de texto, hojas de cálculo, presentaciones y archivos comprimidos, bastante amplio). Lo que si que te recomiendo es que no permitas la carga de ficheros con extensiones ejecutables de manera local o remota, como archivos Javascript o similares, por supuesto.

Esto mismo lo puedes hacer en otras carpetas que también requieren la carga de archivos, como “upgrade“, por ejemplo, que la usa WordPress como carpeta temporal para las actualizaciones y demás.

¡Que usted lo asegure bien!